fix(providers/anthropic): convert reasoning effort to budget thinking on pre-4.6 models

Effort previously always sent thinking type "adaptive" plus
output_config.effort, which models older than Claude 4.6 reject with
an HTTP 400 ("adaptive thinking is not supported on this model").

- Gate the adaptive path on supportsAdaptiveThinking (Claude >= 4.6,
  parsed from the model ID, tolerant of Bedrock prefixes and both
  name orders; unparseable names are treated as legacy).
- On legacy models, convert effort into enabled thinking with a
  budget derived from max_tokens (ratios mirror the coder/aibridge
  shim), omitting thinking when the budget would fall below the
  API's 1024-token minimum.
- Normalize effort values outside the output_config.effort enum:
  minimal maps to low, xhigh maps to max, and none disables thinking
  entirely.

Author: ibetitsmike

providers/anthropic/anthropic.go

@@ -58,6 +58,122 @@ func requiresAdaptiveThinking(model string) bool {
 	return defaultsToAdaptiveThinking(model) || defaultsToOmittedOpusThinkingDisplay(model)
 }
 
+// Claude models before 4.6 reject adaptive thinking. Unknown versions use
+// legacy budget thinking unless explicitly allowlisted.
+func supportsAdaptiveThinking(model string) bool {
+	if defaultsToAdaptiveThinking(model) {
+		return true
+	}
+	major, minor, ok := claudeVersion(model)
+	if !ok {
+		return false
+	}
+	return major > 4 || (major == 4 && minor >= 6)
+}
+
+func claudeVersion(model string) (major, minor int, ok bool) {
+	model = strings.ToLower(strings.TrimSpace(model))
+	_, rest, found := strings.Cut(model, "claude-")
+	if !found {
+		return 0, 0, false
+	}
+	parts := strings.Split(rest, "-")
+	for i, part := range parts {
+		v, valid := shortVersionComponent(part)
+		if !valid {
+			continue
+		}
+		major = v
+		if i+1 < len(parts) {
+			if m, validMinor := shortVersionComponent(parts[i+1]); validMinor {
+				minor = m
+			}
+		}
+		return major, minor, true
+	}
+	return 0, 0, false
+}
+
+func shortVersionComponent(s string) (int, bool) {
+	if len(s) == 0 || len(s) > 2 {
+		return 0, false
+	}
+	v, err := strconv.Atoi(s)
+	if err != nil {
+		return 0, false
+	}
+	return v, true
+}
+
+// Anthropic accepts only low, medium, high, or max for output_config.effort.
+func normalizeEffort(effort Effort) Effort {
+	switch effort {
+	case EffortMinimal:
+		return EffortLow
+	case EffortXHigh:
+		return EffortMax
+	default:
+		return effort
+	}
+}
+
+// Anthropic requires at least 1024 thinking tokens. Smaller derived budgets
+// disable thinking to preserve the requested output limit.
+func legacyEffortBudget(effort Effort, maxTokens int64) int64 {
+	const minBudget = 1024
+	var budget int64
+	switch effort {
+	case EffortMinimal:
+		budget = minBudget
+	case EffortLow:
+		budget = int64(float64(maxTokens) * 0.2)
+	case EffortHigh:
+		budget = int64(float64(maxTokens) * 0.8)
+	case EffortXHigh:
+		budget = int64(float64(maxTokens) * 0.9)
+	case EffortMax:
+		budget = int64(float64(maxTokens) * 0.95)
+	default:
+		budget = int64(float64(maxTokens) * 0.5)
+	}
+	// budget_tokens must be strictly less than max_tokens.
+	if budget >= maxTokens {
+		budget = maxTokens - 1
+	}
+	if budget < minBudget {
+		return 0
+	}
+	return budget
+}
+
+func stripThinkingUnsupportedParams(params *anthropic.MessageNewParams, call fantasy.Call, warnings []fantasy.CallWarning) []fantasy.CallWarning {
+	if call.Temperature != nil {
+		params.Temperature = param.Opt[float64]{}
+		warnings = append(warnings, fantasy.CallWarning{
+			Type:    fantasy.CallWarningTypeUnsupportedSetting,
+			Setting: "temperature",
+			Details: "temperature is not supported when thinking is enabled",
+		})
+	}
+	if call.TopP != nil {
+		params.TopP = param.Opt[float64]{}
+		warnings = append(warnings, fantasy.CallWarning{
+			Type:    fantasy.CallWarningTypeUnsupportedSetting,
+			Setting: "TopP",
+			Details: "TopP is not supported when thinking is enabled",
+		})
+	}
+	if call.TopK != nil {
+		params.TopK = param.Opt[int64]{}
+		warnings = append(warnings, fantasy.CallWarning{
+			Type:    fantasy.CallWarningTypeUnsupportedSetting,
+			Setting: "TopK",
+			Details: "TopK is not supported when thinking is enabled",
+		})
+	}
+	return warnings
+}
+
 func setThinkingDisplay(param interface{ SetExtraFields(map[string]any) }, display ThinkingDisplay) {
 	param.SetExtraFields(map[string]any{"display": string(display)})
 }
