fix(anthropic): translate adaptive thinking/effort to pre-4.6 model support

[mateo-berri]

Relevant issues

Copy of #32858, recreated on a litellm_ branch so CircleCI can run. All credit to the original author @akapur99; his commits (including the Opus 4.5 follow-up d49190e, merged in) are carried unchanged

Linear ticket

Pre-Submission checklist

Please complete all items before asking a LiteLLM maintainer to review your PR

• I have added meaningful tests
• My PR passes all CI/CD checks (e.g., lint, format, unit tests)
• My PR's scope is as isolated as possible; it only solves 1 specific problem
• I have received a Greptile Confidence Score of at least 4/5 before requesting a maintainer review (Greptile reviews automatically once the PR is opened; only comment @greptileai to re-request a review after pushing changes)

Delays in PR merge?

If you're seeing a delay in your PR being merged, ping the LiteLLM Team on Slack (#pr-review).

Screenshots / Proof of Fix

Real /v1/messages calls to the gateway hitting the live Anthropic API (no mocks), captured by the original author on the same commits carried by this PR. The claude-cli user-agent is what auto-enables drop_params, matching how Claude Code actually talks to the gateway

Before (base fdfb122573, model anthropic-haiku-4-5 -> anthropic/claude-haiku-4-5)

curl -s http://localhost:4000/v1/messages -H 'content-type: application/json' \
  -H 'x-api-key: sk-1234' -H 'user-agent: claude-cli/2.1.206 (external, cli)' \
  -d '{"model":"anthropic-haiku-4-5","max_tokens":8192,"thinking":{"type":"adaptive"},"output_config":{"effort":"medium"},"messages":[{"role":"user","content":"In one sentence, why is the sky blue?"}]}'

{"error":{"message":"{\"type\":\"error\",\"error\":{\"type\":\"invalid_request_error\",\"message\":\"This model does not support the effort parameter.\"},\"request_id\":\"req_011CcuEZT7SkY3Vh31RmcMGu\"} ...","code":"400"}}

After (fix commit bd1061c5)

# A) Haiku 4.5, realistic max_tokens: effort translated to legacy extended thinking
curl -s http://localhost:4000/v1/messages -H 'content-type: application/json' \
  -H 'x-api-key: sk-1234' -H 'user-agent: claude-cli/2.1.206 (external, cli)' \
  -d '{"model":"anthropic-haiku-4-5","max_tokens":8192,"thinking":{"type":"adaptive"},"output_config":{"effort":"medium"},"messages":[{"role":"user","content":"In one sentence, why is the sky blue?"}]}'
-> {"stop_reason":"end_turn","content":[{"type":"thinking",...},{"type":"text",...}]}

# B) Haiku 4.5, tiny max_tokens=1024: thinking dropped so the request still succeeds
curl ... '{"model":"anthropic-haiku-4-5","max_tokens":1024,"thinking":{"type":"adaptive"},"output_config":{"effort":"medium"}, ...}'
-> {"stop_reason":"end_turn","content":[{"type":"text",...}]}

# C) Sonnet 4.6 control: native adaptive interface passes through untouched
curl ... '{"model":"anthropic-sonnet-4-6","max_tokens":8192,"thinking":{"type":"adaptive"},"output_config":{"effort":"high"}, ...}'
-> {"stop_reason":"end_turn","content":[{"type":"thinking",...},{"type":"text",...}]}

Additionally, the Opus 4.5 gap found in review was reproduced and verified against the live Anthropic API by the original author (see the reproduction in his comment): thinking:{type:adaptive} on claude-opus-4-5 returns 400 while output_config:{effort:medium} alone returns 200, which is exactly the split the final translation implements

Type

🐛 Bug Fix

Changes

Clients like Claude Code speak native Anthropic /v1/messages and send the 4.6+ adaptive-thinking interface (thinking:{type:adaptive} plus output_config:{effort:...}) on every request, regardless of which model the gateway routes to. When that reaches a pre-4.6 Anthropic model such as Haiku 4.5 or Sonnet 4.5, Anthropic rejects it with "This model does not support the effort parameter" and the request fails. The native passthrough previously only capability-gated the OpenAI-style reasoning_effort alias; native output_config and adaptive thinking were forwarded raw

