feat: Enhance error messages for tool and agent not found errors

Improve developer experience by providing actionable error messages with:
- Clear description of what went wrong
- List of available tools/agents (truncated to 20 for readability)
- Possible causes and suggested fixes
- Fuzzy matching suggestions ("Did you mean...?")

Addresses community issues:
- #2050: Tool verification callback request
- #2933: How to handle Function Not Found error (12 comments)
- #2164: Agent not found ValueError

Changes:
- Enhanced _get_tool() error message in functions.py
- Enhanced __get_agent_to_run() error message in llm_agent.py
- Added _get_available_agent_names() helper for agent tree traversal
- Added fuzzy matching using difflib (standard library)
- Truncates long lists to first 20 items for readability
- Comprehensive unit tests for error scenarios (8 tests, all passing)

Testing:
- pytest tests/unittests/flows/llm_flows/test_functions_error_messages.py: 4/4 passed
- pytest tests/unittests/agents/test_llm_agent_error_messages.py: 4/4 passed
- Performance: < 0.03ms per error (error path only, no hot path impact)

Fixes #3217

Author: jpantsjoha

src/google/adk/agents/llm_agent.py

@@ -641,9 +641,67 @@ def __get_agent_to_run(self, agent_name: str) -> BaseAgent:
     """Find the agent to run under the root agent by name."""
     agent_to_run = self.root_agent.find_agent(agent_name)
     if not agent_to_run:
-      raise ValueError(f'Agent {agent_name} not found in the agent tree.')
+      # Enhanced error message with agent tree context
+      available_agents = self._get_available_agent_names()
+
+      # Truncate to first 20 for readability (prevents log overflow)
+      if len(available_agents) > 20:
+        agents_preview = ', '.join(available_agents[:20])
+        agents_msg = (
+            f'Available agents (showing first 20 of {len(available_agents)}):'
+            f' {agents_preview}...'
+        )
+      else:
+        agents_msg = f"Available agents: {', '.join(available_agents)}"
+
+      error_msg = (
+          f"Agent '{agent_name}' not found in the agent tree.\n\n"
+          f'{agents_msg}\n\n'
+          'Possible causes:\n'
+          '  1. Agent not registered before being referenced\n'
+          '  2. Agent name mismatch (typo or case sensitivity)\n'
+          '  3. Timing issue (agent referenced before creation)\n\n'
+          'Suggested fixes:\n'
+          '  - Verify agent is registered with root agent\n'
+          '  - Check agent name spelling and case\n'
+          '  - Ensure agents are created before being referenced\n'
+      )
+
+      # Fuzzy matching suggestion
+      from difflib import get_close_matches
+
+      close_matches = get_close_matches(
+          agent_name, available_agents, n=3, cutoff=0.6
+      )
+      if close_matches:
+        error_msg += f'\nDid you mean one of these?\n'
+        for match in close_matches:
+          error_msg += f'  - {match}\n'
+
+      raise ValueError(error_msg)
     return agent_to_run
 
+  def _get_available_agent_names(self) -> list[str]:
+    """Helper to get all agent names in the tree for error reporting.
+
+    This is a private helper method used only for error message formatting.
+    Traverses the agent tree starting from root_agent and collects all
+    agent names for display in error messages.
+
+    Returns:
+      List of all agent names in the agent tree.
+    """
+    agents = []
+
+    def collect_agents(agent):
+      agents.append(agent.name)
+      if hasattr(agent, 'sub_agents') and agent.sub_agents:
+        for sub_agent in agent.sub_agents:
+          collect_agents(sub_agent)
+
+    collect_agents(self.root_agent)
+    return agents
+
   def __get_transfer_to_agent_or_none(
       self, event: Event, from_agent: str
   ) -> Optional[BaseAgent]:

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

@@ -660,10 +660,46 @@ def _get_tool(
 ):
   """Returns the tool corresponding to the function call."""
   if function_call.name not in tools_dict:
