Merge branch 'main' into fix/litellm-streaming-content-duplication

Author: thesynapses

contributing/samples/adk_triaging_agent/agent.py

@@ -78,38 +78,6 @@
   APPROVAL_INSTRUCTION = "Only label them when the user approves the labeling!"
 
 
-def list_unlabeled_issues(issue_count: int) -> dict[str, Any]:
-  """List most recent `issue_count` number of unlabeled issues in the repo.
-
-  Args:
-    issue_count: number of issues to return
-
-  Returns:
-    The status of this request, with a list of issues when successful.
-  """
-  url = f"{GITHUB_BASE_URL}/search/issues"
-  query = f"repo:{OWNER}/{REPO} is:open is:issue no:label"
-  params = {
-      "q": query,
-      "sort": "created",
-      "order": "desc",
-      "per_page": issue_count,
-      "page": 1,
-  }
-
-  try:
-    response = get_request(url, params)
-  except requests.exceptions.RequestException as e:
-    return error_response(f"Error: {e}")
-  issues = response.get("items", None)
-
-  unlabeled_issues = []
-  for issue in issues:
-    if not issue.get("labels", None):
-      unlabeled_issues.append(issue)
-  return {"status": "success", "issues": unlabeled_issues}
-
-
 def list_planned_untriaged_issues(issue_count: int) -> dict[str, Any]:
   """List planned issues without component labels (e.g., core, tools, etc.).
 
@@ -276,7 +244,6 @@ def change_issue_type(issue_number: int, issue_type: str) -> dict[str, Any]:
       - the owner of the label if you assign the issue to an owner
     """,
     tools=[
-        list_unlabeled_issues,
         list_planned_untriaged_issues,
         add_label_and_owner_to_issue,
         change_issue_type,

contributing/samples/adk_triaging_agent/main.py

@@ -144,7 +144,8 @@ async def main():
         f" most recent {issue_count} planned issues that haven't been"
         " triaged yet (i.e., issues with 'planned' label but no component"
         " labels like 'core', 'tools', etc.). Then triage each of them by"
-        " applying appropriate component labels."
+        " applying appropriate component labels. If you cannot find any planned"
+        " issues, please don't try to triage any issues."
     )
 
   response = await call_agent_async(runner, USER_ID, session.id, prompt)

src/google/adk/agents/base_agent.py

@@ -15,6 +15,7 @@
 from __future__ import annotations
 
 import inspect
+import logging
 from typing import Any
 from typing import AsyncGenerator
 from typing import Awaitable
@@ -49,6 +50,8 @@
 if TYPE_CHECKING:
   from .invocation_context import InvocationContext
 
+logger = logging.getLogger('google_adk.' + __name__)
+
 _SingleAgentCallback: TypeAlias = Callable[
     [CallbackContext],
     Union[Awaitable[Optional[types.Content]], Optional[types.Content]],
@@ -563,6 +566,45 @@ def validate_name(cls, value: str):
       )
     return value
 
+  @field_validator('sub_agents', mode='after')
+  @classmethod
+  def validate_sub_agents_unique_names(
+      cls, value: list[BaseAgent]
+  ) -> list[BaseAgent]:
+    """Validates that all sub-agents have unique names.
+
+    Args:
+      value: The list of sub-agents to validate.
+
+    Returns:
+      The validated list of sub-agents.
+
+    """
+    if not value:
+      return value
+
+    seen_names: set[str] = set()
+    duplicates: set[str] = set()
+
+    for sub_agent in value:
+      name = sub_agent.name
+      if name in seen_names:
+        duplicates.add(name)
+      else:
+        seen_names.add(name)
+
+    if duplicates:
+      duplicate_names_str = ', '.join(
+          f'`{name}`' for name in sorted(duplicates)
+      )
+      logger.warning(
+          'Found duplicate sub-agent names: %s. '
+          'All sub-agents must have unique names.',
+          duplicate_names_str,
+      )
+
+    return value
+
   def __set_parent_agent_for_sub_agents(self) -> BaseAgent:
     for sub_agent in self.sub_agents:
       if sub_agent.parent_agent is not None:

src/google/adk/agents/config_agent_utils.py

