feat: Add support for toolsets to additional_tools field of SkillToolset

Co-authored-by: Kathy Wu <wukathy@google.com>
PiperOrigin-RevId: 882212923

Author: wukath

src/google/adk/tools/skill_toolset.py

@@ -702,8 +702,11 @@ def __init__(
     self._script_timeout = script_timeout
 
     self._provided_tools_by_name = {}
+    self._provided_toolsets = []
     for tool_union in additional_tools or []:
-      if isinstance(tool_union, BaseTool):
+      if isinstance(tool_union, BaseToolset):
+        self._provided_toolsets.append(tool_union)
+      elif isinstance(tool_union, BaseTool):
         self._provided_tools_by_name[tool_union.name] = tool_union
       elif callable(tool_union):
         ft = FunctionTool(tool_union)
@@ -754,11 +757,22 @@ async def _resolve_additional_tools_from_state(
     if not additional_tool_names:
       return []
 
+    # Collect all candidate tools from both individual tools and toolsets
+    candidate_tools = self._provided_tools_by_name.copy()
+    if self._provided_toolsets:
+      ts_results = await asyncio.gather(*(
+          ts.get_tools_with_prefix(readonly_context)
+          for ts in self._provided_toolsets
+      ))
+      for ts_tools in ts_results:
+        for t in ts_tools:
+          candidate_tools[t.name] = t
+
     resolved_tools = []
     existing_tool_names = {t.name for t in self._tools}
     for name in additional_tool_names:
-      if name in self._provided_tools_by_name:
-        tool = self._provided_tools_by_name[name]
+      if name in candidate_tools:
+        tool = candidate_tools[name]
         if tool.name in existing_tool_names:
           logger.error(
               "Tool name collision: tool '%s' already exists.", tool.name

tests/unittests/tools/test_skill_toolset.py

@@ -15,6 +15,7 @@
 import logging
 from unittest import mock
 
+from google.adk.agents.readonly_context import ReadonlyContext
 from google.adk.code_executors.base_code_executor import BaseCodeExecutor
 from google.adk.code_executors.code_execution_utils import CodeExecutionResult
 from google.adk.models import llm_request as llm_request_model
@@ -1290,41 +1291,87 @@ async def test_execute_script_binary_content_packaged():
 
 
 @pytest.mark.asyncio
-async def test_skill_toolset_dynamic_tool_resolution(mock_skill1):
-  # Set up a skill with additional_tools in metadata
+async def test_skill_toolset_dynamic_tool_resolution(mock_skill1, mock_skill2):
+  # Set up skills with additional_tools in metadata
   mock_skill1.frontmatter.metadata = {
-      "adk_additional_tools": ["my_custom_tool", "my_func"]
+      "adk_additional_tools": ["my_custom_tool", "my_func", "shared_tool"]
   }
   mock_skill1.name = "skill1"
 
+  mock_skill2.frontmatter.metadata = {
+      "adk_additional_tools": [
+          "skill2_tool",
+          "shared_tool",
+          "prefixed_mock_tool",
+      ]
+  }
+  mock_skill2.name = "skill2"
+
   # Prepare additional tools
   custom_tool = mock.create_autospec(skill_toolset.BaseTool, instance=True)
   custom_tool.name = "my_custom_tool"
 
+  skill2_tool = mock.create_autospec(skill_toolset.BaseTool, instance=True)
+  skill2_tool.name = "skill2_tool"
+
+  shared_tool = mock.create_autospec(skill_toolset.BaseTool, instance=True)
+  shared_tool.name = "shared_tool"
+
   def my_func():
     """My function description."""
     pass
 
+  # Setup prefixed toolset
+  mock_tool = mock.create_autospec(skill_toolset.BaseTool, instance=True)
+  mock_tool.name = "prefixed_mock_tool"
+  prefixed_set = mock.create_autospec(skill_toolset.BaseToolset, instance=True)
+  prefixed_set.get_tools_with_prefix.return_value = [mock_tool]
+
   toolset = skill_toolset.SkillToolset(
-      [mock_skill1],
-      additional_tools=[custom_tool, my_func],
+      [mock_skill1, mock_skill2],
+      additional_tools=[
+          custom_tool,
+          skill2_tool,
+          shared_tool,
+          my_func,
+          prefixed_set,
+      ],
   )
 
   ctx = _make_tool_context_with_agent()
   # Initial tools (only core)
   tools = await toolset.get_tools(readonly_context=ctx)
   assert len(tools) == 4
 
-  # Activate skill
+  # Activate skills
   load_tool = skill_toolset.LoadSkillTool(toolset)
   await load_tool.run_async(args={"name": "skill1"}, tool_context=ctx)
+  await load_tool.run_async(args={"name": "skill2"}, tool_context=ctx)
 
   # Dynamic tools should now be resolved
   tools = await toolset.get_tools(readonly_context=ctx)
   tool_names = {t.name for t in tools}
+
+  # Core tools
+  assert "list_skills" in tool_names
+  assert "load_skill" in tool_names
+  assert "load_skill_resource" in tool_names
+  assert "run_skill_script" in tool_names
+
+  # Skill 1 tools
   assert "my_custom_tool" in tool_names
   assert "my_func" in tool_names
 
+  # Skill 2 tools
+  assert "skill2_tool" in tool_names
+
+  # Shared tool (should only appear once)
+  assert "shared_tool" in tool_names
+  assert len([t for t in tools if t.name == "shared_tool"]) == 1
+
+  # Prefixed toolset tool
+  assert "prefixed_mock_tool" in tool_names
+
   # Check specific tool resolution details
   my_func_tool = next(t for t in tools if t.name == "my_func")
   assert isinstance(my_func_tool, skill_toolset.FunctionTool)