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>

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(

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

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

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

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,

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)