Add run_config inheritance for agent-as-tool functionality

Author: DanielHashmi

src/agents/agent.py

@@ -108,7 +108,8 @@ class Agent(Generic[TContext]):
     LLM knows what it does and when to invoke it.
     """
 
-    handoffs: list[Agent[Any] | Handoff[TContext]] = field(default_factory=list)
+    handoffs: list[Agent[Any] | Handoff[TContext]
+                   ] = field(default_factory=list)
     """Handoffs are sub-agents that the agent can delegate to. You can provide a list of handoffs,
     and the agent can choose to delegate to them if relevant. Allows for separation of concerns and
     modularity.
@@ -141,12 +142,14 @@ class Agent(Generic[TContext]):
     mcp_config: MCPConfig = field(default_factory=lambda: MCPConfig())
     """Configuration for MCP servers."""
 
-    input_guardrails: list[InputGuardrail[TContext]] = field(default_factory=list)
+    input_guardrails: list[InputGuardrail[TContext]
+                           ] = field(default_factory=list)
     """A list of checks that run in parallel to the agent's execution, before generating a
     response. Runs only if the agent is the first agent in the chain.
     """
 
-    output_guardrails: list[OutputGuardrail[TContext]] = field(default_factory=list)
+    output_guardrails: list[OutputGuardrail[TContext]
+                            ] = field(default_factory=list)
     """A list of checks that run on the final output of the agent, after generating a response.
     Runs only if the agent produces a final output.
     """
@@ -165,7 +168,8 @@ class Agent(Generic[TContext]):
     """
 
     tool_use_behavior: (
-        Literal["run_llm_again", "stop_on_first_tool"] | StopAtTools | ToolsToFinalOutputFunction
+        Literal["run_llm_again",
+                "stop_on_first_tool"] | StopAtTools | ToolsToFinalOutputFunction
     ) = "run_llm_again"
     """This lets you configure how tool use is handled.
     - "run_llm_again": The default behavior. Tools are run, and then the LLM receives the results
@@ -187,10 +191,6 @@ class Agent(Generic[TContext]):
     """Whether to reset the tool choice to the default value after a tool has been called. Defaults
     to True. This ensures that the agent doesn't enter an infinite loop of tool usage."""
 
-    def __post_init__(self):
-        if not isinstance(self.name, str):
-            raise TypeError(f"Agent name must be a string, got {type(self.name).__name__}")
-
     def clone(self, **kwargs: Any) -> Agent[TContext]:
         """Make a copy of the agent, with the given arguments changed. For example, you could do:
         ```
@@ -203,15 +203,16 @@ def as_tool(
         self,
         tool_name: str | None,
         tool_description: str | None,
-        custom_output_extractor: Callable[[RunResult], Awaitable[str]] | None = None,
+        custom_output_extractor: Callable[[
+            RunResult], Awaitable[str]] | None = None,
     ) -> Tool:
         """Transform this agent into a tool, callable by other agents.
 
         This is different from handoffs in two ways:
         1. In handoffs, the new agent receives the conversation history. In this tool, the new agent
-           receives generated input.
+        receives generated input.
         2. In handoffs, the new agent takes over the conversation. In this tool, the new agent is
-           called as a tool, and the conversation is continued by the original agent.
+        called as a tool, and the conversation is continued by the original agent.
 
         Args:
             tool_name: The name of the tool. If not provided, the agent's name will be used.
@@ -222,16 +223,25 @@ def as_tool(
         """
 
         @function_tool(
-            name_override=tool_name or _transforms.transform_string_function_style(self.name),
+            name_override=tool_name or _transforms.transform_string_function_style(
+                self.name),
             description_override=tool_description or "",
         )
         async def run_agent(context: RunContextWrapper, input: str) -> str:
             from .run import Runner
+            from .tracing import get_current_trace
+
+            # Get the current run_config from the trace context if available
+            run_config = None
+            current_trace = get_current_trace()
+            if current_trace and hasattr(current_trace, '_run_config'):
+                run_config = current_trace._run_config
 
             output = await Runner.run(
                 starting_agent=self,
                 input=input,
                 context=context.context,
+                run_config=run_config,
             )
             if custom_output_extractor:
                 return await custom_output_extractor(output)
@@ -250,7 +260,8 @@ async def get_system_prompt(self, run_context: RunContextWrapper[TContext]) -> s
             else:
                 return cast(str, self.instructions(run_context, self))
         elif self.instructions is not None:
-            logger.error(f"Instructions must be a string or a function, got {self.instructions}")
+            logger.error(
+                f"Instructions must be a string or a function, got {self.instructions}")
 
         return None
 
@@ -264,7 +275,8 @@ async def get_mcp_tools(
         self, run_context: RunContextWrapper[TContext]
     ) -> list[Tool]:
         """Fetches the available tools from the MCP servers."""
-        convert_schemas_to_strict = self.mcp_config.get("convert_schemas_to_strict", False)
+        convert_schemas_to_strict = self.mcp_config.get(
+            "convert_schemas_to_strict", False)
         return await MCPUtil.get_all_function_tools(
             self.mcp_servers, convert_schemas_to_strict, run_context, self
         )