@@ -132,7 +132,7 @@ def resolve_agent_reference(
     else:
       return from_config(
           os.path.join(
-              referencing_agent_config_abs_path.rsplit("/", 1)[0],
+              os.path.dirname(referencing_agent_config_abs_path),
               ref_config.config_path,
           )
       )

src/google/adk/agents/remote_a2a_agent.py

@@ -417,7 +417,9 @@ async def _handle_a2a_response(
           # This is the initial response for a streaming task or the complete
           # response for a non-streaming task, which is the full task state.
           # We process this to get the initial message.
-          event = convert_a2a_task_to_event(task, self.name, ctx)
+          event = convert_a2a_task_to_event(
+              task, self.name, ctx, self._a2a_part_converter
+          )
           # for streaming task, we update the event with the task status.
           # We update the event as Thought updates.
           if task and task.status and task.status.state == TaskState.submitted:
@@ -429,7 +431,7 @@ async def _handle_a2a_response(
         ):
           # This is a streaming task status update with a message.
           event = convert_a2a_message_to_event(
-              update.status.message, self.name, ctx
+              update.status.message, self.name, ctx, self._a2a_part_converter
           )
           if event.content and update.status.state in [
               TaskState.submitted,
@@ -447,7 +449,9 @@ async def _handle_a2a_response(
           # signals:
           # 1. append: True for partial updates, False for full updates.
           # 2. last_chunk: True for full updates, False for partial updates.
-          event = convert_a2a_task_to_event(task, self.name, ctx)
+          event = convert_a2a_task_to_event(
+              task, self.name, ctx, self._a2a_part_converter
+          )
         else:
           # This is a streaming update without a message (e.g. status change)
           # or a partial artifact update. We don't emit an event for these
@@ -463,7 +467,9 @@ async def _handle_a2a_response(
 
       # Otherwise, it's a regular A2AMessage for non-streaming responses.
       elif isinstance(a2a_response, A2AMessage):
-        event = convert_a2a_message_to_event(a2a_response, self.name, ctx)
+        event = convert_a2a_message_to_event(
+            a2a_response, self.name, ctx, self._a2a_part_converter
+        )
         event.custom_metadata = event.custom_metadata or {}
 
         if a2a_response.context_id:

src/google/adk/cli/utils/agent_loader.py

@@ -58,7 +58,7 @@ class AgentLoader(BaseAgentLoader):
   """
 
   def __init__(self, agents_dir: str):
-    self.agents_dir = agents_dir.rstrip("/")
+    self.agents_dir = str(Path(agents_dir))
     self._original_sys_path = None
     self._agent_cache: dict[str, Union[BaseAgent, App]] = {}
 
@@ -272,12 +272,13 @@ def _perform_load(self, agent_name: str) -> Union[BaseAgent, App]:
         f"No root_agent found for '{agent_name}'. Searched in"
         f" '{actual_agent_name}.agent.root_agent',"
         f" '{actual_agent_name}.root_agent' and"
-        f" '{actual_agent_name}/root_agent.yaml'.\n\nExpected directory"
-        f" structure:\n  <agents_dir>/\n    {actual_agent_name}/\n     "
-        " agent.py (with root_agent) OR\n      root_agent.yaml\n\nThen run:"
-        f" adk web <agents_dir>\n\nEnsure '{agents_dir}/{actual_agent_name}' is"
-        " structured correctly, an .env file can be loaded if present, and a"
-        f" root_agent is exposed.{hint}"
+        f" '{actual_agent_name}{os.sep}root_agent.yaml'.\n\nExpected directory"
+        f" structure:\n  <agents_dir>{os.sep}\n   "
+        f" {actual_agent_name}{os.sep}\n      agent.py (with root_agent) OR\n  "
+        "    root_agent.yaml\n\nThen run: adk web <agents_dir>\n\nEnsure"
+        f" '{os.path.join(agents_dir, actual_agent_name)}' is structured"
+        " correctly, an .env file can be loaded if present, and a root_agent"
+        f" is exposed.{hint}"
     )
 
   def _record_origin_metadata(

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

@@ -24,9 +24,8 @@
 from ...agents.invocation_context import InvocationContext
 from ...events.event import Event
 from ...models.llm_request import LlmRequest
-from ...tools.function_tool import FunctionTool
 from ...tools.tool_context import ToolContext
-from ...tools.transfer_to_agent_tool import transfer_to_agent
+from ...tools.transfer_to_agent_tool import TransferToAgentTool
 from ._base_llm_processor import BaseLlmRequestProcessor
 
 if typing.TYPE_CHECKING:
@@ -50,13 +49,18 @@ async def run_async(
     if not transfer_targets:
       return
 
+    transfer_to_agent_tool = TransferToAgentTool(
+        agent_names=[agent.name for agent in transfer_targets]
+    )
+
     llm_request.append_instructions([
         _build_target_agents_instructions(
-            invocation_context.agent, transfer_targets
+            transfer_to_agent_tool.name,
+            invocation_context.agent,
+            transfer_targets,
         )
     ])
 
-    transfer_to_agent_tool = FunctionTool(func=transfer_to_agent)
     tool_context = ToolContext(invocation_context)
     await transfer_to_agent_tool.process_llm_request(
         tool_context=tool_context, llm_request=llm_request
@@ -80,10 +84,13 @@ def _build_target_agents_info(target_agent: BaseAgent) -> str:
 
 
 def _build_target_agents_instructions(
-    agent: LlmAgent, target_agents: list[BaseAgent]
+    tool_name: str,
+    agent: LlmAgent,
+    target_agents: list[BaseAgent],
 ) -> str:
   # Build list of available agent names for the NOTE
-  # target_agents already includes parent agent if applicable, so no need to add it again
+  # 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]
 
   # Sort for consistency
@@ -101,15 +108,16 @@ def _build_target_agents_instructions(
     _build_target_agents_info(target_agent) for target_agent in target_agents
 ])}
 
-If you are the best to answer the question according to your description, you
-can answer it.
+If you are the best to answer the question according to your description,
+you can answer it.
 
 If another agent is better for answering the question according to its
-description, call `{_TRANSFER_TO_AGENT_FUNCTION_NAME}` function to transfer the
-question to that agent. When transferring, do not generate any text other than
-the function call.
+description, call `{tool_name}` function to transfer the question to that
+agent. When transferring, do not generate any text other than the function
+call.
 
-**NOTE**: the only available agents for `{_TRANSFER_TO_AGENT_FUNCTION_NAME}` function are {formatted_agent_names}.
+**NOTE**: the only available agents for `{tool_name}` function are
+{formatted_agent_names}.
 """
 
   if agent.parent_agent and not agent.disallow_transfer_to_parent:
@@ -119,9 +127,6 @@ def _build_target_agents_instructions(
   return si
 
 
-_TRANSFER_TO_AGENT_FUNCTION_NAME = transfer_to_agent.__name__
-
-
 def _get_transfer_targets(agent: LlmAgent) -> list[BaseAgent]:
   from ...agents.llm_agent import LlmAgent
 

src/google/adk/tools/__init__.py

@@ -37,6 +37,7 @@
   from .preload_memory_tool import preload_memory_tool as preload_memory
   from .tool_context import ToolContext
   from .transfer_to_agent_tool import transfer_to_agent
+  from .transfer_to_agent_tool import TransferToAgentTool
   from .url_context_tool import url_context
   from .vertex_ai_search_tool import VertexAiSearchTool
 
@@ -75,6 +76,10 @@
     'preload_memory': ('.preload_memory_tool', 'preload_memory_tool'),
     'ToolContext': ('.tool_context', 'ToolContext'),
     'transfer_to_agent': ('.transfer_to_agent_tool', 'transfer_to_agent'),
+    'TransferToAgentTool': (
+        '.transfer_to_agent_tool',
+        'TransferToAgentTool',
+    ),
     'url_context': ('.url_context_tool', 'url_context'),
     'VertexAiSearchTool': ('.vertex_ai_search_tool', 'VertexAiSearchTool'),
     'MCPToolset': ('.mcp_tool.mcp_toolset', 'MCPToolset'),

src/google/adk/tools/transfer_to_agent_tool.py

@@ -14,6 +14,12 @@
 
 from __future__ import annotations
 
+from typing import Optional
+
+from google.genai import types
+from typing_extensions import override
+
+from .function_tool import FunctionTool
 from .tool_context import ToolContext
 
 
@@ -23,7 +29,61 @@ def transfer_to_agent(agent_name: str, tool_context: ToolContext) -> None:
   This tool hands off control to another agent when it's more suitable to
   answer the user's question according to the agent's description.
 
+  Note:
+    For most use cases, you should use TransferToAgentTool instead of this
+    function directly. TransferToAgentTool provides additional enum constraints
+    that prevent LLMs from hallucinating invalid agent names.
+
   Args:
     agent_name: the agent name to transfer to.
   """
   tool_context.actions.transfer_to_agent = agent_name
+
+
+class TransferToAgentTool(FunctionTool):
+  """A specialized FunctionTool for agent transfer with enum constraints.
+
+  This tool enhances the base transfer_to_agent function by adding JSON Schema
+  enum constraints to the agent_name parameter. This prevents LLMs from
+  hallucinating invalid agent names by restricting choices to only valid agents.
+
+  Attributes:
+    agent_names: List of valid agent names that can be transferred to.
+  """
+
+  def __init__(
+      self,
+      agent_names: list[str],
+  ):
+    """Initialize the TransferToAgentTool.
+
+    Args:
+      agent_names: List of valid agent names that can be transferred to.
+    """
+    super().__init__(func=transfer_to_agent)
+    self._agent_names = agent_names
+
+  @override
+  def _get_declaration(self) -> Optional[types.FunctionDeclaration]:
+    """Add enum constraint to the agent_name parameter.
+
+    Returns:
+      FunctionDeclaration with enum constraint on agent_name parameter.
+    """
+    function_decl = super()._get_declaration()
+    if not function_decl:
+      return function_decl
+
+    # Handle parameters (types.Schema object)
+    if function_decl.parameters:
+      agent_name_schema = function_decl.parameters.properties.get('agent_name')
+      if agent_name_schema:
+        agent_name_schema.enum = self._agent_names
+
+    # Handle parameters_json_schema (dict)
+    if function_decl.parameters_json_schema:
+      properties = function_decl.parameters_json_schema.get('properties', {})
+      if 'agent_name' in properties:
+        properties['agent_name']['enum'] = self._agent_names
+
+    return function_decl