package pipeline import ( "fmt" "sort" "strings" "git.a-wan.net/alan/pipelines/internal/protocol" "git.a-wan.net/alan/pipelines/internal/stage" ) // ModelOverride is a provider/model pair chosen for a run. type ModelOverride struct { Provider string Model string } // String renders the pair as provider/model. func (m ModelOverride) String() string { return m.Provider + "/" + m.Model } // ParseModelOverride parses a provider/model value and validates both sides with // stage.ValidModel. It is the one parser shared by launch-time resolution and the // CLI's pre-flight form check, so the two cannot drift. func ParseModelOverride(value string) (ModelOverride, error) { provider, model, ok := strings.Cut(strings.TrimSpace(value), "/") provider, model = strings.TrimSpace(provider), strings.TrimSpace(model) if !ok || !stage.ValidModel(provider, model) { return ModelOverride{}, fmt.Errorf("model override %q must be provider/model", value) } return ModelOverride{Provider: provider, Model: model}, nil } // EffectiveModels resolves the provider/model each model stage will run with for // one run. Precedence: a per-stage override beats the whole-run override, which // beats the model pinned in the pipeline version. It is pure and validates the // overrides against the pinned graph: an unknown stage key fails naming the valid // keys, a value that is not a provider/model fails, and a per-stage key for a // non-model stage fails because that stage could never honour it. A whole-run // override on a graph with no model stage is accepted and inert. The helper is // shared by the server (authoritative, against the pinned version) and the CLI // (pre-flight form check), so the precedence rule lives once. func EffectiveModels(graph protocol.Graph, model string, stageModels map[string]string) (map[string]ModelOverride, error) { keys := make([]string, 0, len(graph.Stages)) byKey := make(map[string]protocol.Stage, len(graph.Stages)) for _, s := range graph.Stages { keys = append(keys, s.Key) byKey[s.Key] = s } sort.Strings(keys) var whole *ModelOverride if strings.TrimSpace(model) != "" { parsed, err := ParseModelOverride(model) if err != nil { return nil, err } whole = &parsed } perStage := make(map[string]ModelOverride, len(stageModels)) overrideKeys := make([]string, 0, len(stageModels)) for key := range stageModels { overrideKeys = append(overrideKeys, key) } sort.Strings(overrideKeys) for _, key := range overrideKeys { declared, exists := byKey[key] if !exists { return nil, fmt.Errorf("unknown stage key %q; valid keys: %s", key, strings.Join(keys, ", ")) } if stage.EffectiveType(declared.Type) != stage.ModelType { return nil, fmt.Errorf("stage %q cannot honour a model override; it is not a model stage", key) } parsed, err := ParseModelOverride(stageModels[key]) if err != nil { return nil, fmt.Errorf("stage %q: %w", key, err) } perStage[key] = parsed } effective := make(map[string]ModelOverride, len(graph.Stages)) for _, s := range graph.Stages { if stage.EffectiveType(s.Type) != stage.ModelType { continue } if override, ok := perStage[s.Key]; ok { effective[s.Key] = override continue } if whole != nil { effective[s.Key] = *whole continue } effective[s.Key] = ModelOverride{Provider: s.Configs["provider"], Model: s.Configs["model"]} } return effective, nil }