From a465382ac6312b59508587dcce093062e231e8f7 Mon Sep 17 00:00:00 2001 From: mateo Date: Sat, 31 Oct 2026 23:11:55 +0000 Subject: [PATCH] fix(anthropic-messages): map disable_parallel_tool_use only where the target declares parallel_tool_calls Co-Authored-By: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com> --- .../messages/adapters/transformation.py | 38 +++++++++++++++---- .../messages/responses_adapters/handler.py | 13 ++++++- .../responses_adapters/transformation.py | 6 ++- ...hropic_messages_adapters_transformation.py | 26 +++++++++---- .../test_responses_adapters_handler.py | 24 ++++++++++++ .../test_responses_adapters_transformation.py | 8 ++++ 6 files changed, 97 insertions(+), 18 deletions(-) diff --git a/litellm/llms/anthropic/messages/adapters/transformation.py b/litellm/llms/anthropic/messages/adapters/transformation.py index ace202fe057..a1490ed8237 100644 --- a/litellm/llms/anthropic/messages/adapters/transformation.py +++ b/litellm/llms/anthropic/messages/adapters/transformation.py @@ -1060,12 +1060,7 @@ class LiteLLMAnthropicMessagesAdapter: unknown backend, because that provider declares this param and forwards it to a proxy that resolves the real target itself, where a derived cache key has no such guarantee. """ - if not model or not custom_llm_provider: - return False - supported_params: Final = litellm.get_supported_openai_params( - model=model, custom_llm_provider=custom_llm_provider - ) - return "reasoning_effort" in (supported_params or ()) + return LiteLLMAnthropicMessagesAdapter._target_declares("reasoning_effort", model, custom_llm_provider) def _translate_metadata_to_openai( self, @@ -1094,8 +1089,14 @@ class LiteLLMAnthropicMessagesAdapter: self, anthropic_message_request: AnthropicMessagesRequest, new_kwargs: ChatCompletionRequest, + custom_llm_provider: str | None = None, ) -> None: - """Translate Anthropic tool_choice to OpenAI format.""" + """Translate Anthropic tool_choice to OpenAI format. + + ``disable_parallel_tool_use`` becomes ``parallel_tool_calls=False`` only for a target that + declares the param, so a provider without it keeps answering instead of rejecting the + request the way it already does an OpenAI-shaped ``parallel_tool_calls``. + """ if "tool_choice" not in anthropic_message_request: return tool_choice: Final = anthropic_message_request["tool_choice"] @@ -1103,9 +1104,29 @@ class LiteLLMAnthropicMessagesAdapter: return anthropic_tool_choice: Final = cast(AnthropicMessagesToolChoice, tool_choice) new_kwargs["tool_choice"] = self.translate_anthropic_tool_choice_to_openai(tool_choice=anthropic_tool_choice) - if anthropic_tool_choice.get("disable_parallel_tool_use") is True: + if anthropic_tool_choice.get("disable_parallel_tool_use") is True and self._target_declares_parallel_tool_calls( + anthropic_message_request["model"], custom_llm_provider + ): new_kwargs["parallel_tool_calls"] = False # rebind-ok: out-param store like tool_choice above + @staticmethod + def _target_declares_parallel_tool_calls(model: str | None, custom_llm_provider: str | None) -> bool: + """Whether the target declares ``parallel_tool_calls`` among its supported params. + + Without a resolved provider the flag stays behind, which is what this bridge sent before + it carried one at all, for the same reasons as ``_target_declares_reasoning_effort``. + """ + return LiteLLMAnthropicMessagesAdapter._target_declares("parallel_tool_calls", model, custom_llm_provider) + + @staticmethod + def _target_declares(param: str, model: str | None, custom_llm_provider: str | None) -> bool: + if not model or not custom_llm_provider: + return False + supported_params: Final = litellm.get_supported_openai_params( + model=model, custom_llm_provider=custom_llm_provider + ) + return param in (supported_params or ()) + def _translate_stop_sequences_to_openai( self, anthropic_message_request: AnthropicMessagesRequest, @@ -1327,6 +1348,7 @@ class LiteLLMAnthropicMessagesAdapter: self._translate_tool_choice_to_openai( anthropic_message_request=anthropic_message_request, new_kwargs=new_kwargs, + custom_llm_provider=custom_llm_provider, ) ## CONVERT TOOLS tool_name_mapping = self._translate_tools_to_openai( diff --git a/litellm/llms/anthropic/messages/responses_adapters/handler.py b/litellm/llms/anthropic/messages/responses_adapters/handler.py index 0eef3fd87c0..c6be8a0379d 100644 --- a/litellm/llms/anthropic/messages/responses_adapters/handler.py +++ b/litellm/llms/anthropic/messages/responses_adapters/handler.py @@ -171,12 +171,20 @@ def _forwarded_kwargs(extra_kwargs: Mapping[str, object] | None) -> Mapping[str, def _provider_returns_encrypted_reasoning(model: str, custom_llm_provider: object) -> bool: + return _responses_config_declares("include", model, custom_llm_provider) + + +def _provider_declares_parallel_tool_calls(model: str, custom_llm_provider: object) -> bool: + return _responses_config_declares("parallel_tool_calls", model, custom_llm_provider) + + +def _responses_config_declares(param: str, model: str, custom_llm_provider: object) -> bool: provider: Final = ( custom_llm_provider if isinstance(custom_llm_provider, str) else litellm.get_llm_provider(model=model)[1] ) provider_model: Final = local_model_name(model, provider) responses_config: Final = ProviderConfigManager.get_provider_responses_api_config(provider, provider_model) - return responses_config is not None and "include" in responses_config.get_supported_openai_params(provider_model) + return responses_config is not None and param in responses_config.get_supported_openai_params(provider_model) def _reads_prompt_cache_breakpoint(model: str, forwarded_kwargs: Mapping[str, object]) -> bool: @@ -321,6 +329,9 @@ def _build_responses_kwargs( ), auto_summary_level=auto_reasoning_summary(model, forwarded_kwargs.get("custom_llm_provider")), drop_params=drops_unsupported_params(forwarded_kwargs.get("drop_params")), + declares_parallel_tool_calls=_provider_declares_parallel_tool_calls( + model, forwarded_kwargs.get("custom_llm_provider") + ), ) # Normalize reasoning effort based on model capabilities diff --git a/litellm/llms/anthropic/messages/responses_adapters/transformation.py b/litellm/llms/anthropic/messages/responses_adapters/transformation.py index 964189ca7da..d2bb3a73e34 100644 --- a/litellm/llms/anthropic/messages/responses_adapters/transformation.py +++ b/litellm/llms/anthropic/messages/responses_adapters/transformation.py @@ -587,11 +587,15 @@ class LiteLLMAnthropicToResponsesAPIAdapter: auto_summary_level: str = "detailed", *, drop_params: bool = True, + declares_parallel_tool_calls: bool = True, ) -> dict[str, Any]: """ Translate a full Anthropic /v1/messages request dict to litellm.responses() / litellm.aresponses() kwargs. + ``declares_parallel_tool_calls`` says whether the provider's Responses API accepts + ``parallel_tool_calls``; ``tool_choice.disable_parallel_tool_use`` maps onto it only then. + ``include_encrypted_reasoning`` asks the provider for ``reasoning.encrypted_content`` on every call, so a reasoning model's items can be replayed intact next turn even when the client sent no ``thinking`` block; pass False for a provider whose @@ -658,7 +662,7 @@ class LiteLLMAnthropicToResponsesAPIAdapter: if tool_choice: anthropic_tool_choice: Final = cast(AnthropicMessagesToolChoice, tool_choice) responses_kwargs["tool_choice"] = self.translate_tool_choice_to_responses_api(anthropic_tool_choice) - if anthropic_tool_choice.get("disable_parallel_tool_use") is True: + if anthropic_tool_choice.get("disable_parallel_tool_use") is True and declares_parallel_tool_calls: responses_kwargs["parallel_tool_calls"] = False # thinking -> reasoning diff --git a/tests/unit/llms/anthropic/messages/adapters/test_anthropic_messages_adapters_transformation.py b/tests/unit/llms/anthropic/messages/adapters/test_anthropic_messages_adapters_transformation.py index a3670a2d7ba..29fa57225ea 100644 --- a/tests/unit/llms/anthropic/messages/adapters/test_anthropic_messages_adapters_transformation.py +++ b/tests/unit/llms/anthropic/messages/adapters/test_anthropic_messages_adapters_transformation.py @@ -5530,27 +5530,37 @@ async def test_chat_bridge_tool_result_text_block_without_text_reaches_the_model @pytest.mark.parametrize( - ("tool_choice", "expected_parallel_tool_calls"), + ("tool_choice", "model", "custom_llm_provider", "expected_parallel_tool_calls"), [ - ({"type": "auto", "disable_parallel_tool_use": True}, False), - ({"type": "any", "disable_parallel_tool_use": True}, False), - ({"type": "auto", "disable_parallel_tool_use": False}, None), - ({"type": "auto"}, None), + ({"type": "auto", "disable_parallel_tool_use": True}, "gpt-5.4", "openai", False), + ({"type": "any", "disable_parallel_tool_use": True}, "gpt-5.4", "openai", False), + ({"type": "auto", "disable_parallel_tool_use": True}, "openai/gpt-oss-120b", "groq", False), + ({"type": "auto", "disable_parallel_tool_use": False}, "gpt-5.4", "openai", None), + ({"type": "auto"}, "gpt-5.4", "openai", None), + # cohere_chat declares no parallel_tool_calls: the flag stays behind instead of raising UnsupportedParamsError + ({"type": "auto", "disable_parallel_tool_use": True}, "command-a-03-2025", "cohere_chat", None), + # no resolved provider (logging and guardrail callers): the flag stays behind as before + ({"type": "auto", "disable_parallel_tool_use": True}, "gpt-5.4", None, None), ], ) def test_translate_anthropic_to_openai_disable_parallel_tool_use_sets_parallel_tool_calls( - tool_choice: dict[str, object], expected_parallel_tool_calls: bool | None + tool_choice: dict[str, object], + model: str, + custom_llm_provider: str | None, + expected_parallel_tool_calls: bool | None, ) -> None: from litellm.types.llms.anthropic import AnthropicMessagesRequest request: Final = AnthropicMessagesRequest( - model="gpt-5.4", + model=model, max_tokens=64, messages=[{"role": "user", "content": "What is the weather in Paris?"}], tools=[{"name": "lookup_weather", "input_schema": {"type": "object", "properties": {}}}], tool_choice=tool_choice, ) - translated, _ = LiteLLMAnthropicMessagesAdapter().translate_anthropic_to_openai(request) + translated, _ = LiteLLMAnthropicMessagesAdapter().translate_anthropic_to_openai( + request, custom_llm_provider=custom_llm_provider + ) assert translated.get("parallel_tool_calls") == expected_parallel_tool_calls diff --git a/tests/unit/llms/anthropic/messages/responses_adapters/test_responses_adapters_handler.py b/tests/unit/llms/anthropic/messages/responses_adapters/test_responses_adapters_handler.py index 382917fc756..687cde6d7f6 100644 --- a/tests/unit/llms/anthropic/messages/responses_adapters/test_responses_adapters_handler.py +++ b/tests/unit/llms/anthropic/messages/responses_adapters/test_responses_adapters_handler.py @@ -52,6 +52,30 @@ def test_build_responses_kwargs_never_asks_the_nested_call_to_replay_a_stream(): assert responses_kwargs["custom_llm_provider"] == "azure" +@pytest.mark.parametrize( + ("model", "custom_llm_provider", "expected_parallel_tool_calls"), + [ + ("openai/gpt-5.6-luna", "openai", False), + ("azure/gpt-5.6-luna", "azure", False), + # Perplexity's Responses API declares no parallel_tool_calls: the flag stays behind instead of a 400 + ("perplexity/sonar", "perplexity", None), + ], +) +def test_build_responses_kwargs_maps_disable_parallel_tool_use_only_where_the_provider_declares_it( + model: str, custom_llm_provider: str, expected_parallel_tool_calls: bool | None +): + responses_kwargs = _build_responses_kwargs( + max_tokens=1024, + messages=MESSAGES, + model=model, + tools=[{"name": "do_thing", "input_schema": {"type": "object", "properties": {}}}], + tool_choice={"type": "auto", "disable_parallel_tool_use": True}, + extra_kwargs={"custom_llm_provider": custom_llm_provider}, + ) + assert responses_kwargs.get("parallel_tool_calls") == expected_parallel_tool_calls + assert responses_kwargs["tool_choice"] == "auto" + + def test_build_responses_kwargs_derives_prompt_cache_key_from_claude_code_session_id(): responses_kwargs = _build_responses_kwargs( max_tokens=1024, diff --git a/tests/unit/llms/anthropic/messages/responses_adapters/test_responses_adapters_transformation.py b/tests/unit/llms/anthropic/messages/responses_adapters/test_responses_adapters_transformation.py index ba6410fd970..5d858fbc54b 100644 --- a/tests/unit/llms/anthropic/messages/responses_adapters/test_responses_adapters_transformation.py +++ b/tests/unit/llms/anthropic/messages/responses_adapters/test_responses_adapters_transformation.py @@ -1194,6 +1194,14 @@ class TestTranslateRequestBroaderCoverage: kwargs = _ADAPTER.translate_request(req) assert kwargs.get("parallel_tool_calls") == expected_parallel_tool_calls + def test_disable_parallel_tool_use_stays_behind_when_provider_lacks_parallel_tool_calls(self): + req = _make_request( + tools=[{"name": "do_thing"}], tool_choice={"type": "auto", "disable_parallel_tool_use": True} + ) + kwargs = _ADAPTER.translate_request(req, declares_parallel_tool_calls=False) + assert "parallel_tool_calls" not in kwargs + assert kwargs["tool_choice"] == "auto" + def test_thinking_translated_to_reasoning(self): req = _make_request(thinking={"type": "enabled", "budget_tokens": 12000}) kwargs = _ADAPTER.translate_request(req)