ToolRegistry and ToolDiscovery API for Dynamic Agent Tooling

[kshitizz36]

ToolRegistry and ToolDiscovery API for Dynamic Agent Tooling

As our agent ecosystem grows, managing and discovering tools becomes increasingly complex. Hardcoding tool dependencies in agents is not scalable, especially when new tools are added or provided by third parties. The proposed tool_registry and tool_discovery APIs address this by enabling dynamic registration and discovery of tools, making agents more flexible, extensible, and maintainable.**

---

What Are tool_registry and tool_discovery?

• tool_registry: A singleton registry where all tools register themselves. It keeps track of available tools and their categories.
• tool_discovery: A utility that allows agents to discover and select the most appropriate tools for a given user task or context, using the registry.

Real-World Example: Smart Assistant Agent Scenario

Imagine building a smart assistant agent that can:

• Summarise documents
• Translate text
• Search the web
• Send emails
  Each of these is implemented as a separate tool (a subclass of base_tool.py). You want your agent to handle new tasks in the future without changing its core logic every time a new tool is added.

---

Without ToolRegistry/ToolDiscovery
You must hardcode all available tools in your agent:

from tools.summarize_tool import SummarizeTool
from tools.translate_tool import TranslateTool
from tools.web_search_tool import WebSearchTool

class HardcodedAgent:
    def __init__(self):
        self.tools = [
            SummarizeTool(),
            TranslateTool(),
            WebSearchTool(),
        ]
    # ... logic to pick a tool manually ... 

If you add a new tool (e.g., SendEmailTool), you must update the agent code.

Each tool registers itself with the registry (using a decorator or in its constructor). Now, your agent can dynamically discover tools based on the user’s request:

from google.adk.tools.tool_discovery import ToolDiscovery

class SmartAgent:
    def handle_request(self, user_input: str):
        # Dynamically find the best tools for the user's request
        tools = ToolDiscovery.get_tools_for_task(user_input)
        if not tools:
            print("Sorry, I can't help with that.")
            return
        print("I can use these tools:")
        for tool in tools:
            print(f"- {tool.name}: {tool.description}")
        # Optionally, run the most relevant tool
        # result = await tools[0].run_async(args=..., tool_context=...)

Example Usage

If the user says:

"Can you summarise this article?"

The agent calls:

tools = ToolDiscovery.get_tools_for_task("summarize this article")

This returns the SummarizeTool (and maybe others), without the agent knowing about it in advance.

If you later add a TranslateTool or SendEmailTool, the agent will automatically discover and use them if the user asks for translation or email tasks.

Benefits

• Extensibility: Add new tools without changing agent code.
• Plug-and-play: Third-party developers can add tools that your agent can use.
• Dynamic selection: The agent can pick the best tool for the user's request at runtime.
• Separation of concerns: Tool logic is decoupled from agent logic.
• Future-proof: As the number of tools grows, the agent remains maintainable.

---

Sample Implementation

Tool Registration

from google.adk.tools.tool_registry import register_tool
from google.adk.tools.base_tool import BaseTool

@register_tool(categories=["text", "summarization"])
class SummarizeTool(BaseTool):
    def __init__(self):
        super().__init__(name="summarize", description="Summarize documents.")
    # ... implementation ...
    ```
    Tool Discovery
    ```pyhton
    from google.adk.tools.tool_discovery import ToolDiscovery

tools = ToolDiscovery.get_tools_for_task("summarize this article")
for tool in tools:
    print(tool.name, tool.description)

The tool_registry and tool_discovery APIs provide a robust foundation for building dynamic, extensible, and maintainable agents. They decouple tool management from agent logic, making it easy to add, remove, or update tools without touching the agent codebase. This is especially valuable as our ecosystem grows and as we enable third-party tool contributions.

---

Feedback and suggestions are welcome!

This proposal references ongoing work in PR [#129]