Fix OllamaChatClient passing unsupported kwargs to ollama.AsyncClient.chat()

Stop forwarding **kwargs from _inner_get_response() to ollama.AsyncClient.chat().
When the orchestration layer (e.g. HandoffBuilder) injects kwargs like
allow_multiple_tool_calls=True, these were passed through unfiltered, causing
a TypeError since ollama.AsyncClient.chat() does not accept them.

This aligns with how other clients (e.g. OpenAIChatClient) handle kwargs —
they only pass the prepared options_dict to the provider's API, not the
raw **kwargs from the middleware chain.

Fixes #4402

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: max-montes

python/packages/ollama/agent_framework_ollama/_chat_client.py

@@ -349,7 +349,7 @@ def _inner_get_response(
         messages: Sequence[Message],
         options: Mapping[str, Any],
         stream: bool = False,
-        **kwargs: Any,
+        **kwargs: Any,  # noqa: ARG002 — accepted for interface compatibility; not forwarded to Ollama
     ) -> Awaitable[ChatResponse] | ResponseStream[ChatResponseUpdate, ChatResponse]:
         if stream:
             # Streaming mode
@@ -360,7 +360,6 @@ async def _stream() -> AsyncIterable[ChatResponseUpdate]:
                     response_object: AsyncIterable[OllamaChatResponse] = await self.client.chat(  # type: ignore[misc]
                         stream=True,
                         **options_dict,
-                        **kwargs,
                     )
                 except Exception as ex:
                     raise ChatClientException(f"Ollama streaming chat request failed : {ex}", ex) from ex
@@ -378,7 +377,6 @@ async def _get_response() -> ChatResponse:
                 response: OllamaChatResponse = await self.client.chat(  # type: ignore[misc]
                     stream=False,
                     **options_dict,
-                    **kwargs,
                 )
             except Exception as ex:
                 raise ChatClientException(f"Ollama chat request failed : {ex}", ex) from ex
@@ -395,8 +393,9 @@ def _prepare_options(self, messages: Sequence[Message], options: Mapping[str, An
 
             messages = prepend_instructions_to_messages(list(messages), instructions, role="system")
 
-        # Keys to exclude from processing
-        exclude_keys = {"instructions", "tool_choice"}
+        # Keys to exclude from processing — these are either handled separately
+        # or not supported by the Ollama API.
+        exclude_keys = {"instructions", "tool_choice", "allow_multiple_tool_calls"}
 
         # Build run_options and model_options separately
         run_options: dict[str, Any] = {}

python/packages/ollama/tests/test_ollama_chat_client.py

@@ -248,6 +248,88 @@ async def test_cmc(
     assert result.text == "test"
 
 
+@patch.object(AsyncClient, "chat", new_callable=AsyncMock)
+async def test_cmc_ignores_unsupported_kwargs(
+    mock_chat: AsyncMock,
+    ollama_unit_test_env: dict[str, str],
+    chat_history: list[Message],
+    mock_chat_completion_response: OllamaChatResponse,
+) -> None:
+    """Verify that unsupported kwargs (e.g. allow_multiple_tool_calls) are
+    silently filtered out and never forwarded to ollama.AsyncClient.chat().
+
+    Regression test for: https://github.com/microsoft/agent-framework/issues/4402
+    """
+    mock_chat.return_value = mock_chat_completion_response
+    chat_history.append(Message(text="hello world", role="user"))
+
+    ollama_client = OllamaChatClient()
+    result = await ollama_client.get_response(
+        messages=chat_history,
+        allow_multiple_tool_calls=True,
+    )
+
+    assert result.text == "test"
+    mock_chat.assert_called_once()
+    call_kwargs = mock_chat.call_args.kwargs
+    assert "allow_multiple_tool_calls" not in call_kwargs
+
+
+@patch.object(AsyncClient, "chat", new_callable=AsyncMock)
+async def test_cmc_streaming_ignores_unsupported_kwargs(
+    mock_chat: AsyncMock,
+    ollama_unit_test_env: dict[str, str],
+    chat_history: list[Message],
+    mock_streaming_chat_completion_response: AsyncStream[OllamaChatResponse],
+) -> None:
+    """Verify that unsupported kwargs are filtered in streaming mode too.
+
+    Regression test for: https://github.com/microsoft/agent-framework/issues/4402
+    """
+    mock_chat.return_value = mock_streaming_chat_completion_response
+    chat_history.append(Message(text="hello world", role="user"))
+
+    ollama_client = OllamaChatClient()
+    result = ollama_client.get_response(
+        messages=chat_history,
+        stream=True,
+        allow_multiple_tool_calls=True,
+    )
+
+    async for chunk in result:
+        assert chunk.text == "test"
+
+    mock_chat.assert_called_once()
+    call_kwargs = mock_chat.call_args.kwargs
+    assert "allow_multiple_tool_calls" not in call_kwargs
+
+
+@patch.object(AsyncClient, "chat", new_callable=AsyncMock)
+async def test_cmc_ignores_unsupported_options(
+    mock_chat: AsyncMock,
+    ollama_unit_test_env: dict[str, str],
+    chat_history: list[Message],
+    mock_chat_completion_response: OllamaChatResponse,
+) -> None:
+    """Verify that unsupported keys inside the options dict are also stripped
+    before reaching ollama.AsyncClient.chat().
+
+    Regression test for: https://github.com/microsoft/agent-framework/issues/4402
+    """
+    mock_chat.return_value = mock_chat_completion_response
+    chat_history.append(Message(text="hello world", role="user"))
+
+    ollama_client = OllamaChatClient()
+    await ollama_client.get_response(
+        messages=chat_history,
+        options={"allow_multiple_tool_calls": True},
+    )
+
+    mock_chat.assert_called_once()
+    call_kwargs = mock_chat.call_args.kwargs
+    assert "allow_multiple_tool_calls" not in call_kwargs
+
+
 @patch.object(AsyncClient, "chat", new_callable=AsyncMock)
 async def test_cmc_reasoning(
     mock_chat: AsyncMock,