add tools api with a stub provider impl

llama_stack/distribution/routers/__init__.py

@@ -17,6 +17,7 @@ from .routing_tables import (
     ModelsRoutingTable,
     ScoringFunctionsRoutingTable,
     ShieldsRoutingTable,
+    ToolsRoutingTable,
 )
 
 
@@ -33,6 +34,7 @@ async def get_routing_table_impl(
         "datasets": DatasetsRoutingTable,
         "scoring_functions": ScoringFunctionsRoutingTable,
         "eval_tasks": EvalTasksRoutingTable,
+        "tools": ToolsRoutingTable,
     }
 
     if api.value not in api_to_tables:
@@ -51,6 +53,7 @@ async def get_auto_router_impl(api: Api, routing_table: RoutingTable, _deps) ->
         MemoryRouter,
         SafetyRouter,
         ScoringRouter,
+        ToolRuntimeRouter,
     )
 
     api_to_routers = {
@@ -60,6 +63,7 @@ async def get_auto_router_impl(api: Api, routing_table: RoutingTable, _deps) ->
         "datasetio": DatasetIORouter,
         "scoring": ScoringRouter,
         "eval": EvalRouter,
+        "tool_runtime": ToolRuntimeRouter,
     }
     if api.value not in api_to_routers:
         raise ValueError(f"API {api.value} not found in router map")

llama_stack/distribution/routers/routers.py

@@ -15,6 +15,7 @@ from llama_stack.apis.safety import *  # noqa: F403
 from llama_stack.apis.datasetio import *  # noqa: F403
 from llama_stack.apis.scoring import *  # noqa: F403
 from llama_stack.apis.eval import *  # noqa: F403
+from llama_stack.apis.tools import *  # noqa: F403
 
 
 class MemoryRouter(Memory):
@@ -372,3 +373,23 @@ class EvalRouter(Eval):
             task_id,
             job_id,
         )
+
+
+class ToolRuntimeRouter(ToolRuntime):
+    def __init__(
+        self,
+        routing_table: RoutingTable,
+    ) -> None:
+        self.routing_table = routing_table
+
+    async def initialize(self) -> None:
+        pass
+
+    async def shutdown(self) -> None:
+        pass
+
+    async def invoke_tool(self, tool_id: str, args: Dict[str, Any]) -> Any:
+        return await self.routing_table.get_provider_impl(tool_id).invoke_tool(
+            tool_id=tool_id,
+            args=args,
+        )

llama_stack/distribution/routers/routing_tables.py

@@ -15,7 +15,7 @@ from llama_stack.apis.shields import *  # noqa: F403
 from llama_stack.apis.memory_banks import *  # noqa: F403
 from llama_stack.apis.datasets import *  # noqa: F403
 from llama_stack.apis.eval_tasks import *  # noqa: F403
-
+from llama_stack.apis.tools import *  # noqa: F403
 from llama_stack.apis.common.content_types import URL
 
 from llama_stack.apis.common.type_system import ParamType
@@ -45,6 +45,8 @@ async def register_object_with_provider(obj: RoutableObject, p: Any) -> Routable
         return await p.register_scoring_function(obj)
     elif api == Api.eval:
         return await p.register_eval_task(obj)
+    elif api == Api.tool_runtime:
+        return await p.register_tool(obj)
     else:
         raise ValueError(f"Unknown API {api} for registering object with provider")
 
@@ -57,6 +59,8 @@ async def unregister_object_from_provider(obj: RoutableObject, p: Any) -> None:
         return await p.unregister_model(obj.identifier)
     elif api == Api.datasetio:
         return await p.unregister_dataset(obj.identifier)
+    elif api == Api.tool_runtime:
+        return await p.unregister_tool(obj.identifier)
     else:
         raise ValueError(f"Unregister not supported for {api}")
 
@@ -461,3 +465,51 @@ class EvalTasksRoutingTable(CommonRoutingTableImpl, EvalTasks):
             provider_resource_id=provider_eval_task_id,
         )
         await self.register_object(eval_task)
+
+
+class ToolsRoutingTable(CommonRoutingTableImpl, Tools):
+    async def list_tools(self) -> List[Tool]:
+        return await self.get_all_with_type("tool")
+
+    async def get_tool(self, tool_id: str) -> Tool:
+        return await self.get_object_by_identifier("tool", tool_id)
+
+    async def register_tool(
+        self,
+        tool_id: str,
+        name: str,
+        description: str,
+        parameters: List[ToolParameter],
+        returns: ToolReturn,
+        provider_id: Optional[str] = None,
+        provider_metadata: Optional[Dict[str, Any]] = None,
+        tool_prompt_format: Optional[ToolPromptFormat] = None,
+    ) -> None:
+        if provider_metadata is None:
+            provider_metadata = {}
+        if tool_prompt_format is None:
+            tool_prompt_format = ToolPromptFormat.json
+        if provider_id is None:
+            if len(self.impls_by_provider_id) == 1:
+                provider_id = list(self.impls_by_provider_id.keys())[0]
+            else:
+                raise ValueError(
+                    "No provider specified and multiple providers available. Please specify a provider_id."
+                )
+        tool = Tool(
+            identifier=tool_id,
+            name=name,
+            description=description,
+            parameters=parameters,
+            returns=returns,
+            provider_id=provider_id,
+            provider_metadata=provider_metadata,
+            tool_prompt_format=tool_prompt_format,
+        )
+        await self.register_object(tool)
+
+    async def unregister_tool(self, tool_id: str) -> None:
+        tool = await self.get_tool(tool_id)
+        if tool is None:
+            raise ValueError(f"Tool {tool_id} not found")
+        await self.unregister_object(tool)