tutti/packages/agent/daemon/modelcatalog/runtime_config_options.go

package modelcatalog

import (
	"encoding/json"
	"fmt"
	"strings"
)

// ParseRuntimeConfigOptionModels reads the canonical model select descriptor
// published by provider runtimes. The returned advertised bit distinguishes a
// missing descriptor from an explicitly advertised empty model catalog.
func ParseRuntimeConfigOptionModels(value any, modelOptionID string) ([]ModelOption, bool, error) {
	raw, err := json.Marshal(value)
	if err != nil {
		return nil, false, fmt.Errorf("marshal runtime config options: %w", err)
	}
	var descriptors []struct {
		ID      string            `json:"id"`
		Options []json.RawMessage `json:"options"`
	}
	if err := json.Unmarshal(raw, &descriptors); err != nil {
		return nil, false, fmt.Errorf("parse runtime config options: %w", err)
	}
	modelOptionID = strings.TrimSpace(modelOptionID)
	if modelOptionID == "" {
		modelOptionID = "model"
	}
	for _, descriptor := range descriptors {
		if strings.TrimSpace(descriptor.ID) != modelOptionID {
			continue
		}
		models := make([]ModelOption, 0, len(descriptor.Options))
		for _, rawOption := range descriptor.Options {
			if model, ok := NormalizeRuntimeConfigOptionModel(rawOption); ok {
				models = append(models, model)
			}
		}
		return models, true, nil
	}
	return nil, false, nil
}

// NormalizeRuntimeConfigOptionModel converts one provider-neutral model option
// descriptor into the same canonical catalog type used by CLI model/list
// discovery. Field presence remains authoritative for empty capability sets.
func NormalizeRuntimeConfigOptionModel(raw json.RawMessage) (ModelOption, bool) {
	var object map[string]any
	if err := json.Unmarshal(raw, &object); err != nil {
		return ModelOption{}, false
	}
	id := firstNonBlank(stringMapValue(object, "value"), stringMapValue(object, "model"), stringMapValue(object, "id"))
	if id == "" {
		return ModelOption{}, false
	}
	displayName := firstNonBlank(
		stringMapValue(object, "label"),
		stringMapValue(object, "name"),
		stringMapValue(object, "displayName"),
		stringMapValue(object, "display_name"),
		id,
	)
	reasoningValue, reasoningAdvertised := advertisedValue(object, "reasoningEfforts", "supportedReasoningEfforts", "supported_reasoning_efforts")
	supportsReasoning, supportsReasoningAdvertised := object["supportsReasoningEffort"].(bool)
	reasoningOptions := normalizeCodexReasoningEfforts(reasoningValue)
	if supportsReasoningAdvertised && !supportsReasoning {
		reasoningOptions = []ReasoningEffortOption{}
	}
	defaultReasoning := firstNonBlank(
		stringMapValue(object, "reasoningEffort"),
		stringMapValue(object, "defaultReasoningEffort"),
		stringMapValue(object, "default_reasoning_effort"),
	)
	reasoningAdvertised = reasoningAdvertised || supportsReasoningAdvertised || defaultReasoning != ""

	speedValue, speedsAdvertised := advertisedValue(object, "speeds", "serviceTiers", "service_tiers")
	speeds := normalizeRuntimeSpeedOptions(speedValue)
	defaultSpeed := firstNonBlank(stringMapValue(object, "speed"), stringMapValue(object, "defaultSpeed"), stringMapValue(object, "defaultServiceTier"))

	return ModelOption{
		ID:                         id,
		DisplayName:                displayName,
		Description:                stringMapValue(object, "description"),
		ConsumptionMultiplier:      stringMapValue(object, "consumptionMultiplier"),
		DefaultReasoningEffort:     validReasoningDefault(reasoningOptions, defaultReasoning),
		DefaultSpeed:               validSpeedDefault(speeds, canonicalCodexSpeed(defaultSpeed)),
		IsDefault:                  id == "default" || boolMapValue(object, "default") || boolMapValue(object, "isDefault") || boolMapValue(object, "is_default"),
		ReasoningEffortsAdvertised: reasoningAdvertised,
		SupportedReasoningEfforts:  reasoningOptions,
		SpeedsAdvertised:           speedsAdvertised,
		SupportedSpeeds:            speeds,
		SupportsImageInput:         runtimeConfigImageInputSupport(object),
	}, true
}

