Update ADK doc for TransferToAgentTool and unique sub-agent names

Author: xuanyang15

docs/agents/multi-agents.md

@@ -29,6 +29,7 @@ The foundation for structuring multi-agent systems is the parent-child relations
 
 * **Establishing Hierarchy:** You create a tree structure by passing a list of agent instances to the `sub_agents` argument when initializing a parent agent. ADK automatically sets the `parent_agent` attribute on each child agent during initialization.
 * **Single Parent Rule:** An agent instance can only be added as a sub-agent once. Attempting to assign a second parent will result in a `ValueError`.
+* **Unique Sub-Agent Names:** All sub-agents of a parent agent must have unique names. The framework validates this, and will raise a `ValueError` if duplicate names are detected among sub-agents.
 * **Importance:** This hierarchy defines the scope for [Workflow Agents](#workflow-agents-as-orchestrators) and influences the potential targets for LLM-Driven Delegation. You can navigate the hierarchy using `agent.parent_agent` or find descendants using `agent.find_agent(name)`.
 
 === "Python"
@@ -348,29 +349,37 @@ Leverages an [`LlmAgent`](llm-agents.md)'s understanding to dynamically route ta
 
 * **Mechanism:** The agent's LLM generates a specific function call: `transfer_to_agent(agent_name='target_agent_name')`.
 * **Handling:** The `AutoFlow`, used by default when sub-agents are present or transfer isn't disallowed, intercepts this call. It identifies the target agent using `root_agent.find_agent()` and updates the `InvocationContext` to switch execution focus.
+* **Robustness with `TransferToAgentTool`**: To make this process more reliable, ADK provides the `TransferToAgentTool`. This tool wraps the standard `transfer_to_agent` function and adds enum constraints to the `agent_name` parameter. This prevents the LLM from hallucinating or calling non-existent agent names by restricting its choices to a predefined list of valid sub-agents, significantly reducing runtime errors.
 * **Requires:** The calling `LlmAgent` needs clear `instructions` on when to transfer, and potential target agents need distinct `description`s for the LLM to make informed decisions. Transfer scope (parent, sub-agent, siblings) can be configured on the `LlmAgent`.
 * **Nature:** Dynamic, flexible routing based on LLM interpretation.
 
 === "Python"
 
     ```python
-    # Conceptual Setup: LLM Transfer
+    # Conceptual Setup: LLM Transfer with TransferToAgentTool
     from google.adk.agents import LlmAgent
+    from google.adk.tools import TransferToAgentTool
 
     booking_agent = LlmAgent(name="Booker", description="Handles flight and hotel bookings.")
     info_agent = LlmAgent(name="Info", description="Provides general information and answers questions.")
 
+    # The TransferToAgentTool is initialized with the names of the valid sub-agents
+    transfer_tool = TransferToAgentTool(
+        agent_names=[booking_agent.name, info_agent.name]
+    )
+
     coordinator = LlmAgent(
         name="Coordinator",
         model="gemini-2.0-flash",
         instruction="You are an assistant. Delegate booking tasks to Booker and info requests to Info.",
         description="Main coordinator.",
-        # AutoFlow is typically used implicitly here
+        tools=[transfer_tool],  # Include the transfer tool
         sub_agents=[booking_agent, info_agent]
     )
     # If coordinator receives "Book a flight", its LLM should generate:
     # FunctionCall(name='transfer_to_agent', args={'agent_name': 'Booker'})
     # ADK framework then routes execution to booking_agent.
+    # The enum constraint in TransferToAgentTool ensures the LLM can only pick 'Booker' or 'Info'.
     ```
 
 === "Java"
@@ -483,7 +492,7 @@ Allows an [`LlmAgent`](llm-agents.md) to treat another `BaseAgent` instance as a
 
         Event responseEvent = Event.builder()
             .author(this.name())
-            .content(Content.fromParts(Part.fromText("\b...")))
+            .content(Content.fromParts(Part.fromText("...")))
             .build();
 
         return Flowable.just(responseEvent);
@@ -557,16 +566,21 @@ By combining ADK's composition primitives, you can implement various established
     ```python
     # Conceptual Code: Coordinator using LLM Transfer
     from google.adk.agents import LlmAgent
+    from google.adk.tools import TransferToAgentTool
 
     billing_agent = LlmAgent(name="Billing", description="Handles billing inquiries.")
     support_agent = LlmAgent(name="Support", description="Handles technical support requests.")
+    
+    transfer_tool = TransferToAgentTool(
+        agent_names=[billing_agent.name, support_agent.name]
+    )
 
     coordinator = LlmAgent(
         name="HelpDeskCoordinator",
         model="gemini-2.0-flash",
         instruction="Route user requests: Use Billing agent for payment issues, Support agent for technical problems.",
         description="Main help desk router.",
-        # allow_transfer=True is often implicit with sub_agents in AutoFlow
+        tools=[transfer_tool],
         sub_agents=[billing_agent, support_agent]
     )
     # User asks "My payment failed" -> Coordinator's LLM should call transfer_to_agent(agent_name='Billing')

docs/tutorials/agent-team.md

@@ -667,7 +667,7 @@ A more robust approach is to build an **Agent Team**. This involves:
 1. Define simple tools for handling greetings (`say_hello`) and farewells (`say_goodbye`).  
 2. Create two new specialized sub-agents: `greeting_agent` and `farewell_agent`.  
 3. Update our main weather agent (`weather_agent_v2`) to act as the **root agent**.  
-4. Configure the root agent with its sub-agents, enabling **automatic delegation**.  
+4. Configure the root agent with its sub-agents, enabling **automatic delegation** using the `TransferToAgentTool`.
 5. Test the delegation flow by sending different types of requests to the root agent.
 
 ---
@@ -727,6 +727,7 @@ Now, create the `Agent` instances for our specialists. Notice their highly focus
 
 ```python
 # @title Define Greeting and Farewell Sub-Agents
+from google.adk.tools import TransferToAgentTool
 
 # If you want to use models other than Gemini, Ensure LiteLlm is imported and API keys are set (from Step 0/2)
 # from google.adk.models.lite_llm import LiteLlm
@@ -778,12 +779,13 @@ except Exception as e:
 
 Now, we upgrade our `weather_agent`. The key changes are:
 
-* Adding the `sub_agents` parameter: We pass a list containing the `greeting_agent` and `farewell_agent` instances we just created.  
-* Updating the `instruction`: We explicitly tell the root agent *about* its sub-agents and *when* it should delegate tasks to them.
+* Adding the `sub_agents` parameter: We pass a list containing the `greeting_agent` and `farewell_agent` instances we just created.
+* Using the `TransferToAgentTool`: We create an instance of `TransferToAgentTool` with the names of our sub-agents and add it to the root agent's tools.
+* Updating the `instruction`: We explicitly tell the root agent *about* its sub-agents and instruct it to use the `transfer_to_agent` tool for delegation.
 
-**Key Concept: Automatic Delegation (Auto Flow)** By providing the `sub_agents` list, ADK enables automatic delegation. When the root agent receives a user query, its LLM considers not only its own instructions and tools but also the `description` of each sub-agent. If the LLM determines that a query aligns better with a sub-agent's described capability (e.g., "Handles simple greetings"), it will automatically generate a special internal action to *transfer control* to that sub-agent for that turn. The sub-agent then processes the query using its own model, instructions, and tools.
+**Key Concept: Delegation with `TransferToAgentTool`** By providing the `sub_agents` list and the `TransferToAgentTool`, we set up a robust delegation system. When the root agent receives a user query, its LLM considers its own instructions and tools, including the `transfer_to_agent` tool. The `TransferToAgentTool` constrains the `agent_name` parameter to only the names of the sub-agents, preventing the LLM from hallucinating non-existent agents. If the LLM determines a query matches a sub-agent's `description`, it will call the `transfer_to_agent` tool with the correct agent name, and ADK will transfer control to that sub-agent.
 
-**Best Practice:** Ensure the root agent's instructions clearly guide its delegation decisions. Mention the sub-agents by name and describe the conditions under which delegation should occur.
+**Best Practice:** Ensure the root agent's instructions clearly guide its delegation decisions. Mention the sub-agents by name and describe the conditions under which the `transfer_to_agent` tool should be used.
 
 
 ```python
@@ -797,6 +799,11 @@ runner_root = None # Initialize runner
 if greeting_agent and farewell_agent and 'get_weather' in globals():
     # Let's use a capable Gemini model for the root agent to handle orchestration
     root_agent_model = MODEL_GEMINI_2_0_FLASH
+    
+    # Create the TransferToAgentTool with the names of the sub-agents
+    transfer_tool = TransferToAgentTool(
+        agent_names=[greeting_agent.name, farewell_agent.name]
+    )
 
     weather_agent_team = Agent(
         name="weather_agent_v2", # Give it a new version name
@@ -808,9 +815,10 @@ if greeting_agent and farewell_agent and 'get_weather' in globals():
                     "1. 'greeting_agent': Handles simple greetings like 'Hi', 'Hello'. Delegate to it for these. "
                     "2. 'farewell_agent': Handles simple farewells like 'Bye', 'See you'. Delegate to it for these. "
                     "Analyze the user's query. If it's a greeting, delegate to 'greeting_agent'. If it's a farewell, delegate to 'farewell_agent'. "
+                    "Use the 'transfer_to_agent' tool to delegate. "
                     "If it's a weather request, handle it yourself using 'get_weather'. "
                     "For anything else, respond appropriately or state you cannot handle it.",
-        tools=[get_weather], # Root agent still needs the weather tool for its core task
+        tools=[get_weather, transfer_tool], # Root agent has weather tool and transfer tool
         # Key change: Link the sub-agents here!
         sub_agents=[greeting_agent, farewell_agent]
     )
@@ -829,7 +837,7 @@ else:
 
 **4\. Interact with the Agent Team**
 
-Now that we've defined our root agent (`weather_agent_team` - *Note: Ensure this variable name matches the one defined in the previous code block, likely `# @title Define the Root Agent with Sub-Agents`, which might have named it `root_agent`*) with its specialized sub-agents, let's test the delegation mechanism.
+Now that we've defined our root agent (`weather_agent_team`) with its specialized sub-agents, let's test the delegation mechanism.
 
 The following code block will:
 
@@ -842,10 +850,11 @@ The following code block will:
 We expect the following flow:
 
 1.  The "Hello there!" query goes to `runner_agent_team`.
-2.  The root agent (`weather_agent_team`) receives it and, based on its instructions and the `greeting_agent`'s description, delegates the task.
+2.  The root agent (`weather_agent_team`) receives it and, based on its instructions, uses the `transfer_to_agent` tool to delegate the task to the `greeting_agent`.
 3.  `greeting_agent` handles the query, calls its `say_hello` tool, and generates the response.
 4.  The "What is the weather in New York?" query is *not* delegated and is handled directly by the root agent using its `get_weather` tool.
-5.  The "Thanks, bye!" query is delegated to the `farewell_agent`, which uses its `say_goodbye` tool.
+5.  The "Thanks, bye!" query is delegated to the `farewell_agent` using the `transfer_to_agent` tool, which then uses its `say_goodbye` tool.
+