How to disable parallel function calling when using openai responses agent in python

[smokhasi]

As the title indicates, I am looking for the attribute to disable function calling which seems to be set to be True by default.

This is my sample Openai responses agent.

from pydantic import BaseModel
from semantic_kernel.functions import KernelArguments
from semantic_kernel.agents import AzureResponsesAgent
from semantic_kernel.connectors.ai.function_choice_behavior import FunctionChoiceBehavior
from semantic_kernel.agents import OpenAIResponsesAgent


##########################################

class BaseResponsesAgent:
    """
    Base class for agents using responses api. This class holds common parameters that are shared 
    among all agents and do not change frequently.
    """

    def __init__(
        self,
        deployment_name: str,
        api_key: str,
        endpoint: str,
        api_version: str,
        metadata: AgentMetadata,
        name: str,
        description: str,
        instructions: str,
        structured_output: bool,
        response_model: type[BaseModel],
        temperature: float = 0.0,
        arguments: KernelArguments | None = None,
        plugins: list[] = [],
        function_choice_behavior: FunctionChoiceBehavior = FunctionChoiceBehavior.Auto(),
    ):
        self.deployment_name = deployment_name
        self.api_key = api_key
        self.endpoint = endpoint
        self.api_version = api_version
        self.metadata = metadata
        self.temperature = temperature
        self.name = name
        self.description = description
        self.instructions = instructions
        self.structured_output = structured_output
        self.response_model = response_model
        self.plugins = plugins
        self.arguments = arguments
        self.function_choice_behavior = function_choice_behavior

    
    async def create(
        self,
    ) -> AzureResponsesAgent:
        
        if self.structured_output:
            if self.response_model is None:
                raise ValueError("response_model must be provided when structured_output is enabled")

            response_format = OpenAIResponsesAgent.configure_response_format(self.response_model)
        else:
            response_format = None

        
        client = AzureResponsesAgent.create_client(api_key=self.api_key,
                                                   endpoint=self.endpoint,
                                                   api_version=self.api_version,
                                                   deployment_name=self.deployment_name)
        
        agent = AzureResponsesAgent(
            # ai_model_id=AzureOpenAISettings().responses_deployment_name,
            ai_model_id=self.deployment_name,
            client=client,
            instructions=self.instructions,
            name= self.name,
            metadata=self.metadata.model_dump(),
            temperature=self.temperature,
            arguments=self.arguments,
            description=self.description,
            function_choice_behavior=self.function_choice_behavior,
            plugins = self.plugins,
            text=response_format
        )
        return agent

All my tools are added as plugins to this agent.
How do I disable parallel function calling?

Note: For reference, I am using this agent with GPT-4.1

[smokhasi]

@moonbox3 tagging for visibility. Thanks!

[smokhasi]

Thanks for the quick response @moonbox3 .
We don't invoke the get_response method directly as we are using multi-agent orchestration similar to what is provided in this example
https://github.com/microsoft/semantic-kernel/blob/main/python/samples/getting_started_with_agents/multi_agent_orchestration/step3_group_chat.py

with the difference being, the agents are all responses agents.

I assume the get_response method is invoked under the hood when we do

    orchestration_result = await group_chat_orchestration.invoke(
        task="Create a slogan for a new electric SUV that is affordable and fun to drive.",
        runtime=runtime,
    )

Would you be able to provide an example of how to disable parallel_tool_calls with this approach?

Ideally, I would like to disable parallel_tool_calls for all the agents involved in the multi-agent orchestration.

[moonbox3]

I see. As a short-term workaround, before we add it to the constructor, you can try subclassing the agent to override invoke_stream(...):

class MyResponsesAgent(OpenAIResponsesAgent):
    async def invoke_stream(self, *args, **kwargs):
        kwargs.setdefault("parallel_tool_calls", False)
        async for item in super().invoke_stream(*args, **kwargs):
            yield item

I'll add the parallel_tool_calls to the constructor, though.

[smokhasi]

The above approach results in an exception

ERROR:semantic_kernel.agents.orchestration.agent_actor_base:Exception occurred in agent research_agent_a4d3fb7da99047a69dcbde7ffaece68e/default:
Agent "research_agent" did not return any response.
ERROR:in_process_runtime:Error processing publish message for research_agent_a4d3fb7da99047a69dcbde7ffaece68e/default
Traceback (most recent call last):

.venv/lib/python3.13/site-packages/semantic_kernel/agents/runtime/in_process/in_process_runtime.py", line 470, in _on_message
    return await agent.on_message(
           ^^^^^^^^^^^^^^^^^^^^^^^
    ...<2 lines>...
    )
    
    .venv/lib/python3.13/site-packages/semantic_kernel/agents/runtime/core/base_agent.py", line 129, in on_message
    return await self.on_message_impl(message, ctx)
    
    .venv/lib/python3.13/site-packages/semantic_kernel/agents/orchestration/agent_actor_base.py", line 53, in on_message_impl
    return await super().on_message_impl(message, ctx)
    
    .venv/lib/python3.13/site-packages/semantic_kernel/agents/runtime/core/routed_agent.py", line 488, in on_message_impl
    return await h(self, message, ctx)
    
    .venv/lib/python3.13/site-packages/semantic_kernel/agents/runtime/core/routed_agent.py", line 156, in wrapper
    return_value = await func(self, message, ctx)
    
    .venv/lib/python3.13/site-packages/semantic_kernel/agents/orchestration/group_chat.py", line 129, in _handle_request_message
    response = await self._invoke_agent()
    
    .venv/lib/python3.13/site-packages/semantic_kernel/agents/orchestration/agent_actor_base.py", line 76, in async_wrapper
    return await func(self, *args, **kwargs)
    
    .venv/lib/python3.13/site-packages/semantic_kernel/agents/orchestration/agent_actor_base.py", line 193, in _invoke_agent
    raise RuntimeError(f'Agent "{self._agent.name}" did not return any response.')
    
    Orchestration Exception occurred: Agent "research_agent" did not return any response.
Traceback (most recent call last):

[smokhasi]

@moonbox3 This maybe a separate issue but I am seeing this agent run into this exception on semantic-kernel versions 1.37.1 and above, even without disabling parallel_tool_calls.
I tested the agent across multiple semantic-kernel versions and can consistently reproduce the above exception on 1.37.1 through the latest 1.39, but not on 1.37. This suggests a regression was introduced starting in 1.37.1

[moonbox3]

Are you able to provide info for the following:

• Minimal reproducible example
• Whether the issue occurs with a single agent (not in orchestration)
• Whether it occurs with/without plugins