hud-python 0.5.5__tar.gz → 0.5.7__tar.gz

{hud_python-0.5.5 → hud_python-0.5.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hud-python
-Version: 0.5.5
+Version: 0.5.7
 Summary: SDK for the HUD platform.
 Project-URL: Homepage, https://github.com/hud-evals/hud-python
 Project-URL: Bug Tracker, https://github.com/hud-evals/hud-python/issues

{hud_python-0.5.5 → hud_python-0.5.7}/hud/agents/claude.py

@@ -5,16 +5,18 @@ from __future__ import annotations
 import copy
 import logging
 from inspect import cleandoc
-from typing import Any, ClassVar, Literal, cast
+from typing import TYPE_CHECKING, Any, ClassVar, Literal, cast
 
 import mcp.types as types
 from anthropic import AsyncAnthropic, AsyncAnthropicBedrock, Omit
 from anthropic.types import CacheControlEphemeralParam
 from anthropic.types.beta import (
     BetaBase64ImageSourceParam,
+    BetaBase64PDFSourceParam,
     BetaContentBlockParam,
     BetaImageBlockParam,
     BetaMessageParam,
+    BetaRequestDocumentBlockParam,
     BetaTextBlockParam,
     BetaToolBash20250124Param,
     BetaToolComputerUse20250124Param,
@@ -33,6 +35,9 @@ from hud.utils.types import with_signature
 
 from .base import BaseCreateParams, MCPAgent
 
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
 logger = logging.getLogger(__name__)
 
 
@@ -220,7 +225,10 @@ class ClaudeAgent(MCPAgent):
     async def format_tool_results(
         self, tool_calls: list[MCPToolCall], tool_results: list[MCPToolResult]
     ) -> list[BetaMessageParam]:
-        """Format tool results into Claude messages."""
+        """Format tool results into Claude messages.
+
+        Handles EmbeddedResource (PDFs), images, and text content.
+        """
         # Process each tool result
         user_content = []
 
@@ -232,7 +240,9 @@ class ClaudeAgent(MCPAgent):
                 continue
 
             # Convert MCP tool results to Claude format
-            claude_blocks = []
+            claude_blocks: list[
+                BetaTextBlockParam | BetaImageBlockParam | BetaRequestDocumentBlockParam
+            ] = []
 
             if result.isError:
                 # Extract error message from content
@@ -249,6 +259,16 @@ class ClaudeAgent(MCPAgent):
                         claude_blocks.append(text_to_content_block(content.text))
                     elif isinstance(content, types.ImageContent):
                         claude_blocks.append(base64_to_content_block(content.data))
+                    elif isinstance(content, types.EmbeddedResource):
+                        # Handle embedded resources (PDFs)
+                        resource = content.resource
+                        if (
+                            isinstance(resource, types.BlobResourceContents)
+                            and resource.mimeType == "application/pdf"
+                        ):
+                            claude_blocks.append(
+                                document_to_content_block(base64_data=resource.blob)
+                            )
 
             # Add tool result
             user_content.append(tool_use_content_block(tool_use_id, claude_blocks))
@@ -303,7 +323,7 @@ class ClaudeAgent(MCPAgent):
                         display_width_px=computer_settings.ANTHROPIC_COMPUTER_WIDTH,
                         display_height_px=computer_settings.ANTHROPIC_COMPUTER_HEIGHT,
                     )
-                elif tool.name == "computer":
+                elif tool.name == "computer" or tool.name.endswith("_computer"):
                     logger.warning(
                         "Renamed tool %s to 'computer', dropping original 'computer' tool",
                         selected_computer_tool.name,
@@ -330,11 +350,14 @@ class ClaudeAgent(MCPAgent):
         self.claude_tools = []
         for tool in available_tools:
             claude_tool = to_api_tool(tool)
-            if claude_tool is None or "name" not in claude_tool:
+            if claude_tool is None:
                 continue
-            if claude_tool["name"] == "computer":
+            tool_name = claude_tool.get("name")
+            if tool_name is None:
+                continue
+            if tool_name == "computer":
                 self.has_computer_tool = True
-            self.tool_mapping[claude_tool["name"]] = tool.name
+            self.tool_mapping[tool_name] = tool.name
             self.claude_tools.append(claude_tool)
 
     def _add_prompt_caching(self, messages: list[BetaMessageParam]) -> list[BetaMessageParam]:
@@ -380,8 +403,21 @@ def text_to_content_block(text: str) -> BetaTextBlockParam:
     return {"type": "text", "text": text}
 
 
+def document_to_content_block(base64_data: str) -> BetaRequestDocumentBlockParam:
+    """Convert base64 PDF to Claude document content block."""
+    return BetaRequestDocumentBlockParam(
+        type="document",
+        source=BetaBase64PDFSourceParam(
+            type="base64",
+            media_type="application/pdf",
+            data=base64_data,
+        ),
+    )
+
+
 def tool_use_content_block(
-    tool_use_id: str, content: list[BetaTextBlockParam | BetaImageBlockParam]
+    tool_use_id: str,
+    content: Sequence[BetaTextBlockParam | BetaImageBlockParam | BetaRequestDocumentBlockParam],
 ) -> BetaToolResultBlockParam:
     """Create tool result content block."""
-    return {"type": "tool_result", "tool_use_id": tool_use_id, "content": content}
+    return {"type": "tool_result", "tool_use_id": tool_use_id, "content": content}  # pyright: ignore[reportReturnType]

{hud_python-0.5.5 → hud_python-0.5.7}/hud/agents/gemini_cua.py

@@ -123,6 +123,9 @@ class GeminiCUAAgent(GeminiAgent):
                 )
             )
 
