hud-python 0.4.48__py3-none-any.whl → 0.4.50__py3-none-any.whl

hud/cli/tests/test_mcp_server.py

@@ -2,101 +2,15 @@
 
 from __future__ import annotations
 
-from pathlib import Path  # noqa: TC003
-from unittest.mock import MagicMock, patch
+from unittest.mock import patch
 
 import pytest
 
 from hud.cli.dev import (
-    create_proxy_server,
-    get_docker_cmd,
-    get_image_name,
     run_mcp_dev_server,
-    update_pyproject_toml,
 )
 
 
-class TestCreateMCPServer:
-    """Test MCP server creation."""
-
-    def test_create_mcp_server(self) -> None:
-        """Test that MCP server is created with correct configuration."""
-        mcp = create_proxy_server(".", "test-image:latest")
-        assert mcp._mcp_server.name == "HUD Dev Proxy - test-image:latest"
-        # Proxy server doesn't define its own tools, it forwards to Docker containers
-
-
-class TestDockerUtils:
-    """Test Docker utility functions."""
-
-    def test_get_docker_cmd(self) -> None:
-        """Test extracting CMD from Docker image."""
-        with patch("subprocess.run") as mock_run:
-            mock_result = MagicMock()
-            mock_result.returncode = 0
-            mock_result.stdout = '["python", "-m", "server"]'
-            mock_run.return_value = mock_result
-
-            cmd = get_docker_cmd("test-image:latest")
-            assert cmd is None
-
-    def test_get_docker_cmd_failure(self) -> None:
-        """Test handling when Docker inspect fails."""
-        import subprocess
-
-        with patch("subprocess.run") as mock_run:
-            # check=True causes CalledProcessError on non-zero return
-            mock_run.side_effect = subprocess.CalledProcessError(1, "docker inspect")
-
-            cmd = get_docker_cmd("test-image:latest")
-            assert cmd is None
-
-
-class TestImageResolution:
-    """Test image name resolution."""
-
-    def test_get_image_name_override(self) -> None:
-        """Test image name with override."""
-        name, source = get_image_name(".", "custom-image:v1")
-        assert name == "custom-image:v1"
-        assert source == "override"
-
-    def test_get_image_name_from_pyproject(self, tmp_path: Path) -> None:
-        """Test image name from pyproject.toml."""
-        pyproject = tmp_path / "pyproject.toml"
-        pyproject.write_text("""
-[tool.hud]
-image = "my-project:latest"
-""")
-
-        name, source = get_image_name(str(tmp_path))
-        assert name == "my-project:latest"
-        assert source == "cache"
-
-    def test_get_image_name_auto_generate(self, tmp_path: Path) -> None:
-        """Test auto-generated image name."""
-        test_dir = tmp_path / "my_test_project"
-        test_dir.mkdir()
-
-        name, source = get_image_name(str(test_dir))
-        assert name == "my-test-project:dev"
-        assert source == "auto"
-
-    def test_update_pyproject_toml(self, tmp_path: Path) -> None:
-        """Test updating pyproject.toml with image name."""
-        pyproject = tmp_path / "pyproject.toml"
-        pyproject.write_text("""
-[project]
-name = "test"
-""")
-
-        update_pyproject_toml(str(tmp_path), "new-image:v1", silent=True)
-
-        content = pyproject.read_text()
-        assert "[tool.hud]" in content
-        assert 'image = "new-image:v1"' in content
-
-
 class TestRunMCPDevServer:
     """Test the main server runner."""
 
@@ -110,16 +24,13 @@ class TestRunMCPDevServer:
             pytest.raises(click.Abort),
         ):
             run_mcp_dev_server(
-                directory=".",
-                image="missing:latest",
-                build=False,
-                no_cache=False,
-                transport="http",
+                module=".",
+                stdio=False,
                 port=8765,
-                no_reload=False,
                 verbose=False,
                 inspector=False,
-                no_logs=False,
-                docker_args=[],
                 interactive=False,
+                watch=[],
+                docker=False,
+                docker_args=[],
             )

hud/cli/utils/env_check.py

@@ -175,16 +175,16 @@ def ensure_built(env_dir: Path, *, interactive: bool = True) -> dict[str, Any]:
             _print_section("Added files", diffs.get("added", []))
             _print_section("Removed files", diffs.get("removed", []))
 
-            if interactive:
-                if hud_console.confirm("Rebuild now (runs 'hud build')?", default=True):
-                    require_docker_running()
-                    build_environment(str(env_dir), platform="linux/amd64")
-                    with open(lock_path) as f:
-                        lock_data = yaml.safe_load(f) or {}
-                else:
-                    hud_console.hint("Continuing without rebuild; this may use an outdated image.")
+            # if interactive:
+            if hud_console.confirm("Rebuild now (runs 'hud build')?", default=True):
+                require_docker_running()
+                build_environment(str(env_dir), platform="linux/amd64")
+                with open(lock_path) as f:
+                    lock_data = yaml.safe_load(f) or {}
             else:
