Bug: `run_streamed` Buffers `tool_call_item` Events, Delaying Real-Time Feedback

[habema]

Describe the bug

The Runner.run_streamed() method buffers tool_call_item events and only emits them when the tool actually starts executing, rather than streaming them immediately when the tool call is made. This significantly delays real-time feedback in streaming applications and defeats the purpose of using streamed execution for responsive UIs.

Debug information

• Agents SDK version: 0.2.3
• Python version: 3.10.16

Repro steps

import asyncio
import datetime
import time
from agents import Agent, ItemHelpers, Runner, function_tool

@function_tool
def get_server_time() -> str:
    time.sleep(10)  # Simulate a slow tool
    return datetime.datetime.now().isoformat()

async def main():
    agent = Agent(
        name="TimeKeeper",
        instructions="First call the `get_server_time` tool to get the current server time, then tell the user what time it is.",
        tools=[get_server_time],
    )

    result = Runner.run_streamed(agent, input="Hello")
    print("=== Run starting ===")

    async for event in result.stream_events():
        timestamp = datetime.datetime.now().strftime("%H:%M:%S.%f")[:-3]
        if event.type == "run_item_stream_event":
            if event.item.type == "tool_call_item":
                print(f"[{timestamp}] -- Tool was called")
            elif event.item.type == "tool_call_output_item":
                print(f"[{timestamp}] -- Tool output: {event.item.output}")

    print("=== Run complete ===")

if __name__ == "__main__":
    asyncio.run(main())

Current output:

=== Run starting ===
[15:44:50.553] Agent updated: TimeKeeper
[15:45:01.710] -- Tool was called        # ← This appears AFTER the 10-second delay
[15:45:01.710] -- Tool output: 2025-07-28T15:45:01.708868
=== Run complete ===

Expected behavior

The tool_call_item event should be emitted immediately when the agent decides to call a tool, not when the tool starts executing. The expected output should be:

=== Run starting ===
[15:44:50.553] Agent updated: TimeKeeper
[15:44:50.XXX] -- Tool was called        # ← Should appear immediately
# ... 10 second delay while tool executes ...
[15:45:01.710] -- Tool output: 2025-07-28T15:45:01.708868
=== Run complete ===

[habema]

Let me know if the identified root case is correct, and if the suggested fix sounds good so I can create a PR.

Identified root cause
Runner.run_streamed() waited until the model finished streaming (until it received the ResponseCompletedEvent) before converting the raw streaming data into higher-level semantic items. Because of that, the ToolCallItem representing a tool invocation (and its corresponding tool_called RunItemStreamEvent) was only enqueued after the tool had already finished executing.

Key code path (src/agents/run.py):

_run_single_turn_streamed()
    async for event in model.stream_response(...):
        ...
    # only after the loop completes:
    RunImpl.stream_step_result_to_queue(...)  # emits tool_called event

Suggested fix
Emit the tool_called event as soon as the first tool-call chunk is added during streaming:

1. In _run_single_turn_streamed():
   • Track already-emitted tool-call IDs.
   • While iterating over model.stream_response(...), detect ResponseOutputItemAddedEvent whose item is any tool-call type (ResponseFunctionToolCall, ResponseComputerToolCall, ImageGenerationCall, etc.).
   • Immediately construct a ToolCallItem and enqueue

   RunItemStreamEvent(item=tool_item, name="tool_called")

2. Continue forwarding all raw chunks unchanged (RawResponsesStreamEvent).
3. After streaming ends, filter out duplicate tool calls before enqueuing the end-of-turn items so nothing is emitted twice.

Result
tool_called now arrives instantaneously; tool_call_output still arrives when the tool finishes.

[felixs8696]

This is a common issue that we're is affected us as well. Been popping up a lot in the forums lately too, is this something we can prioritize a fix for @rm-openai ? Perceived latency is more acceptable for users if they know a tool call is currently running and we can generate loading UI components when tool calls are made.

[mav913ai]

Has anyone figured out a fix for this issue?

[habema]

@mav913ai A fix for this has been PR'd (#1300 and #974), hoping @rm-openai will get to them soon.

You can work around this temporarily by parsing the raw events yourself:

import asyncio
import datetime
import time
from agents import Agent, Runner, function_tool

from openai.types.responses import (
    ResponseOutputItemAddedEvent,
    ResponseFunctionToolCall,
)

@function_tool
def get_server_time() -> str:
    """A slow tool that takes 10 seconds to complete."""
    time.sleep(10)
    return datetime.datetime.now().isoformat()


async def main():
    agent = Agent(
        name="TimeKeeper",
        instructions="First call the `get_server_time` tool to get the current server time, then tell the user what time it is.",
        tools=[get_server_time],
    )

    result = Runner.run_streamed(agent, input="Hello")
    print("=== Run starting ===")

    processed_tool_call_ids = set()

    async for event in result.stream_events():
        timestamp = datetime.datetime.now().strftime("%H:%M:%S.%f")[:-3]

        if event.type == "raw_response_event":
            if isinstance(event.data, ResponseOutputItemAddedEvent):
                if isinstance(event.data.item, ResponseFunctionToolCall):
                    tool_call = event.data.item
                    if tool_call.call_id not in processed_tool_call_ids:
                        print(f"[{timestamp}] -- Tool was called")
                        processed_tool_call_ids.add(tool_call.call_id)

        if event.type == "run_item_stream_event":
            # The original logic for the high-level events
            if event.item.type == "tool_call_output_item":
                print(f"[{timestamp}] -- Tool output: {event.item.output}")

    print("=== Run complete ===")


if __name__ == "__main__":
    asyncio.run(main())