From f030ec3384bfabc39f1c8f550d09e409fff3fd17 Mon Sep 17 00:00:00 2001 From: RCD <90105158+Finesssee@users.noreply.github.com> Date: Mon, 19 Jan 2026 06:36:22 +0700 Subject: [PATCH] feat(thinking): add unified thinking configuration package Port the internal/thinking package from CLIProxyAPI for unified thinking configuration processing across all AI providers. Features: - Core types: ThinkingConfig, ThinkingMode, ThinkingLevel, SuffixResult - Suffix parsing: model-name(16384) or model-name(high) syntax - Validation: auto-conversion between budget/level formats, clamping - Provider appliers: claude, gemini, antigravity, openai, codex - Config extraction: extract thinking config from various request formats - Stripping: remove thinking config for non-supporting models Registry updates: - Add UserDefined field to ModelInfo for passthrough behavior - Add LookupModelInfo function for model capability lookup --- internal/registry/model_registry.go | 21 + internal/thinking/apply.go | 481 ++++++++++++++++++ internal/thinking/convert.go | 142 ++++++ internal/thinking/errors.go | 82 +++ .../thinking/provider/antigravity/apply.go | 201 ++++++++ internal/thinking/provider/claude/apply.go | 108 ++++ internal/thinking/provider/codex/apply.go | 130 +++++ internal/thinking/provider/gemini/apply.go | 169 ++++++ internal/thinking/provider/openai/apply.go | 127 +++++ internal/thinking/strip.go | 58 +++ internal/thinking/suffix.go | 146 ++++++ internal/thinking/text.go | 41 ++ internal/thinking/types.go | 116 +++++ internal/thinking/validate.go | 378 ++++++++++++++ 14 files changed, 2200 insertions(+) create mode 100644 internal/thinking/apply.go create mode 100644 internal/thinking/convert.go create mode 100644 internal/thinking/errors.go create mode 100644 internal/thinking/provider/antigravity/apply.go create mode 100644 internal/thinking/provider/claude/apply.go create mode 100644 internal/thinking/provider/codex/apply.go create mode 100644 internal/thinking/provider/gemini/apply.go create mode 100644 internal/thinking/provider/openai/apply.go create mode 100644 internal/thinking/strip.go create mode 100644 internal/thinking/suffix.go create mode 100644 internal/thinking/text.go create mode 100644 internal/thinking/types.go create mode 100644 internal/thinking/validate.go diff --git a/internal/registry/model_registry.go b/internal/registry/model_registry.go index 6e865273..72ffc741 100644 --- a/internal/registry/model_registry.go +++ b/internal/registry/model_registry.go @@ -50,6 +50,11 @@ type ModelInfo struct { // Thinking holds provider-specific reasoning/thinking budget capabilities. // This is optional and currently used for Gemini thinking budget normalization. Thinking *ThinkingSupport `json:"thinking,omitempty"` + + // UserDefined indicates whether this model was registered via user configuration + // (e.g., openai-compatibility.*.models[], *-api-key.models[]). + // User-defined models skip thinking validation and pass through to upstream. + UserDefined bool `json:"-"` } // ThinkingSupport describes a model family's supported internal reasoning budget range. @@ -970,3 +975,19 @@ func (r *ModelRegistry) GetModelsForClient(clientID string) []*ModelInfo { } return result } + +// LookupModelInfo looks up model information by model ID from the global registry. +// Returns nil if the model is not found. +// +// This is a convenience function for use by the thinking package to validate +// model capabilities without needing direct registry access. +func LookupModelInfo(modelID string) *ModelInfo { + registry := GetGlobalRegistry() + registry.mutex.RLock() + defer registry.mutex.RUnlock() + + if reg, ok := registry.models[modelID]; ok && reg.Info != nil { + return reg.Info + } + return nil +} diff --git a/internal/thinking/apply.go b/internal/thinking/apply.go new file mode 100644 index 00000000..cf0e373b --- /dev/null +++ b/internal/thinking/apply.go @@ -0,0 +1,481 @@ +// Package thinking provides unified thinking configuration processing. +package thinking + +import ( + "strings" + + "github.com/router-for-me/CLIProxyAPI/v6/internal/registry" + log "github.com/sirupsen/logrus" + "github.com/tidwall/gjson" +) + +// providerAppliers maps provider names to their ProviderApplier implementations. +var providerAppliers = map[string]ProviderApplier{ + "gemini": nil, + "gemini-cli": nil, + "claude": nil, + "openai": nil, + "codex": nil, + "iflow": nil, + "antigravity": nil, +} + +// GetProviderApplier returns the ProviderApplier for the given provider name. +// Returns nil if the provider is not registered. +func GetProviderApplier(provider string) ProviderApplier { + return providerAppliers[provider] +} + +// RegisterProvider registers a provider applier by name. +func RegisterProvider(name string, applier ProviderApplier) { + providerAppliers[name] = applier +} + +// IsUserDefinedModel reports whether the model is a user-defined model that should +// have thinking configuration passed through without validation. +// +// User-defined models are configured via config file's models[] array +// (e.g., openai-compatibility.*.models[], *-api-key.models[]). These models +// are marked with UserDefined=true at registration time. +// +// User-defined models should have their thinking configuration applied directly, +// letting the upstream service validate the configuration. +func IsUserDefinedModel(modelInfo *registry.ModelInfo) bool { + if modelInfo == nil { + return true + } + return modelInfo.UserDefined +} + +// ApplyThinking applies thinking configuration to a request body. +// +// This is the unified entry point for all providers. It follows the processing +// order defined in FR25: route check → model capability query → config extraction +// → validation → application. +// +// Suffix Priority: When the model name includes a thinking suffix (e.g., "gemini-2.5-pro(8192)"), +// the suffix configuration takes priority over any thinking parameters in the request body. +// This enables users to override thinking settings via the model name without modifying their +// request payload. +// +// Parameters: +// - body: Original request body JSON +// - model: Model name, optionally with thinking suffix (e.g., "claude-sonnet-4-5(16384)") +// - fromFormat: Source request format (e.g., openai, codex, gemini) +// - toFormat: Target provider format for the request body (gemini, gemini-cli, antigravity, claude, openai, codex, iflow) +// +// Returns: +// - Modified request body JSON with thinking configuration applied +// - Error if validation fails (ThinkingError). On error, the original body +// is returned (not nil) to enable defensive programming patterns. +// +// Passthrough behavior (returns original body without error): +// - Unknown provider (not in providerAppliers map) +// - modelInfo.Thinking is nil (model doesn't support thinking) +// +// Note: Unknown models (modelInfo is nil) are treated as user-defined models: we skip +// validation and still apply the thinking config so the upstream can validate it. +// +// Example: +// +// // With suffix - suffix config takes priority +// result, err := thinking.ApplyThinking(body, "gemini-2.5-pro(8192)", "gemini", "gemini") +// +// // Without suffix - uses body config +// result, err := thinking.ApplyThinking(body, "gemini-2.5-pro", "gemini", "gemini") +func ApplyThinking(body []byte, model string, fromFormat string, toFormat string) ([]byte, error) { + providerFormat := strings.ToLower(strings.TrimSpace(toFormat)) + fromFormat = strings.ToLower(strings.TrimSpace(fromFormat)) + if fromFormat == "" { + fromFormat = providerFormat + } + // 1. Route check: Get provider applier + applier := GetProviderApplier(providerFormat) + if applier == nil { + log.WithFields(log.Fields{ + "provider": providerFormat, + "model": model, + }).Debug("thinking: unknown provider, passthrough |") + return body, nil + } + + // 2. Parse suffix and get modelInfo + suffixResult := ParseSuffix(model) + baseModel := suffixResult.ModelName + modelInfo := registry.LookupModelInfo(baseModel) + + // 3. Model capability check + // Unknown models are treated as user-defined so thinking config can still be applied. + // The upstream service is responsible for validating the configuration. + if IsUserDefinedModel(modelInfo) { + return applyUserDefinedModel(body, modelInfo, fromFormat, providerFormat, suffixResult) + } + if modelInfo.Thinking == nil { + config := extractThinkingConfig(body, providerFormat) + if hasThinkingConfig(config) { + log.WithFields(log.Fields{ + "model": baseModel, + "provider": providerFormat, + }).Debug("thinking: model does not support thinking, stripping config |") + return StripThinkingConfig(body, providerFormat), nil + } + log.WithFields(log.Fields{ + "provider": providerFormat, + "model": baseModel, + }).Debug("thinking: model does not support thinking, passthrough |") + return body, nil + } + + // 4. Get config: suffix priority over body + var config ThinkingConfig + if suffixResult.HasSuffix { + config = parseSuffixToConfig(suffixResult.RawSuffix, providerFormat, model) + log.WithFields(log.Fields{ + "provider": providerFormat, + "model": model, + "mode": config.Mode, + "budget": config.Budget, + "level": config.Level, + }).Debug("thinking: config from model suffix |") + } else { + config = extractThinkingConfig(body, providerFormat) + if hasThinkingConfig(config) { + log.WithFields(log.Fields{ + "provider": providerFormat, + "model": modelInfo.ID, + "mode": config.Mode, + "budget": config.Budget, + "level": config.Level, + }).Debug("thinking: original config from request |") + } + } + + if !hasThinkingConfig(config) { + log.WithFields(log.Fields{ + "provider": providerFormat, + "model": modelInfo.ID, + }).Debug("thinking: no config found, passthrough |") + return body, nil + } + + // 5. Validate and normalize configuration + validated, err := ValidateConfig(config, modelInfo, fromFormat, providerFormat, suffixResult.HasSuffix) + if err != nil { + log.WithFields(log.Fields{ + "provider": providerFormat, + "model": modelInfo.ID, + "error": err.Error(), + }).Warn("thinking: validation failed |") + // Return original body on validation failure (defensive programming). + // This ensures callers who ignore the error won't receive nil body. + // The upstream service will decide how to handle the unmodified request. + return body, err + } + + // Defensive check: ValidateConfig should never return (nil, nil) + if validated == nil { + log.WithFields(log.Fields{ + "provider": providerFormat, + "model": modelInfo.ID, + }).Warn("thinking: ValidateConfig returned nil config without error, passthrough |") + return body, nil + } + + log.WithFields(log.Fields{ + "provider": providerFormat, + "model": modelInfo.ID, + "mode": validated.Mode, + "budget": validated.Budget, + "level": validated.Level, + }).Debug("thinking: processed config to apply |") + + // 6. Apply configuration using provider-specific applier + return applier.Apply(body, *validated, modelInfo) +} + +// parseSuffixToConfig converts a raw suffix string to ThinkingConfig. +// +// Parsing priority: +// 1. Special values: "none" → ModeNone, "auto"/"-1" → ModeAuto +// 2. Level names: "minimal", "low", "medium", "high", "xhigh" → ModeLevel +// 3. Numeric values: positive integers → ModeBudget, 0 → ModeNone +// +// If none of the above match, returns empty ThinkingConfig (treated as no config). +func parseSuffixToConfig(rawSuffix, provider, model string) ThinkingConfig { + // 1. Try special values first (none, auto, -1) + if mode, ok := ParseSpecialSuffix(rawSuffix); ok { + switch mode { + case ModeNone: + return ThinkingConfig{Mode: ModeNone, Budget: 0} + case ModeAuto: + return ThinkingConfig{Mode: ModeAuto, Budget: -1} + } + } + + // 2. Try level parsing (minimal, low, medium, high, xhigh) + if level, ok := ParseLevelSuffix(rawSuffix); ok { + return ThinkingConfig{Mode: ModeLevel, Level: level} + } + + // 3. Try numeric parsing + if budget, ok := ParseNumericSuffix(rawSuffix); ok { + if budget == 0 { + return ThinkingConfig{Mode: ModeNone, Budget: 0} + } + return ThinkingConfig{Mode: ModeBudget, Budget: budget} + } + + // Unknown suffix format - return empty config + log.WithFields(log.Fields{ + "provider": provider, + "model": model, + "raw_suffix": rawSuffix, + }).Debug("thinking: unknown suffix format, treating as no config |") + return ThinkingConfig{} +} + +// applyUserDefinedModel applies thinking configuration for user-defined models +// without ThinkingSupport validation. +func applyUserDefinedModel(body []byte, modelInfo *registry.ModelInfo, fromFormat, toFormat string, suffixResult SuffixResult) ([]byte, error) { + // Get model ID for logging + modelID := "" + if modelInfo != nil { + modelID = modelInfo.ID + } else { + modelID = suffixResult.ModelName + } + + // Get config: suffix priority over body + var config ThinkingConfig + if suffixResult.HasSuffix { + config = parseSuffixToConfig(suffixResult.RawSuffix, toFormat, modelID) + } else { + config = extractThinkingConfig(body, toFormat) + } + + if !hasThinkingConfig(config) { + log.WithFields(log.Fields{ + "model": modelID, + "provider": toFormat, + }).Debug("thinking: user-defined model, passthrough (no config) |") + return body, nil + } + + applier := GetProviderApplier(toFormat) + if applier == nil { + log.WithFields(log.Fields{ + "model": modelID, + "provider": toFormat, + }).Debug("thinking: user-defined model, passthrough (unknown provider) |") + return body, nil + } + + log.WithFields(log.Fields{ + "provider": toFormat, + "model": modelID, + "mode": config.Mode, + "budget": config.Budget, + "level": config.Level, + }).Debug("thinking: applying config for user-defined model (skip validation)") + + config = normalizeUserDefinedConfig(config, fromFormat, toFormat) + return applier.Apply(body, config, modelInfo) +} + +func normalizeUserDefinedConfig(config ThinkingConfig, fromFormat, toFormat string) ThinkingConfig { + if config.Mode != ModeLevel { + return config + } + if !isBudgetBasedProvider(toFormat) || !isLevelBasedProvider(fromFormat) { + return config + } + budget, ok := ConvertLevelToBudget(string(config.Level)) + if !ok { + return config + } + config.Mode = ModeBudget + config.Budget = budget + config.Level = "" + return config +} + +// extractThinkingConfig extracts provider-specific thinking config from request body. +func extractThinkingConfig(body []byte, provider string) ThinkingConfig { + if len(body) == 0 || !gjson.ValidBytes(body) { + return ThinkingConfig{} + } + + switch provider { + case "claude": + return extractClaudeConfig(body) + case "gemini", "gemini-cli", "antigravity": + return extractGeminiConfig(body, provider) + case "openai": + return extractOpenAIConfig(body) + case "codex": + return extractCodexConfig(body) + case "iflow": + config := extractIFlowConfig(body) + if hasThinkingConfig(config) { + return config + } + return extractOpenAIConfig(body) + default: + return ThinkingConfig{} + } +} + +func hasThinkingConfig(config ThinkingConfig) bool { + return config.Mode != ModeBudget || config.Budget != 0 || config.Level != "" +} + +// extractClaudeConfig extracts thinking configuration from Claude format request body. +// +// Claude API format: +// - thinking.type: "enabled" or "disabled" +// - thinking.budget_tokens: integer (-1=auto, 0=disabled, >0=budget) +// +// Priority: thinking.type="disabled" takes precedence over budget_tokens. +// When type="enabled" without budget_tokens, returns ModeAuto to indicate +// the user wants thinking enabled but didn't specify a budget. +func extractClaudeConfig(body []byte) ThinkingConfig { + thinkingType := gjson.GetBytes(body, "thinking.type").String() + if thinkingType == "disabled" { + return ThinkingConfig{Mode: ModeNone, Budget: 0} + } + + // Check budget_tokens + if budget := gjson.GetBytes(body, "thinking.budget_tokens"); budget.Exists() { + value := int(budget.Int()) + switch value { + case 0: + return ThinkingConfig{Mode: ModeNone, Budget: 0} + case -1: + return ThinkingConfig{Mode: ModeAuto, Budget: -1} + default: + return ThinkingConfig{Mode: ModeBudget, Budget: value} + } + } + + // If type="enabled" but no budget_tokens, treat as auto (user wants thinking but no budget specified) + if thinkingType == "enabled" { + return ThinkingConfig{Mode: ModeAuto, Budget: -1} + } + + return ThinkingConfig{} +} + +// extractGeminiConfig extracts thinking configuration from Gemini format request body. +// +// Gemini API format: +// - generationConfig.thinkingConfig.thinkingLevel: "none", "auto", or level name (Gemini 3) +// - generationConfig.thinkingConfig.thinkingBudget: integer (Gemini 2.5) +// +// For gemini-cli and antigravity providers, the path is prefixed with "request.". +// +// Priority: thinkingLevel is checked first (Gemini 3 format), then thinkingBudget (Gemini 2.5 format). +// This allows newer Gemini 3 level-based configs to take precedence. +func extractGeminiConfig(body []byte, provider string) ThinkingConfig { + prefix := "generationConfig.thinkingConfig" + if provider == "gemini-cli" || provider == "antigravity" { + prefix = "request.generationConfig.thinkingConfig" + } + + // Check thinkingLevel first (Gemini 3 format takes precedence) + if level := gjson.GetBytes(body, prefix+".thinkingLevel"); level.Exists() { + value := level.String() + switch value { + case "none": + return ThinkingConfig{Mode: ModeNone, Budget: 0} + case "auto": + return ThinkingConfig{Mode: ModeAuto, Budget: -1} + default: + return ThinkingConfig{Mode: ModeLevel, Level: ThinkingLevel(value)} + } + } + + // Check thinkingBudget (Gemini 2.5 format) + if budget := gjson.GetBytes(body, prefix+".thinkingBudget"); budget.Exists() { + value := int(budget.Int()) + switch value { + case 0: + return ThinkingConfig{Mode: ModeNone, Budget: 0} + case -1: + return ThinkingConfig{Mode: ModeAuto, Budget: -1} + default: + return ThinkingConfig{Mode: ModeBudget, Budget: value} + } + } + + return ThinkingConfig{} +} + +// extractOpenAIConfig extracts thinking configuration from OpenAI format request body. +// +// OpenAI API format: +// - reasoning_effort: "none", "low", "medium", "high" (discrete levels) +// +// OpenAI uses level-based thinking configuration only, no numeric budget support. +// The "none" value is treated specially to return ModeNone. +func extractOpenAIConfig(body []byte) ThinkingConfig { + // Check reasoning_effort (OpenAI Chat Completions format) + if effort := gjson.GetBytes(body, "reasoning_effort"); effort.Exists() { + value := effort.String() + if value == "none" { + return ThinkingConfig{Mode: ModeNone, Budget: 0} + } + return ThinkingConfig{Mode: ModeLevel, Level: ThinkingLevel(value)} + } + + return ThinkingConfig{} +} + +// extractCodexConfig extracts thinking configuration from Codex format request body. +// +// Codex API format (OpenAI Responses API): +// - reasoning.effort: "none", "low", "medium", "high" +// +// This is similar to OpenAI but uses nested field "reasoning.effort" instead of "reasoning_effort". +func extractCodexConfig(body []byte) ThinkingConfig { + // Check reasoning.effort (Codex / OpenAI Responses API format) + if effort := gjson.GetBytes(body, "reasoning.effort"); effort.Exists() { + value := effort.String() + if value == "none" { + return ThinkingConfig{Mode: ModeNone, Budget: 0} + } + return ThinkingConfig{Mode: ModeLevel, Level: ThinkingLevel(value)} + } + + return ThinkingConfig{} +} + +// extractIFlowConfig extracts thinking configuration from iFlow format request body. +// +// iFlow API format (supports multiple model families): +// - GLM format: chat_template_kwargs.enable_thinking (boolean) +// - MiniMax format: reasoning_split (boolean) +// +// Returns ModeBudget with Budget=1 as a sentinel value indicating "enabled". +// The actual budget/configuration is determined by the iFlow applier based on model capabilities. +// Budget=1 is used because iFlow models don't use numeric budgets; they only support on/off. +func extractIFlowConfig(body []byte) ThinkingConfig { + // GLM format: chat_template_kwargs.enable_thinking + if enabled := gjson.GetBytes(body, "chat_template_kwargs.enable_thinking"); enabled.Exists() { + if enabled.Bool() { + // Budget=1 is a sentinel meaning "enabled" (iFlow doesn't use numeric budgets) + return ThinkingConfig{Mode: ModeBudget, Budget: 1} + } + return ThinkingConfig{Mode: ModeNone, Budget: 0} + } + + // MiniMax format: reasoning_split + if split := gjson.GetBytes(body, "reasoning_split"); split.Exists() { + if split.Bool() { + // Budget=1 is a sentinel meaning "enabled" (iFlow doesn't use numeric budgets) + return ThinkingConfig{Mode: ModeBudget, Budget: 1} + } + return ThinkingConfig{Mode: ModeNone, Budget: 0} + } + + return ThinkingConfig{} +} diff --git a/internal/thinking/convert.go b/internal/thinking/convert.go new file mode 100644 index 00000000..776ccef6 --- /dev/null +++ b/internal/thinking/convert.go @@ -0,0 +1,142 @@ +package thinking + +import ( + "strings" + + "github.com/router-for-me/CLIProxyAPI/v6/internal/registry" +) + +// levelToBudgetMap defines the standard Level → Budget mapping. +// All keys are lowercase; lookups should use strings.ToLower. +var levelToBudgetMap = map[string]int{ + "none": 0, + "auto": -1, + "minimal": 512, + "low": 1024, + "medium": 8192, + "high": 24576, + "xhigh": 32768, +} + +// ConvertLevelToBudget converts a thinking level to a budget value. +// +// This is a semantic conversion that maps discrete levels to numeric budgets. +// Level matching is case-insensitive. +// +// Level → Budget mapping: +// - none → 0 +// - auto → -1 +// - minimal → 512 +// - low → 1024 +// - medium → 8192 +// - high → 24576 +// - xhigh → 32768 +// +// Returns: +// - budget: The converted budget value +// - ok: true if level is valid, false otherwise +func ConvertLevelToBudget(level string) (int, bool) { + budget, ok := levelToBudgetMap[strings.ToLower(level)] + return budget, ok +} + +// BudgetThreshold constants define the upper bounds for each thinking level. +// These are used by ConvertBudgetToLevel for range-based mapping. +const ( + // ThresholdMinimal is the upper bound for "minimal" level (1-512) + ThresholdMinimal = 512 + // ThresholdLow is the upper bound for "low" level (513-1024) + ThresholdLow = 1024 + // ThresholdMedium is the upper bound for "medium" level (1025-8192) + ThresholdMedium = 8192 + // ThresholdHigh is the upper bound for "high" level (8193-24576) + ThresholdHigh = 24576 +) + +// ConvertBudgetToLevel converts a budget value to the nearest thinking level. +// +// This is a semantic conversion that maps numeric budgets to discrete levels. +// Uses threshold-based mapping for range conversion. +// +// Budget → Level thresholds: +// - -1 → auto +// - 0 → none +// - 1-512 → minimal +// - 513-1024 → low +// - 1025-8192 → medium +// - 8193-24576 → high +// - 24577+ → xhigh +// +// Returns: +// - level: The converted thinking level string +// - ok: true if budget is valid, false for invalid negatives (< -1) +func ConvertBudgetToLevel(budget int) (string, bool) { + switch { + case budget < -1: + // Invalid negative values + return "", false + case budget == -1: + return string(LevelAuto), true + case budget == 0: + return string(LevelNone), true + case budget <= ThresholdMinimal: + return string(LevelMinimal), true + case budget <= ThresholdLow: + return string(LevelLow), true + case budget <= ThresholdMedium: + return string(LevelMedium), true + case budget <= ThresholdHigh: + return string(LevelHigh), true + default: + return string(LevelXHigh), true + } +} + +// ModelCapability describes the thinking format support of a model. +type ModelCapability int + +const ( + // CapabilityUnknown indicates modelInfo is nil (passthrough behavior, internal use). + CapabilityUnknown ModelCapability = iota - 1 + // CapabilityNone indicates model doesn't support thinking (Thinking is nil). + CapabilityNone + // CapabilityBudgetOnly indicates the model supports numeric budgets only. + CapabilityBudgetOnly + // CapabilityLevelOnly indicates the model supports discrete levels only. + CapabilityLevelOnly + // CapabilityHybrid indicates the model supports both budgets and levels. + CapabilityHybrid +) + +// detectModelCapability determines the thinking format capability of a model. +// +// This is an internal function used by validation and conversion helpers. +// It analyzes the model's ThinkingSupport configuration to classify the model: +// - CapabilityNone: modelInfo.Thinking is nil (model doesn't support thinking) +// - CapabilityBudgetOnly: Has Min/Max but no Levels (Claude, Gemini 2.5) +// - CapabilityLevelOnly: Has Levels but no Min/Max (OpenAI, iFlow) +// - CapabilityHybrid: Has both Min/Max and Levels (Gemini 3) +// +// Note: Returns a special sentinel value when modelInfo itself is nil (unknown model). +func detectModelCapability(modelInfo *registry.ModelInfo) ModelCapability { + if modelInfo == nil { + return CapabilityUnknown // sentinel for "passthrough" behavior + } + if modelInfo.Thinking == nil { + return CapabilityNone + } + support := modelInfo.Thinking + hasBudget := support.Min > 0 || support.Max > 0 + hasLevels := len(support.Levels) > 0 + + switch { + case hasBudget && hasLevels: + return CapabilityHybrid + case hasBudget: + return CapabilityBudgetOnly + case hasLevels: + return CapabilityLevelOnly + default: + return CapabilityNone + } +} diff --git a/internal/thinking/errors.go b/internal/thinking/errors.go new file mode 100644 index 00000000..5eed9381 --- /dev/null +++ b/internal/thinking/errors.go @@ -0,0 +1,82 @@ +// Package thinking provides unified thinking configuration processing logic. +package thinking + +import "net/http" + +// ErrorCode represents the type of thinking configuration error. +type ErrorCode string + +// Error codes for thinking configuration processing. +const ( + // ErrInvalidSuffix indicates the suffix format cannot be parsed. + // Example: "model(abc" (missing closing parenthesis) + ErrInvalidSuffix ErrorCode = "INVALID_SUFFIX" + + // ErrUnknownLevel indicates the level value is not in the valid list. + // Example: "model(ultra)" where "ultra" is not a valid level + ErrUnknownLevel ErrorCode = "UNKNOWN_LEVEL" + + // ErrThinkingNotSupported indicates the model does not support thinking. + // Example: claude-haiku-4-5 does not have thinking capability + ErrThinkingNotSupported ErrorCode = "THINKING_NOT_SUPPORTED" + + // ErrLevelNotSupported indicates the model does not support level mode. + // Example: using level with a budget-only model + ErrLevelNotSupported ErrorCode = "LEVEL_NOT_SUPPORTED" + + // ErrBudgetOutOfRange indicates the budget value is outside model range. + // Example: budget 64000 exceeds max 20000 + ErrBudgetOutOfRange ErrorCode = "BUDGET_OUT_OF_RANGE" + + // ErrProviderMismatch indicates the provider does not match the model. + // Example: applying Claude format to a Gemini model + ErrProviderMismatch ErrorCode = "PROVIDER_MISMATCH" +) + +// ThinkingError represents an error that occurred during thinking configuration processing. +// +// This error type provides structured information about the error, including: +// - Code: A machine-readable error code for programmatic handling +// - Message: A human-readable description of the error +// - Model: The model name related to the error (optional) +// - Details: Additional context information (optional) +type ThinkingError struct { + // Code is the machine-readable error code + Code ErrorCode + // Message is the human-readable error description. + // Should be lowercase, no trailing period, with context if applicable. + Message string + // Model is the model name related to this error (optional) + Model string + // Details contains additional context information (optional) + Details map[string]interface{} +} + +// Error implements the error interface. +// Returns the message directly without code prefix. +// Use Code field for programmatic error handling. +func (e *ThinkingError) Error() string { + return e.Message +} + +// NewThinkingError creates a new ThinkingError with the given code and message. +func NewThinkingError(code ErrorCode, message string) *ThinkingError { + return &ThinkingError{ + Code: code, + Message: message, + } +} + +// NewThinkingErrorWithModel creates a new ThinkingError with model context. +func NewThinkingErrorWithModel(code ErrorCode, message, model string) *ThinkingError { + return &ThinkingError{ + Code: code, + Message: message, + Model: model, + } +} + +// StatusCode implements a portable status code interface for HTTP handlers. +func (e *ThinkingError) StatusCode() int { + return http.StatusBadRequest +} diff --git a/internal/thinking/provider/antigravity/apply.go b/internal/thinking/provider/antigravity/apply.go new file mode 100644 index 00000000..9c1c79f6 --- /dev/null +++ b/internal/thinking/provider/antigravity/apply.go @@ -0,0 +1,201 @@ +// Package antigravity implements thinking configuration for Antigravity API format. +// +// Antigravity uses request.generationConfig.thinkingConfig.* path (same as gemini-cli) +// but requires additional normalization for Claude models: +// - Ensure thinking budget < max_tokens +// - Remove thinkingConfig if budget < minimum allowed +package antigravity + +import ( + "strings" + + "github.com/router-for-me/CLIProxyAPI/v6/internal/registry" + "github.com/router-for-me/CLIProxyAPI/v6/internal/thinking" + "github.com/tidwall/gjson" + "github.com/tidwall/sjson" +) + +// Applier applies thinking configuration for Antigravity API format. +type Applier struct{} + +var _ thinking.ProviderApplier = (*Applier)(nil) + +// NewApplier creates a new Antigravity thinking applier. +func NewApplier() *Applier { + return &Applier{} +} + +func init() { + thinking.RegisterProvider("antigravity", NewApplier()) +} + +// Apply applies thinking configuration to Antigravity request body. +// +// For Claude models, additional constraints are applied: +// - Ensure thinking budget < max_tokens +// - Remove thinkingConfig if budget < minimum allowed +func (a *Applier) Apply(body []byte, config thinking.ThinkingConfig, modelInfo *registry.ModelInfo) ([]byte, error) { + if thinking.IsUserDefinedModel(modelInfo) { + return a.applyCompatible(body, config, modelInfo) + } + if modelInfo.Thinking == nil { + return body, nil + } + + if config.Mode != thinking.ModeBudget && config.Mode != thinking.ModeLevel && config.Mode != thinking.ModeNone && config.Mode != thinking.ModeAuto { + return body, nil + } + + if len(body) == 0 || !gjson.ValidBytes(body) { + body = []byte(`{}`) + } + + isClaude := strings.Contains(strings.ToLower(modelInfo.ID), "claude") + + // ModeAuto: Always use Budget format with thinkingBudget=-1 + if config.Mode == thinking.ModeAuto { + return a.applyBudgetFormat(body, config, modelInfo, isClaude) + } + if config.Mode == thinking.ModeBudget { + return a.applyBudgetFormat(body, config, modelInfo, isClaude) + } + + // For non-auto modes, choose format based on model capabilities + support := modelInfo.Thinking + if len(support.Levels) > 0 { + return a.applyLevelFormat(body, config) + } + return a.applyBudgetFormat(body, config, modelInfo, isClaude) +} + +func (a *Applier) applyCompatible(body []byte, config thinking.ThinkingConfig, modelInfo *registry.ModelInfo) ([]byte, error) { + if config.Mode != thinking.ModeBudget && config.Mode != thinking.ModeLevel && config.Mode != thinking.ModeNone && config.Mode != thinking.ModeAuto { + return body, nil + } + + if len(body) == 0 || !gjson.ValidBytes(body) { + body = []byte(`{}`) + } + + isClaude := false + if modelInfo != nil { + isClaude = strings.Contains(strings.ToLower(modelInfo.ID), "claude") + } + + if config.Mode == thinking.ModeAuto { + return a.applyBudgetFormat(body, config, modelInfo, isClaude) + } + + if config.Mode == thinking.ModeLevel || (config.Mode == thinking.ModeNone && config.Level != "") { + return a.applyLevelFormat(body, config) + } + + return a.applyBudgetFormat(body, config, modelInfo, isClaude) +} + +func (a *Applier) applyLevelFormat(body []byte, config thinking.ThinkingConfig) ([]byte, error) { + // Remove conflicting field to avoid both thinkingLevel and thinkingBudget in output + result, _ := sjson.DeleteBytes(body, "request.generationConfig.thinkingConfig.thinkingBudget") + // Normalize includeThoughts field name to avoid oneof conflicts in upstream JSON parsing. + result, _ = sjson.DeleteBytes(result, "request.generationConfig.thinkingConfig.include_thoughts") + + if config.Mode == thinking.ModeNone { + result, _ = sjson.SetBytes(result, "request.generationConfig.thinkingConfig.includeThoughts", false) + if config.Level != "" { + result, _ = sjson.SetBytes(result, "request.generationConfig.thinkingConfig.thinkingLevel", string(config.Level)) + } + return result, nil + } + + // Only handle ModeLevel - budget conversion should be done by upper layer + if config.Mode != thinking.ModeLevel { + return body, nil + } + + level := string(config.Level) + result, _ = sjson.SetBytes(result, "request.generationConfig.thinkingConfig.thinkingLevel", level) + result, _ = sjson.SetBytes(result, "request.generationConfig.thinkingConfig.includeThoughts", true) + return result, nil +} + +func (a *Applier) applyBudgetFormat(body []byte, config thinking.ThinkingConfig, modelInfo *registry.ModelInfo, isClaude bool) ([]byte, error) { + // Remove conflicting field to avoid both thinkingLevel and thinkingBudget in output + result, _ := sjson.DeleteBytes(body, "request.generationConfig.thinkingConfig.thinkingLevel") + // Normalize includeThoughts field name to avoid oneof conflicts in upstream JSON parsing. + result, _ = sjson.DeleteBytes(result, "request.generationConfig.thinkingConfig.include_thoughts") + + budget := config.Budget + includeThoughts := false + switch config.Mode { + case thinking.ModeNone: + includeThoughts = false + case thinking.ModeAuto: + includeThoughts = true + default: + includeThoughts = budget > 0 + } + + // Apply Claude-specific constraints + if isClaude && modelInfo != nil { + budget, result = a.normalizeClaudeBudget(budget, result, modelInfo) + // Check if budget was removed entirely + if budget == -2 { + return result, nil + } + } + + result, _ = sjson.SetBytes(result, "request.generationConfig.thinkingConfig.thinkingBudget", budget) + result, _ = sjson.SetBytes(result, "request.generationConfig.thinkingConfig.includeThoughts", includeThoughts) + return result, nil +} + +// normalizeClaudeBudget applies Claude-specific constraints to thinking budget. +// +// It handles: +// - Ensuring thinking budget < max_tokens +// - Removing thinkingConfig if budget < minimum allowed +// +// Returns the normalized budget and updated payload. +// Returns budget=-2 as a sentinel indicating thinkingConfig was removed entirely. +func (a *Applier) normalizeClaudeBudget(budget int, payload []byte, modelInfo *registry.ModelInfo) (int, []byte) { + if modelInfo == nil { + return budget, payload + } + + // Get effective max tokens + effectiveMax, setDefaultMax := a.effectiveMaxTokens(payload, modelInfo) + if effectiveMax > 0 && budget >= effectiveMax { + budget = effectiveMax - 1 + } + + // Check minimum budget + minBudget := 0 + if modelInfo.Thinking != nil { + minBudget = modelInfo.Thinking.Min + } + if minBudget > 0 && budget >= 0 && budget < minBudget { + // Budget is below minimum, remove thinking config entirely + payload, _ = sjson.DeleteBytes(payload, "request.generationConfig.thinkingConfig") + return -2, payload + } + + // Set default max tokens if needed + if setDefaultMax && effectiveMax > 0 { + payload, _ = sjson.SetBytes(payload, "request.generationConfig.maxOutputTokens", effectiveMax) + } + + return budget, payload +} + +// effectiveMaxTokens returns the max tokens to cap thinking: +// prefer request-provided maxOutputTokens; otherwise fall back to model default. +// The boolean indicates whether the value came from the model default (and thus should be written back). +func (a *Applier) effectiveMaxTokens(payload []byte, modelInfo *registry.ModelInfo) (max int, fromModel bool) { + if maxTok := gjson.GetBytes(payload, "request.generationConfig.maxOutputTokens"); maxTok.Exists() && maxTok.Int() > 0 { + return int(maxTok.Int()), false + } + if modelInfo != nil && modelInfo.MaxCompletionTokens > 0 { + return modelInfo.MaxCompletionTokens, true + } + return 0, false +} diff --git a/internal/thinking/provider/claude/apply.go b/internal/thinking/provider/claude/apply.go new file mode 100644 index 00000000..0f3dc2d1 --- /dev/null +++ b/internal/thinking/provider/claude/apply.go @@ -0,0 +1,108 @@ +// Package claude implements thinking configuration scaffolding for Claude models. +// +// Claude models use the thinking.budget_tokens format with values in the range +// 1024-128000. Some Claude models support ZeroAllowed (sonnet-4-5, opus-4-5), +// while older models do not. +package claude + +import ( + "github.com/router-for-me/CLIProxyAPI/v6/internal/registry" + "github.com/router-for-me/CLIProxyAPI/v6/internal/thinking" + "github.com/tidwall/gjson" + "github.com/tidwall/sjson" +) + +// Applier implements thinking.ProviderApplier for Claude models. +// This applier is stateless and holds no configuration. +type Applier struct{} + +// NewApplier creates a new Claude thinking applier. +func NewApplier() *Applier { + return &Applier{} +} + +func init() { + thinking.RegisterProvider("claude", NewApplier()) +} + +// Apply applies thinking configuration to Claude request body. +// +// IMPORTANT: This method expects config to be pre-validated by thinking.ValidateConfig. +// ValidateConfig handles: +// - Mode conversion (Level→Budget, Auto→Budget) +// - Budget clamping to model range +// - ZeroAllowed constraint enforcement +// +// Apply only processes ModeBudget and ModeNone; other modes are passed through unchanged. +// +// Expected output format when enabled: +// +// { +// "thinking": { +// "type": "enabled", +// "budget_tokens": 16384 +// } +// } +// +// Expected output format when disabled: +// +// { +// "thinking": { +// "type": "disabled" +// } +// } +func (a *Applier) Apply(body []byte, config thinking.ThinkingConfig, modelInfo *registry.ModelInfo) ([]byte, error) { + if thinking.IsUserDefinedModel(modelInfo) { + return applyCompatibleClaude(body, config) + } + if modelInfo.Thinking == nil { + return body, nil + } + + // Only process ModeBudget and ModeNone; other modes pass through + // (caller should use ValidateConfig first to normalize modes) + if config.Mode != thinking.ModeBudget && config.Mode != thinking.ModeNone { + return body, nil + } + + if len(body) == 0 || !gjson.ValidBytes(body) { + body = []byte(`{}`) + } + + // Budget is expected to be pre-validated by ValidateConfig (clamped, ZeroAllowed enforced) + // Decide enabled/disabled based on budget value + if config.Budget == 0 { + result, _ := sjson.SetBytes(body, "thinking.type", "disabled") + result, _ = sjson.DeleteBytes(result, "thinking.budget_tokens") + return result, nil + } + + result, _ := sjson.SetBytes(body, "thinking.type", "enabled") + result, _ = sjson.SetBytes(result, "thinking.budget_tokens", config.Budget) + return result, nil +} + +func applyCompatibleClaude(body []byte, config thinking.ThinkingConfig) ([]byte, error) { + if config.Mode != thinking.ModeBudget && config.Mode != thinking.ModeNone && config.Mode != thinking.ModeAuto { + return body, nil + } + + if len(body) == 0 || !gjson.ValidBytes(body) { + body = []byte(`{}`) + } + + switch config.Mode { + case thinking.ModeNone: + result, _ := sjson.SetBytes(body, "thinking.type", "disabled") + result, _ = sjson.DeleteBytes(result, "thinking.budget_tokens") + return result, nil + case thinking.ModeAuto: + result, _ := sjson.SetBytes(body, "thinking.type", "enabled") + result, _ = sjson.DeleteBytes(result, "thinking.budget_tokens") + return result, nil + default: + result, _ := sjson.SetBytes(body, "thinking.type", "enabled") + result, _ = sjson.SetBytes(result, "thinking.budget_tokens", config.Budget) + return result, nil + } +} diff --git a/internal/thinking/provider/codex/apply.go b/internal/thinking/provider/codex/apply.go new file mode 100644 index 00000000..42406e74 --- /dev/null +++ b/internal/thinking/provider/codex/apply.go @@ -0,0 +1,130 @@ +// Package codex implements thinking configuration for Codex (OpenAI Responses API) models. +// +// Codex models use the reasoning.effort format with discrete levels +// (low/medium/high). This is similar to OpenAI but uses nested field +// "reasoning.effort" instead of "reasoning_effort". +package codex + +import ( + "strings" + + "github.com/router-for-me/CLIProxyAPI/v6/internal/registry" + "github.com/router-for-me/CLIProxyAPI/v6/internal/thinking" + "github.com/tidwall/gjson" + "github.com/tidwall/sjson" +) + +// Applier implements thinking.ProviderApplier for Codex models. +// +// Codex-specific behavior: +// - Output format: reasoning.effort (string: low/medium/high/xhigh) +// - Level-only mode: no numeric budget support +// - Some models support ZeroAllowed (gpt-5.1, gpt-5.2) +type Applier struct{} + +var _ thinking.ProviderApplier = (*Applier)(nil) + +// NewApplier creates a new Codex thinking applier. +func NewApplier() *Applier { + return &Applier{} +} + +func init() { + thinking.RegisterProvider("codex", NewApplier()) +} + +// Apply applies thinking configuration to Codex request body. +// +// Expected output format: +// +// { +// "reasoning": { +// "effort": "high" +// } +// } +func (a *Applier) Apply(body []byte, config thinking.ThinkingConfig, modelInfo *registry.ModelInfo) ([]byte, error) { + if thinking.IsUserDefinedModel(modelInfo) { + return applyCompatibleCodex(body, config) + } + if modelInfo.Thinking == nil { + return body, nil + } + + // Only handle ModeLevel and ModeNone; other modes pass through unchanged. + if config.Mode != thinking.ModeLevel && config.Mode != thinking.ModeNone { + return body, nil + } + + if len(body) == 0 || !gjson.ValidBytes(body) { + body = []byte(`{}`) + } + + if config.Mode == thinking.ModeLevel { + result, _ := sjson.SetBytes(body, "reasoning.effort", string(config.Level)) + return result, nil + } + + effort := "" + support := modelInfo.Thinking + if config.Budget == 0 { + if support.ZeroAllowed || hasLevel(support.Levels, string(thinking.LevelNone)) { + effort = string(thinking.LevelNone) + } + } + if effort == "" && config.Level != "" { + effort = string(config.Level) + } + if effort == "" && len(support.Levels) > 0 { + effort = support.Levels[0] + } + if effort == "" { + return body, nil + } + + result, _ := sjson.SetBytes(body, "reasoning.effort", effort) + return result, nil +} + +func applyCompatibleCodex(body []byte, config thinking.ThinkingConfig) ([]byte, error) { + if len(body) == 0 || !gjson.ValidBytes(body) { + body = []byte(`{}`) + } + + var effort string + switch config.Mode { + case thinking.ModeLevel: + if config.Level == "" { + return body, nil + } + effort = string(config.Level) + case thinking.ModeNone: + effort = string(thinking.LevelNone) + if config.Level != "" { + effort = string(config.Level) + } + case thinking.ModeAuto: + // Auto mode for user-defined models: pass through as "auto" + effort = string(thinking.LevelAuto) + case thinking.ModeBudget: + // Budget mode: convert budget to level using threshold mapping + level, ok := thinking.ConvertBudgetToLevel(config.Budget) + if !ok { + return body, nil + } + effort = level + default: + return body, nil + } + + result, _ := sjson.SetBytes(body, "reasoning.effort", effort) + return result, nil +} + +func hasLevel(levels []string, target string) bool { + for _, level := range levels { + if strings.EqualFold(strings.TrimSpace(level), target) { + return true + } + } + return false +} diff --git a/internal/thinking/provider/gemini/apply.go b/internal/thinking/provider/gemini/apply.go new file mode 100644 index 00000000..c8560f19 --- /dev/null +++ b/internal/thinking/provider/gemini/apply.go @@ -0,0 +1,169 @@ +// Package gemini implements thinking configuration for Gemini models. +// +// Gemini models have two formats: +// - Gemini 2.5: Uses thinkingBudget (numeric) +// - Gemini 3.x: Uses thinkingLevel (string: minimal/low/medium/high) +// or thinkingBudget=-1 for auto/dynamic mode +// +// Output format is determined by ThinkingConfig.Mode and ThinkingSupport.Levels: +// - ModeAuto: Always uses thinkingBudget=-1 (both Gemini 2.5 and 3.x) +// - len(Levels) > 0: Uses thinkingLevel (Gemini 3.x discrete levels) +// - len(Levels) == 0: Uses thinkingBudget (Gemini 2.5) +package gemini + +import ( + "github.com/router-for-me/CLIProxyAPI/v6/internal/registry" + "github.com/router-for-me/CLIProxyAPI/v6/internal/thinking" + "github.com/tidwall/gjson" + "github.com/tidwall/sjson" +) + +// Applier applies thinking configuration for Gemini models. +// +// Gemini-specific behavior: +// - Gemini 2.5: thinkingBudget format, flash series supports ZeroAllowed +// - Gemini 3.x: thinkingLevel format, cannot be disabled +// - Use ThinkingSupport.Levels to decide output format +type Applier struct{} + +// NewApplier creates a new Gemini thinking applier. +func NewApplier() *Applier { + return &Applier{} +} + +func init() { + thinking.RegisterProvider("gemini", NewApplier()) +} + +// Apply applies thinking configuration to Gemini request body. +// +// Expected output format (Gemini 2.5): +// +// { +// "generationConfig": { +// "thinkingConfig": { +// "thinkingBudget": 8192, +// "includeThoughts": true +// } +// } +// } +// +// Expected output format (Gemini 3.x): +// +// { +// "generationConfig": { +// "thinkingConfig": { +// "thinkingLevel": "high", +// "includeThoughts": true +// } +// } +// } +func (a *Applier) Apply(body []byte, config thinking.ThinkingConfig, modelInfo *registry.ModelInfo) ([]byte, error) { + if thinking.IsUserDefinedModel(modelInfo) { + return a.applyCompatible(body, config) + } + if modelInfo.Thinking == nil { + return body, nil + } + + if config.Mode != thinking.ModeBudget && config.Mode != thinking.ModeLevel && config.Mode != thinking.ModeNone && config.Mode != thinking.ModeAuto { + return body, nil + } + + if len(body) == 0 || !gjson.ValidBytes(body) { + body = []byte(`{}`) + } + + // Choose format based on config.Mode and model capabilities: + // - ModeLevel: use Level format (validation will reject unsupported levels) + // - ModeNone: use Level format if model has Levels, else Budget format + // - ModeBudget/ModeAuto: use Budget format + switch config.Mode { + case thinking.ModeLevel: + return a.applyLevelFormat(body, config) + case thinking.ModeNone: + // ModeNone: route based on model capability (has Levels or not) + if len(modelInfo.Thinking.Levels) > 0 { + return a.applyLevelFormat(body, config) + } + return a.applyBudgetFormat(body, config) + default: + return a.applyBudgetFormat(body, config) + } +} + +func (a *Applier) applyCompatible(body []byte, config thinking.ThinkingConfig) ([]byte, error) { + if config.Mode != thinking.ModeBudget && config.Mode != thinking.ModeLevel && config.Mode != thinking.ModeNone && config.Mode != thinking.ModeAuto { + return body, nil + } + + if len(body) == 0 || !gjson.ValidBytes(body) { + body = []byte(`{}`) + } + + if config.Mode == thinking.ModeAuto { + return a.applyBudgetFormat(body, config) + } + + if config.Mode == thinking.ModeLevel || (config.Mode == thinking.ModeNone && config.Level != "") { + return a.applyLevelFormat(body, config) + } + + return a.applyBudgetFormat(body, config) +} + +func (a *Applier) applyLevelFormat(body []byte, config thinking.ThinkingConfig) ([]byte, error) { + // ModeNone semantics: + // - ModeNone + Budget=0: completely disable thinking (not possible for Level-only models) + // - ModeNone + Budget>0: forced to think but hide output (includeThoughts=false) + // ValidateConfig sets config.Level to the lowest level when ModeNone + Budget > 0. + + // Remove conflicting field to avoid both thinkingLevel and thinkingBudget in output + result, _ := sjson.DeleteBytes(body, "generationConfig.thinkingConfig.thinkingBudget") + // Normalize includeThoughts field name to avoid oneof conflicts in upstream JSON parsing. + result, _ = sjson.DeleteBytes(result, "generationConfig.thinkingConfig.include_thoughts") + + if config.Mode == thinking.ModeNone { + result, _ = sjson.SetBytes(result, "generationConfig.thinkingConfig.includeThoughts", false) + if config.Level != "" { + result, _ = sjson.SetBytes(result, "generationConfig.thinkingConfig.thinkingLevel", string(config.Level)) + } + return result, nil + } + + // Only handle ModeLevel - budget conversion should be done by upper layer + if config.Mode != thinking.ModeLevel { + return body, nil + } + + level := string(config.Level) + result, _ = sjson.SetBytes(result, "generationConfig.thinkingConfig.thinkingLevel", level) + result, _ = sjson.SetBytes(result, "generationConfig.thinkingConfig.includeThoughts", true) + return result, nil +} + +func (a *Applier) applyBudgetFormat(body []byte, config thinking.ThinkingConfig) ([]byte, error) { + // Remove conflicting field to avoid both thinkingLevel and thinkingBudget in output + result, _ := sjson.DeleteBytes(body, "generationConfig.thinkingConfig.thinkingLevel") + // Normalize includeThoughts field name to avoid oneof conflicts in upstream JSON parsing. + result, _ = sjson.DeleteBytes(result, "generationConfig.thinkingConfig.include_thoughts") + + budget := config.Budget + // ModeNone semantics: + // - ModeNone + Budget=0: completely disable thinking + // - ModeNone + Budget>0: forced to think but hide output (includeThoughts=false) + // When ZeroAllowed=false, ValidateConfig clamps Budget to Min while preserving ModeNone. + includeThoughts := false + switch config.Mode { + case thinking.ModeNone: + includeThoughts = false + case thinking.ModeAuto: + includeThoughts = true + default: + includeThoughts = budget > 0 + } + + result, _ = sjson.SetBytes(result, "generationConfig.thinkingConfig.thinkingBudget", budget) + result, _ = sjson.SetBytes(result, "generationConfig.thinkingConfig.includeThoughts", includeThoughts) + return result, nil +} diff --git a/internal/thinking/provider/openai/apply.go b/internal/thinking/provider/openai/apply.go new file mode 100644 index 00000000..37b8b89f --- /dev/null +++ b/internal/thinking/provider/openai/apply.go @@ -0,0 +1,127 @@ +// Package openai implements thinking configuration for OpenAI/Codex models. +// +// OpenAI models use the reasoning_effort format with discrete levels +// (low/medium/high). Some models support xhigh and none levels. +package openai + +import ( + "strings" + + "github.com/router-for-me/CLIProxyAPI/v6/internal/registry" + "github.com/router-for-me/CLIProxyAPI/v6/internal/thinking" + "github.com/tidwall/gjson" + "github.com/tidwall/sjson" +) + +// Applier implements thinking.ProviderApplier for OpenAI models. +// +// OpenAI-specific behavior: +// - Output format: reasoning_effort (string: low/medium/high/xhigh) +// - Level-only mode: no numeric budget support +// - Some models support ZeroAllowed (gpt-5.1, gpt-5.2) +type Applier struct{} + +var _ thinking.ProviderApplier = (*Applier)(nil) + +// NewApplier creates a new OpenAI thinking applier. +func NewApplier() *Applier { + return &Applier{} +} + +func init() { + thinking.RegisterProvider("openai", NewApplier()) +} + +// Apply applies thinking configuration to OpenAI request body. +// +// Expected output format: +// +// { +// "reasoning_effort": "high" +// } +func (a *Applier) Apply(body []byte, config thinking.ThinkingConfig, modelInfo *registry.ModelInfo) ([]byte, error) { + if thinking.IsUserDefinedModel(modelInfo) { + return applyCompatibleOpenAI(body, config) + } + if modelInfo.Thinking == nil { + return body, nil + } + + // Only handle ModeLevel and ModeNone; other modes pass through unchanged. + if config.Mode != thinking.ModeLevel && config.Mode != thinking.ModeNone { + return body, nil + } + + if len(body) == 0 || !gjson.ValidBytes(body) { + body = []byte(`{}`) + } + + if config.Mode == thinking.ModeLevel { + result, _ := sjson.SetBytes(body, "reasoning_effort", string(config.Level)) + return result, nil + } + + effort := "" + support := modelInfo.Thinking + if config.Budget == 0 { + if support.ZeroAllowed || hasLevel(support.Levels, string(thinking.LevelNone)) { + effort = string(thinking.LevelNone) + } + } + if effort == "" && config.Level != "" { + effort = string(config.Level) + } + if effort == "" && len(support.Levels) > 0 { + effort = support.Levels[0] + } + if effort == "" { + return body, nil + } + + result, _ := sjson.SetBytes(body, "reasoning_effort", effort) + return result, nil +} + +func applyCompatibleOpenAI(body []byte, config thinking.ThinkingConfig) ([]byte, error) { + if len(body) == 0 || !gjson.ValidBytes(body) { + body = []byte(`{}`) + } + + var effort string + switch config.Mode { + case thinking.ModeLevel: + if config.Level == "" { + return body, nil + } + effort = string(config.Level) + case thinking.ModeNone: + effort = string(thinking.LevelNone) + if config.Level != "" { + effort = string(config.Level) + } + case thinking.ModeAuto: + // Auto mode for user-defined models: pass through as "auto" + effort = string(thinking.LevelAuto) + case thinking.ModeBudget: + // Budget mode: convert budget to level using threshold mapping + level, ok := thinking.ConvertBudgetToLevel(config.Budget) + if !ok { + return body, nil + } + effort = level + default: + return body, nil + } + + result, _ := sjson.SetBytes(body, "reasoning_effort", effort) + return result, nil +} + +func hasLevel(levels []string, target string) bool { + for _, level := range levels { + if strings.EqualFold(strings.TrimSpace(level), target) { + return true + } + } + return false +} diff --git a/internal/thinking/strip.go b/internal/thinking/strip.go new file mode 100644 index 00000000..eb691715 --- /dev/null +++ b/internal/thinking/strip.go @@ -0,0 +1,58 @@ +// Package thinking provides unified thinking configuration processing. +package thinking + +import ( + "github.com/tidwall/gjson" + "github.com/tidwall/sjson" +) + +// StripThinkingConfig removes thinking configuration fields from request body. +// +// This function is used when a model doesn't support thinking but the request +// contains thinking configuration. The configuration is silently removed to +// prevent upstream API errors. +// +// Parameters: +// - body: Original request body JSON +// - provider: Provider name (determines which fields to strip) +// +// Returns: +// - Modified request body JSON with thinking configuration removed +// - Original body is returned unchanged if: +// - body is empty or invalid JSON +// - provider is unknown +// - no thinking configuration found +func StripThinkingConfig(body []byte, provider string) []byte { + if len(body) == 0 || !gjson.ValidBytes(body) { + return body + } + + var paths []string + switch provider { + case "claude": + paths = []string{"thinking"} + case "gemini": + paths = []string{"generationConfig.thinkingConfig"} + case "gemini-cli", "antigravity": + paths = []string{"request.generationConfig.thinkingConfig"} + case "openai": + paths = []string{"reasoning_effort"} + case "codex": + paths = []string{"reasoning.effort"} + case "iflow": + paths = []string{ + "chat_template_kwargs.enable_thinking", + "chat_template_kwargs.clear_thinking", + "reasoning_split", + "reasoning_effort", + } + default: + return body + } + + result := body + for _, path := range paths { + result, _ = sjson.DeleteBytes(result, path) + } + return result +} diff --git a/internal/thinking/suffix.go b/internal/thinking/suffix.go new file mode 100644 index 00000000..275c0856 --- /dev/null +++ b/internal/thinking/suffix.go @@ -0,0 +1,146 @@ +// Package thinking provides unified thinking configuration processing. +// +// This file implements suffix parsing functionality for extracting +// thinking configuration from model names in the format model(value). +package thinking + +import ( + "strconv" + "strings" +) + +// ParseSuffix extracts thinking suffix from a model name. +// +// The suffix format is: model-name(value) +// Examples: +// - "claude-sonnet-4-5(16384)" -> ModelName="claude-sonnet-4-5", RawSuffix="16384" +// - "gpt-5.2(high)" -> ModelName="gpt-5.2", RawSuffix="high" +// - "gemini-2.5-pro" -> ModelName="gemini-2.5-pro", HasSuffix=false +// +// This function only extracts the suffix; it does not validate or interpret +// the suffix content. Use ParseNumericSuffix, ParseLevelSuffix, etc. for +// content interpretation. +func ParseSuffix(model string) SuffixResult { + // Find the last opening parenthesis + lastOpen := strings.LastIndex(model, "(") + if lastOpen == -1 { + return SuffixResult{ModelName: model, HasSuffix: false} + } + + // Check if the string ends with a closing parenthesis + if !strings.HasSuffix(model, ")") { + return SuffixResult{ModelName: model, HasSuffix: false} + } + + // Extract components + modelName := model[:lastOpen] + rawSuffix := model[lastOpen+1 : len(model)-1] + + return SuffixResult{ + ModelName: modelName, + HasSuffix: true, + RawSuffix: rawSuffix, + } +} + +// ParseNumericSuffix attempts to parse a raw suffix as a numeric budget value. +// +// This function parses the raw suffix content (from ParseSuffix.RawSuffix) as an integer. +// Only non-negative integers are considered valid numeric suffixes. +// +// Platform note: The budget value uses Go's int type, which is 32-bit on 32-bit +// systems and 64-bit on 64-bit systems. Values exceeding the platform's int range +// will return ok=false. +// +// Leading zeros are accepted: "08192" parses as 8192. +// +// Examples: +// - "8192" -> budget=8192, ok=true +// - "0" -> budget=0, ok=true (represents ModeNone) +// - "08192" -> budget=8192, ok=true (leading zeros accepted) +// - "-1" -> budget=0, ok=false (negative numbers are not valid numeric suffixes) +// - "high" -> budget=0, ok=false (not a number) +// - "9223372036854775808" -> budget=0, ok=false (overflow on 64-bit systems) +// +// For special handling of -1 as auto mode, use ParseSpecialSuffix instead. +func ParseNumericSuffix(rawSuffix string) (budget int, ok bool) { + if rawSuffix == "" { + return 0, false + } + + value, err := strconv.Atoi(rawSuffix) + if err != nil { + return 0, false + } + + // Negative numbers are not valid numeric suffixes + // -1 should be handled by special value parsing as "auto" + if value < 0 { + return 0, false + } + + return value, true +} + +// ParseSpecialSuffix attempts to parse a raw suffix as a special thinking mode value. +// +// This function handles special strings that represent a change in thinking mode: +// - "none" -> ModeNone (disables thinking) +// - "auto" -> ModeAuto (automatic/dynamic thinking) +// - "-1" -> ModeAuto (numeric representation of auto mode) +// +// String values are case-insensitive. +func ParseSpecialSuffix(rawSuffix string) (mode ThinkingMode, ok bool) { + if rawSuffix == "" { + return ModeBudget, false + } + + // Case-insensitive matching + switch strings.ToLower(rawSuffix) { + case "none": + return ModeNone, true + case "auto", "-1": + return ModeAuto, true + default: + return ModeBudget, false + } +} + +// ParseLevelSuffix attempts to parse a raw suffix as a discrete thinking level. +// +// This function parses the raw suffix content (from ParseSuffix.RawSuffix) as a level. +// Only discrete effort levels are valid: minimal, low, medium, high, xhigh. +// Level matching is case-insensitive. +// +// Special values (none, auto) are NOT handled by this function; use ParseSpecialSuffix +// instead. This separation allows callers to prioritize special value handling. +// +// Examples: +// - "high" -> level=LevelHigh, ok=true +// - "HIGH" -> level=LevelHigh, ok=true (case insensitive) +// - "medium" -> level=LevelMedium, ok=true +// - "none" -> level="", ok=false (special value, use ParseSpecialSuffix) +// - "auto" -> level="", ok=false (special value, use ParseSpecialSuffix) +// - "8192" -> level="", ok=false (numeric, use ParseNumericSuffix) +// - "ultra" -> level="", ok=false (unknown level) +func ParseLevelSuffix(rawSuffix string) (level ThinkingLevel, ok bool) { + if rawSuffix == "" { + return "", false + } + + // Case-insensitive matching + switch strings.ToLower(rawSuffix) { + case "minimal": + return LevelMinimal, true + case "low": + return LevelLow, true + case "medium": + return LevelMedium, true + case "high": + return LevelHigh, true + case "xhigh": + return LevelXHigh, true + default: + return "", false + } +} diff --git a/internal/thinking/text.go b/internal/thinking/text.go new file mode 100644 index 00000000..eed1ba28 --- /dev/null +++ b/internal/thinking/text.go @@ -0,0 +1,41 @@ +package thinking + +import ( + "github.com/tidwall/gjson" +) + +// GetThinkingText extracts the thinking text from a content part. +// Handles various formats: +// - Simple string: { "thinking": "text" } or { "text": "text" } +// - Wrapped object: { "thinking": { "text": "text", "cache_control": {...} } } +// - Gemini-style: { "thought": true, "text": "text" } +// Returns the extracted text string. +func GetThinkingText(part gjson.Result) string { + // Try direct text field first (Gemini-style) + if text := part.Get("text"); text.Exists() && text.Type == gjson.String { + return text.String() + } + + // Try thinking field + thinkingField := part.Get("thinking") + if !thinkingField.Exists() { + return "" + } + + // thinking is a string + if thinkingField.Type == gjson.String { + return thinkingField.String() + } + + // thinking is an object with inner text/thinking + if thinkingField.IsObject() { + if inner := thinkingField.Get("text"); inner.Exists() && inner.Type == gjson.String { + return inner.String() + } + if inner := thinkingField.Get("thinking"); inner.Exists() && inner.Type == gjson.String { + return inner.String() + } + } + + return "" +} diff --git a/internal/thinking/types.go b/internal/thinking/types.go new file mode 100644 index 00000000..6ae1e088 --- /dev/null +++ b/internal/thinking/types.go @@ -0,0 +1,116 @@ +// Package thinking provides unified thinking configuration processing. +// +// This package offers a unified interface for parsing, validating, and applying +// thinking configurations across various AI providers (Claude, Gemini, OpenAI, iFlow). +package thinking + +import "github.com/router-for-me/CLIProxyAPI/v6/internal/registry" + +// ThinkingMode represents the type of thinking configuration mode. +type ThinkingMode int + +const ( + // ModeBudget indicates using a numeric budget (corresponds to suffix "(1000)" etc.) + ModeBudget ThinkingMode = iota + // ModeLevel indicates using a discrete level (corresponds to suffix "(high)" etc.) + ModeLevel + // ModeNone indicates thinking is disabled (corresponds to suffix "(none)" or budget=0) + ModeNone + // ModeAuto indicates automatic/dynamic thinking (corresponds to suffix "(auto)" or budget=-1) + ModeAuto +) + +// String returns the string representation of ThinkingMode. +func (m ThinkingMode) String() string { + switch m { + case ModeBudget: + return "budget" + case ModeLevel: + return "level" + case ModeNone: + return "none" + case ModeAuto: + return "auto" + default: + return "unknown" + } +} + +// ThinkingLevel represents a discrete thinking level. +type ThinkingLevel string + +const ( + // LevelNone disables thinking + LevelNone ThinkingLevel = "none" + // LevelAuto enables automatic/dynamic thinking + LevelAuto ThinkingLevel = "auto" + // LevelMinimal sets minimal thinking effort + LevelMinimal ThinkingLevel = "minimal" + // LevelLow sets low thinking effort + LevelLow ThinkingLevel = "low" + // LevelMedium sets medium thinking effort + LevelMedium ThinkingLevel = "medium" + // LevelHigh sets high thinking effort + LevelHigh ThinkingLevel = "high" + // LevelXHigh sets extra-high thinking effort + LevelXHigh ThinkingLevel = "xhigh" +) + +// ThinkingConfig represents a unified thinking configuration. +// +// This struct is used to pass thinking configuration information between components. +// Depending on Mode, either Budget or Level field is effective: +// - ModeNone: Budget=0, Level is ignored +// - ModeAuto: Budget=-1, Level is ignored +// - ModeBudget: Budget is a positive integer, Level is ignored +// - ModeLevel: Budget is ignored, Level is a valid level +type ThinkingConfig struct { + // Mode specifies the configuration mode + Mode ThinkingMode + // Budget is the thinking budget (token count), only effective when Mode is ModeBudget. + // Special values: 0 means disabled, -1 means automatic + Budget int + // Level is the thinking level, only effective when Mode is ModeLevel + Level ThinkingLevel +} + +// SuffixResult represents the result of parsing a model name for thinking suffix. +// +// A thinking suffix is specified in the format model-name(value), where value +// can be a numeric budget (e.g., "16384") or a level name (e.g., "high"). +type SuffixResult struct { + // ModelName is the model name with the suffix removed. + // If no suffix was found, this equals the original input. + ModelName string + + // HasSuffix indicates whether a valid suffix was found. + HasSuffix bool + + // RawSuffix is the content inside the parentheses, without the parentheses. + // Empty string if HasSuffix is false. + RawSuffix string +} + +// ProviderApplier defines the interface for provider-specific thinking configuration application. +// +// Types implementing this interface are responsible for converting a unified ThinkingConfig +// into provider-specific format and applying it to the request body. +// +// Implementation requirements: +// - Apply method must be idempotent +// - Must not modify the input config or modelInfo +// - Returns a modified copy of the request body +// - Returns appropriate ThinkingError for unsupported configurations +type ProviderApplier interface { + // Apply applies the thinking configuration to the request body. + // + // Parameters: + // - body: Original request body JSON + // - config: Unified thinking configuration + // - modelInfo: Model registry information containing ThinkingSupport properties + // + // Returns: + // - Modified request body JSON + // - ThinkingError if the configuration is invalid or unsupported + Apply(body []byte, config ThinkingConfig, modelInfo *registry.ModelInfo) ([]byte, error) +} diff --git a/internal/thinking/validate.go b/internal/thinking/validate.go new file mode 100644 index 00000000..f082ad56 --- /dev/null +++ b/internal/thinking/validate.go @@ -0,0 +1,378 @@ +// Package thinking provides unified thinking configuration processing logic. +package thinking + +import ( + "fmt" + "strings" + + "github.com/router-for-me/CLIProxyAPI/v6/internal/registry" + log "github.com/sirupsen/logrus" +) + +// ValidateConfig validates a thinking configuration against model capabilities. +// +// This function performs comprehensive validation: +// - Checks if the model supports thinking +// - Auto-converts between Budget and Level formats based on model capability +// - Validates that requested level is in the model's supported levels list +// - Clamps budget values to model's allowed range +// - When converting Budget -> Level for level-only models, clamps the derived standard level to the nearest supported level +// (special values none/auto are preserved) +// - When config comes from a model suffix, strict budget validation is disabled (we clamp instead of error) +// +// Parameters: +// - config: The thinking configuration to validate +// - support: Model's ThinkingSupport properties (nil means no thinking support) +// - fromFormat: Source provider format (used to determine strict validation rules) +// - toFormat: Target provider format +// - fromSuffix: Whether config was sourced from model suffix +// +// Returns: +// - Normalized ThinkingConfig with clamped values +// - ThinkingError if validation fails (ErrThinkingNotSupported, ErrLevelNotSupported, etc.) +// +// Auto-conversion behavior: +// - Budget-only model + Level config → Level converted to Budget +// - Level-only model + Budget config → Budget converted to Level +// - Hybrid model → preserve original format +func ValidateConfig(config ThinkingConfig, modelInfo *registry.ModelInfo, fromFormat, toFormat string, fromSuffix bool) (*ThinkingConfig, error) { + fromFormat, toFormat = strings.ToLower(strings.TrimSpace(fromFormat)), strings.ToLower(strings.TrimSpace(toFormat)) + model := "unknown" + support := (*registry.ThinkingSupport)(nil) + if modelInfo != nil { + if modelInfo.ID != "" { + model = modelInfo.ID + } + support = modelInfo.Thinking + } + + if support == nil { + if config.Mode != ModeNone { + return nil, NewThinkingErrorWithModel(ErrThinkingNotSupported, "thinking not supported for this model", model) + } + return &config, nil + } + + allowClampUnsupported := isBudgetBasedProvider(fromFormat) && isLevelBasedProvider(toFormat) + strictBudget := !fromSuffix && fromFormat != "" && isSameProviderFamily(fromFormat, toFormat) + budgetDerivedFromLevel := false + + capability := detectModelCapability(modelInfo) + switch capability { + case CapabilityBudgetOnly: + if config.Mode == ModeLevel { + if config.Level == LevelAuto { + break + } + budget, ok := ConvertLevelToBudget(string(config.Level)) + if !ok { + return nil, NewThinkingError(ErrUnknownLevel, fmt.Sprintf("unknown level: %s", config.Level)) + } + config.Mode = ModeBudget + config.Budget = budget + config.Level = "" + budgetDerivedFromLevel = true + } + case CapabilityLevelOnly: + if config.Mode == ModeBudget { + level, ok := ConvertBudgetToLevel(config.Budget) + if !ok { + return nil, NewThinkingError(ErrUnknownLevel, fmt.Sprintf("budget %d cannot be converted to a valid level", config.Budget)) + } + // When converting Budget -> Level for level-only models, clamp the derived standard level + // to the nearest supported level. Special values (none/auto) are preserved. + config.Mode = ModeLevel + config.Level = clampLevel(ThinkingLevel(level), modelInfo, toFormat) + config.Budget = 0 + } + case CapabilityHybrid: + } + + if config.Mode == ModeLevel && config.Level == LevelNone { + config.Mode = ModeNone + config.Budget = 0 + config.Level = "" + } + if config.Mode == ModeLevel && config.Level == LevelAuto { + config.Mode = ModeAuto + config.Budget = -1 + config.Level = "" + } + if config.Mode == ModeBudget && config.Budget == 0 { + config.Mode = ModeNone + config.Level = "" + } + + if len(support.Levels) > 0 && config.Mode == ModeLevel { + if !isLevelSupported(string(config.Level), support.Levels) { + if allowClampUnsupported { + config.Level = clampLevel(config.Level, modelInfo, toFormat) + } + if !isLevelSupported(string(config.Level), support.Levels) { + // User explicitly specified an unsupported level - return error + // (budget-derived levels may be clamped based on source format) + validLevels := normalizeLevels(support.Levels) + message := fmt.Sprintf("level %q not supported, valid levels: %s", strings.ToLower(string(config.Level)), strings.Join(validLevels, ", ")) + return nil, NewThinkingError(ErrLevelNotSupported, message) + } + } + } + + if strictBudget && config.Mode == ModeBudget && !budgetDerivedFromLevel { + min, max := support.Min, support.Max + if min != 0 || max != 0 { + if config.Budget < min || config.Budget > max || (config.Budget == 0 && !support.ZeroAllowed) { + message := fmt.Sprintf("budget %d out of range [%d,%d]", config.Budget, min, max) + return nil, NewThinkingError(ErrBudgetOutOfRange, message) + } + } + } + + // Convert ModeAuto to mid-range if dynamic not allowed + if config.Mode == ModeAuto && !support.DynamicAllowed { + config = convertAutoToMidRange(config, support, toFormat, model) + } + + if config.Mode == ModeNone && toFormat == "claude" { + // Claude supports explicit disable via thinking.type="disabled". + // Keep Budget=0 so applier can omit budget_tokens. + config.Budget = 0 + config.Level = "" + } else { + switch config.Mode { + case ModeBudget, ModeAuto, ModeNone: + config.Budget = clampBudget(config.Budget, modelInfo, toFormat) + } + + // ModeNone with clamped Budget > 0: set Level to lowest for Level-only/Hybrid models + // This ensures Apply layer doesn't need to access support.Levels + if config.Mode == ModeNone && config.Budget > 0 && len(support.Levels) > 0 { + config.Level = ThinkingLevel(support.Levels[0]) + } + } + + return &config, nil +} + +// convertAutoToMidRange converts ModeAuto to a mid-range value when dynamic is not allowed. +// +// This function handles the case where a model does not support dynamic/auto thinking. +// The auto mode is silently converted to a fixed value based on model capability: +// - Level-only models: convert to ModeLevel with LevelMedium +// - Budget models: convert to ModeBudget with mid = (Min + Max) / 2 +// +// Logging: +// - Debug level when conversion occurs +// - Fields: original_mode, clamped_to, reason +func convertAutoToMidRange(config ThinkingConfig, support *registry.ThinkingSupport, provider, model string) ThinkingConfig { + // For level-only models (has Levels but no Min/Max range), use ModeLevel with medium + if len(support.Levels) > 0 && support.Min == 0 && support.Max == 0 { + config.Mode = ModeLevel + config.Level = LevelMedium + config.Budget = 0 + log.WithFields(log.Fields{ + "provider": provider, + "model": model, + "original_mode": "auto", + "clamped_to": string(LevelMedium), + }).Debug("thinking: mode converted, dynamic not allowed, using medium level |") + return config + } + + // For budget models, use mid-range budget + mid := (support.Min + support.Max) / 2 + if mid <= 0 && support.ZeroAllowed { + config.Mode = ModeNone + config.Budget = 0 + } else if mid <= 0 { + config.Mode = ModeBudget + config.Budget = support.Min + } else { + config.Mode = ModeBudget + config.Budget = mid + } + log.WithFields(log.Fields{ + "provider": provider, + "model": model, + "original_mode": "auto", + "clamped_to": config.Budget, + }).Debug("thinking: mode converted, dynamic not allowed |") + return config +} + +// standardLevelOrder defines the canonical ordering of thinking levels from lowest to highest. +var standardLevelOrder = []ThinkingLevel{LevelMinimal, LevelLow, LevelMedium, LevelHigh, LevelXHigh} + +// clampLevel clamps the given level to the nearest supported level. +// On tie, prefers the lower level. +func clampLevel(level ThinkingLevel, modelInfo *registry.ModelInfo, provider string) ThinkingLevel { + model := "unknown" + var supported []string + if modelInfo != nil { + if modelInfo.ID != "" { + model = modelInfo.ID + } + if modelInfo.Thinking != nil { + supported = modelInfo.Thinking.Levels + } + } + + if len(supported) == 0 || isLevelSupported(string(level), supported) { + return level + } + + pos := levelIndex(string(level)) + if pos == -1 { + return level + } + bestIdx, bestDist := -1, len(standardLevelOrder)+1 + + for _, s := range supported { + if idx := levelIndex(strings.TrimSpace(s)); idx != -1 { + if dist := abs(pos - idx); dist < bestDist || (dist == bestDist && idx < bestIdx) { + bestIdx, bestDist = idx, dist + } + } + } + + if bestIdx >= 0 { + clamped := standardLevelOrder[bestIdx] + log.WithFields(log.Fields{ + "provider": provider, + "model": model, + "original_value": string(level), + "clamped_to": string(clamped), + }).Debug("thinking: level clamped |") + return clamped + } + return level +} + +// clampBudget clamps a budget value to the model's supported range. +func clampBudget(value int, modelInfo *registry.ModelInfo, provider string) int { + model := "unknown" + support := (*registry.ThinkingSupport)(nil) + if modelInfo != nil { + if modelInfo.ID != "" { + model = modelInfo.ID + } + support = modelInfo.Thinking + } + if support == nil { + return value + } + + // Auto value (-1) passes through without clamping. + if value == -1 { + return value + } + + min, max := support.Min, support.Max + if value == 0 && !support.ZeroAllowed { + log.WithFields(log.Fields{ + "provider": provider, + "model": model, + "original_value": value, + "clamped_to": min, + "min": min, + "max": max, + }).Warn("thinking: budget zero not allowed |") + return min + } + + // Some models are level-only and do not define numeric budget ranges. + if min == 0 && max == 0 { + return value + } + + if value < min { + if value == 0 && support.ZeroAllowed { + return 0 + } + logClamp(provider, model, value, min, min, max) + return min + } + if value > max { + logClamp(provider, model, value, max, min, max) + return max + } + return value +} + +func isLevelSupported(level string, supported []string) bool { + for _, s := range supported { + if strings.EqualFold(level, strings.TrimSpace(s)) { + return true + } + } + return false +} + +func levelIndex(level string) int { + for i, l := range standardLevelOrder { + if strings.EqualFold(level, string(l)) { + return i + } + } + return -1 +} + +func normalizeLevels(levels []string) []string { + out := make([]string, len(levels)) + for i, l := range levels { + out[i] = strings.ToLower(strings.TrimSpace(l)) + } + return out +} + +func isBudgetBasedProvider(provider string) bool { + switch provider { + case "gemini", "gemini-cli", "antigravity", "claude": + return true + default: + return false + } +} + +func isLevelBasedProvider(provider string) bool { + switch provider { + case "openai", "openai-response", "codex": + return true + default: + return false + } +} + +func isGeminiFamily(provider string) bool { + switch provider { + case "gemini", "gemini-cli", "antigravity": + return true + default: + return false + } +} + +func isSameProviderFamily(from, to string) bool { + if from == to { + return true + } + return isGeminiFamily(from) && isGeminiFamily(to) +} + +func abs(x int) int { + if x < 0 { + return -x + } + return x +} + +func logClamp(provider, model string, original, clampedTo, min, max int) { + log.WithFields(log.Fields{ + "provider": provider, + "model": model, + "original_value": original, + "min": min, + "max": max, + "clamped_to": clampedTo, + }).Debug("thinking: budget clamped |") +}