+        if tool.name == "computer" or tool.name.endswith("_computer"):
+            return None
+
         # For non-computer tools, use the parent implementation
         return super()._to_gemini_tool(tool)
 

{hud_python-0.5.5 → hud_python-0.5.7}/hud/agents/operator.py

@@ -129,6 +129,8 @@ class OperatorAgent(OpenAIAgent):
                 display_height=self._operator_display_height,
                 environment=self._operator_environment,
             )
+        if tool.name == "computer" or tool.name.endswith("_computer"):
+            return None
         return super()._to_openai_tool(tool)
 
     def _extract_tool_call(self, item: Any) -> MCPToolCall | None:

{hud_python-0.5.5 → hud_python-0.5.7}/hud/agents/tests/test_claude.py

@@ -22,7 +22,7 @@ from hud.types import MCPToolCall, MCPToolResult
 if TYPE_CHECKING:
     from collections.abc import Generator
 
-    from anthropic.types.beta import BetaImageBlockParam, BetaMessageParam, BetaTextBlockParam
+    from anthropic.types.beta import BetaMessageParam
 
 
 class MockEvalContext(EvalContext):
@@ -123,9 +123,7 @@ class TestClaudeHelperFunctions:
     def test_tool_use_content_block(self) -> None:
         """Test tool result content block creation."""
         tool_use_id = "tool_123"
-        content: list[BetaTextBlockParam | BetaImageBlockParam] = [
-            text_to_content_block("Result text")
-        ]
+        content = [text_to_content_block("Result text")]
 
         result = tool_use_content_block(tool_use_id, content)
 

{hud_python-0.5.5 → hud_python-0.5.7}/hud/cli/dev.py

