diff --git a/litellm/litellm_core_utils/prompt_templates/factory.py b/litellm/litellm_core_utils/prompt_templates/factory.py index 22e0ea2cc33..0c7068b338b 100644 --- a/litellm/litellm_core_utils/prompt_templates/factory.py +++ b/litellm/litellm_core_utils/prompt_templates/factory.py @@ -2330,19 +2330,13 @@ def sanitize_messages_for_tool_calling( def _is_unsignable_thinking_block(block: object) -> bool: """A `thinking` block that Anthropic cannot accept on input. - Anthropic verifies the thinking signature cryptographically, so a block whose - signature is null, empty, or missing (e.g. from an open-source reasoning model) - is rejected with a 400 and must be dropped rather than blanked or repaired. - `redacted_thinking` blocks carry no signature and are always kept. - - Anthropic also rejects a `thinking` block whose `thinking` text is empty or - whitespace-only ("each thinking block must contain thinking"), regardless of - signature. This shape reaches us when a caller replays a `thinking_blocks` - history item that originated from a non-Anthropic reasoning provider (e.g. an - OpenAI Responses-API turn with no summary text) through this Anthropic-shaped - request path (`/v1/chat/completions` -> anthropic/vertex_ai's claude models), - which is the same failure the Anthropic Responses-bridge adapter guards - against (see PR #36033) for its own separate content-block path. + Anthropic verifies the signature cryptographically, so a block with a null, + empty, or missing signature (e.g. from an open-source reasoning model) is + rejected with a 400. It also rejects a `thinking` block whose text is empty + or whitespace-only ("each thinking block must contain thinking"), regardless + of signature, e.g. when a `thinking_blocks` history item from a non-Anthropic + reasoning provider is replayed through this path. `redacted_thinking` blocks + carry no signature and are always kept. """ if not isinstance(block, dict) or block.get("type") != "thinking": return False diff --git a/tests/test_litellm/litellm_core_utils/prompt_templates/test_litellm_core_utils_prompt_templates_factory.py b/tests/test_litellm/litellm_core_utils/prompt_templates/test_litellm_core_utils_prompt_templates_factory.py index 532193f2a7f..e4227a0924d 100644 --- a/tests/test_litellm/litellm_core_utils/prompt_templates/test_litellm_core_utils_prompt_templates_factory.py +++ b/tests/test_litellm/litellm_core_utils/prompt_templates/test_litellm_core_utils_prompt_templates_factory.py @@ -3519,14 +3519,7 @@ async def test_bedrock_converse_pdf_only_user_message_gets_text_block_async(): def test_anthropic_messages_pt_drops_empty_but_signed_thinking_block(): - """ - Anthropic rejects a `thinking` block whose `thinking` text is empty, even - when it carries a valid-looking signature, with: - 400 messages.N.content.M.thinking: each thinking block must contain thinking - This shape is reachable via cross-provider replay of a `thinking_blocks` - history item (see PR #36033), so `_is_unsignable_thinking_block()` must - also check the thinking text, not just the signature. - """ + """An empty-but-signed thinking block must still be dropped.""" from litellm.litellm_core_utils.prompt_templates.factory import ( anthropic_messages_pt, ) @@ -3559,10 +3552,7 @@ def test_anthropic_messages_pt_drops_empty_but_signed_thinking_block(): def test_anthropic_messages_pt_keeps_non_empty_signed_thinking_block(): - """ - Regression: a real, non-empty, signed thinking block must still pass - through unchanged. - """ + """Regression: a non-empty, signed thinking block passes through unchanged.""" from litellm.litellm_core_utils.prompt_templates.factory import ( anthropic_messages_pt, ) @@ -3597,11 +3587,7 @@ def test_anthropic_messages_pt_keeps_non_empty_signed_thinking_block(): def test_anthropic_messages_pt_keeps_redacted_thinking_block(): - """ - Regression: `redacted_thinking` blocks carry no signature and no plaintext - `thinking` field by design, and must always be kept regardless of the new - emptiness check (which only applies to `type == "thinking"` blocks). - """ + """Regression: redacted_thinking blocks are unaffected by the emptiness check.""" from litellm.litellm_core_utils.prompt_templates.factory import ( anthropic_messages_pt, ) @@ -3633,11 +3619,7 @@ def test_anthropic_messages_pt_keeps_redacted_thinking_block(): def test_anthropic_messages_pt_drops_unsigned_thinking_block(): - """ - Regression (pre-existing behaviour): a thinking block with no signature - (or an empty/null one) must still be dropped, independent of whether the - thinking text is populated. - """ + """Regression: an unsigned thinking block is still dropped, regardless of text.""" from litellm.litellm_core_utils.prompt_templates.factory import ( anthropic_messages_pt, ) @@ -3670,24 +3652,7 @@ def test_anthropic_messages_pt_drops_unsigned_thinking_block(): def test_is_unsignable_thinking_block_treats_whitespace_only_as_empty(): - """ - Edge case: a `thinking` field that is present but whitespace-only (e.g. - a single trailing newline forwarded from another provider's empty - reasoning summary) is functionally empty and Anthropic's API will still - reject it with "each thinking block must contain thinking". We treat it - the same as a fully empty string and drop the block. - - Note the sibling check ~30 lines below this function's definition - (the "don't pass empty text blocks" comment) uses a bare - `len(thinking_block) > 0`, which by itself would treat whitespace-only - text as non-empty. That sibling check is always combined with - `not _is_unsignable_thinking_block(m)` in an `and`, so this function's - stricter whitespace-aware check is still the one that decides whether a - whitespace-only block survives — the two checks don't disagree in - practice, but this function is intentionally the stricter of the two - since it is also called standalone (via `_drop_unsignable_thinking_blocks`) - without that extra `len(...) > 0` guard. - """ + """Whitespace-only `thinking` text is treated as empty and dropped.""" from litellm.litellm_core_utils.prompt_templates.factory import ( _is_unsignable_thinking_block, )