AnthropicMessagesConfig now reshapes that interface to what the routed model actually supports, treating adaptive thinking and the effort param as the independent capabilities they are (supports_adaptive_thinking vs supports_output_config in the model map). Adaptive-thinking models (4.6+) pass through untouched. Models that accept output_config.effort natively but predate adaptive thinking (Claude Opus 4.5) keep their effort and only have the adaptive thinking block dropped; when the adaptive payload carries an effort level the model rejects (xhigh/max on Opus 4.5, and xhigh is Claude Code's default on newer models), it falls through to the legacy translation instead of forwarding a level Anthropic would 400 on. Effort-only requests (no adaptive thinking) are always left untouched, since provider subclasses own their level normalization; bedrock invoke clamps xhigh to the model's ceiling after this base transform runs, and consuming the effort in the base class broke that contract (caught by test_bedrock_messages_normalizes_output_config_effort_for_opus in CI). Thinking-capable models without effort support (Haiku 4.5, Sonnet 4.5) get the effort translated to a legacy thinking={type: enabled, budget_tokens} via the existing _map_reasoning_effort, preserving the caller's intent. Models with no reasoning support have thinking dropped. Because adaptive thinking carries no budget while the legacy form must satisfy Anthropic's max_tokens > budget_tokens rule, the translated budget is capped below max_tokens, and thinking is dropped when max_tokens cannot fit even the minimum budget so the request still succeeds. An unrecognized effort string surfaces as a clean 400 in the Anthropic error shape, matching the sibling _translate_reasoning_effort_to_anthropic

The reshape is silent rather than raising, matching how the messages path already strips unsupported output_config for older models on bedrock invoke (issue #22797); the goal is to keep the request working, not to fail it. Only the consumed effort key is removed from output_config; any residual (e.g. format) is left for the provider subclasses (bedrock, vertex) to handle, which is what keeps their existing strip and format-to-schema behavior intact. The non-Anthropic branches (Gemini via chat-completion transform, OpenAI/Azure via the Responses API) already performed this translation, so this change is scoped to the Anthropic-native passthrough

---

Note

Medium Risk
Touches hot-path request shaping for all Anthropic native /v1/messages traffic and branches on model capability flags; mistakes could change reasoning behavior or break Bedrock effort normalization contracts, though coverage is broad and changes are additive.

Overview
Fixes Anthropic /v1/messages passthrough so clients like Claude Code can send the 4.6+ thinking.type=adaptive and output_config.effort shape to older routed models without Anthropic 400s.

AnthropicMessagesConfig now runs _translate_adaptive_effort_for_non_adaptive_model during request transform (after the existing reasoning-effort and legacy→adaptive steps). Behavior is model-capability aware: 4.6+ unchanged; Opus 4.5 keeps native effort and drops only adaptive thinking (with unsupported levels like xhigh falling back to legacy budget thinking); Haiku/Sonnet 4.5 map effort to thinking={type: enabled, budget_tokens} via _map_reasoning_effort, with _cap_thinking_budget_to_max_tokens enforcing max_tokens > budget_tokens or silently dropping thinking when max_tokens is too small. Non-reasoning models drop both. Only effort is stripped from output_config; other keys (e.g. format) remain for Bedrock/Vertex subclasses. Invalid effort strings raise AnthropicError 400.

Adds test_anthropic_messages_effort.py covering Haiku/Sonnet 4.5, 4.6 passthrough, Opus 4.5 splits, budget capping, and drop paths.

^{Reviewed by Cursor Bugbot for commit bab0c13. Bugbot is set up for automated code reviews on this repo. Configure here.}

[mateo-berri]

@greptileai

---

Generated by Claude Code

[greptile-apps]

Greptile Summary

This PR adds _translate_adaptive_effort_for_non_adaptive_model to AnthropicMessagesConfig, translating the 4.6+ adaptive-thinking interface (thinking.type=adaptive + output_config.effort) to what pre-4.6 models actually support before forwarding requests to Anthropic, fixing the "This model does not support the effort parameter" 400 errors.

• Adaptive models (4.6+): pass through untouched via early return.
• Opus 4.5 (supports_output_config but no adaptive thinking): keeps output_config.effort natively; drops the adaptive thinking block; if the effort level is unsupported (e.g. xhigh), falls through to budget-based legacy thinking.
• Haiku/Sonnet 4.5 (supports_reasoning only): maps output_config.effort to legacy thinking={type:enabled, budget_tokens} via _map_reasoning_effort, capped below max_tokens, or dropped when max_tokens is too small; BedrockClaudePlatformMessagesConfig inherits the fix via subclassing.

Confidence Score: 5/5

Safe to merge — the transformation is scoped to the Anthropic messages passthrough, all capability routing reads from the model cost map (no hardcoded strings), and the three model-tier branches are each covered by regression tests that also protect the bedrock-inherit path.

All capability checks are driven by the model cost map rather than hardcoded version strings. The two previously flagged issues (missing BadRequestError guard and the Opus 4.5 early-return being too broad) are both addressed in this version. The _cap_thinking_budget_to_max_tokens helper correctly implements Anthropic's strict budget_tokens < max_tokens invariant. Thirteen unit tests cover the happy paths, edge cases (xhigh fallback, budget capping, residual output_config), and the clean-400 error surface. No existing tests are modified.

No files require special attention.

Important Files Changed

Filename	Overview
litellm/llms/anthropic/experimental_pass_through/messages/transformation.py	Adds _translate_adaptive_effort_for_non_adaptive_model and _cap_thinking_budget_to_max_tokens to reshape the 4.6+ adaptive-thinking interface for pre-4.6 Anthropic models; all capability checks are model-map driven and correctly differentiate the three model tiers (adaptive, output_config-only, reasoning-only, none).
tests/test_litellm/llms/anthropic/experimental_pass_through/messages/test_anthropic_messages_effort.py	Adds 13 pure-unit tests covering the major model-tier scenarios (Haiku/Sonnet 4.5, Opus 4.5 native effort, Opus 4.5 xhigh fallback, 4.6 passthrough, non-reasoning models, budget capping, and clean-400 on unknown effort); no real network calls.

_{Reviews (5): Last reviewed commit: "fix(anthropic): keep effort-only request..." | Re-trigger Greptile}

[greptile-apps]

Greptile Summary

Adds downgrade translation for the 4.6+ adaptive-thinking interface (thinking.type=adaptive + output_config.effort) when the Anthropic-native pass-through routes to a pre-4.6 model. Thinking-capable models get effort mapped to a legacy thinking.type=enabled with a capped budget; models with no reasoning support have thinking silently dropped so the request still succeeds.

• AnthropicMessagesConfig gains _translate_adaptive_effort_for_non_adaptive_model and _cap_thinking_budget_to_max_tokens, called at the end of transform_anthropic_messages_request after the existing reasoning-effort translators.
• A new unit-test file validates Haiku 4.5 / Sonnet 4.5 / Sonnet 4.6 / non-reasoning-model paths; it does not cover Claude Opus 4.5 with an adaptive-thinking payload, which is the one model where the guard bug described below is triggered.

Confidence Score: 3/5

The change achieves its stated goal for Haiku 4.5 and Sonnet 4.5, but the same failure mode it fixes (adaptive thinking forwarded raw to a model that does not support it) is reproduced for Claude Opus 4.5 through an overly broad guard condition.

The early-return guard in _translate_adaptive_effort_for_non_adaptive_model short-circuits for any model where _model_supports_effort_param returns True. Claude Opus 4.5 satisfies that predicate via supports_output_config: true in the model map, but it does not have supports_adaptive_thinking, so thinking.type=adaptive is forwarded untranslated to Anthropic and will be rejected. The test suite validates the Haiku 4.5 / Sonnet 4.5 / 4.6 paths correctly, but there is no test for Opus 4.5 with an adaptive-thinking payload, leaving this regression invisible until a live request hits it.

litellm/llms/anthropic/experimental_pass_through/messages/transformation.py — specifically the early-return guard on line 291 and the absence of a test for Claude Opus 4.5 with adaptive thinking.

Important Files Changed

Filename	Overview
litellm/llms/anthropic/experimental_pass_through/messages/transformation.py	Adds _translate_adaptive_effort_for_non_adaptive_model and _cap_thinking_budget_to_max_tokens; the early-return guard incorrectly skips translation for Claude Opus 4.5 because _model_supports_effort_param fires for that model even though it does not support adaptive thinking.
tests/test_litellm/llms/anthropic/experimental_pass_through/messages/test_anthropic_messages_effort.py	New unit test file covering effort translation for Haiku 4.5, Sonnet 4.5, Sonnet 4.6, and non-reasoning models; missing a test for Claude Opus 4.5 with adaptive thinking, which is the exact scenario affected by the guard bug.

_{Reviews (2): Last reviewed commit: "fix(anthropic): make adaptive-effort tra..." | Re-trigger Greptile}

[akapur99]

Greptile is right, this is a real bug and I reproduced it live against the Anthropic API.

Claude Opus 4.5 advertises supports_output_config: true (it accepts output_config.effort) but does not have supports_adaptive_thinking. The early-return guard treats those as the same capability, so for Opus 4.5 it short-circuits and forwards thinking:{type:adaptive} untranslated, which Anthropic rejects:

# opus-4-5 + thinking:{type:adaptive} + output_config:{effort:medium}  (the Claude Code payload)
HTTP 400  "adaptive thinking is not supported on this model"

# opus-4-5 + output_config:{effort:medium}  (no adaptive thinking)
HTTP 200  ok

So thinking.type=adaptive and output_config.effort are independent capabilities: adaptive thinking needs supports_adaptive_thinking, effort needs supports_output_config, and Opus 4.5 has only the latter. The fix is to early-return only for adaptive-thinking models, and for a model that supports output_config.effort but is not adaptive, keep the native effort and drop only the unsupported adaptive thinking block:

if AnthropicConfig._is_adaptive_thinking_model(model):
    return

output_config = optional_params.get("output_config")
thinking = optional_params.get("thinking")
effort = output_config.get("effort") if isinstance(output_config, dict) else None
adaptive_thinking = isinstance(thinking, dict) and thinking.get("type") == "adaptive"
if effort is None and not adaptive_thinking:
    return

if AnthropicConfig._model_supports_effort_param(model):
    if adaptive_thinking:
        optional_params.pop("thinking", None)
    return
# ... existing supports_reasoning / no-reasoning handling ...

After the fix, the Opus 4.5 Claude Code payload returns 200 with output_config.effort kept and the adaptive thinking block dropped. I pushed this with regression tests (Opus 4.5 with and without adaptive thinking) to my branch at akapur99/litellm@d49190e; feel free to pull it into this PR

[codspeed-hq]

Merging this PR will not alter performance

✅ 31 untouched benchmarks

---

_{Comparing litellm_translate_effort_pre46 (bab0c13) with litellm_internal_staging (4baf326)}

[mateo-berri]

@greptileai

---

Generated by Claude Code

[codecov]

Codecov Report

❌ Patch coverage is 97.67442% with 1 line in your changes missing coverage. Please review.

Files with missing lines	Patch %	Lines
...perimental_pass_through/messages/transformation.py	97.67%	1 Missing ⚠️

📢 Thoughts on this report? Let us know!

[mateo-berri]

@greptileai

---

Generated by Claude Code

[akapur99]

The All Other Providers failure looks like a test typo rather than a logic bug. The failing case is:

test_bedrock_messages_normalizes_output_config_effort_for_opus[anthropic.claude-opus-4-5-20251001-v1:0-high]
AssertionError: assert None == {"effort": "high"}

The parametrized model id uses the date 20251001, but the model map only has anthropic.claude-opus-4-5-20251101-v1:0 (note 20251101, Nov 1, not Oct 1). Because 20251001 is not a real map entry, AnthropicConfig._model_supports_effort_param resolves to False for it, so the translation treats it as a no-capability model and strips output_config.effort, hence the None.

_model_supports_effort_param("anthropic.claude-opus-4-5-20251001-v1:0")  # False
_model_supports_effort_param("anthropic.claude-opus-4-5-20251101-v1:0")  # True

Fix is a one-character date correction in the parametrize list (20251001 -> 20251101); with the real id the effort is preserved and the assertion passes. Worth double-checking the other opus parametrizations use ids that exist in the map too

[mateo-berri]

Thanks for digging into the job. The parametrize list turns out not to have the date typo though: line 917 of the test file reads anthropic.claude-opus-4-5-20251101-v1:0, the failing case in the CI log is [anthropic.claude-opus-4-5-20251101-v1:0-high], and _model_supports_effort_param resolves True for that id locally, so the map entry was never the problem

The actual cause was the xhigh fall-through added in db94548 on this branch. The test sends output_config:{effort:"xhigh"} with no thinking at all; the base transform treated xhigh as an unsupported level for Opus 4.5 and consumed it into a legacy thinking budget (hence the thinking:{type:"enabled","budget_tokens":4095} in the assertion output), so bedrock invoke's normalize_bedrock_opus_output_config_effort, which clamps xhigh to the model's ceiling after the base transform runs, had nothing left to clamp

Fixed in bab0c13 by restricting the fall-through to requests that actually carry thinking:{type:adaptive}. Effort-only requests now pass through untouched so provider subclasses keep owning level clamping, while the Claude Code adaptive payload with an unsupported level still degrades to the budget translation instead of being forwarded raw. Reproduced the failure and verified the fix locally against the full bedrock invoke test file (92 passed) and the passthrough suite (508 passed)

---

Generated by Claude Code

[mateo-berri]

@greptileai

---

Generated by Claude Code

[akapur99]

The bab0c13 fix looks right and matches what I traced; gating the legacy fall-through on the presence of thinking:{type:adaptive} keeps bedrock/vertex owning level clamping while still degrading the Claude Code adaptive payload. Nothing blocking here

One FYI for a possible follow-up, not for this PR: with the fall-through now scoped to adaptive requests, an effort-only payload (output_config:{effort:"xhigh"} with no thinking) sent to a model that supports output_config but not that level (e.g. Opus 4.5, which only accepts low/medium/high) still forwards the level raw on the direct Anthropic path, where there is no provider subclass to clamp it, so Anthropic returns a 400 ("Supported levels: high, low, medium"). Claude Code never hits this since it always sends the adaptive block, so it is niche. If it ever matters, clamping the level in the base transform via normalize_reasoning_effort_value (xhigh -> high) and keeping output_config would close it for the direct path too

[mateo-berri]

bugbot run

---

Generated by Claude Code

[cursor]

✅ Bugbot reviewed your changes and found no new issues!

Comment @cursor review or bugbot run to trigger another review on this PR

^{Reviewed by Cursor Bugbot for commit bab0c13. Configure here.}

[akapur99]

LGTM