@@ -250,6 +250,15 @@ async def run_mcp_module(
     elif hasattr(module, "__dict__") and attr_name in module.__dict__:
         mcp_server = module.__dict__[attr_name]
 
+    # If default 'mcp' not found, try 'env' as fallback
+    if mcp_server is None and attr_name == "mcp":
+        for fallback in ["env", "environment", "server"]:
+            if hasattr(module, fallback):
+                mcp_server = getattr(module, fallback)
+                if verbose:
+                    hud_console.info(f"Found '{fallback}' instead of 'mcp'")
+                break
+
     if mcp_server is None:
         hud_console.error(f"Module '{module_name}' does not have '{attr_name}' defined")
         hud_console.info("")
@@ -258,8 +267,8 @@ async def run_mcp_module(
         hud_console.info("")
         hud_console.info("[bold cyan]Expected structure:[/bold cyan]")
         hud_console.info("  from hud.environment import Environment")
-        hud_console.info(f"  {attr_name} = Environment('my-env')")
-        raise AttributeError(f"Module '{module_name}' must define '{attr_name}'")
+        hud_console.info("  env = Environment('my-env')  # or mcp = ...")
+        raise AttributeError(f"Module '{module_name}' must define 'mcp', 'env', or 'environment'")
 
     # Only show full header on first run, brief message on reload
     if is_reload:

{hud_python-0.5.5 → hud_python-0.5.7}/hud/environment/__init__.py

@@ -27,8 +27,8 @@ Usage:
 from hud.environment.connection import ConnectionConfig, ConnectionType, Connector
 from hud.environment.environment import Environment
 from hud.environment.mock import MockMixin, generate_mock_value
-from hud.environment.router import ConflictResolution, ToolRouter
-from hud.environment.scenarios import ScenarioMixin
+from hud.environment.router import ConflictResolution, MCPRouter, ToolRouter
+from hud.environment.scenarios import ScenarioMixin, ScenarioSession
 from hud.environment.types import EnvConfig
 from hud.environment.utils import ToolFormat, format_result, parse_tool_call, parse_tool_calls
 
@@ -39,10 +39,12 @@ __all__ = [
     "Connector",
     "EnvConfig",
     "Environment",
+    "MCPRouter",
     "MockMixin",
     "ScenarioMixin",
+    "ScenarioSession",
     "ToolFormat",
-    "ToolRouter",
+    "ToolRouter",  # Backwards compat alias for MCPRouter
     "format_result",
     "generate_mock_value",
     "parse_tool_call",

{hud_python-0.5.5 → hud_python-0.5.7}/hud/environment/connection.py

@@ -68,6 +68,8 @@ class Connector:
         self.connection_type = connection_type
         self.client: FastMCPClient[Any] | None = None
         self._tools_cache: list[mcp_types.Tool] | None = None
+        self._prompts_cache: list[mcp_types.Prompt] | None = None
+        self._resources_cache: list[mcp_types.Resource] | None = None
 
     def copy(self) -> Connector:
         """Create a copy of this connector with fresh (unconnected) state.
@@ -101,6 +103,14 @@ class Connector:
     def cached_tools(self) -> list[mcp_types.Tool]:
         return self._tools_cache or []
 
+    @property
+    def cached_prompts(self) -> list[mcp_types.Prompt]:
+        return self._prompts_cache or []
+
+    @property
+    def cached_resources(self) -> list[mcp_types.Resource]:
+        return self._resources_cache or []
+
     async def connect(self) -> None:
         """Create FastMCP client and connect.
 
@@ -115,14 +125,20 @@ class Connector:
         await self.client.__aenter__()
 
     async def disconnect(self) -> None:
-        """Disconnect and clear cache."""
+        """Disconnect and clear all caches."""
         if self.client is not None and self.is_connected:
             await self.client.__aexit__(None, None, None)
         self.client = None
         self._tools_cache = None
+        self._prompts_cache = None
+        self._resources_cache = None
 
     async def list_tools(self) -> list[mcp_types.Tool]:
-        """Fetch tools from server, apply filters/transforms/prefix, and cache."""
+        """Fetch tools from server, apply filters/transforms/prefix, and cache.
+
+        Always fetches fresh data from the server (no caching check).
+        The result is cached for use by router.build() via cached_tools property.
+        """
         if self.client is None:
             raise RuntimeError("Not connected - call connect() first")
         tools = await self.client.list_tools()
@@ -178,14 +194,26 @@ class Connector:
         return await self.client.call_tool_mcp(name, arguments or {})
 
     async def list_resources(self) -> list[mcp_types.Resource]:
+        """Fetch resources from server and cache.
+
+        Always fetches fresh data from the server (no caching check).
+        The result is cached for use by router.build_resources() via cached_resources property.
+        """
         if self.client is None:
             raise RuntimeError("Not connected - call connect() first")
-        return await self.client.list_resources()
+        self._resources_cache = await self.client.list_resources()
+        return self._resources_cache
 
     async def list_prompts(self) -> list[mcp_types.Prompt]:
+        """Fetch prompts from server and cache.
+
+        Always fetches fresh data from the server (no caching check).
+        The result is cached for use by router.build_prompts() via cached_prompts property.
+        """
         if self.client is None:
             raise RuntimeError("Not connected - call connect() first")
-        return await self.client.list_prompts()
+        self._prompts_cache = await self.client.list_prompts()
+        return self._prompts_cache
 
     async def read_resource(
         self, uri: str

{hud_python-0.5.5 → hud_python-0.5.7}/hud/environment/environment.py

@@ -119,6 +119,26 @@ class Environment(
 
     MAX_CONCURRENT_CONNECTIONS = 10
 
+    @staticmethod
+    def _normalize_name(name: str) -> str:
+        """Normalize environment name to lowercase with hyphens.
+
+        - Strips whitespace
+        - Replaces spaces and underscores with hyphens
+        - Lowercases the result
+        - Removes any non-alphanumeric characters except hyphens
+        """
+        import re
+
+        normalized = name.strip().lower()
+        normalized = normalized.replace(" ", "-").replace("_", "-")
+        # Keep only alphanumeric and hyphens
+        normalized = re.sub(r"[^a-z0-9-]", "", normalized)
+        # Collapse multiple hyphens
+        normalized = re.sub(r"-+", "-", normalized)
+        # Strip leading/trailing hyphens
+        return normalized.strip("-") or "environment"
+
     def __init__(
         self,
         name: str = "environment",
@@ -126,10 +146,15 @@ class Environment(
         conflict_resolution: ConflictResolution = ConflictResolution.PREFIX,
         **fastmcp_kwargs: Any,
     ) -> None:
+        # Normalize name to prevent casing/spacing issues
+        name = self._normalize_name(name)
         super().__init__(name=name, instructions=instructions, **fastmcp_kwargs)
         self._connections: dict[str, Connector] = {}
         self._router = ToolRouter(conflict_resolution=conflict_resolution)
-        self._routing_built = False  # Track if _build_routing has been called
+        # Granular routing flags - only rebuild what's invalidated
+        self._tool_routing_built = False
+        self._prompt_routing_built = False
+        self._resource_routing_built = False
         self._in_context = False
 
         # Tool call queues - run after connections established
@@ -182,6 +207,10 @@ class Environment(
 
         return tools
 
+    def add_tool(self, obj: Any, **kwargs: Any) -> None:
+        super().add_tool(obj, **kwargs)
+        self._tool_routing_built = False  # Only invalidate tool routing
+
     async def call_tool(self, call: Any, /, **kwargs: Any) -> Any:
         """Call a tool, auto-detecting format and returning matching result format.
 
@@ -312,7 +341,7 @@ class Environment(
         """Connect all connectors, build routing, run setup tools."""
         self._in_context = True
 
-        # Connect to all servers (on_connect callbacks run first within connect())
+        # Connect to all servers and fetch tools/prompts/resources in parallel
         sem = asyncio.Semaphore(self.MAX_CONCURRENT_CONNECTIONS)
         errors: list[tuple[str, Exception]] = []
 
@@ -320,7 +349,12 @@ class Environment(
             async with sem:
                 try:
                     await conn.connect()
-                    await conn.list_tools()
+                    # Batch fetch all MCP primitives in parallel for performance
+                    await asyncio.gather(
+                        conn.list_tools(),
+                        conn.list_prompts(),
+                        conn.list_resources(),
+                    )
                 except Exception as e:
                     errors.append((name, e))
 
@@ -369,7 +403,10 @@ class Environment(
         if self._connections:
             await asyncio.gather(*[c.disconnect() for c in self._connections.values()])
         self._router.clear()
-        self._routing_built = False
+        self._tool_routing_built = False
+        self._prompt_routing_built = False
+        self._resource_routing_built = False
+        self._active_session = None  # Clear stale scenario state
 
     async def run_async(
         self,
@@ -388,9 +425,22 @@ class Environment(
             )
 
     async def _build_routing(self) -> None:
+        """Build routing for tools, prompts, and resources in parallel.
+
+        Only rebuilds what's actually invalidated for performance.
+        """
+        tasks = []
+        if not self._tool_routing_built:
+            tasks.append(self._build_tool_routing())
+        if not self._prompt_routing_built:
+            tasks.append(self._build_prompt_routing())
+        if not self._resource_routing_built:
+            tasks.append(self._build_resource_routing())
+        if tasks:
+            await asyncio.gather(*tasks)
+
+    async def _build_tool_routing(self) -> None:
         """Build tool routing from local tools and connection caches."""
-        # Use get_tools() not list_tools() - it includes mounted servers without
-        # requiring MCP server communication (via_server=False)
         local_tools_dict = await self._tool_manager.get_tools()
         local_tools = list(local_tools_dict.values())
         self._router.build(
@@ -398,9 +448,23 @@ class Environment(
             connections=self._connections,
             connection_order=list(self._connections.keys()),
         )
-        self._routing_built = True
         # Populate mock schemas for auto-generated mock values
         self._populate_mock_schemas()
+        self._tool_routing_built = True
+
+    async def _build_prompt_routing(self) -> None:
+        """Build prompt routing from local prompts and connections."""
+        local_prompts_dict = await self._prompt_manager.get_prompts()
+        local_prompts = [p.to_mcp_prompt() for p in local_prompts_dict.values()]
+        self._router.build_prompts(local_prompts, self._connections)
+        self._prompt_routing_built = True
+
+    async def _build_resource_routing(self) -> None:
+        """Build resource routing from local resources and connections."""
+        local_resources_dict = await self._resource_manager.get_resources()
+        local_resources = [r.to_mcp_resource() for r in local_resources_dict.values()]
+        self._router.build_resources(local_resources, self._connections)
+        self._resource_routing_built = True
 
     # =========================================================================
     # MCP Protocol Overrides - Include connector tools in MCP responses
@@ -416,8 +480,8 @@ class Environment(
 
     async def _env_list_tools(self) -> list[mcp_types.Tool]:
         """Return all tools including those from connectors."""
-        if not self._routing_built:
-            await self._build_routing()
+        if not self._tool_routing_built:
+            await self._build_tool_routing()
         return self._router.tools
 
     async def _env_call_tool(self, name: str, arguments: dict[str, Any] | None = None) -> list[Any]:
@@ -430,10 +494,10 @@ class Environment(
     # =========================================================================
 
     async def list_tools(self) -> list[mcp_types.Tool]:
-        """Refresh tools from all connections and rebuild routing."""
+        """Refresh tools from all connections and rebuild tool routing."""
         if self._connections:
             await asyncio.gather(*[c.list_tools() for c in self._connections.values()])
-        await self._build_routing()
+        await self._build_tool_routing()
         return self._router.tools
 
     async def _execute_tool(self, name: str, arguments: dict[str, Any]) -> MCPToolResult:
@@ -446,6 +510,10 @@ class Environment(
             logger.debug("Mock mode: returning mock result for tool %s", name)
             return self._get_mock_result(name, arguments)
 
+        # Rebuild tool routing if invalidated (e.g., after add_tool)
+        if not self._tool_routing_built:
+            await self._build_tool_routing()
+
         if self._router.is_local(name):
             # Call tool manager directly to avoid FastMCP context requirement
             result = await self._tool_manager.call_tool(name, arguments)
@@ -471,86 +539,83 @@ class Environment(
     # =========================================================================
 
     async def list_resources(self) -> list[mcp_types.Resource]:
-        """List all resources (local + remote)."""
-        local = list((await self._resource_manager.get_resources()).values())
-        resources: list[mcp_types.Resource] = [r.to_mcp_resource() for r in local]
-
+        """Refresh resources from all connections and rebuild resource routing."""
         if self._connections:
-            results = await asyncio.gather(
-                *[c.list_resources() for c in self._connections.values()], return_exceptions=True
-            )
-            for r in results:
-                if isinstance(r, list):
-                    resources.extend(r)
-
-        return resources
+            await asyncio.gather(*[c.list_resources() for c in self._connections.values()])
+        await self._build_resource_routing()
+        return self._router.resources
 
     async def read_resource(
         self, uri: str
     ) -> list[mcp_types.TextResourceContents | mcp_types.BlobResourceContents]:
-        """Read a resource by URI (tries local first, then remote)."""
+        """Read a resource by URI using router for connection lookup."""
         from pydantic import AnyUrl
 
-        try:
-            result = await self._resource_manager.read_resource(uri)
-            resource_uri = AnyUrl(uri)
-            if isinstance(result, str):
-                return [mcp_types.TextResourceContents(uri=resource_uri, text=result)]
-            import base64
+        # Ensure resource routing is built
+        if not self._resource_routing_built:
+            await self._build_resource_routing()
 
-            return [
-                mcp_types.BlobResourceContents(
-                    uri=resource_uri, blob=base64.b64encode(result).decode()
-                )
-            ]
-        except Exception as e:
-            logger.debug("Local resource read failed for %s: %s", uri, e)
+        # Use router to find which connection has this resource
+        conn_name = self._router.get_resource_connection(uri)
 
-        for conn in self._connections.values():
+        if conn_name is None:
+            # Local resource
             try:
-                return await conn.read_resource(uri)
+                result = await self._resource_manager.read_resource(uri)
+                resource_uri = AnyUrl(uri)
+                if isinstance(result, str):
+                    return [mcp_types.TextResourceContents(uri=resource_uri, text=result)]
+                import base64
+
+                return [
+                    mcp_types.BlobResourceContents(
+                        uri=resource_uri, blob=base64.b64encode(result).decode()
+                    )
+                ]
             except Exception as e:
-                logger.debug("Remote resource read failed for %s: %s", uri, e)
-                continue
-
-        raise ValueError(f"Resource not found: {uri}")
+                logger.debug("Local resource read failed for %s: %s", uri, e)
+                raise ValueError(f"Resource not found: {uri}") from e
+        else:
+            # Remote resource
+            conn = self._connections.get(conn_name)
+            if conn is None:
+                raise ValueError(f"Connection '{conn_name}' not found for resource '{uri}'")
+            return await conn.read_resource(uri)
 
     # =========================================================================
     # Prompt Operations
     # =========================================================================
 
     async def list_prompts(self) -> list[mcp_types.Prompt]:
-        """List all prompts (local + remote)."""
-        local = list((await self._prompt_manager.get_prompts()).values())
-        prompts: list[mcp_types.Prompt] = [p.to_mcp_prompt() for p in local]
-
+        """Refresh prompts from all connections and rebuild prompt routing."""
         if self._connections:
-            results = await asyncio.gather(
-                *[c.list_prompts() for c in self._connections.values()], return_exceptions=True
-            )
-            for r in results:
-                if isinstance(r, list):
-                    prompts.extend(r)
-
-        return prompts
+            await asyncio.gather(*[c.list_prompts() for c in self._connections.values()])
+        await self._build_prompt_routing()
+        return self._router.prompts
 
     async def get_prompt(
         self, name: str, arguments: dict[str, Any] | None = None
     ) -> mcp_types.GetPromptResult:
-        """Get a prompt by name (tries local first, then remote)."""
-        try:
-            return await self._prompt_manager.render_prompt(name, arguments or {})
-        except Exception as e:
-            logger.debug("Local prompt render failed for %s: %s", name, e)
+        """Get a prompt by name using router for connection lookup."""
+        # Ensure prompt routing is built
+        if not self._prompt_routing_built:
+            await self._build_prompt_routing()
+
+        # Use router to find which connection has this prompt
+        conn_name = self._router.get_prompt_connection(name)
 
-        for conn in self._connections.values():
+        if conn_name is None:
+            # Local prompt
             try:
-                return await conn.get_prompt(name, arguments)
+                return await self._prompt_manager.render_prompt(name, arguments or {})
             except Exception as e:
-                logger.debug("Remote prompt get failed for %s: %s", name, e)
-                continue
-
-        raise ValueError(f"Prompt not found: {name}")
+                raise ValueError(f"Prompt not found: {name}") from e
+        else:
+            # Remote prompt
+            conn = self._connections.get(conn_name)
+            if conn is None:
+                raise ValueError(f"Connection '{conn_name}' not found for prompt '{name}'")
+            return await conn.get_prompt(name, arguments)
 
     # =========================================================================
     # Server Methods
@@ -602,7 +667,7 @@ class Environment(
         For v4 format: requires mcp_config, prompt, AND evaluate_tool
         """
         # Check for local tools (registered via @env.tool)
-        if self._router._local_names:
+        if self._router._local_tool_names:
             return False
         # Check for local scenarios (registered via @env.scenario)
         if getattr(self, "_scenarios", {}):
@@ -639,10 +704,10 @@ class Environment(
             task.env.to_config()  # {"prompt": "...", "mcp_config": {...}, ...}
             ```
         """
-        if self._router._local_names:
+        if self._router._local_tool_names:
             raise ValueError(
                 f"Cannot serialize Environment with local tools: "
-                f"{list(self._router._local_names)}. "
+                f"{list(self._router._local_tool_names)}. "
                 "Local tools require local execution. For remote submission, "
                 "use dict config or connect to a remote hub."
             )