@@ -392,14 +508,27 @@ func (a languageModel) prepareParams(call fantasy.Call) (
 	switch {
 	case providerOptions.Effort != nil:
 		effort := *providerOptions.Effort
-		params.OutputConfig = anthropic.OutputConfigParam{
-			Effort: anthropic.OutputConfigEffort(effort),
-		}
-		adaptive := anthropic.NewThinkingConfigAdaptiveParam()
-		if display, ok := thinkingDisplay(providerOptions, a.modelID); ok {
-			setThinkingDisplay(&adaptive, display)
+		switch {
+		case effort == EffortNone:
+			// An explicit none overrides models that default to adaptive thinking.
+		case supportsAdaptiveThinking(a.modelID):
+			params.OutputConfig = anthropic.OutputConfigParam{
+				Effort: anthropic.OutputConfigEffort(normalizeEffort(effort)),
+			}
+			adaptive := anthropic.NewThinkingConfigAdaptiveParam()
+			if display, ok := thinkingDisplay(providerOptions, a.modelID); ok {
+				setThinkingDisplay(&adaptive, display)
+			}
+			params.Thinking.OfAdaptive = &adaptive
+		default:
+			if budget := legacyEffortBudget(effort, params.MaxTokens); budget > 0 {
+				params.Thinking = anthropic.ThinkingConfigParamOfEnabled(budget)
+				if display, ok := thinkingDisplay(providerOptions, a.modelID); ok {
+					setThinkingDisplay(params.Thinking.OfEnabled, display)
+				}
+				warnings = stripThinkingUnsupportedParams(params, call, warnings)
+			}
 		}
-		params.Thinking.OfAdaptive = &adaptive
 	case providerOptions.Thinking != nil:
 		if providerOptions.Thinking.BudgetTokens == 0 {
 			return nil, nil, nil, nil, &fantasy.Error{Title: "no budget", Message: "thinking requires budget"}
@@ -416,30 +545,7 @@ func (a languageModel) prepareParams(call fantasy.Call) (
 				setThinkingDisplay(params.Thinking.OfEnabled, display)
 			}
 		}
-		if call.Temperature != nil {
-			params.Temperature = param.Opt[float64]{}
-			warnings = append(warnings, fantasy.CallWarning{
-				Type:    fantasy.CallWarningTypeUnsupportedSetting,
-				Setting: "temperature",
-				Details: "temperature is not supported when thinking is enabled",
-			})
-		}
-		if call.TopP != nil {
-			params.TopP = param.Opt[float64]{}
-			warnings = append(warnings, fantasy.CallWarning{
-				Type:    fantasy.CallWarningTypeUnsupportedSetting,
-				Setting: "TopP",
-				Details: "TopP is not supported when thinking is enabled",
-			})
-		}
-		if call.TopK != nil {
-			params.TopK = param.Opt[int64]{}
-			warnings = append(warnings, fantasy.CallWarning{
-				Type:    fantasy.CallWarningTypeUnsupportedSetting,
-				Setting: "TopK",
-				Details: "TopK is not supported when thinking is enabled",
-			})
-		}
+		warnings = stripThinkingUnsupportedParams(params, call, warnings)
 	case defaultsToAdaptiveThinking(a.modelID):
 		adaptive := anthropic.NewThinkingConfigAdaptiveParam()
 		if display, ok := thinkingDisplay(providerOptions, a.modelID); ok {