diff --git a/litellm/llms/anthropic/experimental_pass_through/adapters/handler.py b/litellm/llms/anthropic/experimental_pass_through/adapters/handler.py index 87a29ca50ba..e89fcd52fc4 100644 --- a/litellm/llms/anthropic/experimental_pass_through/adapters/handler.py +++ b/litellm/llms/anthropic/experimental_pass_through/adapters/handler.py @@ -318,6 +318,20 @@ ANTHROPIC_ADAPTER: Final = AnthropicAdapter() class LiteLLMMessagesToCompletionTransformationHandler: + @staticmethod + def _is_thinking_disabled(thinking: Mapping | None) -> bool: + """Return True (suppressed) unless the client explicitly opted in. + + Only ``{"type": "enabled"|"adaptive"}`` enables the reasoning + translation. Absent, disabled, or malformed objects (missing + ``type``) fail closed: the request side + (``translate_anthropic_thinking_to_reasoning_effort``) already + defaults a missing ``type`` to ``disabled``, and a malformed + object must not surface provider ``reasoning_content`` through + a thinking block (review finding). + """ + return not (isinstance(thinking, dict) and thinking.get("type") in ("enabled", "adaptive")) + @staticmethod def _route_openai_thinking_to_responses_api_if_needed( completion_kwargs: _CompletionKwargs, @@ -615,6 +629,8 @@ class LiteLLMMessagesToCompletionTransformationHandler: completion_response: Final = await litellm.acompletion(**completion_kwargs) + thinking_disabled = LiteLLMMessagesToCompletionTransformationHandler._is_thinking_disabled(thinking) + if stream: transformed_stream: Final = ANTHROPIC_ADAPTER.translate_completion_output_params_streaming( completion_response, @@ -622,6 +638,7 @@ class LiteLLMMessagesToCompletionTransformationHandler: tool_name_mapping=tool_name_mapping, polyfill_result=polyfill_result, is_async=True, + thinking_disabled=thinking_disabled, litellm_logging_obj=litellm_logging_obj_from_kwargs(kwargs), ) if transformed_stream is not None: @@ -632,6 +649,7 @@ class LiteLLMMessagesToCompletionTransformationHandler: cast(ModelResponse, completion_response), tool_name_mapping=tool_name_mapping, polyfill_result=polyfill_result, + thinking_disabled=thinking_disabled, ) if anthropic_response is not None: return anthropic_response @@ -750,6 +768,8 @@ class LiteLLMMessagesToCompletionTransformationHandler: completion_response: Final = litellm.completion(**completion_kwargs) + thinking_disabled = LiteLLMMessagesToCompletionTransformationHandler._is_thinking_disabled(thinking) + if stream: transformed_stream: Final = ANTHROPIC_ADAPTER.translate_completion_output_params_streaming( completion_response, @@ -757,6 +777,7 @@ class LiteLLMMessagesToCompletionTransformationHandler: tool_name_mapping=tool_name_mapping, polyfill_result=polyfill_result, is_async=False, + thinking_disabled=thinking_disabled, litellm_logging_obj=litellm_logging_obj_from_kwargs(kwargs), ) if transformed_stream is not None: @@ -767,6 +788,7 @@ class LiteLLMMessagesToCompletionTransformationHandler: cast(ModelResponse, completion_response), tool_name_mapping=tool_name_mapping, polyfill_result=polyfill_result, + thinking_disabled=thinking_disabled, ) if anthropic_response is not None: return anthropic_response diff --git a/litellm/llms/anthropic/experimental_pass_through/adapters/streaming_iterator.py b/litellm/llms/anthropic/experimental_pass_through/adapters/streaming_iterator.py index e7179aad25b..e6321c6c6fc 100644 --- a/litellm/llms/anthropic/experimental_pass_through/adapters/streaming_iterator.py +++ b/litellm/llms/anthropic/experimental_pass_through/adapters/streaming_iterator.py @@ -31,7 +31,7 @@ from litellm.types.llms.anthropic import ( UsageDelta, UsageIteration, ) -from litellm.types.utils import AdapterCompletionStreamWrapper, Delta +from litellm.types.utils import AdapterCompletionStreamWrapper, Delta, StreamingChoices if TYPE_CHECKING: from litellm.litellm_core_utils.litellm_logging import Logging as LiteLLMLoggingObject @@ -300,7 +300,7 @@ class AnthropicStreamWrapper(AdapterCompletionStreamWrapper): sent_first_chunk: bool = False sent_content_block_start: bool = False sent_content_block_finish: bool = False - current_content_block_type: Literal["text", "tool_use", "thinking"] = "text" + current_content_block_type: Literal["text", "tool_use", "thinking", "redacted_thinking"] = "text" sent_last_message: bool = False holding_chunk: ContentBlockDelta | None = None holding_stop_reason_chunk: MessageBlockDelta | None = None @@ -315,6 +315,7 @@ class AnthropicStreamWrapper(AdapterCompletionStreamWrapper): applied_edits: list[AppliedEdit] | None = None, compaction_block: CompactionBlock | None = None, iterations_usage: list[UsageIteration] | None = None, + thinking_disabled: bool = False, litellm_logging_obj: "LiteLLMLoggingObject | None" = None, ): # Wrap the upstream stream so chunks that carry both content and a @@ -332,6 +333,7 @@ class AnthropicStreamWrapper(AdapterCompletionStreamWrapper): # Synthesized compaction block from compact_20260112 polyfill (streaming). self.compaction_block = compaction_block self.iterations_usage = iterations_usage + self.thinking_disabled = thinking_disabled self._refusal_text: str = "" self.sent_compaction_block: bool = False # Per-phase flags so the compaction block's start/delta/stop events @@ -584,6 +586,29 @@ class AnthropicStreamWrapper(AdapterCompletionStreamWrapper): elif should_start_new_block: self._increment_content_block_index() + is_final_chunk = chunk.choices[0].finish_reason is not None + + # Guard fired in _should_start_new_content_block: a + # non-substantial (empty/role-only) chunk arrived while a + # thinking block is open, and the guard suppressed the block + # TRANSITION (correctly, no spurious text block opens) but the + # chunk would still be translated below into an empty + # text_delta and emitted INSIDE the open thinking block — a + # block-type/delta-type mismatch, the exact class of bug this + # patch series exists to prevent. Suppress the chunk entirely. + # Exclude the finish chunk (it ALSO has should_start_new_block + # == False, per _should_start_new_content_block's own early + # `if chunk.choices[0].finish_reason is not None: return False` + # guard) — it must still flow through to close the block and + # emit message_delta/message_stop, not be silently dropped. + if ( + not should_start_new_block + and not is_final_chunk + and self.current_content_block_type in ("thinking", "redacted_thinking") + and not self._chunk_has_substantial_content(chunk, thinking_disabled=self.thinking_disabled) + ): + continue + # applied_edits only needs to flow to the final message_delta # (when finish_reason is set); skip threading it through every # intermediate chunk. For the hold-and-merge path below, @@ -594,11 +619,11 @@ class AnthropicStreamWrapper(AdapterCompletionStreamWrapper): will_merge_into_held = ( self.holding_stop_reason_chunk is not None and getattr(chunk, "usage", None) is not None ) - is_final_chunk = chunk.choices[0].finish_reason is not None processed_chunk = LiteLLMAnthropicMessagesAdapter().translate_streaming_openai_response_to_anthropic( response=chunk, current_content_block_index=self.current_content_block_index, applied_edits=(self.applied_edits if is_final_chunk and not will_merge_into_held else None), + thinking_disabled=self.thinking_disabled, ) processed_chunk = self._with_refusal_stop_details(processed_chunk) @@ -667,20 +692,24 @@ class AnthropicStreamWrapper(AdapterCompletionStreamWrapper): continue if processed_chunk["type"] == "message_delta" and self.sent_content_block_finish is False: - # Queue both the content_block_stop and the message_delta - self.chunk_queue.append( - { - "type": "content_block_stop", - "index": self.current_content_block_index, - } - ) + # Empty responses legitimately have no content block. Only + # close a block if one was actually opened. + if self.sent_content_block_start: + self.chunk_queue.append( + { + "type": "content_block_stop", + "index": self.current_content_block_index, + } + ) self.sent_content_block_finish = True if processed_chunk.get("delta", {}).get("stop_reason") is not None: self.holding_stop_reason_chunk = processed_chunk else: processed_chunk = self._augment_message_delta_usage(processed_chunk) self.chunk_queue.append(processed_chunk) - return self.chunk_queue.popleft() + if self.chunk_queue: + return self.chunk_queue.popleft() + continue elif self.holding_chunk is not None: self.chunk_queue.append(self.holding_chunk) if processed_chunk.get("type") == "message_delta": @@ -712,7 +741,7 @@ class AnthropicStreamWrapper(AdapterCompletionStreamWrapper): # valid Anthropic order (... -> content_block_stop -> # message_delta). Emit ``content_block_stop`` here if # the active content block was not already closed. - if not self.sent_content_block_finish: + if self.sent_content_block_start and not self.sent_content_block_finish: self.chunk_queue.append( { "type": "content_block_stop", @@ -741,7 +770,7 @@ class AnthropicStreamWrapper(AdapterCompletionStreamWrapper): # Anthropic SSE ordering is preserved (content_block_stop -> # message_delta). if self.holding_stop_reason_chunk is not None: - if not self.sent_content_block_finish: + if self.sent_content_block_start and not self.sent_content_block_finish: self.sent_content_block_finish = True self.chunk_queue.append(self._augment_message_delta_usage(self.holding_stop_reason_chunk)) self.holding_stop_reason_chunk = None @@ -819,6 +848,29 @@ class AnthropicStreamWrapper(AdapterCompletionStreamWrapper): elif should_start_new_block: self._increment_content_block_index() + is_final_chunk = chunk.choices[0].finish_reason is not None + + # Guard fired in _should_start_new_content_block: a + # non-substantial (empty/role-only) chunk arrived while a + # thinking block is open, and the guard suppressed the block + # TRANSITION (correctly, no spurious text block opens) but the + # chunk would still be translated below into an empty + # text_delta and emitted INSIDE the open thinking block — a + # block-type/delta-type mismatch, the exact class of bug this + # patch series exists to prevent. Suppress the chunk entirely. + # Exclude the finish chunk (it ALSO has should_start_new_block + # == False, per _should_start_new_content_block's own early + # `if chunk.choices[0].finish_reason is not None: return False` + # guard) — it must still flow through to close the block and + # emit message_delta/message_stop, not be silently dropped. + if ( + not should_start_new_block + and not is_final_chunk + and self.current_content_block_type in ("thinking", "redacted_thinking") + and not self._chunk_has_substantial_content(chunk, thinking_disabled=self.thinking_disabled) + ): + continue + # applied_edits only needs to flow to the final message_delta # (when finish_reason is set); skip threading it through every # intermediate chunk. For the hold-and-merge path below, @@ -829,11 +881,11 @@ class AnthropicStreamWrapper(AdapterCompletionStreamWrapper): will_merge_into_held = ( self.holding_stop_reason_chunk is not None and getattr(chunk, "usage", None) is not None ) - is_final_chunk = chunk.choices[0].finish_reason is not None processed_chunk = LiteLLMAnthropicMessagesAdapter().translate_streaming_openai_response_to_anthropic( response=chunk, current_content_block_index=self.current_content_block_index, applied_edits=(self.applied_edits if is_final_chunk and not will_merge_into_held else None), + thinking_disabled=self.thinking_disabled, ) processed_chunk = self._with_refusal_stop_details(processed_chunk) @@ -894,20 +946,24 @@ class AnthropicStreamWrapper(AdapterCompletionStreamWrapper): continue if processed_chunk["type"] == "message_delta" and self.sent_content_block_finish is False: - # Queue both the content_block_stop and the holding chunk - self.chunk_queue.append( - { - "type": "content_block_stop", - "index": self.current_content_block_index, - } - ) + # Empty responses legitimately have no content block. Only + # close a block if one was actually opened. + if self.sent_content_block_start: + self.chunk_queue.append( + { + "type": "content_block_stop", + "index": self.current_content_block_index, + } + ) self.sent_content_block_finish = True if processed_chunk.get("delta", {}).get("stop_reason") is not None: self.holding_stop_reason_chunk = processed_chunk else: processed_chunk = self._augment_message_delta_usage(processed_chunk) self.chunk_queue.append(processed_chunk) - return self.chunk_queue.popleft() + if self.chunk_queue: + return self.chunk_queue.popleft() + continue elif self.holding_chunk is not None: # Queue both chunks self.chunk_queue.append(self.holding_chunk) @@ -940,7 +996,7 @@ class AnthropicStreamWrapper(AdapterCompletionStreamWrapper): # valid Anthropic order (... -> content_block_stop -> # message_delta). Emit ``content_block_stop`` here if # the active content block was not already closed. - if not self.sent_content_block_finish: + if self.sent_content_block_start and not self.sent_content_block_finish: self.chunk_queue.append( { "type": "content_block_stop", @@ -974,7 +1030,7 @@ class AnthropicStreamWrapper(AdapterCompletionStreamWrapper): # Anthropic SSE ordering is preserved (content_block_stop -> # message_delta). if self.holding_stop_reason_chunk is not None: - if not self.sent_content_block_finish: + if self.sent_content_block_start and not self.sent_content_block_finish: self.sent_content_block_finish = True self.chunk_queue.append(self._augment_message_delta_usage(self.holding_stop_reason_chunk)) self.holding_stop_reason_chunk = None @@ -1088,7 +1144,65 @@ class AnthropicStreamWrapper(AdapterCompletionStreamWrapper): delta_type: Final = delta.get("type") if delta_type not in _STREAMING_DELTA_TYPES: return False - return bool(delta.get(_delta_payload_field(delta_type))) + # The membership test above is the runtime guard; the cast tells the type + # checker what it already proved, so the exhaustive match in + # _delta_payload_field keeps its compile-time value. + return bool(delta.get(_delta_payload_field(cast(StreamingContentBlockDeltaType, delta_type)))) + + @staticmethod + def _chunk_has_substantial_content(chunk: "ModelResponseStream", thinking_disabled: bool = False) -> bool: + """Return True when the chunk carries content that should determine or + continue a content block. Delegates to the shared classifier + (ADR-0022) so this check can never diverge from the block-type + classifier or delta emitter's own notion of substantiality — the + root cause of the CTG-85 corrected bug was exactly this kind of + divergence (this function previously used a truthy check while the + classifier used .strip()). + + Remains a @staticmethod with an explicit thinking_disabled parameter + (default False) rather than becoming an instance method, because two + pre-existing tests (test_empty_chunk_is_not_substantial, + test_reasoning_chunk_is_substantial) call it unbound as + AnthropicStreamWrapper._chunk_has_substantial_content(chunk) — converting + to an instance method would break those calls. + + The two sites' conditions are kept identical in code so they cannot + drift into two different notions of substantiality (the CTG-85 failure + mode). Rules mirrored from the classifier, per choice, with the same + getattr-with-default guards (Delta deletes reasoning_content / + thinking_blocks entirely when unset): + + - a reasoning-only chunk is not substantial when thinking is disabled; + - a structured thinking / redacted block is always substantial (even + with an empty payload) when thinking is enabled; + - a flat reasoning_content string is substantial only when it carries + non-whitespace, when thinking is enabled; + - a tool call with a function, and a truthy (NOT .strip()-based) text + content, are substantial regardless of thinking state.""" + for choice in chunk.choices: + reasoning_text = "" + has_structured_thinking_block = False + if isinstance(choice, StreamingChoices): + thinking_blocks = getattr(choice.delta, "thinking_blocks", None) or [] + if len(thinking_blocks) > 0: + first_block = thinking_blocks[0] + if first_block.get("type") in ("thinking", "redacted_thinking"): + has_structured_thinking_block = True + reasoning_text = str(first_block.get("thinking") or "") + if not has_structured_thinking_block: + reasoning_text = str(getattr(choice.delta, "reasoning_content", "") or "") + has_substantial_reasoning = bool(reasoning_text.strip()) or has_structured_thinking_block + has_tool_calls = ( + choice.delta.tool_calls is not None + and len(choice.delta.tool_calls) > 0 + and choice.delta.tool_calls[0].function is not None + ) + text_content = str(choice.delta.content or "") + if has_tool_calls or bool(text_content): + return True + if not thinking_disabled and has_substantial_reasoning: + return True + return False @staticmethod def _is_blank_delta(chunk: "ModelResponseStream") -> bool: @@ -1147,7 +1261,8 @@ class AnthropicStreamWrapper(AdapterCompletionStreamWrapper): block_type, content_block_start, ) = LiteLLMAnthropicMessagesAdapter()._translate_streaming_openai_chunk_to_anthropic_content_block( - choices=chunk.choices + choices=chunk.choices, + thinking_disabled=self.thinking_disabled, ) # Restore original tool name if it was truncated for OpenAI's 64-char limit @@ -1165,6 +1280,12 @@ class AnthropicStreamWrapper(AdapterCompletionStreamWrapper): tool_block["name"] = original_name if block_type != self.current_content_block_type: + if ( + block_type == "text" + and self.current_content_block_type in ("thinking", "redacted_thinking") + and not self._chunk_has_substantial_content(chunk, thinking_disabled=self.thinking_disabled) + ): + return False self.current_content_block_type = block_type self.current_content_block_start = content_block_start return True diff --git a/litellm/llms/anthropic/experimental_pass_through/adapters/transformation.py b/litellm/llms/anthropic/experimental_pass_through/adapters/transformation.py index 8ff9f2e0679..c63890cee8e 100644 --- a/litellm/llms/anthropic/experimental_pass_through/adapters/transformation.py +++ b/litellm/llms/anthropic/experimental_pass_through/adapters/transformation.py @@ -247,6 +247,7 @@ class AnthropicAdapter: response: ModelResponse, tool_name_mapping: dict[str, str] | None = None, polyfill_result: PolyfillResult | None = None, + thinking_disabled: bool = False, ) -> AnthropicMessagesResponse | None: """ Translate OpenAI response to Anthropic format. @@ -257,11 +258,13 @@ class AnthropicAdapter: Used to restore original names for tools that exceeded OpenAI's 64-char limit. polyfill_result: PolyfillResult from context_management polyfill. + thinking_disabled: When True, suppress reasoning_content → thinking block. """ return LiteLLMAnthropicMessagesAdapter().translate_openai_response_to_anthropic( response=response, tool_name_mapping=tool_name_mapping, polyfill_result=polyfill_result, + thinking_disabled=thinking_disabled, ) def translate_completion_output_params_streaming( @@ -271,6 +274,7 @@ class AnthropicAdapter: tool_name_mapping: dict[str, str] | None = None, polyfill_result: PolyfillResult | None = None, is_async: bool = True, + thinking_disabled: bool = False, litellm_logging_obj: "LiteLLMLoggingObject | None" = None, ) -> AsyncIterator[bytes] | Iterator[bytes] | None: """ @@ -298,6 +302,7 @@ class AnthropicAdapter: applied_edits=applied_edits, compaction_block=compaction_block, iterations_usage=iterations_usage, + thinking_disabled=thinking_disabled, litellm_logging_obj=litellm_logging_obj, ) # Return the SSE-wrapped version for proper event formatting. @@ -490,6 +495,7 @@ class LiteLLMAnthropicMessagesAdapter: has_cache_control_in_text = False tool_calls: list[ChatCompletionAssistantToolCall] = [] thinking_blocks: list[ChatCompletionThinkingBlock | ChatCompletionRedactedThinkingBlock] = [] + unsigned_thinking_texts: list[str] = [] if m["role"] == "assistant": if isinstance(m.get("content"), str): assistant_message_str = str(m.get("content", "")) @@ -533,16 +539,32 @@ class LiteLLMAnthropicMessagesAdapter: self._add_cache_control_if_applicable(content, tool_call, model) tool_calls.append(tool_call) elif content.get("type") == "thinking": + # Only include thinking blocks that have a real + # signature. Blocks synthesized from flat + # reasoning_content have no signature — passing + # them to Claude causes: + # "signature.str: Input should be a valid string" + # Strip them so multi-turn history stays clean. # Anthropic's schema has no cache_control on thinking or # redacted_thinking blocks, and anthropic_messages_pt replays # these verbatim at content[0], so carrying one here (or # inventing an empty one) is a guaranteed 400 on the way back. - thinking_block = ChatCompletionThinkingBlock( - type="thinking", - thinking=content.get("thinking") or "", - signature=content.get("signature") or "", - ) - thinking_blocks.append(thinking_block) + if content.get("signature"): + thinking_block = ChatCompletionThinkingBlock( + type="thinking", + thinking=content.get("thinking") or "", + signature=content.get("signature") or "", + ) + thinking_blocks.append(thinking_block) + else: + # Unsigned text is NOT dropped: it is + # replayed as the flat reasoning_content field + # below (the provider-visible form), while + # staying out of thinking_blocks, so the + # signature-400 stays avoided. + unsigned_text = str(content.get("thinking") or "") + if unsigned_text: + unsigned_thinking_texts.append(unsigned_text) elif content.get("type") == "redacted_thinking": redacted_thinking_block = ChatCompletionRedactedThinkingBlock( type="redacted_thinking", @@ -575,6 +597,9 @@ class LiteLLMAnthropicMessagesAdapter: if len(thinking_blocks) > 0: assistant_message["thinking_blocks"] = thinking_blocks reasoning_content = reasoning_content_from_thinking_blocks(thinking_blocks) + if unsigned_thinking_texts: + unsigned = "\n".join(unsigned_thinking_texts) + reasoning_content = f"{reasoning_content}\n{unsigned}" if reasoning_content else unsigned if reasoning_content: assistant_message["reasoning_content"] = reasoning_content new_messages.append(assistant_message) @@ -1281,6 +1306,7 @@ class LiteLLMAnthropicMessagesAdapter: self, choices: list[Choices], tool_name_mapping: dict[str, str] | None = None, + thinking_disabled: bool = False, ) -> list[dict[str, Any]]: new_content: Final[list[dict[str, Any]]] = [] for choice in choices: @@ -1307,15 +1333,28 @@ class LiteLLMAnthropicMessagesAdapter: data=str(data_value) if data_value is not None else "", ).model_dump() ) - # Handle reasoning_content when thinking_blocks is not present - elif hasattr(choice.message, "reasoning_content") and choice.message.reasoning_content: - new_content.append( - AnthropicResponseContentBlockThinking( - type="thinking", - thinking=str(choice.message.reasoning_content), - signature=None, - ).model_dump() - ) + # Handle reasoning_content when thinking_blocks is not present. + # Skip if the original request had thinking disabled — a provider + # may still return reasoning_content, but emitting + # a thinking block when the client said thinking=disabled causes + # "Content block is not a thinking block" on the client side. + # Also skip empty or whitespace-only reasoning_content — Anthropic + # rejects thinking blocks with no content ("each thinking block + # must contain thinking") when they are replayed as history. + elif ( + not thinking_disabled + and hasattr(choice.message, "reasoning_content") + and choice.message.reasoning_content + ): + reasoning = str(choice.message.reasoning_content).strip() + if reasoning: + new_content.append( + AnthropicResponseContentBlockThinking( + type="thinking", + thinking=reasoning, + signature=None, + ).model_dump() + ) # Handle text content if choice.message.content is not None: @@ -1466,6 +1505,7 @@ class LiteLLMAnthropicMessagesAdapter: response: ModelResponse, tool_name_mapping: dict[str, str] | None = None, polyfill_result: PolyfillResult | None = None, + thinking_disabled: bool = False, ) -> AnthropicMessagesResponse: """ Translate OpenAI response to Anthropic format. @@ -1476,11 +1516,14 @@ class LiteLLMAnthropicMessagesAdapter: Used to restore original names for tools that exceeded OpenAI's 64-char limit. polyfill_result: PolyfillResult from context_management polyfill. + thinking_disabled: When True, suppress reasoning_content translation + into Anthropic thinking blocks. """ ## translate content block anthropic_content: Final = self._translate_openai_content_to_anthropic( choices=response.choices, tool_name_mapping=tool_name_mapping, + thinking_disabled=thinking_disabled, ) refusal_text: Final = next( (text for choice in response.choices if (text := openai_chat_refusal_text(choice.message)) is not None), @@ -1530,23 +1573,165 @@ class LiteLLMAnthropicMessagesAdapter: return translated_obj + @staticmethod + def _classify_streaming_chunk( + choices: Sequence["OpenAIStreamingChoice | StreamingChoices"], + thinking_disabled: bool = False, + ) -> Literal["thinking", "redacted_thinking", "tool_use", "text", "skip"]: + """ + Single source of truth for what an OpenAI-format streaming chunk + represents in Anthropic terms. Both the block-type classifier + (_translate_streaming_openai_chunk_to_anthropic_content_block) and the + delta emitter (_translate_streaming_openai_chunk_to_anthropic) MUST + derive their decision from this function's result for the same chunk, + so they can never disagree on the open block's type (ADR-0022, + CTG-85 corrected fix). + + Precedence when multiple signals are present in one chunk: + thinking > tool_use > text > skip. + + "Substantial" reasoning uses .strip() — a whitespace-only + reasoning_content chunk is NOT substantial and returns "skip". + Text content, by contrast, uses a plain truthy check — whitespace IS + meaningful in visible answer text (e.g. a lone " " token between two + words in a streamed response), so a whitespace-only content chunk + still returns "text", not "skip". Applying .strip() to text would + silently drop those tokens. See the inline comments near + `has_substantial_text` below for the full rationale (and the test + `test_classify_whitespace_text_is_still_text_not_skip`). + + Returns "skip" when the chunk carries nothing that should determine or + continue any content block (role-only chunk, whitespace-only reasoning + with no other signal, or a disabled-thinking chunk whose only content is + empty/whitespace reasoning). + """ + for choice in choices: + has_tool_calls = ( + choice.delta.tool_calls is not None + and len(choice.delta.tool_calls) > 0 + and choice.delta.tool_calls[0].function is not None + ) + + # Reasoning signal: thinking_blocks (structured) OR reasoning_content + # (flat string from an OpenAI-compatible provider). Use getattr with a + # default throughout — Delta deletes reasoning_content/thinking_blocks + # entirely when unset, so a direct attribute access can raise + # AttributeError. + reasoning_text = "" + has_structured_thinking_block = False + structured_thinking_block_type: str | None = None + if isinstance(choice, StreamingChoices): + thinking_blocks = getattr(choice.delta, "thinking_blocks", None) or [] + if len(thinking_blocks) > 0: + first_block = thinking_blocks[0] + if first_block.get("type") in ("thinking", "redacted_thinking"): + has_structured_thinking_block = True + structured_thinking_block_type = first_block.get("type") + reasoning_text = str(first_block.get("thinking") or "") + if not has_structured_thinking_block: + reasoning_text = str(getattr(choice.delta, "reasoning_content", "") or "") + + # A structured thinking_block is ALWAYS substantial, regardless of + # whether its thinking/signature text happens to be empty — it + # represents an explicit, structured signal from the provider (e.g. + # a redacted_thinking block, or a signature-only closing chunk for an + # already-open thinking block), which is categorically different + # from a flat, un-structured reasoning_content string that can + # legitimately be pure incidental whitespace. Flat reasoning_content, + # by contrast, is only substantial when it has non-whitespace + # content — this is the actual bug fix (a whitespace-only flat + # reasoning_content chunk must classify as 'skip', not 'thinking' or + # 'text'). + # + # IMPORTANT: do not require a non-empty data/signature field here. + # A redacted_thinking block remains a structured provider signal + # even when its encrypted payload is empty. + has_substantial_reasoning = bool(reasoning_text.strip()) or has_structured_thinking_block + + # IMPORTANT: text content substantiality uses a plain truthy check, + # NOT .strip() — unlike reasoning, whitespace IS meaningful in + # visible answer text (e.g. the space between two words arriving as + # separate streaming tokens, "foo", " ", "bar"). Only reasoning_content + # gets the .strip()-based "is this incidental formatting whitespace" + # treatment; applying the same rule to text would silently drop + # legitimate whitespace tokens from the visible answer. + text_content = str(choice.delta.content or "") + has_substantial_text = bool(text_content) + + if ( + not thinking_disabled + and has_substantial_reasoning + and structured_thinking_block_type == "redacted_thinking" + ): + return "redacted_thinking" + if not thinking_disabled and has_substantial_reasoning: + return "thinking" + if has_tool_calls: + return "tool_use" + if has_substantial_text: + return "text" + # Nothing substantial on this choice — try the next choice (multiple + # choices is rare but the existing functions loop over all of them). + if thinking_disabled and (reasoning_text.strip() or has_structured_thinking_block): + # Thinking disabled but the backend still sent reasoning — this + # chunk carries no client-visible content once suppressed. + continue + return "skip" + def _translate_streaming_openai_chunk_to_anthropic_content_block( - self, choices: list[OpenAIStreamingChoice | StreamingChoices] + self, + choices: Sequence["OpenAIStreamingChoice | StreamingChoices"], + thinking_disabled: bool = False, ) -> tuple[ - Literal["text", "tool_use", "thinking"], + Literal["text", "tool_use", "thinking", "redacted_thinking"], "ContentBlockContentBlockDict", ]: from litellm._uuid import uuid from litellm.types.llms.anthropic import TextBlock for choice in choices: - if ( - choice.delta.tool_calls is not None - and len(choice.delta.tool_calls) > 0 - and choice.delta.tool_calls[0].function is not None - ): - raw_id = choice.delta.tool_calls[0].id or str(uuid.uuid4()) - tool_name = choice.delta.tool_calls[0].function.name or "" + block_type = self._classify_streaming_chunk(choices=[choice], thinking_disabled=thinking_disabled) + if block_type == "skip": + continue + + if block_type == "thinking": + if ( + isinstance(choice, StreamingChoices) + and hasattr(choice.delta, "thinking_blocks") + and choice.delta.thinking_blocks + and len(choice.delta.thinking_blocks) > 0 + and choice.delta.thinking_blocks[0].get("type") in ("thinking", "redacted_thinking") + ): + thinking_block = choice.delta.thinking_blocks[0] + thinking = thinking_block.get("thinking") or "" + signature = thinking_block.get("signature") or "" + assert isinstance(thinking, str) + assert isinstance(signature, str) + return "thinking", ChatCompletionThinkingBlock( + type="thinking", thinking=thinking, signature=signature + ) + return "thinking", ChatCompletionThinkingBlock(type="thinking", thinking="", signature="") + + if block_type == "redacted_thinking": + thinking_blocks = getattr(choice.delta, "thinking_blocks", None) or [] + data = str(thinking_blocks[0].get("data") or "") + redacted_block = AnthropicResponseContentBlockRedactedThinking( + type="redacted_thinking", + data=data, + ).model_dump() + return "redacted_thinking", cast("ContentBlockContentBlockDict", redacted_block) + + if block_type == "tool_use": + # Explicit narrowing (base pattern): the classifier only emits + # "tool_use" when the first tool call carries a function, so + # these asserts hold and keep the member accesses below + # optional-free without changing behaviour. + tool_calls = choice.delta.tool_calls + assert tool_calls is not None and len(tool_calls) > 0 + first_tool_call = tool_calls[0] + assert first_tool_call.function is not None + raw_id = first_tool_call.id or str(uuid.uuid4()) + tool_name = first_tool_call.function.name or "" thought_sig: str | None = None if THOUGHT_SIGNATURE_SEPARATOR in raw_id: parts = raw_id.split(THOUGHT_SIGNATURE_SEPARATOR, 1) @@ -1558,75 +1743,25 @@ class LiteLLMAnthropicMessagesAdapter: "input": {}, } if thought_sig: - tool_block["provider_specific_fields"] = { - "signature": thought_sig, - } + tool_block["provider_specific_fields"] = {"signature": thought_sig} return "tool_use", cast("ContentBlockContentBlockDict", tool_block) - elif (choice.delta.content is not None and len(choice.delta.content) > 0) or openai_chat_refusal_text( - choice.delta - ) is not None: + + if block_type == "text": return "text", TextBlock(type="text", text="") - elif isinstance(choice, StreamingChoices) and hasattr(choice.delta, "thinking_blocks"): - thinking_blocks = choice.delta.thinking_blocks or [] - if len(thinking_blocks) > 0: - thinking_block = thinking_blocks[0] - if thinking_block["type"] == "thinking": - thinking = thinking_block.get("thinking") or "" - signature = thinking_block.get("signature") or "" - - assert isinstance(thinking, str) - assert isinstance(signature, str) - - return "thinking", ChatCompletionThinkingBlock( - type="thinking", thinking=thinking, signature=signature - ) - # OpenAI-compatible reasoning backends (e.g. vLLM/SGLang reasoning - # parsers) populate ``reasoning_content`` without ``thinking_blocks``. - # ``Delta`` deletes the ``thinking_blocks`` attribute when unset, so the - # branch above is skipped entirely; open a ``thinking`` block here so the - # matching ``thinking_delta`` stream is not emitted into a text block. - elif isinstance(choice, StreamingChoices) and getattr(choice.delta, "reasoning_content", None): - return "thinking", ChatCompletionThinkingBlock(type="thinking", thinking="", signature="") return "text", TextBlock(type="text", text="") def _translate_streaming_openai_chunk_to_anthropic( - self, choices: list[OpenAIStreamingChoice | StreamingChoices] + self, + choices: Sequence["OpenAIStreamingChoice | StreamingChoices"], + thinking_disabled: bool = False, ) -> tuple[ StreamingContentBlockDeltaType, ContentTextBlockDelta | ContentJsonBlockDelta | ContentThinkingBlockDelta | ContentThinkingSignatureBlockDelta, ]: - text: str = "" - reasoning_content: str = "" - reasoning_signature: str = "" - partial_json: str | None = None - for choice in choices: - if choice.delta.content is not None and len(choice.delta.content) > 0: - text += choice.delta.content - if choice.delta.tool_calls: - partial_json = "" - for tool in choice.delta.tool_calls: - if tool.function is not None and tool.function.arguments is not None: - partial_json = (partial_json or "") + tool.function.arguments - elif isinstance(choice, StreamingChoices) and hasattr(choice.delta, "thinking_blocks"): - thinking_blocks = choice.delta.thinking_blocks or [] - if len(thinking_blocks) > 0: - for thinking_block in thinking_blocks: - if thinking_block["type"] == "thinking": - thinking = thinking_block.get("thinking") or "" - signature = thinking_block.get("signature") or "" - - assert isinstance(thinking, str) - assert isinstance(signature, str) - - reasoning_content += thinking - reasoning_signature += signature - # Handle reasoning_content when thinking_blocks is not present - # This handles providers like OpenRouter that return reasoning_content - elif isinstance(choice, StreamingChoices) and hasattr(choice.delta, "reasoning_content"): - if choice.delta.reasoning_content is not None: - reasoning_content += choice.delta.reasoning_content - + text, reasoning_content, reasoning_signature, partial_json = self._accumulate_streaming_chunk_payloads( + choices, thinking_disabled=thinking_disabled + ) if partial_json is not None: return "input_json_delta", ContentJsonBlockDelta(type="input_json_delta", partial_json=partial_json) elif reasoning_signature: @@ -1641,11 +1776,61 @@ class LiteLLMAnthropicMessagesAdapter: ) return "text_delta", ContentTextBlockDelta(type="text_delta", text=text + refusal_text) + def _accumulate_streaming_chunk_payloads( + self, + choices: Sequence["OpenAIStreamingChoice | StreamingChoices"], + thinking_disabled: bool = False, + ) -> tuple[str, str, str, str | None]: + """Fold a chunk's choices into (text, reasoning_content, reasoning_signature, partial_json). + + ``partial_json`` is ``None`` when the chunk carries no tool calls — the + caller uses that to decide the delta type's precedence (tool JSON beats + thinking/thinking-signature text). + """ + text: str = "" + reasoning_content: str = "" + reasoning_signature: str = "" + partial_json: str | None = None + + for choice in choices: + block_type = self._classify_streaming_chunk(choices=[choice], thinking_disabled=thinking_disabled) + if block_type == "skip": + continue + + if block_type == "thinking": + thinking_blocks = getattr(choice.delta, "thinking_blocks", None) + if isinstance(choice, StreamingChoices) and thinking_blocks: + for thinking_block in thinking_blocks: + if thinking_block.get("type") in ("thinking", "redacted_thinking"): + reasoning_content += str(thinking_block.get("thinking") or "") + reasoning_signature += str(thinking_block.get("signature") or "") + elif getattr(choice.delta, "reasoning_content", None): + reasoning_content += str(choice.delta.reasoning_content) + + elif block_type == "redacted_thinking": + # Redacted thinking is carried wholly in content_block_start; + # Anthropic defines no redacted-thinking delta type. + continue + + elif block_type == "tool_use": + if choice.delta.tool_calls: + partial_json = partial_json or "" + for tool in choice.delta.tool_calls: + if tool.function is not None and tool.function.arguments is not None: + partial_json += tool.function.arguments + + elif block_type == "text": + if choice.delta.content is not None and len(choice.delta.content) > 0: + text += choice.delta.content + + return text, reasoning_content, reasoning_signature, partial_json + def translate_streaming_openai_response_to_anthropic( self, response: ModelResponse, current_content_block_index: int, applied_edits: list[AppliedEdit] | None = None, + thinking_disabled: bool = False, ) -> ContentBlockDelta | MessageBlockDelta: ## base case - final chunk w/ finish reason if response.choices[0].finish_reason is not None: @@ -1673,7 +1858,10 @@ class LiteLLMAnthropicMessagesAdapter: ( type_of_content, content_block_delta, - ) = self._translate_streaming_openai_chunk_to_anthropic(choices=response.choices) + ) = self._translate_streaming_openai_chunk_to_anthropic( + choices=response.choices, + thinking_disabled=thinking_disabled, + ) return ContentBlockDelta( type="content_block_delta", index=current_content_block_index, diff --git a/tests/test_litellm/llms/anthropic/experimental_pass_through/adapters/test_anthropic_experimental_pass_through_adapters_transformation.py b/tests/test_litellm/llms/anthropic/experimental_pass_through/adapters/test_anthropic_experimental_pass_through_adapters_transformation.py index 03b9840b1c3..e41047c7978 100644 --- a/tests/test_litellm/llms/anthropic/experimental_pass_through/adapters/test_anthropic_experimental_pass_through_adapters_transformation.py +++ b/tests/test_litellm/llms/anthropic/experimental_pass_through/adapters/test_anthropic_experimental_pass_through_adapters_transformation.py @@ -3971,6 +3971,76 @@ def test_translate_anthropic_tools_to_openai_preserves_parameters_type(): assert new_tools[0]["type"] == "function" +# ============================================================================ +# thinking_disabled gating tests +# ============================================================================ + + +def test_streaming_reasoning_content_suppressed_when_thinking_disabled(): + """A streaming chunk with reasoning_content must NOT open/emit a thinking + block when thinking_disabled=True — the client didn't ask for thinking.""" + adapter = LiteLLMAnthropicMessagesAdapter() + choice = StreamingChoices( + index=0, + delta=Delta(content=None, role="assistant", reasoning_content="internal reasoning"), + finish_reason=None, + ) + block_type, _ = adapter._translate_streaming_openai_chunk_to_anthropic_content_block( + choices=[choice], thinking_disabled=True + ) + assert block_type == "text", f"expected 'text' when thinking_disabled=True, got {block_type!r}" + + +def test_streaming_reasoning_content_preserved_by_default(): + """Default behavior (thinking_disabled omitted) is unchanged: reasoning_content + still opens a thinking block.""" + adapter = LiteLLMAnthropicMessagesAdapter() + choice = StreamingChoices( + index=0, + delta=Delta(content=None, role="assistant", reasoning_content="internal reasoning"), + finish_reason=None, + ) + block_type, _ = adapter._translate_streaming_openai_chunk_to_anthropic_content_block(choices=[choice]) + assert block_type == "thinking", f"expected 'thinking' by default, got {block_type!r}" + + +def test_streaming_emitter_reasoning_content_suppressed_when_thinking_disabled(): + """The delta emitter must not accumulate reasoning_content into a + thinking_delta when thinking_disabled=True.""" + adapter = LiteLLMAnthropicMessagesAdapter() + choice = StreamingChoices( + index=0, + delta=Delta(content=None, role="assistant", reasoning_content="internal reasoning"), + finish_reason=None, + ) + delta_type, _ = adapter._translate_streaming_openai_chunk_to_anthropic(choices=[choice], thinking_disabled=True) + assert delta_type == "text_delta", f"expected 'text_delta' when thinking_disabled=True, got {delta_type!r}" + + +def test_non_streaming_reasoning_content_suppressed_when_thinking_disabled(): + """A non-streaming completion with reasoning_content must not produce a + thinking content block when thinking_disabled=True.""" + adapter = LiteLLMAnthropicMessagesAdapter() + message = Message(role="assistant", content=None, reasoning_content="internal reasoning") + choice = Choices(index=0, message=message, finish_reason="stop") + content = adapter._translate_openai_content_to_anthropic(choices=[choice], thinking_disabled=True) + assert not any(block.get("type") == "thinking" for block in content), ( + f"expected no thinking block when thinking_disabled=True, got {content!r}" + ) + + +def test_non_streaming_reasoning_content_preserved_by_default(): + """Default behavior (thinking_disabled omitted) is unchanged for the + non-streaming path: reasoning_content still becomes a thinking block.""" + adapter = LiteLLMAnthropicMessagesAdapter() + message = Message(role="assistant", content=None, reasoning_content="internal reasoning") + choice = Choices(index=0, message=message, finish_reason="stop") + content = adapter._translate_openai_content_to_anthropic(choices=[choice]) + assert any(block.get("type") == "thinking" for block in content), ( + f"expected a thinking block by default, got {content!r}" + ) + + def test_translate_anthropic_tools_to_openai_maps_strict_onto_function_not_parameters(): """A tool-level `strict` lands on the OpenAI function, leaving the caller's `input_schema` untouched.""" adapter = LiteLLMAnthropicMessagesAdapter() diff --git a/tests/test_litellm/llms/anthropic/experimental_pass_through/adapters/test_handler_thinking_disabled.py b/tests/test_litellm/llms/anthropic/experimental_pass_through/adapters/test_handler_thinking_disabled.py new file mode 100644 index 00000000000..77cb1eea527 --- /dev/null +++ b/tests/test_litellm/llms/anthropic/experimental_pass_through/adapters/test_handler_thinking_disabled.py @@ -0,0 +1,206 @@ +"""Handler-level tests for ``thinking_disabled`` computation and threading. + +Covers the boolean logic that decides whether thinking is disabled +(fail-closed: only an explicit ``{\"type\": \"enabled"|\"adaptive\"}`` +enables it; absent, disabled, or malformed objects disable it) and +verifies it is threaded correctly to ``ANTHROPIC_ADAPTER`` output- +translation calls for both the async and sync handler entry points, in +streaming and non-streaming modes. + +Mocks ``litellm.acompletion`` / ``litellm.completion`` and +``ANTHROPIC_ADAPTER`` directly, alongside the preparation helpers that run +before the ``thinking_disabled`` computation, so the tests are focused on +the computation and threading rather than the full request pipeline. +""" + +from unittest.mock import MagicMock, patch + +import pytest + +from litellm.llms.anthropic.experimental_pass_through.adapters.handler import ( + LiteLLMMessagesToCompletionTransformationHandler, +) + +THINKING_PARAMS = [ + (None, True), + ({}, True), + ({"type": "disabled"}, True), + ({"budget_tokens": 1024}, True), + ({"type": "weird"}, True), + ({"type": "enabled", "budget_tokens": 1024}, False), + ({"type": "adaptive"}, False), +] + +MESSAGES = [{"role": "user", "content": "hello"}] + + +# --------------------------------------------------------------------------- +# Async handler — streaming +# --------------------------------------------------------------------------- + + +@pytest.mark.parametrize( + "thinking_param,expected_thinking_disabled", + THINKING_PARAMS, +) +async def test_async_handler_streaming_threads_thinking_disabled(thinking_param, expected_thinking_disabled): + """Async handler, stream=True: ``thinking_disabled`` reaches the streaming + adapter call.""" + with ( + patch( # test-quality-ok: handler unit test - fakes completion dispatch + adapter seams; unit under test is the thinking_disabled translation wiring, not the transport + "litellm.llms.anthropic.experimental_pass_through.adapters.handler._prepare_context_managed_request", + return_value=None, + ), + patch.object( # test-quality-ok: handler unit test - fakes completion dispatch + adapter seams; unit under test is the thinking_disabled translation wiring, not the transport + LiteLLMMessagesToCompletionTransformationHandler, + "_prepare_completion_kwargs", + return_value=({}, {}), + ), + patch( # test-quality-ok: handler unit test - fakes completion dispatch + adapter seams; unit under test is the thinking_disabled translation wiring, not the transport + "litellm.acompletion", return_value=MagicMock() + ), # test-quality-ok: handler unit test - fakes completion dispatch + adapter seams; unit under test is the thinking_disabled translation wiring, not the transport + patch( # test-quality-ok: handler unit test - fakes completion dispatch + adapter seams; unit under test is the thinking_disabled translation wiring, not the transport + "litellm.llms.anthropic.experimental_pass_through.adapters.handler.ANTHROPIC_ADAPTER" + ) as mock_adapter, # test-quality-ok: handler unit test - fakes completion dispatch + adapter seams; unit under test is the thinking_disabled translation wiring, not the transport + ): + mock_adapter.translate_completion_output_params_streaming.return_value = iter([]) + await LiteLLMMessagesToCompletionTransformationHandler.async_anthropic_messages_handler( + max_tokens=100, + messages=MESSAGES, + model="gpt-4o", + stream=True, + thinking=thinking_param, + ) + call_kwargs = mock_adapter.translate_completion_output_params_streaming.call_args.kwargs + assert call_kwargs.get("thinking_disabled") is expected_thinking_disabled, ( + f"thinking={thinking_param!r}: expected thinking_disabled={expected_thinking_disabled}" + ) + + +# --------------------------------------------------------------------------- +# Async handler — non-streaming +# --------------------------------------------------------------------------- + + +@pytest.mark.parametrize( + "thinking_param,expected_thinking_disabled", + THINKING_PARAMS, +) +async def test_async_handler_non_streaming_threads_thinking_disabled(thinking_param, expected_thinking_disabled): + """Async handler, stream=False: ``thinking_disabled`` reaches the + non-streaming adapter call.""" + with ( + patch( # test-quality-ok: handler unit test - fakes completion dispatch + adapter seams; unit under test is the thinking_disabled translation wiring, not the transport + "litellm.llms.anthropic.experimental_pass_through.adapters.handler._prepare_context_managed_request", + return_value=None, + ), + patch.object( # test-quality-ok: handler unit test - fakes completion dispatch + adapter seams; unit under test is the thinking_disabled translation wiring, not the transport + LiteLLMMessagesToCompletionTransformationHandler, + "_prepare_completion_kwargs", + return_value=({}, {}), + ), + patch( # test-quality-ok: handler unit test - fakes completion dispatch + adapter seams; unit under test is the thinking_disabled translation wiring, not the transport + "litellm.acompletion", return_value=MagicMock() + ), # test-quality-ok: handler unit test - fakes completion dispatch + adapter seams; unit under test is the thinking_disabled translation wiring, not the transport + patch( # test-quality-ok: handler unit test - fakes completion dispatch + adapter seams; unit under test is the thinking_disabled translation wiring, not the transport + "litellm.llms.anthropic.experimental_pass_through.adapters.handler.ANTHROPIC_ADAPTER" + ) as mock_adapter, # test-quality-ok: handler unit test - fakes completion dispatch + adapter seams; unit under test is the thinking_disabled translation wiring, not the transport + ): + mock_adapter.translate_completion_output_params.return_value = MagicMock() + await LiteLLMMessagesToCompletionTransformationHandler.async_anthropic_messages_handler( + max_tokens=100, + messages=MESSAGES, + model="gpt-4o", + stream=False, + thinking=thinking_param, + ) + call_kwargs = mock_adapter.translate_completion_output_params.call_args.kwargs + assert call_kwargs.get("thinking_disabled") is expected_thinking_disabled, ( + f"thinking={thinking_param!r}: expected thinking_disabled={expected_thinking_disabled}" + ) + + +# --------------------------------------------------------------------------- +# Sync handler — streaming +# --------------------------------------------------------------------------- + + +@pytest.mark.parametrize( + "thinking_param,expected_thinking_disabled", + THINKING_PARAMS, +) +def test_sync_handler_streaming_threads_thinking_disabled(thinking_param, expected_thinking_disabled): + """Sync handler, stream=True: ``thinking_disabled`` reaches the streaming + adapter call. + + Uses the direct synchronous path (no ``context_management``, no compaction + blocks) so ``run_async_function`` is never invoked. + """ + with ( + patch.object( # test-quality-ok: handler unit test - fakes completion dispatch + adapter seams; unit under test is the thinking_disabled translation wiring, not the transport + LiteLLMMessagesToCompletionTransformationHandler, + "_prepare_completion_kwargs", + return_value=({}, {}), + ), + patch( # test-quality-ok: handler unit test - fakes completion dispatch + adapter seams; unit under test is the thinking_disabled translation wiring, not the transport + "litellm.completion", return_value=MagicMock() + ), # test-quality-ok: handler unit test - fakes completion dispatch + adapter seams; unit under test is the thinking_disabled translation wiring, not the transport + patch( # test-quality-ok: handler unit test - fakes completion dispatch + adapter seams; unit under test is the thinking_disabled translation wiring, not the transport + "litellm.llms.anthropic.experimental_pass_through.adapters.handler.ANTHROPIC_ADAPTER" + ) as mock_adapter, # test-quality-ok: handler unit test - fakes completion dispatch + adapter seams; unit under test is the thinking_disabled translation wiring, not the transport + ): + mock_adapter.translate_completion_output_params_streaming.return_value = iter([]) + LiteLLMMessagesToCompletionTransformationHandler.anthropic_messages_handler( + max_tokens=100, + messages=MESSAGES, + model="gpt-4o", + stream=True, + thinking=thinking_param, + ) + call_kwargs = mock_adapter.translate_completion_output_params_streaming.call_args.kwargs + assert call_kwargs.get("thinking_disabled") is expected_thinking_disabled, ( + f"thinking={thinking_param!r}: expected thinking_disabled={expected_thinking_disabled}" + ) + + +# --------------------------------------------------------------------------- +# Sync handler — non-streaming +# --------------------------------------------------------------------------- + + +@pytest.mark.parametrize( + "thinking_param,expected_thinking_disabled", + THINKING_PARAMS, +) +def test_sync_handler_non_streaming_threads_thinking_disabled(thinking_param, expected_thinking_disabled): + """Sync handler, stream=False: ``thinking_disabled`` reaches the + non-streaming adapter call. + + Uses the direct synchronous path (no ``context_management``, no compaction + blocks) so ``run_async_function`` is never invoked. + """ + with ( + patch.object( # test-quality-ok: handler unit test - fakes completion dispatch + adapter seams; unit under test is the thinking_disabled translation wiring, not the transport + LiteLLMMessagesToCompletionTransformationHandler, + "_prepare_completion_kwargs", + return_value=({}, {}), + ), + patch( # test-quality-ok: handler unit test - fakes completion dispatch + adapter seams; unit under test is the thinking_disabled translation wiring, not the transport + "litellm.completion", return_value=MagicMock() + ), # test-quality-ok: handler unit test - fakes completion dispatch + adapter seams; unit under test is the thinking_disabled translation wiring, not the transport + patch( # test-quality-ok: handler unit test - fakes completion dispatch + adapter seams; unit under test is the thinking_disabled translation wiring, not the transport + "litellm.llms.anthropic.experimental_pass_through.adapters.handler.ANTHROPIC_ADAPTER" + ) as mock_adapter, # test-quality-ok: handler unit test - fakes completion dispatch + adapter seams; unit under test is the thinking_disabled translation wiring, not the transport + ): + mock_adapter.translate_completion_output_params.return_value = MagicMock() + LiteLLMMessagesToCompletionTransformationHandler.anthropic_messages_handler( + max_tokens=100, + messages=MESSAGES, + model="gpt-4o", + stream=False, + thinking=thinking_param, + ) + call_kwargs = mock_adapter.translate_completion_output_params.call_args.kwargs + assert call_kwargs.get("thinking_disabled") is expected_thinking_disabled, ( + f"thinking={thinking_param!r}: expected thinking_disabled={expected_thinking_disabled}" + ) diff --git a/tests/test_litellm/llms/together_ai/chat/test_together_ai_chat_transformation.py b/tests/test_litellm/llms/together_ai/chat/test_together_ai_chat_transformation.py index 7eb7dc41d4f..ce8a51b00f6 100644 --- a/tests/test_litellm/llms/together_ai/chat/test_together_ai_chat_transformation.py +++ b/tests/test_litellm/llms/together_ai/chat/test_together_ai_chat_transformation.py @@ -1013,7 +1013,11 @@ def test_anthropic_messages_replays_tool_loop_and_maps_reasoning_to_thinking_blo assert tool_turn["content"] == "Sunny, 18C" blocks = {block["type"]: block for block in response["content"]} - assert blocks["thinking"]["thinking"] == "Tool said sunny." + + # Contract (thinking param absent): the provider's reasoning is NOT + # surfaced as an Anthropic thinking block. The mock response still + # carries reasoning, and this asserts it is suppressed. + assert "thinking" not in blocks assert blocks["text"]["text"] == "Sunny in SF." assert response["stop_reason"] == "end_turn" @@ -1031,6 +1035,9 @@ def test_anthropic_messages_streams_together_tool_call_as_input_json_delta(): captured_requests: list[httpx.Request] = [] client = _sync_client(captured_requests, _sse_response(*PARALLEL_TOOL_CALL_STREAM)) + # Explicit thinking= would be needed to surface provider reasoning + # (the pass-through contract suppresses it when the thinking param is + # absent); this test asserts the streaming translation only. events = _anthropic_sse_events( litellm.anthropic.messages.create( model=f"together_ai/{UNMAPPED_MODEL}", @@ -1067,7 +1074,9 @@ def test_anthropic_messages_streams_together_tool_call_as_input_json_delta(): for event in events if event["type"] == "content_block_delta" and event["delta"]["type"] == "thinking_delta" ) - assert thinking_text == "Need weather and time." + # thinking param absent in the request: provider reasoning is + # suppressed per the contract, so no thinking block may appear. + assert thinking_text == "" assert [event["delta"]["stop_reason"] for event in events if event["type"] == "message_delta"] == ["tool_use"]