feat(a2a): agents-as-tools

src/strands/tools/__init__.py

@@ -3,11 +3,13 @@
 This module provides the core functionality for creating, managing, and executing tools through agents.
 """
 
+from .agent_tool_wrapper import AgentToolWrapper
 from .decorator import tool
 from .structured_output import convert_pydantic_to_tool_spec
 from .tools import InvalidToolUseNameException, PythonAgentTool, normalize_schema, normalize_tool_spec
 
 __all__ = [
+    "AgentToolWrapper",
     "tool",
     "PythonAgentTool",
     "InvalidToolUseNameException",

src/strands/tools/agent_tool_wrapper.py

@@ -0,0 +1,114 @@
+"""Agent tool wrapper that enables using Agent objects as tools."""
+
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from ..agent.agent import Agent
+
+from ..types.tools import AgentTool, ToolGenerator, ToolResult, ToolResultContent, ToolSpec, ToolUse
+
+
+class AgentToolWrapper(AgentTool):
+    """Wrapper that makes an Agent usable as a tool.
+
+    This class enables the agents-as-tools pattern by wrapping an Agent
+    and implementing the AgentTool interface. The wrapped agent can then
+    be used as a tool by other agents.
+    """
+
+    def __init__(self, agent: "Agent"):
+        """Initialize the agent tool wrapper.
+
+        Args:
+            agent: The Agent instance to wrap
+        """
+        super().__init__()
+        self._agent = agent
+        self._validate_agent()
+        self._name = agent.name
+        self._description = agent.description or ""
+
+    def _validate_agent(self) -> None:
+        """Check if agent has the required attributes and they are properly set."""
+        if (
+            not hasattr(self._agent, "name")
+            or not hasattr(self._agent, "description")
+            or not self._agent.name
+            or self._agent.name == "Strands Agents"  # Default agent name
+            or not self._agent.description
+        ):
+            raise ValueError(
+                "Agent must have both 'name' and 'description' parameters "
+                "to be used as a tool. 'name' must not be default agent name: 'Strands Agents'. "
+                "Initialize the Agent with: "
+                "Agent(name='tool_name', description='tool_description', ...)"
+            )
+
+    @property
+    def tool_name(self) -> str:
+        """The unique name of the tool used for identification and invocation."""
+        return self._name
+
+    @property
+    def tool_spec(self) -> ToolSpec:
+        """Tool specification that describes its functionality and parameters."""
+        return ToolSpec(
+            name=self._name,
+            description=self._description,
+            inputSchema={
+                "type": "object",
+                "properties": {"prompt": {"type": "string", "description": "The prompt to send to the sub-agent"}},
+                "required": ["prompt"],
+            },
+        )
+
+    @property
+    def tool_type(self) -> str:
+        """The type of the tool implementation."""
+        return "agent"
+
+    async def stream(self, tool_use: ToolUse, invocation_state: dict[str, Any], **kwargs: Any) -> ToolGenerator:
+        """Stream tool events by delegating to the wrapped agent.
+
+        Args:
+            tool_use: The tool use request containing tool ID and parameters
+            invocation_state: Context for the tool invocation, including agent state
+            **kwargs: Additional keyword arguments for future extensibility
+
+        Yields:
+            Tool events with the last being the tool result
+        """
+        try:
+            # Extract the prompt from tool input
+            prompt = tool_use["input"].get("prompt", "")
+
+            # Invoke the sub-agent
+            result = await self._agent.invoke_async(prompt)
+
+            # Convert agent response to tool result format
+            tool_result = ToolResult(
+                toolUseId=tool_use["toolUseId"], status="success", content=[ToolResultContent(text=str(result))]
+            )
+
+            yield tool_result
+
+        except Exception as e:
+            # Return error result
+            tool_result = ToolResult(
+                toolUseId=tool_use["toolUseId"],
+                status="error",
+                content=[ToolResultContent(text=f"Error executing '{self._name}': {str(e)}")],
+            )
+            yield tool_result
+
+    def get_display_properties(self) -> dict[str, str]:
+        """Get properties to display in UI representations of this tool.
+
+        Returns:
+            Dictionary of property names and their string values
+        """
+        return {
+            "Name": self.tool_name,
+            "Type": self.tool_type,
+            "Description": self._description,
+        }

src/strands/tools/registry.py

@@ -18,6 +18,7 @@
 from strands.tools.decorator import DecoratedFunctionTool
 
 from ..types.tools import AgentTool, ToolSpec
+from .agent_tool_wrapper import AgentToolWrapper
 from .tools import PythonAgentTool, normalize_schema, normalize_tool_spec
 
 logger = logging.getLogger(__name__)
@@ -97,6 +98,12 @@ def process_tools(self, tools: List[Any]) -> List[str]:
             elif isinstance(tool, AgentTool):
                 self.register_tool(tool)
                 tool_names.append(tool.tool_name)
+
+            # Case 6: Agent as tools
+            elif self._is_agent_instance(tool):
+                agent_tool = AgentToolWrapper(tool)
+                self.register_tool(agent_tool)
+                tool_names.append(agent_tool.tool_name)
             else:
                 logger.warning("tool=<%s> | unrecognized tool specification", tool)
 
@@ -598,3 +605,10 @@ def _scan_module_for_tools(self, module: Any) -> List[AgentTool]:
                     logger.warning("tool_name=<%s> | failed to create function tool | %s", name, e)
 
         return tools
+
+    def _is_agent_instance(self, obj: Any) -> bool:
+        """Check if an object is an Agent instance."""
+        # Use local import to avoid circular dependencies
+        from ..agent.agent import Agent
+
+        return isinstance(obj, Agent)