feat: #864 support streaming nested tool events in Agent.as_tool

src/agents/agent.py

@@ -27,7 +27,7 @@
 if TYPE_CHECKING:
     from .lifecycle import AgentHooks
     from .mcp import MCPServer
-    from .result import RunResult
+    from .result import RunResult, RunResultStreaming
 
 
 @dataclass
@@ -356,9 +356,11 @@ def as_tool(
         self,
         tool_name: str | None,
         tool_description: str | None,
+        *,
         custom_output_extractor: Callable[[RunResult], Awaitable[str]] | None = None,
         is_enabled: bool
         | Callable[[RunContextWrapper[Any], AgentBase[Any]], MaybeAwaitable[bool]] = True,
+        stream_inner_events: bool = False,
     ) -> Tool:
         """Transform this agent into a tool, callable by other agents.
 
@@ -387,17 +389,36 @@ def as_tool(
         async def run_agent(context: RunContextWrapper, input: str) -> str:
             from .run import Runner
 
-            output = await Runner.run(
-                starting_agent=self,
-                input=input,
-                context=context.context,
-            )
+            output_run: RunResult | RunResultStreaming
+            if stream_inner_events:
+                from .stream_events import RunItemStreamEvent
+
+                sub_run = Runner.run_streamed(
+                    self,
+                    input=input,
+                    context=context.context,
+                )
+                parent_queue = getattr(context, "_event_queue", None)
+                async for ev in sub_run.stream_events():
+                    if parent_queue is not None and isinstance(ev, RunItemStreamEvent):
+                        if ev.name in ("tool_called", "tool_output"):
+                            parent_queue.put_nowait(ev)
+                output_run = sub_run
+            else:
+                output_run = await Runner.run(
+                    starting_agent=self,
+                    input=input,
+                    context=context.context,
+                )
+
             if custom_output_extractor:
-                return await custom_output_extractor(output)
+                return await custom_output_extractor(cast(Any, output_run))
 
-            return ItemHelpers.text_message_outputs(output.new_items)
+            return ItemHelpers.text_message_outputs(output_run.new_items)
 
-        return run_agent
+        tool = run_agent
+        tool.stream_inner_events = stream_inner_events  # type: ignore[attr-defined]
+        return tool
 
     async def get_system_prompt(self, run_context: RunContextWrapper[TContext]) -> str | None:
         if isinstance(self.instructions, str):

src/agents/tool_context.py

@@ -1,5 +1,6 @@
+import asyncio
 from dataclasses import dataclass, field, fields
-from typing import Any, Optional
+from typing import Any, Optional, Union
 
 from openai.types.responses import ResponseFunctionToolCall
 
@@ -21,14 +22,24 @@ class ToolContext(RunContextWrapper[TContext]):
     tool_name: str = field(default_factory=_assert_must_pass_tool_name)
     """The name of the tool being invoked."""
 
-    tool_call_id: str = field(default_factory=_assert_must_pass_tool_call_id)
+    tool_call_id: Union[str, int] = field(default_factory=_assert_must_pass_tool_call_id)
     """The ID of the tool call."""
 
+    _event_queue: Optional[asyncio.Queue[Any]] = field(default=None, init=False, repr=False)
+
+    @property
+    def event_queue(self) -> Optional[asyncio.Queue[Any]]:
+        return self._event_queue
+
+    @event_queue.setter
+    def event_queue(self, queue: Optional[asyncio.Queue[Any]]) -> None:
+        self._event_queue = queue
+
     @classmethod
     def from_agent_context(
         cls,
         context: RunContextWrapper[TContext],
-        tool_call_id: str,
+        tool_call_id: Union[str, int],
         tool_call: Optional[ResponseFunctionToolCall] = None,
     ) -> "ToolContext":
         """