fix(llms): remove stale xhigh/max clamp in GetEffort

GetEffort was silently downgrading ReasoningXHigh/ReasoningMax to
ReasoningHigh on the non-adaptive (effort/budget) path. Now that
OpenAI-compatible providers such as GPT-5.5 and GLM-5.2 accept
reasoning_effort=xhigh/max natively, the clamp is incorrect and
prevents those levels from reaching the API.

Update the GetEffort table tests to assert pass-through (they still
asserted the removed clamp), and drop the now-false "adaptive-only"
wording from the GetTokens budget comment. GetTokens itself still maps
xhigh/max to the high token budget — there is no distinct budget tier.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: sirozha

llms/options.go

@@ -34,9 +34,9 @@ const (
 	ReasoningMedium ReasoningEffort = "medium"
 	ReasoningLow    ReasoningEffort = "low"
 	ReasoningNone   ReasoningEffort = ""
-	// ReasoningXHigh and ReasoningMax are adaptive-thinking efforts (Claude Opus 4.7+);
-	// pass them via WithAdaptiveReasoning. On the budget-token path they clamp to high
-	// (no provider has a distinct budget for them).
+	// ReasoningXHigh and ReasoningMax are the top reasoning efforts. Anthropic adaptive
+	// thinking (Claude Opus 4.7+) carries them via WithAdaptiveReasoning; OpenAI-compatible
+	// providers that expose them (e.g. GPT-5.5, GLM-5.2) accept them as reasoning_effort.
 	ReasoningXHigh ReasoningEffort = "xhigh"
 	ReasoningMax   ReasoningEffort = "max"
 )
@@ -83,12 +83,6 @@ func (r *ReasoningConfig) GetEffort(maxTokens int) ReasoningEffort {
 	}
 
 	if r.Effort != ReasoningNone {
-		// xhigh/max are adaptive-only; on the budget/effort path clamp them to high
-		// so callers never emit an effort the budget API rejects.
-		if r.Effort == ReasoningXHigh || r.Effort == ReasoningMax {
-			return ReasoningHigh
-		}
-
 		return r.Effort
 	}
 
@@ -139,7 +133,7 @@ func (r *ReasoningConfig) GetTokens(maxTokens int) int {
 		case ReasoningMedium:
 			tokens = max(maxTokens/3, 2048)
 		case ReasoningHigh, ReasoningXHigh, ReasoningMax:
-			// xhigh/max are adaptive-only; on the budget path treat them as high.
+			// no distinct token budget for xhigh/max; map them to the high budget.
 			tokens = max(maxTokens/2, 4096)
 		case ReasoningNone:
 			return 0 // disabled

llms/options_test.go

@@ -597,16 +597,16 @@ func TestReasoningConfig_GetEffort(t *testing.T) {
 			expected:  llms.ReasoningHigh,
 		},
 		{
-			name:      "xhigh effort clamps to high (adaptive-only on the effort path)",
+			name:      "xhigh effort passes through on the effort path",
 			config:    &llms.ReasoningConfig{Effort: llms.ReasoningXHigh},
 			maxTokens: maxTokens,
-			expected:  llms.ReasoningHigh,
+			expected:  llms.ReasoningXHigh,
 		},
 		{
-			name:      "max effort clamps to high (adaptive-only on the effort path)",
+			name:      "max effort passes through on the effort path",
 			config:    &llms.ReasoningConfig{Effort: llms.ReasoningMax},
 			maxTokens: maxTokens,
-			expected:  llms.ReasoningHigh,
+			expected:  llms.ReasoningMax,
 		},
 		{
 			name:      "config with low tokens",