-    raise ValueError(
-        f'Function {function_call.name} is not found in the tools_dict:'
-        f' {tools_dict.keys()}.'
+    # Enhanced error message with actionable guidance
+    available_tools = list(tools_dict.keys())
+
+    # Truncate to first 20 for readability (prevents log overflow)
+    if len(available_tools) > 20:
+      tools_preview = ', '.join(available_tools[:20])
+      tools_msg = (
+          f'Available tools (showing first 20 of {len(available_tools)}):'
+          f' {tools_preview}...'
+      )
+    else:
+      tools_msg = f"Available tools: {', '.join(available_tools)}"
+
+    error_msg = (
+        f"Function '{function_call.name}' is not found in available"
+        ' tools.\n\n'
+        f'{tools_msg}\n\n'
+        'Possible causes:\n'
+        '  1. LLM hallucinated the function name - review agent'
+        ' instruction clarity\n'
+        '  2. Tool not registered - verify agent.tools list\n'
+        '  3. Name mismatch - check for typos\n\n'
+        'Suggested fixes:\n'
+        '  - Review agent instruction to ensure tool usage is clear\n'
+        '  - Verify tool is included in agent.tools list\n'
+        '  - Check for typos in function name\n'
+    )
+
+    # Fuzzy matching suggestion
+    from difflib import get_close_matches
+
+    close_matches = get_close_matches(
+        function_call.name, available_tools, n=3, cutoff=0.6
     )
+    if close_matches:
+      error_msg += f'\nDid you mean one of these?\n'
+      for match in close_matches:
+        error_msg += f'  - {match}\n'
+
+    raise ValueError(error_msg)
 
   return tools_dict[function_call.name]
 

tests/unittests/agents/test_llm_agent_error_messages.py

@@ -0,0 +1,109 @@
+# Copyright 2025 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Tests for enhanced error messages in agent handling."""
+from google.adk.agents import LlmAgent
+import pytest
+
+
+def test_agent_not_found_enhanced_error():
+  """Verify enhanced error message for agent not found."""
+  root_agent = LlmAgent(
+      name='root',
+      model='gemini-2.0-flash',
+      sub_agents=[
+          LlmAgent(name='agent_a', model='gemini-2.0-flash'),
+          LlmAgent(name='agent_b', model='gemini-2.0-flash'),
+      ],
+  )
+
+  with pytest.raises(ValueError) as exc_info:
+    root_agent._LlmAgent__get_agent_to_run('nonexistent_agent')
+
+  error_msg = str(exc_info.value)
+
+  # Verify error message components
+  assert 'nonexistent_agent' in error_msg
+  assert 'Available agents:' in error_msg
+  assert 'agent_a' in error_msg
+  assert 'agent_b' in error_msg
+  assert 'Possible causes:' in error_msg
+  assert 'Suggested fixes:' in error_msg
+
+
+def test_agent_not_found_fuzzy_matching():
+  """Verify fuzzy matching for agent names."""
+  root_agent = LlmAgent(
+      name='root',
+      model='gemini-2.0-flash',
+      sub_agents=[
+          LlmAgent(name='approval_handler', model='gemini-2.0-flash'),
+      ],
+  )
+
+  with pytest.raises(ValueError) as exc_info:
+    root_agent._LlmAgent__get_agent_to_run('aproval_handler')  # Typo
+
+  error_msg = str(exc_info.value)
+
+  # Verify fuzzy matching suggests correct agent
+  assert 'Did you mean' in error_msg
+  assert 'approval_handler' in error_msg
+
+
+def test_agent_tree_traversal():
+  """Verify agent tree traversal helper works correctly."""
+  root_agent = LlmAgent(
+      name='orchestrator',
+      model='gemini-2.0-flash',
+      sub_agents=[
+          LlmAgent(
+              name='parent_agent',
+              model='gemini-2.0-flash',
+              sub_agents=[
+                  LlmAgent(name='child_agent', model='gemini-2.0-flash'),
+              ],
+          ),
+      ],
+  )
+
+  available_agents = root_agent._get_available_agent_names()
+
+  # Verify all agents in tree are found
+  assert 'orchestrator' in available_agents
+  assert 'parent_agent' in available_agents
+  assert 'child_agent' in available_agents
+  assert len(available_agents) == 3
+
+
+def test_agent_not_found_truncates_long_list():
+  """Verify error message truncates when 100+ agents exist."""
+  # Create 100 sub-agents
+  sub_agents = [
+      LlmAgent(name=f'agent_{i}', model='gemini-2.0-flash') for i in range(100)
+  ]
+
+  root_agent = LlmAgent(
+      name='root', model='gemini-2.0-flash', sub_agents=sub_agents
+  )
+
+  with pytest.raises(ValueError) as exc_info:
+    root_agent._LlmAgent__get_agent_to_run('nonexistent')
+
+  error_msg = str(exc_info.value)
+
+  # Verify truncation message
+  assert 'showing first 20 of' in error_msg
+  assert 'agent_0' in error_msg  # First agent shown
+  assert 'agent_99' not in error_msg  # Last agent NOT shown

tests/unittests/flows/llm_flows/test_functions_error_messages.py

@@ -0,0 +1,105 @@
+# Copyright 2025 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Tests for enhanced error messages in function tool handling."""
+from google.adk.flows.llm_flows.functions import _get_tool
+from google.adk.tools import BaseTool
+from google.genai import types
+import pytest
+
+
+# Mock tool for testing error messages
+class MockTool(BaseTool):
+  """Mock tool for testing error messages."""
+
+  def __init__(self, name: str = 'mock_tool'):
+    super().__init__(name=name, description=f'Mock tool: {name}')
+
+  def call(self, *args, **kwargs):
+    return 'mock_response'
+
+
+def test_tool_not_found_enhanced_error():
+  """Verify enhanced error message for tool not found."""
+  function_call = types.FunctionCall(name='nonexistent_tool', args={})
+  tools_dict = {
+      'get_weather': MockTool(name='get_weather'),
+      'calculate_sum': MockTool(name='calculate_sum'),
+      'search_database': MockTool(name='search_database'),
+  }
+
+  with pytest.raises(ValueError) as exc_info:
+    _get_tool(function_call, tools_dict)
+
+  error_msg = str(exc_info.value)
+
+  # Verify error message components
+  assert 'nonexistent_tool' in error_msg
+  assert 'Available tools:' in error_msg
+  assert 'get_weather' in error_msg
+  assert 'Possible causes:' in error_msg
+  assert 'Suggested fixes:' in error_msg
+
+
+def test_tool_not_found_fuzzy_matching():
+  """Verify fuzzy matching suggestions in error message."""
+  function_call = types.FunctionCall(name='get_wether', args={})  # Typo
+  tools_dict = {
+      'get_weather': MockTool(name='get_weather'),
+      'calculate_sum': MockTool(name='calculate_sum'),
+  }
+
+  with pytest.raises(ValueError) as exc_info:
+    _get_tool(function_call, tools_dict)
+
+  error_msg = str(exc_info.value)
+
+  # Verify fuzzy matching suggests correct tool
+  assert 'Did you mean' in error_msg
+  assert 'get_weather' in error_msg
+
+
+def test_tool_not_found_no_fuzzy_match():
+  """Verify error message when no close matches exist."""
+  function_call = types.FunctionCall(name='completely_different', args={})
+  tools_dict = {
+      'get_weather': MockTool(name='get_weather'),
+      'calculate_sum': MockTool(name='calculate_sum'),
+  }
+
+  with pytest.raises(ValueError) as exc_info:
+    _get_tool(function_call, tools_dict)
+
+  error_msg = str(exc_info.value)
+
+  # Verify no fuzzy matching section when no close matches
+  assert 'Did you mean' not in error_msg
+
+
+def test_tool_not_found_truncates_long_list():
+  """Verify error message truncates when 100+ tools exist."""
+  function_call = types.FunctionCall(name='nonexistent', args={})
+
+  # Create 100 tools
+  tools_dict = {f'tool_{i}': MockTool(name=f'tool_{i}') for i in range(100)}
+
+  with pytest.raises(ValueError) as exc_info:
+    _get_tool(function_call, tools_dict)
+
+  error_msg = str(exc_info.value)
+
+  # Verify truncation message
+  assert 'showing first 20 of 100' in error_msg
+  assert 'tool_0' in error_msg  # First tool shown
+  assert 'tool_99' not in error_msg  # Last tool NOT shown