hud-python 0.4.45__py3-none-any.whl → 0.5.1__py3-none-any.whl

hud/patches/mcp_patches.py

@@ -0,0 +1,151 @@
+"""
+Runtime patches for the standard mcp package.
+
+These patches apply fixes from the HUD fork without requiring a separate package.
+Import this module early (e.g., in hud/__init__.py) to apply patches.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+
+def patch_streamable_http_error_handling() -> None:
+    """
+    Patch StreamableHTTPTransport.post_writer to handle request errors properly.
+
+    The original implementation doesn't catch errors in handle_request_async,
+    which can cause silent failures. This patch wraps the handler to send
+    errors to the read stream so clients know the request failed.
+    """
+    try:
+        from mcp.client.streamable_http import StreamableHTTPTransport
+
+        async def patched_post_writer(
+            self: Any,
+            client: Any,
+            write_stream_reader: Any,
+            read_stream_writer: Any,
+            write_stream: Any,
+            start_get_stream: Any,
+            tg: Any,
+        ) -> None:
+            """Patched post_writer with error handling for handle_request_async."""
+            from mcp.client.streamable_http import RequestContext
+            from mcp.shared.message import ClientMessageMetadata
+            from mcp.types import JSONRPCRequest
+
+            try:
+                async with write_stream_reader:
+                    async for session_message in write_stream_reader:
+                        message = session_message.message
+                        metadata = (
+                            session_message.metadata
+                            if isinstance(session_message.metadata, ClientMessageMetadata)
+                            else None
+                        )
+
+                        is_resumption = bool(metadata and metadata.resumption_token)
+
+                        logger.debug("Sending client message: %s", message)
+
+                        if self._is_initialized_notification(message):
+                            start_get_stream()
+
+                        ctx = RequestContext(
+                            client=client,
+                            headers=self.request_headers,
+                            session_id=self.session_id,
+                            session_message=session_message,
+                            metadata=metadata,
+                            read_stream_writer=read_stream_writer,
+                            sse_read_timeout=self.sse_read_timeout,
+                        )
+
+                        # Patched: Accept ctx and is_resumption as params, add error handling
+                        async def handle_request_async(
+                            ctx: RequestContext = ctx,
+                            is_resumption: bool = is_resumption,
+                        ) -> None:
+                            try:
+                                if is_resumption:
+                                    await self._handle_resumption_request(ctx)
+                                else:
+                                    await self._handle_post_request(ctx)
+                            except Exception as e:
+                                # Send error to read stream so client knows request failed
+                                logger.error("Request handler error: %s", e)
+                                await ctx.read_stream_writer.send(e)
+
+                        if isinstance(message.root, JSONRPCRequest):
+                            tg.start_soon(handle_request_async, ctx, is_resumption)
+                        else:
+                            await handle_request_async(ctx, is_resumption)
+
+            except Exception:
+                logger.exception("Error in post_writer")
+            finally:
+                await read_stream_writer.aclose()
+                await write_stream.aclose()
+
+        StreamableHTTPTransport.post_writer = patched_post_writer
+        logger.debug("Patched StreamableHTTPTransport.post_writer")
+
+    except ImportError:
+        logger.debug("mcp.client.streamable_http not available, skipping patch")
+    except Exception as e:
+        logger.warning("Failed to patch streamable_http: %s", e)
+
+
+def patch_client_session_validation() -> None:
+    """
+    Patch ClientSession to skip structured output validation.
+
+    The original validation is strict and raises errors for non-conforming
+    but usable responses. We replace it with a no-op.
+    """
+    try:
+        from mcp.client.session import ClientSession
+
+        async def noop_validate(self: Any, name: str, result: Any) -> None:
+            """Skip structured output validation entirely."""
+
+        ClientSession._validate_tool_result = noop_validate
+        logger.debug("Patched ClientSession._validate_tool_result to skip validation")
+
+    except ImportError:
+        logger.debug("mcp.client.session not available, skipping patch")
+    except Exception as e:
+        logger.warning("Failed to patch client session: %s", e)
+
+
+def suppress_fastmcp_logging(level: int = logging.WARNING) -> None:
+    """
+    Suppress verbose fastmcp logging.
+
+    FastMCP logs a lot of INFO-level messages that clutter output.
+    This sets all fastmcp loggers to the specified level.
+
+    Args:
+        level: Logging level to set (default: WARNING)
+    """
+    loggers_to_suppress = [
+        "fastmcp",
+        "fastmcp.server.server",
+        "fastmcp.server.openapi",
+        "fastmcp.tools.tool_manager",
+    ]
+    for logger_name in loggers_to_suppress:
+        logging.getLogger(logger_name).setLevel(level)
+    logger.debug("Suppressed fastmcp logging to level %s", level)
+
+
+def apply_all_patches() -> None:
+    """Apply all MCP patches."""
+    patch_streamable_http_error_handling()
+    patch_client_session_validation()
+    suppress_fastmcp_logging()
+    logger.debug("All MCP patches applied")

hud/patches/warnings.py

@@ -0,0 +1,54 @@
+"""
+Centralized warning filters for noisy third-party dependencies.
+
+Keep these helpers here so the rest of the codebase can stay clean and avoid
+scattering warning filters across unrelated modules.
+"""
+
+from __future__ import annotations
+
+import warnings
+from contextlib import contextmanager
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from collections.abc import Iterator
+
+
+def apply_default_warning_filters(*, verbose: bool) -> None:
+    """Apply our default warning filters for non-verbose CLI/server modes."""
+    if verbose:
+        return
+
+    warnings.filterwarnings("ignore", category=DeprecationWarning)
+
+    # Pydantic v2 emits PydanticDeprecatedSince20 for v1-style config usage in deps.
+    try:
+        from pydantic.warnings import PydanticDeprecatedSince20
+    except Exception:
+        return
+
+    warnings.filterwarnings("ignore", category=PydanticDeprecatedSince20)
+
+
+@contextmanager
+def suppress_mcp_use_import_warnings() -> Iterator[None]:
+    """Suppress known noisy warnings emitted during `mcp_use` imports."""
+    try:
+        from pydantic.warnings import PydanticDeprecatedSince20
+    except Exception:  # pragma: no cover
+        PydanticDeprecatedSince20 = None  # type: ignore[assignment]
+
+    with warnings.catch_warnings():
+        # mcp_use currently emits DeprecationWarning from its package __init__.py.
+        warnings.filterwarnings("ignore", category=DeprecationWarning, module=r"mcp_use(\..*)?$")
+
+        # mcp_use currently defines Pydantic v1-style `class Config` in oauth models.
+        if PydanticDeprecatedSince20 is not None:
+            warnings.filterwarnings(
+                "ignore",
+                category=PydanticDeprecatedSince20,
+                module=r"mcp_use\.client\.auth\.oauth$",
+            )
+
+        yield

hud/samples/browser.py

@@ -7,17 +7,17 @@ from typing import Any
 from pydantic import Field
 
 from hud.settings import settings
-from hud.types import MCPToolCall, Task
+from hud.types import LegacyTask, MCPToolCall
 
 
-class BrowserTask(Task):
-    """Task subclass with browser defaults for BrowserTask(prompt=...)."""
+class BrowserTask(LegacyTask):
+    """LegacyTask subclass with browser defaults for BrowserTask(prompt=...)."""
 
     prompt: str = "Open Google and be ready to search."
     mcp_config: dict[str, Any] = Field(
         default_factory=lambda: {
             "browser": {
-                "url": "https://mcp.hud.so/v3/mcp",
+                "url": settings.hud_mcp_url,
                 "headers": {
                     "Authorization": f"Bearer {settings.api_key}",
                     "Mcp-Image": "hudevals/hud-remote-browser:0.1.1",

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/low_level.py

@@ -89,11 +89,12 @@ class LowLevelServerWithInit(_BaseLL):
 
     def __init__(
         self,
+        fastmcp: Any,
         *args: Any,
         init_fn: Callable[[RequestContext], Awaitable[None]] | None = None,
         **kwargs: Any,
     ) -> None:
-        super().__init__(*args, **kwargs)
+        super().__init__(fastmcp, *args, **kwargs)
         self._init_fn = init_fn
 
     async def run(

hud/server/router.py

@@ -0,0 +1,164 @@
+"""MCP Router utilities for FastAPI-like composition patterns."""
+
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING, Any
+
+from hud.server.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, context: Any = None) -> list[Tool]:
+        """Override _list_tools to hide internal tools when mounted.
+
+        Args:
+            context: MiddlewareContext passed by FastMCP (optional for backwards compat)
+        """
+        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"]