feat(pipeline): parse optional reasoning effort for model stages

This commit is contained in:
2026-10-20 23:40:14 +01:00
parent 6f4543444c
commit 2aaf7fe2cc
3 changed files with 124 additions and 11 deletions
+18 -11
View File
@@ -15,14 +15,15 @@ const ModelID = "deepseek-v4.1-flash"
// ModelConfig and ModelSpec group the settings/contracts that belong specifically
// to an LLM stage. Other stage types need not have a prompt, provider, or model.
type ModelConfig struct {
Harness string
Provider string
Model string
Retries int
Timeout time.Duration
BudgetUSD float64
BudgetTokens int64
Budget *Budget
Harness string
Provider string
Model string
ReasoningEffort string
Retries int
Timeout time.Duration
BudgetUSD float64
BudgetTokens int64
Budget *Budget
}
type ModelSpec struct {
@@ -78,7 +79,7 @@ func (ModelStage) Spec(def Definition) (ModelSpec, error) {
}
for key := range def.Configs {
switch key {
case "provider", "model", "retries", "timeout", "budget_usd", "budget_tokens", "harness", "delivery":
case "provider", "model", "reasoning_effort", "retries", "timeout", "budget_usd", "budget_tokens", "harness", "delivery":
default:
return ModelSpec{}, fmt.Errorf("unknown config %q", key)
}
@@ -93,6 +94,13 @@ func (ModelStage) Spec(def Definition) (ModelSpec, error) {
if backend != "opencode" && backend != "pi" {
return ModelSpec{}, fmt.Errorf("harness must be opencode or pi")
}
effort, err := normalizeReasoningEffort(def.Configs["reasoning_effort"])
if err != nil {
return ModelSpec{}, err
}
if backend == "pi" && effort == "max" {
return ModelSpec{}, fmt.Errorf("reasoning_effort=max is not supported by pi; use a supported thinking level up to xhigh")
}
if delivery := def.Configs["delivery"]; delivery != "" && delivery != "true" {
return ModelSpec{}, fmt.Errorf("delivery must be true when set")
}
@@ -109,7 +117,6 @@ func (ModelStage) Spec(def Definition) (ModelSpec, error) {
}
}
retries := DefaultRetries
var err error
if value := def.Configs["retries"]; value != "" {
retries, err = strconv.Atoi(value)
}
@@ -126,6 +133,6 @@ func (ModelStage) Spec(def Definition) (ModelSpec, error) {
}
return ModelSpec{
Prompt: def.Blocks["prompt"],
Config: ModelConfig{Harness: backend, Provider: def.Configs["provider"], Model: def.Configs["model"], Retries: retries, Timeout: timeout, BudgetUSD: usd, BudgetTokens: tokens},
Config: ModelConfig{Harness: backend, Provider: def.Configs["provider"], Model: def.Configs["model"], ReasoningEffort: effort, Retries: retries, Timeout: timeout, BudgetUSD: usd, BudgetTokens: tokens},
}, nil
}
+36
View File
@@ -0,0 +1,36 @@
package stage
import "fmt"
// Omission preserves the configured harness/model default. These are effort
// levels, not provider token budgets or permission to choose a different model.
func normalizeReasoningEffort(value string) (string, error) {
switch value {
case "", "default":
return "", nil
case "off":
return "none", nil
case "none", "minimal", "low", "medium", "high", "xhigh", "max":
return value, nil
default:
return "", fmt.Errorf("reasoning_effort must be default, none (or off), minimal, low, medium, high, xhigh, or max")
}
}
// OpenCode V2 resolves named variants against the selected model's catalogue.
// Its resolver rejects unsupported variants; do not mutate global model config
// or silently fall back to another effort level. V1 has no supported mapping.
func openCodeModelSelection(config ModelConfig, backend string) (map[string]string, error) {
effort, err := normalizeReasoningEffort(config.ReasoningEffort)
if err != nil {
return nil, err
}
model := map[string]string{"providerID": config.Provider, "id": config.Model}
if effort != "" {
if backend != "v2" {
return nil, fmt.Errorf("reasoning_effort requires OpenCode V2; this backend cannot apply it")
}
model["variant"] = effort
}
return model, nil
}
+70
View File
@@ -0,0 +1,70 @@
package stage
import (
"strings"
"testing"
)
func TestReasoningEffortConfig(t *testing.T) {
for _, value := range []string{"", "default", "none", "off", "minimal", "low", "medium", "high", "xhigh", "max", "HIGH", "lots", "1000"} {
t.Run(value, func(t *testing.T) {
def := Definition{Type: ModelType, Blocks: map[string]string{"prompt": "task", "configs": "config"}, Configs: map[string]string{"provider": "fixture", "model": "model", "reasoning_effort": value}}
spec, err := (ModelStage{}).Spec(def)
if value == "HIGH" || value == "lots" || value == "1000" {
if err == nil {
t.Fatal("invalid effort accepted")
}
return
}
if err != nil {
t.Fatal(err)
}
want := value
if value == "default" {
want = ""
}
if value == "off" {
want = "none"
}
if spec.Config.ReasoningEffort != want {
t.Fatalf("got %q want %q", spec.Config.ReasoningEffort, want)
}
def.Configs["harness"] = "pi"
_, err = (ModelStage{}).Spec(def)
if value == "max" {
if err == nil || !strings.Contains(err.Error(), "pi") {
t.Fatal("unsupported Pi effort accepted")
}
} else if err != nil {
t.Fatal(err)
}
})
}
}
func TestOpenCodeReasoningEffortModelReference(t *testing.T) {
for _, value := range []string{"", "default", "off", "none", "high", "max"} {
model, err := openCodeModelSelection(ModelConfig{Provider: "fixture", Model: "model", ReasoningEffort: value}, "v2")
if err != nil {
t.Fatal(err)
}
want := value
if value == "default" {
want = ""
}
if value == "off" {
want = "none"
}
if model["variant"] != want || model["providerID"] != "fixture" || model["id"] != "model" {
t.Fatalf("wrong reference: %+v", model)
}
if want == "" {
if _, ok := model["variant"]; ok {
t.Fatal("omission changed default selection")
}
}
}
if _, err := openCodeModelSelection(ModelConfig{ReasoningEffort: "high"}, "v1"); err == nil {
t.Fatal("V1 silently ignored effort")
}
}