Test adding the skills instead of just RemoteA2aAgent description

Author: luis5tb

src/google/adk/flows/llm_flows/agent_transfer.py

@@ -30,8 +30,11 @@
 from ._base_llm_processor import BaseLlmRequestProcessor
 
 if typing.TYPE_CHECKING:
+  from a2a.types import AgentCard
+
   from ...agents import BaseAgent
   from ...agents import LlmAgent
+  from ...agents.remote_a2a_agent import RemoteA2aAgent
 
 
 class _AgentTransferLlmRequestProcessor(BaseLlmRequestProcessor):
@@ -50,11 +53,11 @@ async def run_async(
     if not transfer_targets:
       return
 
-    llm_request.append_instructions([
-        _build_target_agents_instructions(
-            invocation_context.agent, transfer_targets
-        )
-    ])
+    # Build instructions asynchronously to support A2A agent card resolution
+    instructions = await _build_target_agents_instructions(
+        invocation_context.agent, transfer_targets
+    )
+    llm_request.append_instructions([instructions])
 
     transfer_to_agent_tool = FunctionTool(func=transfer_to_agent)
     tool_context = ToolContext(invocation_context)
@@ -69,7 +72,102 @@ async def run_async(
 request_processor = _AgentTransferLlmRequestProcessor()
 
 
+def _build_target_agent_info_from_card(
+    target_agent: RemoteA2aAgent, agent_card: AgentCard
+) -> str:
+  """Build rich agent info from A2A Agent Card.
+
+  Args:
+    target_agent: The RemoteA2aAgent instance
+    agent_card: The resolved A2A Agent Card
+
+  Returns:
+    Formatted string with detailed agent information from the card
+  """
+  info_parts = [f'Agent name: {target_agent.name}']
+
+  # Use card description if available, fallback to agent description
+  description = agent_card.description or target_agent.description
+  if description:
+    info_parts.append(f'Agent description: {description}')
+
+  # Add skills information from the card
+  if agent_card.skills:
+    skills_info = []
+    for skill in agent_card.skills:
+      skill_desc = f'  - {skill.name}'
+      if skill.description:
+        skill_desc += f': {skill.description}'
+      if skill.tags:
+        skill_desc += f' (tags: {", ".join(skill.tags)})'
+      skills_info.append(skill_desc)
+
+    info_parts.append(f'Agent skills:\n' + '\n'.join(skills_info))
+
+  # Add capabilities if available
+  if agent_card.capabilities:
+    caps = agent_card.capabilities
+    cap_info = []
+    if hasattr(caps, 'streaming') and caps.streaming:
+      cap_info.append('supports streaming')
+    if hasattr(caps, 'multimodal') and caps.multimodal:
+      cap_info.append('supports multimodal input/output')
+
+    if cap_info:
+      info_parts.append(f'Capabilities: {", ".join(cap_info)}')
+
+  # Add input/output modes
+  if agent_card.default_input_modes:
+    info_parts.append(
+        f'Input modes: {", ".join(agent_card.default_input_modes)}'
+    )
+  if agent_card.default_output_modes:
+    info_parts.append(
+        f'Output modes: {", ".join(agent_card.default_output_modes)}'
+    )
+
+  return '\n'.join(info_parts)
+
+
+async def _build_target_agents_info_async(target_agent: BaseAgent) -> str:
+  """Build agent info, using A2A Agent Card if available.
+
+  Args:
+    target_agent: The agent to build info for
+
+  Returns:
+    Formatted string with agent information
+  """
+  from ...agents.remote_a2a_agent import RemoteA2aAgent
+
+  # Check if this is a RemoteA2aAgent and ensure it's resolved
+  if isinstance(target_agent, RemoteA2aAgent):
+    try:
+      # Ensure the agent card is resolved
+      await target_agent._ensure_resolved()
+
+      # If we have an agent card, use it to build rich info
+      if target_agent._agent_card:
+        return _build_target_agent_info_from_card(
+            target_agent, target_agent._agent_card
+        )
+    except Exception:
+      # If resolution fails, fall through to default behavior
+      pass
+
+  # Fallback to original behavior for non-A2A agents or if card unavailable
+  return _build_target_agents_info(target_agent)
+
+
 def _build_target_agents_info(target_agent: BaseAgent) -> str:
+  """Build basic agent info (fallback for non-A2A agents).
+
+  Args:
+    target_agent: The agent to build info for
+
+  Returns:
+    Formatted string with basic agent information
+  """
   return f"""
 Agent name: {target_agent.name}
 Agent description: {target_agent.description}
@@ -79,9 +177,18 @@ def _build_target_agents_info(target_agent: BaseAgent) -> str:
 line_break = '\n'
 
 
-def _build_target_agents_instructions(
+async def _build_target_agents_instructions(
     agent: LlmAgent, target_agents: list[BaseAgent]
 ) -> str:
+  """Build instructions for agent transfer with detailed agent information.
+
+  Args:
+    agent: The current agent
+    target_agents: List of agents that can be transferred to
+
+  Returns:
+    Formatted instructions string with agent transfer information
+  """
   # Build list of available agent names for the NOTE
   # target_agents already includes parent agent if applicable, so no need to add it again
   available_agent_names = [target_agent.name for target_agent in target_agents]
@@ -94,12 +201,16 @@ def _build_target_agents_instructions(
       f'`{name}`' for name in available_agent_names
   )
 
+  # Build agent info asynchronously to support A2A agent card resolution
+  agent_info_list = []
+  for target_agent in target_agents:
+    agent_info = await _build_target_agents_info_async(target_agent)
+    agent_info_list.append(agent_info)
+
   si = f"""
 You have a list of other agents to transfer to:
 
-{line_break.join([
-    _build_target_agents_info(target_agent) for target_agent in target_agents
-])}
+{line_break.join(agent_info_list)}
 
 If you are the best to answer the question according to your description, you
 can answer it.