-                hud_console.hint("Run 'hud build' to update the image before proceeding.")
+                hud_console.hint("Continuing without rebuild; this may use an outdated image.")
+            # else:
+            #     hud_console.hint("Run 'hud build' to update the image before proceeding.")
         elif not stored_hash:
             hud_console.dim_info(
                 "Info",

hud/cli/utils/source_hash.py

@@ -41,7 +41,7 @@ EXCLUDE_FILES = {
 }
 
 INCLUDE_FILES = {"Dockerfile", "pyproject.toml"}
-INCLUDE_DIRS = {"controller", "environment"}
+INCLUDE_DIRS = {"server", "mcp", "controller", "environment"}
 
 
 def iter_source_files(root: Path) -> Iterable[Path]:

hud/server/__init__.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from .router import MCPRouter
 from .server import MCPServer
 
-__all__ = ["MCPServer"]
+__all__ = ["MCPRouter", "MCPServer"]

hud/server/router.py

@@ -0,0 +1,160 @@
+"""MCP Router utilities for FastAPI-like composition patterns."""
+
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING, Any
+
+from hud.server import MCPServer
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    from fastmcp import FastMCP
+    from fastmcp.tools import Tool
+
+logger = logging.getLogger(__name__)
+
+# MCPRouter is just an alias to FastMCP for FastAPI-like patterns
+MCPRouter = MCPServer
+
+# Prefix for internal tool names
+_INTERNAL_PREFIX = "int_"
+
+
+class HiddenRouter(MCPRouter):
+    """Wraps a FastMCP router to provide a single dispatcher tool for its sub-tools.
+
+    Instead of exposing all tools at the top level, this creates a single tool
+    (named after the router) that dispatches to the router's tools internally.
+
+    Useful for setup/evaluate patterns where you want:
+    - A single 'setup' tool that can call setup_basic(), setup_advanced(), etc.
+    - A single 'evaluate' tool that can call evaluate_score(), evaluate_complete(), etc.
+
+    Example:
+        # Create a router with multiple setup functions
+        setup_router = MCPRouter(name="setup")
+
+        @setup_router.tool
+        async def reset():
+            return "Environment reset"
+
+        @setup_router.tool
+        async def seed_data():
+            return "Data seeded"
+
+        # Wrap in HiddenRouter
+        hidden_setup = HiddenRouter(setup_router)
+
+        # Now you have one 'setup' tool that dispatches to reset/seed_data
+        mcp.include_router(hidden_setup)
+    """
+
+    def __init__(
+        self,
+        router: FastMCP,
+        *,
+        title: str | None = None,
+        description: str | None = None,
+        meta: dict[str, Any] | None = None,
+    ) -> None:
+        """Wrap an existing router with a dispatcher pattern.
+
+        Args:
+            router: The FastMCP router to wrap
+            title: Optional title for the dispatcher tool (defaults to "{name} Dispatcher")
+            description: Optional description for the dispatcher tool
+            meta: Optional metadata for the dispatcher tool
+        """
+        name = router.name or "router"
+
+        # Naming scheme for hidden/internal tools
+        self._prefix_fn: Callable[[str], str] = lambda n: f"{_INTERNAL_PREFIX}{n}"
+
+        super().__init__(name=name)
+
+        # Set up dispatcher tool
+        dispatcher_title = title or f"{name.title()} Dispatcher"
+        dispatcher_desc = description or f"Call internal '{name}' functions"
+
+        # Register dispatcher that routes to hidden tools
+        async def _dispatch(
+            name: str,
+            arguments: dict | str | None = None,
+            ctx: Any | None = None,
+        ) -> Any:
+            """Gateway to hidden tools.
+
+            Args:
+                name: Internal function name (without prefix)
+                arguments: Arguments to forward to the internal tool (dict or JSON string)
+                ctx: Request context injected by FastMCP
+            """
+            # Handle JSON string inputs
+            if isinstance(arguments, str):
+                import json
+
+                try:
+                    arguments = json.loads(arguments)
+                except json.JSONDecodeError:
+                    arguments = {}
+
+            # Call the internal tool
+            return await self._tool_manager.call_tool(self._prefix_fn(name), arguments or {})  # type: ignore
+
+        from fastmcp.tools.tool import FunctionTool
+
+        dispatcher_tool = FunctionTool.from_function(
+            _dispatch,
+            name=name,
+            title=dispatcher_title,
+            description=dispatcher_desc,
+            tags=set(),
+            meta=meta,
+        )
+        self._tool_manager.add_tool(dispatcher_tool)
+
+        # Copy all tools from source router as hidden tools
+        for tool in router._tool_manager._tools.values():
+            tool._key = self._prefix_fn(tool.name)
+            self._tool_manager.add_tool(tool)
+
+        # Expose list of available functions via resource
+        async def _functions_catalogue() -> list[str]:
+            """List all internal function names without prefix."""
+            return [
+                key.removeprefix(_INTERNAL_PREFIX)
+                for key in self._tool_manager._tools
+                if key.startswith(_INTERNAL_PREFIX)
+            ]
+
+        from fastmcp.resources import Resource
+
+        catalogue_resource = Resource.from_function(
+            _functions_catalogue,
+            uri=f"{name}://functions",
+            name=f"{name.title()} Functions",
+            description=f"List of available {name} functions",
+        )
+        self._resource_manager.add_resource(catalogue_resource)
+
+    # Override _list_tools to hide internal tools when mounted
+    async def _list_tools(self) -> list[Tool]:
+        """Override _list_tools to hide internal tools when mounted."""
+        return [
+            tool
+            for key, tool in self._tool_manager._tools.items()
+            if not key.startswith(_INTERNAL_PREFIX)
+        ]
+
+    def _sync_list_tools(self) -> dict[str, Tool]:
+        """Override _list_tools to hide internal tools when mounted."""
+        return {
+            key: tool
+            for key, tool in self._tool_manager._tools.items()
+            if not key.startswith(_INTERNAL_PREFIX)
+        }
+
+
+__all__ = ["HiddenRouter", "MCPRouter"]