// ProjectRuntimeConfigOptionModel publishes one canonical catalog model using
// the provider-neutral descriptor vocabulary consumed by every Agent host.
func ProjectRuntimeConfigOptionModel(model ModelOption) map[string]any {
	option := map[string]any{
		"value":       strings.TrimSpace(model.ID),
		"name":        firstNonBlank(model.DisplayName, model.ID),
		"description": strings.TrimSpace(model.Description),
		"default":     model.IsDefault,
	}
	if consumptionMultiplier := strings.TrimSpace(model.ConsumptionMultiplier); consumptionMultiplier != "" {
		option["consumptionMultiplier"] = consumptionMultiplier
	}
	if model.SupportsImageInput != nil {
		option["supportsImageInput"] = *model.SupportsImageInput
	}
	if model.ReasoningEffortsAdvertised {
		reasoningOptions := make([]map[string]any, 0, len(model.SupportedReasoningEfforts))
		for _, reasoning := range model.SupportedReasoningEfforts {
			value := strings.TrimSpace(reasoning.Value)
			if value == "" {
				continue
			}
			reasoningOptions = append(reasoningOptions, map[string]any{
				"value":       value,
				"name":        firstNonBlank(reasoning.Label, value),
				"description": strings.TrimSpace(reasoning.Description),
				"default":     reasoning.Default || value == strings.TrimSpace(model.DefaultReasoningEffort),
			})
		}
		option["supportsReasoningEffort"] = len(reasoningOptions) > 0
		option["reasoningEffort"] = validReasoningDefault(model.SupportedReasoningEfforts, model.DefaultReasoningEffort)
		option["reasoningEfforts"] = reasoningOptions
	}
	if model.SpeedsAdvertised {
		speedOptions := make([]map[string]any, 0, len(model.SupportedSpeeds))
		for _, speed := range model.SupportedSpeeds {
			value := strings.TrimSpace(speed.Value)
			if value == "" {
				continue
			}
			speedOptions = append(speedOptions, map[string]any{
				"value":       value,
				"name":        firstNonBlank(speed.Label, value),
				"description": strings.TrimSpace(speed.Description),
			})
		}
		option["speed"] = validSpeedDefault(model.SupportedSpeeds, model.DefaultSpeed)
		option["speeds"] = speedOptions
	}
	return option
}

func normalizeRuntimeSpeedOptions(value any) []SpeedOption {
	rawOptions, ok := value.([]any)
	if !ok {
		return nil
	}
	options := make([]SpeedOption, 0, len(rawOptions))
	seen := make(map[string]struct{}, len(rawOptions))
	for _, rawOption := range rawOptions {
		var option SpeedOption
		switch typed := rawOption.(type) {
		case string:
			option.Value = canonicalCodexSpeed(typed)
		case map[string]any:
			option.Value = canonicalCodexSpeed(firstNonBlank(stringMapValue(typed, "value"), stringMapValue(typed, "id")))
			option.Label = firstNonBlank(stringMapValue(typed, "label"), stringMapValue(typed, "name"))
			option.Description = stringMapValue(typed, "description")
		}
		if option.Value == "" {
			continue
		}
		if _, exists := seen[option.Value]; exists {
			continue
		}
		seen[option.Value] = struct{}{}
		options = append(options, option)
	}
	return options
}

func runtimeConfigImageInputSupport(object map[string]any) *bool {
	if supported, advertised := object["supportsImageInput"].(bool); advertised {
		return &supported
	}
	return codexImageInputSupport(object)
}