run tool only once.

sandeepcmsm · sandeepcmsm · commit ca600995ae31 · 2025-04-24T20:10:54.000+05:30
diff --git a/src/agents/_run_impl.py b/src/agents/_run_impl.py
@@ -173,7 +173,7 @@ def generated_items(self) -> list[RunItem]:
 
 
 def get_model_tracing_impl(
-    tracing_disabled: bool, trace_include_sensitive_data: bool
+        tracing_disabled: bool, trace_include_sensitive_data: bool
 ) -> ModelTracing:
     if tracing_disabled:
         return ModelTracing.DISABLED
@@ -186,19 +186,19 @@ def get_model_tracing_impl(
 class RunImpl:
     @classmethod
     async def execute_tools_and_side_effects(
-        cls,
-        *,
-        agent: Agent[TContext],
-        # The original input to the Runner
-        original_input: str | list[TResponseInputItem],
-        # Everything generated by Runner since the original input, but before the current step
-        pre_step_items: list[RunItem],
-        new_response: ModelResponse,
-        processed_response: ProcessedResponse,
-        output_schema: AgentOutputSchemaBase | None,
-        hooks: RunHooks[TContext],
-        context_wrapper: RunContextWrapper[TContext],
-        run_config: RunConfig,
+            cls,
+            *,
+            agent: Agent[TContext],
+            # The original input to the Runner
+            original_input: str | list[TResponseInputItem],
+            # Everything generated by Runner since the original input, but before the current step
+            pre_step_items: list[RunItem],
+            new_response: ModelResponse,
+            processed_response: ProcessedResponse,
+            output_schema: AgentOutputSchemaBase | None,
+            hooks: RunHooks[TContext],
+            context_wrapper: RunContextWrapper[TContext],
+            run_config: RunConfig,
     ) -> SingleStepResult:
         # Make a copy of the generated items
         pre_step_items = list(pre_step_items)
@@ -294,7 +294,7 @@ async def execute_tools_and_side_effects(
                 context_wrapper=context_wrapper,
             )
         elif (
-            not output_schema or output_schema.is_plain_text()
+                not output_schema or output_schema.is_plain_text()
         ) and not processed_response.has_tools_to_run():
             return await cls.execute_final_output(
                 agent=agent,
@@ -318,7 +318,7 @@ async def execute_tools_and_side_effects(
 
     @classmethod
     def maybe_reset_tool_choice(
-        cls, agent: Agent[Any], tool_use_tracker: AgentToolUseTracker, model_settings: ModelSettings
+            cls, agent: Agent[Any], tool_use_tracker: AgentToolUseTracker, model_settings: ModelSettings
     ) -> ModelSettings:
         """Resets tool choice to None if the agent has used tools and the agent's reset_tool_choice
         flag is True."""
@@ -330,13 +330,13 @@ def maybe_reset_tool_choice(
 
     @classmethod
     def process_model_response(
-        cls,
-        *,
-        agent: Agent[Any],
-        all_tools: list[Tool],
-        response: ModelResponse,
-        output_schema: AgentOutputSchemaBase | None,
-        handoffs: list[Handoff],
+            cls,
+            *,
+            agent: Agent[Any],
+            all_tools: list[Tool],
+            response: ModelResponse,
+            output_schema: AgentOutputSchemaBase | None,
+            handoffs: list[Handoff],
     ) -> ProcessedResponse:
         items: list[RunItem] = []
 
@@ -421,16 +421,16 @@ def process_model_response(
 
     @classmethod
     async def execute_function_tool_calls(
-        cls,
-        *,
-        agent: Agent[TContext],
-        tool_runs: list[ToolRunFunction],
-        hooks: RunHooks[TContext],
-        context_wrapper: RunContextWrapper[TContext],
-        config: RunConfig,
+            cls,
+            *,
+            agent: Agent[TContext],
+            tool_runs: list[ToolRunFunction],
+            hooks: RunHooks[TContext],
+            context_wrapper: RunContextWrapper[TContext],
+            config: RunConfig,
     ) -> list[FunctionToolResult]:
         async def run_single_tool(
-            func_tool: FunctionTool, tool_call: ResponseFunctionToolCall
+                func_tool: FunctionTool, tool_call: ResponseFunctionToolCall
         ) -> Any:
             with function_span(func_tool.name) as span_fn:
                 if config.trace_include_sensitive_data:
@@ -473,6 +473,8 @@ async def run_single_tool(
         for tool_run in tool_runs:
             function_tool = tool_run.function_tool
             tasks.append(run_single_tool(function_tool, tool_run.tool_call))
+            # run tool only once.
+            break
 
         results = await asyncio.gather(*tasks)
 
@@ -491,13 +493,13 @@ async def run_single_tool(
 
     @classmethod
     async def execute_computer_actions(
-        cls,
-        *,
-        agent: Agent[TContext],
-        actions: list[ToolRunComputerAction],
-        hooks: RunHooks[TContext],
-        context_wrapper: RunContextWrapper[TContext],
-        config: RunConfig,
+            cls,
+            *,
+            agent: Agent[TContext],
+            actions: list[ToolRunComputerAction],
+            hooks: RunHooks[TContext],
+            context_wrapper: RunContextWrapper[TContext],
+            config: RunConfig,
     ) -> list[RunItem]:
         results: list[RunItem] = []
         # Need to run these serially, because each action can affect the computer state
@@ -516,17 +518,17 @@ async def execute_computer_actions(
 
     @classmethod
     async def execute_handoffs(
-        cls,
-        *,
-        agent: Agent[TContext],
-        original_input: str | list[TResponseInputItem],
-        pre_step_items: list[RunItem],
-        new_step_items: list[RunItem],
-        new_response: ModelResponse,
-        run_handoffs: list[ToolRunHandoff],
-        hooks: RunHooks[TContext],
-        context_wrapper: RunContextWrapper[TContext],
-        run_config: RunConfig,
+            cls,
+            *,
+            agent: Agent[TContext],
+            original_input: str | list[TResponseInputItem],
+            pre_step_items: list[RunItem],
+            new_step_items: list[RunItem],
+            new_response: ModelResponse,
+            run_handoffs: list[ToolRunHandoff],
+            hooks: RunHooks[TContext],
+            context_wrapper: RunContextWrapper[TContext],
+            run_config: RunConfig,
     ) -> SingleStepResult:
         # If there is more than one handoff, add tool responses that reject those handoffs
         multiple_handoffs = len(run_handoffs) > 1
@@ -645,16 +647,16 @@ async def execute_handoffs(
 
     @classmethod
     async def execute_final_output(
-        cls,
-        *,
-        agent: Agent[TContext],
-        original_input: str | list[TResponseInputItem],
-        new_response: ModelResponse,
-        pre_step_items: list[RunItem],
-        new_step_items: list[RunItem],
-        final_output: Any,
-        hooks: RunHooks[TContext],
-        context_wrapper: RunContextWrapper[TContext],
+            cls,
+            *,
+            agent: Agent[TContext],
+            original_input: str | list[TResponseInputItem],
+            new_response: ModelResponse,
+            pre_step_items: list[RunItem],
+            new_step_items: list[RunItem],
+            final_output: Any,
+            hooks: RunHooks[TContext],
+            context_wrapper: RunContextWrapper[TContext],
     ) -> SingleStepResult:
         # Run the on_end hooks
         await cls.run_final_output_hooks(agent, hooks, context_wrapper, final_output)
@@ -669,11 +671,11 @@ async def execute_final_output(
 
     @classmethod
     async def run_final_output_hooks(
-        cls,
-        agent: Agent[TContext],
-        hooks: RunHooks[TContext],
-        context_wrapper: RunContextWrapper[TContext],
-        final_output: Any,
+            cls,
+            agent: Agent[TContext],
+            hooks: RunHooks[TContext],
+            context_wrapper: RunContextWrapper[TContext],
+            final_output: Any,
     ):
         await asyncio.gather(
             hooks.on_agent_end(context_wrapper, agent, final_output),
@@ -684,11 +686,11 @@ async def run_final_output_hooks(
 
     @classmethod
     async def run_single_input_guardrail(
-        cls,
-        agent: Agent[Any],
-        guardrail: InputGuardrail[TContext],
-        input: str | list[TResponseInputItem],
-        context: RunContextWrapper[TContext],
+            cls,
+            agent: Agent[Any],
+            guardrail: InputGuardrail[TContext],
+            input: str | list[TResponseInputItem],
+            context: RunContextWrapper[TContext],
     ) -> InputGuardrailResult:
         with guardrail_span(guardrail.get_name()) as span_guardrail:
             result = await guardrail.run(agent, input, context)
@@ -697,11 +699,11 @@ async def run_single_input_guardrail(
 
     @classmethod
     async def run_single_output_guardrail(
-        cls,
-        guardrail: OutputGuardrail[TContext],
-        agent: Agent[Any],
-        agent_output: Any,
-        context: RunContextWrapper[TContext],
+            cls,
+            guardrail: OutputGuardrail[TContext],
+            agent: Agent[Any],
+            agent_output: Any,
+            context: RunContextWrapper[TContext],
     ) -> OutputGuardrailResult:
         with guardrail_span(guardrail.get_name()) as span_guardrail:
             result = await guardrail.run(agent=agent, agent_output=agent_output, context=context)
@@ -710,9 +712,9 @@ async def run_single_output_guardrail(
 
     @classmethod
     def stream_step_result_to_queue(
-        cls,
-        step_result: SingleStepResult,
-        queue: asyncio.Queue[StreamEvent | QueueCompleteSentinel],
+            cls,
+            step_result: SingleStepResult,
+            queue: asyncio.Queue[StreamEvent | QueueCompleteSentinel],
     ):
         for item in step_result.new_step_items:
             if isinstance(item, MessageOutputItem):
@@ -736,12 +738,12 @@ def stream_step_result_to_queue(
 
     @classmethod
     async def _check_for_final_output_from_tools(
-        cls,
-        *,
-        agent: Agent[TContext],
-        tool_results: list[FunctionToolResult],
-        context_wrapper: RunContextWrapper[TContext],
-        config: RunConfig,
+            cls,
+            *,
+            agent: Agent[TContext],
+            tool_results: list[FunctionToolResult],
+            context_wrapper: RunContextWrapper[TContext],
+            config: RunConfig,
     ) -> ToolsToFinalOutputResult:
         """Returns (i, final_output)."""
         if not tool_results:
@@ -780,12 +782,12 @@ class TraceCtxManager:
     """Creates a trace only if there is no current trace, and manages the trace lifecycle."""
 
     def __init__(
-        self,
-        workflow_name: str,
-        trace_id: str | None,
-        group_id: str | None,
-        metadata: dict[str, Any] | None,
-        disabled: bool,
+            self,
+            workflow_name: str,
+            trace_id: str | None,
+            group_id: str | None,
+            metadata: dict[str, Any] | None,
+            disabled: bool,
     ):
         self.trace: Trace | None = None
         self.workflow_name = workflow_name
@@ -816,13 +818,13 @@ def __exit__(self, exc_type, exc_val, exc_tb):
 class ComputerAction:
     @classmethod
     async def execute(
-        cls,
-        *,
-        agent: Agent[TContext],
-        action: ToolRunComputerAction,
-        hooks: RunHooks[TContext],
-        context_wrapper: RunContextWrapper[TContext],
-        config: RunConfig,
+            cls,
+            *,
+            agent: Agent[TContext],
+            action: ToolRunComputerAction,
+            hooks: RunHooks[TContext],
+            context_wrapper: RunContextWrapper[TContext],
+            config: RunConfig,
     ) -> RunItem:
         output_func = (
             cls._get_screenshot_async(action.computer_tool.computer, action.tool_call)
@@ -866,9 +868,9 @@ async def execute(
 
     @classmethod
     async def _get_screenshot_sync(
-        cls,
-        computer: Computer,
-        tool_call: ResponseComputerToolCall,
+            cls,
+            computer: Computer,
+            tool_call: ResponseComputerToolCall,
     ) -> str:
         action = tool_call.action
         if isinstance(action, ActionClick):
@@ -894,9 +896,9 @@ async def _get_screenshot_sync(
 
     @classmethod
     async def _get_screenshot_async(
-        cls,
-        computer: AsyncComputer,
-        tool_call: ResponseComputerToolCall,
+            cls,
+            computer: AsyncComputer,
+            tool_call: ResponseComputerToolCall,
     ) -> str:
         action = tool_call.action
         if isinstance(action, ActionClick):
