package stage import ( "context" "fmt" "strconv" "strings" "time" ) const ModelType = "model" 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 ReasoningEffort string Retries int Timeout time.Duration BudgetUSD float64 BudgetTokens int64 Budget *Budget } type ModelSpec struct { Prompt string Config ModelConfig } // ModelGenerator isolates the provider integration from stage instructions/results. type ModelGenerator interface { Generate(context.Context, ModelConfig, string) (string, error) } type ModelStage struct { Client ModelGenerator // nil uses the locally authenticated OpenCode service } var _ Stage = ModelStage{} func (m ModelStage) Validate(def Definition) error { _, err := m.Spec(def) return err } func (ModelStage) Spec(def Definition) (ModelSpec, error) { if EffectiveType(def.Type) != ModelType { return ModelSpec{}, fmt.Errorf("expected model stage, got %q", def.Type) } for _, block := range []string{"prompt", "configs"} { if strings.TrimSpace(def.Blocks[block]) == "" { return ModelSpec{}, fmt.Errorf("required block %s is missing or empty", block) } } for block := range def.Blocks { switch block { case "output", "prompt", "edges", "configs", "tools", "permissions", "checks", "verification": default: return ModelSpec{}, fmt.Errorf("unexpected block %q for model stage", block) } } if _, _, err := ToolNames(def); err != nil { return ModelSpec{}, err } if _, err := StagePermissions(def); err != nil { return ModelSpec{}, err } if _, err := VerificationTargetFor(def); err != nil { return ModelSpec{}, err } for _, key := range []string{"provider", "model"} { if def.Configs[key] == "" { return ModelSpec{}, fmt.Errorf("missing config %s", key) } } for key := range def.Configs { switch key { case "provider", "model", "reasoning_effort", "retries", "timeout", "budget_usd", "budget_tokens", "harness", "delivery": default: return ModelSpec{}, fmt.Errorf("unknown config %q", key) } } if !ValidModel(def.Configs["provider"], def.Configs["model"]) { return ModelSpec{}, fmt.Errorf("invalid provider/model identifier; use the exact IDs validated during setup") } backend := def.Configs["harness"] if backend == "" { backend = "opencode" } 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 delivery := def.Configs["delivery"]; delivery != "" && delivery != "true" { return ModelSpec{}, fmt.Errorf("delivery must be true when set") } if def.Configs["delivery"] == "true" && backend != "opencode" { return ModelSpec{}, fmt.Errorf("delivery is supported only by the opencode harness") } if _, present := def.Blocks["checks"]; present && def.Configs["delivery"] != "true" { return ModelSpec{}, fmt.Errorf("checks block is supported only by delivery stages") } if backend == "pi" { tools, _, _ := ToolNames(def) if _, err := piTools(tools); err != nil { return ModelSpec{}, err } } retries := DefaultRetries if value := def.Configs["retries"]; value != "" { retries, err = strconv.Atoi(value) } if err != nil || retries < 0 || retries > 100 { return ModelSpec{}, fmt.Errorf("retries must be an integer from 0 to 100") } timeout, err := StageTimeout(def) if err != nil { return ModelSpec{}, err } usd, tokens, err := parseBudget(def) if err != nil { return ModelSpec{}, err } return ModelSpec{ Prompt: def.Blocks["prompt"], Config: ModelConfig{Harness: backend, Provider: def.Configs["provider"], Model: def.Configs["model"], ReasoningEffort: effort, Retries: retries, Timeout: timeout, BudgetUSD: usd, BudgetTokens: tokens}, }, nil }