diff --git a/internal/stage/model.go b/internal/stage/model.go index e9e7cd0c..4764e934 100644 --- a/internal/stage/model.go +++ b/internal/stage/model.go @@ -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 } diff --git a/internal/stage/reasoning_effort.go b/internal/stage/reasoning_effort.go new file mode 100644 index 00000000..9b912bb7 --- /dev/null +++ b/internal/stage/reasoning_effort.go @@ -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 +} diff --git a/internal/stage/reasoning_effort_test.go b/internal/stage/reasoning_effort_test.go new file mode 100644 index 00000000..6b741ef1 --- /dev/null +++ b/internal/stage/reasoning_effort_test.go @@ -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") + } +}