hud-python 0.4.56__py3-none-any.whl → 0.4.57__py3-none-any.whl

hud/cli/dev.py

@@ -237,7 +237,7 @@ async def run_mcp_module(
 
                 from hud.cli.flows.dev import create_dynamic_trace
 
-                live_trace_url = await create_dynamic_trace(
+                _, live_trace_url = await create_dynamic_trace(
                     mcp_config=local_mcp_config,
                     build_status=False,
                     environment_name=mcp_server.name or "mcp-server",
@@ -608,7 +608,7 @@ def run_docker_dev_server(
                     "headers": {},
                 }
             }
-            live_trace_url = _asy.run(
+            _, live_trace_url = _asy.run(
                 create_dynamic_trace(
                     mcp_config=local_mcp_config,
                     build_status=True,
@@ -661,13 +661,33 @@ def run_docker_dev_server(
     # Create and run proxy with HUD helpers
     async def run_proxy() -> None:
         from fastmcp import FastMCP
+        from fastmcp.server.proxy import ProxyClient
 
-        # Create FastMCP proxy to Docker stdio
-        fastmcp_proxy = FastMCP.as_proxy(mcp_config, name="HUD Docker Dev Proxy")
+        # Create ProxyClient without custom log handler since we capture Docker logs directly
+        proxy_client = ProxyClient(mcp_config, name="HUD Docker Dev Proxy")
+
+        # Extract container name from docker args and store for logs endpoint
+        docker_cmd = mcp_config["docker"]["args"]
+        container_name = None
+        for i, arg in enumerate(docker_cmd):
+            if arg == "--name" and i + 1 < len(docker_cmd):
+                container_name = docker_cmd[i + 1]
+                break
+
+        if container_name:
+            # Store container name for logs endpoint to use
+            os.environ["_HUD_DEV_DOCKER_CONTAINER"] = container_name
+            hud_console.debug(f"Docker container: {container_name}")
+
+        # Create FastMCP proxy using the ProxyClient
+        fastmcp_proxy = FastMCP.as_proxy(proxy_client)
 
         # Wrap in MCPServer to get /docs and REST wrappers
         proxy = MCPServer(name="HUD Docker Dev Proxy")
 
+        # Enable logs endpoint on HTTP server
+        os.environ["_HUD_DEV_LOGS_PROVIDER"] = "enabled"
+
         # Import all tools from the FastMCP proxy
         await proxy.import_server(fastmcp_proxy)
 

hud/cli/flows/dev.py

@@ -18,7 +18,7 @@ async def create_dynamic_trace(
     mcp_config: dict[str, dict[str, Any]],
     build_status: bool,
     environment_name: str,
-) -> str | None:
+) -> tuple[str | None, str | None]:
     """
     Create a dynamic trace for HUD dev sessions when running in HTTP mode.
 
@@ -43,27 +43,16 @@ async def create_dynamic_trace(
     api_key = settings.api_key
     if not api_key:
         logger.warning("Skipping dynamic trace creation; missing HUD_API_KEY")
-        return None
+        return None, None
 
     try:
         resp = await make_request("POST", url=url, json=payload, api_key=api_key)
         # New API returns an id; construct the URL as https://hud.so/trace/{id}
-        trace_id = None
-        if isinstance(resp, dict):
-            trace_id = resp.get("id")
-            if trace_id is None:
-                data = resp.get("data", {}) or {}
-                if isinstance(data, dict):
-                    trace_id = data.get("id")
-            # Backcompat: if url is provided directly
-            if not trace_id:
-                direct_url = resp.get("url") or (resp.get("data", {}) or {}).get("url")
-                if isinstance(direct_url, str) and direct_url:
-                    return direct_url
+        trace_id = resp.get("id")
 
         if isinstance(trace_id, str) and trace_id:
-            return f"https://hud.so/trace/{trace_id}"
-        return None
+            return trace_id, f"https://hud.so/trace/{trace_id}"
+        return None, None
     except Exception as e:
         # Do not interrupt dev flow
         try:
@@ -71,7 +60,7 @@ async def create_dynamic_trace(
             logger.warning("Failed to create dynamic dev trace: %s | payload=%s", e, preview)
         except Exception:
             logger.warning("Failed to create dynamic dev trace: %s", e)
-        return None
+        return None, None
 
 
 def show_dev_ui(

hud/cli/tests/test_convert.py

@@ -0,0 +1,367 @@
+"""Tests for the convert command."""
+
+import json
+from pathlib import Path
+from unittest.mock import patch
+
+import pytest
+import typer
+
+from hud.cli.flows.tasks import convert_tasks_to_remote
+from hud.types import Task
+
+
+class TestConvertCommand:
+    """Test the convert command functionality."""
+
+    @pytest.fixture
+    def temp_tasks_file(self, tmp_path):
+        """Create a temporary tasks file."""
+        tasks = [
+            {
+                "prompt": "Test task 1",
+                "mcp_config": {
+                    "local": {
+                        "command": "docker",
+                        "args": ["run", "--rm", "-i", "test-image:latest"],
+                    }
+                },
+            }
+        ]
+        tasks_file = tmp_path / "tasks.json"
+        tasks_file.write_text(json.dumps(tasks))
+        return tasks_file
+
+    @pytest.fixture
+    def mock_env_dir(self, tmp_path):
+        """Create a mock environment directory with lock file."""
+        env_dir = tmp_path / "env"
+        env_dir.mkdir()
+
+        # Create lock file
+        lock_data = {
+            "images": {
+                "remote": "registry.hud.so/test-org/test-env:v1.0.0",
+                "local": "test-env:latest",
+            }
+        }
+        lock_file = env_dir / "hud.lock.yaml"
+        import yaml
+
+        lock_file.write_text(yaml.dump(lock_data))
+
+        return env_dir
+
+    @patch("hud.cli.flows.tasks._derive_remote_image")
+    @patch("hud.cli.flows.tasks._ensure_pushed")
+    @patch("hud.cli.flows.tasks.find_environment_dir")
+    @patch("hud.cli.flows.tasks.load_tasks")
+    @patch("hud.settings.settings")
+    def test_convert_tasks_basic(
+        self,
+        mock_settings,
+        mock_load_tasks,
+        mock_find_env,
+        mock_ensure_pushed,
+        mock_derive_remote,
+        temp_tasks_file,
+        mock_env_dir,
+    ):
+        """Test basic task conversion from local to remote."""
+        # Setup mocks
+        mock_settings.api_key = "test-api-key"
+        mock_find_env.return_value = mock_env_dir
+
+        # Mock the push check to return updated lock data
+        mock_ensure_pushed.return_value = {
+            "images": {
+                "remote": "registry.hud.so/test-org/test-env:v1.0.0",
+                "local": "test-env:v1.0.0",
+            }
+        }
+
+        # Mock derive remote image
+        mock_derive_remote.return_value = "registry.hud.so/test-org/test-env:v1.0.0"
+
+        task = Task(
+            prompt="Test task",
+            mcp_config={
+                "local": {"command": "docker", "args": ["run", "--rm", "-i", "test-image:latest"]}
+            },
+        )
+        raw_task = {
+            "prompt": "Test task",
+            "mcp_config": {
+                "local": {"command": "docker", "args": ["run", "--rm", "-i", "test-image:latest"]}
+            },
+        }
+
+        mock_load_tasks.side_effect = [[task], [raw_task]]
+
+        # Run conversion
+        result_path = convert_tasks_to_remote(str(temp_tasks_file))
+
+        # Check result
+        assert result_path.endswith("remote_tasks.json")
+        assert Path(result_path).exists()
+
+        # Verify converted content
+        with open(result_path) as f:
+            converted_tasks = json.load(f)
+
+        assert len(converted_tasks) == 1
+        assert "hud" in converted_tasks[0]["mcp_config"]
+        assert converted_tasks[0]["mcp_config"]["hud"]["url"] == "https://mcp.hud.so/v3/mcp"
+
+    @patch("hud.settings.settings")
+    def test_convert_missing_api_key(self, mock_settings, temp_tasks_file):
+        """Test that conversion fails without API key."""
+        mock_settings.api_key = ""
+
+        with pytest.raises(typer.Exit):
+            convert_tasks_to_remote(str(temp_tasks_file))
+
+    @patch("hud.cli.flows.tasks.find_environment_dir")
+    @patch("hud.cli.flows.tasks.load_tasks")
+    @patch("hud.settings.settings")
+    def test_convert_already_remote(
+        self, mock_settings, mock_load_tasks, mock_find_env, temp_tasks_file
+    ):
+        """Test that already remote tasks are not converted again."""
+        mock_settings.api_key = "test-api-key"
+        mock_find_env.return_value = None  # No env dir needed for remote tasks
+
+        # Create task that's already remote
+        task = Task(
+            prompt="Test task",
+            mcp_config={
+                "remote": {
+                    "url": "https://mcp.hud.so",
+                    "headers": {"Mcp-Image": "registry.hud.so/test/image:v1"},
+                }
+            },
+        )
+
+        mock_load_tasks.return_value = [task]
+
+        # Should return original path without modification
+        result_path = convert_tasks_to_remote(str(temp_tasks_file))
+        assert result_path == str(temp_tasks_file)
+
+    @patch("hud.cli.flows.tasks.find_environment_dir")
+    @patch("hud.cli.flows.tasks.load_tasks")
+    @patch("hud.settings.settings")
+    def test_convert_no_environment(
+        self, mock_settings, mock_load_tasks, mock_find_env, temp_tasks_file
+    ):
+        """Test that conversion fails when no environment is found."""
+        mock_settings.api_key = "test-api-key"
+        mock_find_env.return_value = None
+
+        task = Task(
+            prompt="Test task",
+            mcp_config={
+                "local": {"command": "docker", "args": ["run", "--rm", "-i", "test-image:latest"]}
+            },
+        )
+
+        mock_load_tasks.return_value = [task]
+
+        with pytest.raises(typer.Exit):
+            convert_tasks_to_remote(str(temp_tasks_file))
+
+    @patch("hud.utils.hud_console.hud_console.confirm")
+    @patch("hud.cli.flows.tasks._derive_remote_image")
+    @patch("hud.cli.flows.tasks._ensure_pushed")
+    @patch("hud.cli.flows.tasks.find_environment_dir")
+    @patch("hud.cli.flows.tasks.load_tasks")
+    @patch("hud.settings.settings")
+    def test_convert_with_env_vars(
+        self,
+        mock_settings,
+        mock_load_tasks,
+        mock_find_env,
+        mock_ensure_pushed,
+        mock_derive_remote,
+        mock_confirm,
+        temp_tasks_file,
+        mock_env_dir,
+    ):
+        """Test conversion includes environment variables as headers."""
+        mock_settings.api_key = "test-api-key"
+        mock_find_env.return_value = mock_env_dir
+        mock_confirm.return_value = True  # Always confirm in tests
+
+        # Mock the push check to return updated lock data
+        mock_ensure_pushed.return_value = {
+            "images": {
+                "remote": "registry.hud.so/test-org/test-env:v1.0.0",
+                "local": "test-env:v1.0.0",
+            }
+        }
+
+        # Mock derive remote image
+        mock_derive_remote.return_value = "registry.hud.so/test-org/test-env:v1.0.0"
+
+        # Add .env file with API keys
+        env_file = mock_env_dir / ".env"
+        env_file.write_text("OPENAI_API_KEY=sk-test123\nANTHROPIC_API_KEY=sk-ant456")
+
+        task = Task(
+            prompt="Test task",
+            mcp_config={
+                "local": {
+                    "command": "docker",
+                    "args": ["run", "--rm", "-i", "-e", "OPENAI_API_KEY", "test-image:latest"],
+                }
+            },
+        )
+        raw_task = task.model_dump()
+
+        mock_load_tasks.side_effect = [[task], [raw_task]]
+
+        # Run conversion
+        result_path = convert_tasks_to_remote(str(temp_tasks_file))
+
+        # Verify headers include env vars
+        with open(result_path) as f:
+            converted_tasks = json.load(f)
+
+        headers = converted_tasks[0]["mcp_config"]["hud"]["headers"]
+        assert "Env-Openai-Api-Key" in headers
+        assert headers["Env-Openai-Api-Key"] == "${OPENAI_API_KEY}"
+
+
+class TestConvertHelperFunctions:
+    """Test helper functions used by convert command."""
+
+    def test_env_var_to_header_key(self):
+        """Test environment variable name conversion to header format."""
+        from hud.cli.flows.tasks import _env_var_to_header_key
+
+        assert _env_var_to_header_key("OPENAI_API_KEY") == "Env-Openai-Api-Key"
+        assert _env_var_to_header_key("ANTHROPIC_API_KEY") == "Env-Anthropic-Api-Key"
+        assert _env_var_to_header_key("SIMPLE") == "Env-Simple"
+        assert _env_var_to_header_key("MULTIPLE_WORD_VAR") == "Env-Multiple-Word-Var"
+
+    def test_extract_dotenv_api_key_vars(self):
+        """Test extraction of API-like variables from .env file."""
+        # Create test env directory with .env file
+        import tempfile
+
+        from hud.cli.flows.tasks import _extract_dotenv_api_key_vars
+
+        with tempfile.TemporaryDirectory() as tmpdir:
+            env_dir = Path(tmpdir)
+            env_file = env_dir / ".env"
+            env_file.write_text("""
+# Test .env file
+OPENAI_API_KEY=sk-test123
+ANTHROPIC_API_KEY=sk-ant456
+SOME_TOKEN=abc123
+CLIENT_SECRET=secret789
+USER_PASSWORD=pass123
+REGULAR_VAR=not_included
+HUD_API_URL=https://api.hud.so
+""")
+
+            result = _extract_dotenv_api_key_vars(env_dir)
+
+            # Should include only API-like variables
+            assert "OPENAI_API_KEY" in result
+            assert "ANTHROPIC_API_KEY" in result
+            assert "SOME_TOKEN" in result
+            assert "CLIENT_SECRET" in result
+            assert "USER_PASSWORD" in result
+            assert "REGULAR_VAR" not in result
+            assert "HUD_API_URL" in result  # API in name, so it's included
+
+    def test_is_remote_url(self):
+        """Test remote URL detection."""
+        from hud.cli.flows.tasks import _is_remote_url
+
+        # This function matches URLs with domain names (not localhost or IPs)
+        assert _is_remote_url("https://mcp.hud.so")
+        assert _is_remote_url("http://mcp.hud.so")
+        assert _is_remote_url("https://mcp.hud.so/some/path")
+        assert _is_remote_url("https://example.com")  # Also matches
+        assert not _is_remote_url("http://localhost:8000")  # localhost doesn't match
+        assert not _is_remote_url("file:///path/to/file")  # file:// doesn't match
+
+    def test_extract_env_vars_from_docker_args(self):
+        """Test extraction of environment variables from docker arguments."""
+        from hud.cli.flows.tasks import _extract_env_vars_from_docker_args
+
+        # Test with various docker arg formats
+        args = [
+            "run",
+            "--rm",
+            "-i",
+            "-e",
+            "VAR1",
+            "-e",
+            "VAR2=value",
+            "--env",
+            "VAR3",
+            "--env=VAR4",
+            # Note: -eFOO compact form is not supported by the implementation
+            "--env-file",
+            ".env",
+            "-p",
+            "8080:80",
+        ]
+
+        result = _extract_env_vars_from_docker_args(args)
+
+        assert "VAR1" in result
+        assert "VAR2" in result
+        assert "VAR3" in result
+        assert "VAR4" in result
+        # FOO is not extracted because -eFOO compact form is not supported
+        assert len(result) == 4
+
+    def test_derive_remote_image(self):
+        """Test deriving remote image from lock data."""
+        from hud.cli.flows.tasks import _derive_remote_image
+
+        # The function derives remote image from images.local, not images.remote
+        lock_data = {"images": {"local": "test-env:v1.0.0"}}
+        result = _derive_remote_image(lock_data)
+        assert result == "test-env:v1.0.0"
+
+        # Test fallback to legacy format
+        lock_data = {
+            "image": "test-org/test-env:v1.0.0",
+        }
+        result = _derive_remote_image(lock_data)
+        assert result == "test-org/test-env:v1.0.0"
+
+    def test_extract_vars_from_task_configs(self):
+        """Test extraction of env vars from task configurations."""
+        from hud.cli.flows.tasks import _extract_vars_from_task_configs
+
+        raw_tasks = [
+            {
+                "prompt": "Task 1",
+                "mcp_config": {
+                    "local": {"command": "docker", "args": ["run", "-e", "API_KEY1", "image1"]}
+                },
+            },
+            {
+                "prompt": "Task 2",
+                "mcp_config": {
+                    "local": {
+                        "command": "docker",
+                        "args": ["run", "-e", "API_KEY2", "--env", "API_KEY3", "image2"],
+                    }
+                },
+            },
+            {"prompt": "Task 3", "mcp_config": {"remote": {"url": "https://mcp.hud.so"}}},
+        ]
+
+        result = _extract_vars_from_task_configs(raw_tasks)
+
+        assert "API_KEY1" in result
+        assert "API_KEY2" in result
+        assert "API_KEY3" in result
+        assert len(result) == 3

hud/cli/utils/version_check.py

@@ -17,6 +17,7 @@ from __future__ import annotations
 
 import contextlib
 import json
+import logging
 import os
 import time
 from pathlib import Path
@@ -27,6 +28,9 @@ from packaging import version
 
 from hud.utils.hud_console import HUDConsole
 
+# Logger for version checking
+logger = logging.getLogger(__name__)
+
 # Cache location for version check data
 CACHE_DIR = Path.home() / ".hud" / ".cache"
 VERSION_CACHE_FILE = CACHE_DIR / "version_check.json"
@@ -218,7 +222,7 @@ def display_update_prompt(console: HUDConsole | None = None) -> None:
         console: HUDConsole instance for output. If None, creates a new one.
     """
     if console is None:
-        console = HUDConsole()
+        console = HUDConsole(logger=logger)
 
     try:
         info = check_for_updates()
@@ -231,11 +235,8 @@ def display_update_prompt(console: HUDConsole | None = None) -> None:
                 f"   Run: [bold yellow]uv tool upgrade hud-python[/bold yellow] to update"
             )
 
-            # Display as a subtle but noticeable panel
-            console._stdout_console.print(
-                f"\n[yellow]{update_msg}[/yellow]\n",
-                highlight=False,
-            )
+            # Display using console info
+            console.info(f"[yellow]{update_msg}[/yellow]")
     except Exception:  # noqa: S110
         # Never let version checking disrupt the user's workflow
         pass

hud/clients/base.py

@@ -104,6 +104,7 @@ class BaseHUDClient(AgentMCPClient):
 
         self._initialized = False
         self._telemetry_data = {}  # Initialize telemetry data
+        self._cached_resources: list[types.Resource] = []  # Cache for resources
 
         if self.verbose:
             self._setup_verbose_logging()
@@ -170,6 +171,7 @@ class BaseHUDClient(AgentMCPClient):
         if self._initialized:
             await self._disconnect()
             self._initialized = False
+            self._cached_resources.clear()
             hud_console.info("Environment Shutdown completed")
         else:
             hud_console.debug("Client was not initialized, skipping disconnect")
@@ -211,9 +213,22 @@ class BaseHUDClient(AgentMCPClient):
         """List all available tools."""
         raise NotImplementedError
 
-    @abstractmethod
     async def list_resources(self) -> list[types.Resource]:
-        """List all available resources."""
+        """List all available resources.
+
+        Uses cached resources if available, otherwise fetches from the server.
+
+        Returns:
+            List of available resources.
+        """
+        # If cache is empty, populate it
+        if not self._cached_resources:
+            self._cached_resources = await self._list_resources_impl()
+        return self._cached_resources
+
+    @abstractmethod
+    async def _list_resources_impl(self) -> list[types.Resource]:
+        """Implementation-specific resource listing. Subclasses must implement this."""
         raise NotImplementedError
 
     @abstractmethod
@@ -270,6 +285,17 @@ class BaseHUDClient(AgentMCPClient):
     async def _fetch_telemetry(self) -> None:
         """Common telemetry fetching for all hud clients."""
         try:
+            # Get resources (will use cache if available, otherwise fetch)
+            resources = await self.list_resources()
+            telemetry_available = any(
+                str(resource.uri) == "telemetry://live" for resource in resources
+            )
+
+            if not telemetry_available:
+                if self.verbose:
+                    hud_console.debug("Telemetry resource not available from server")
+                return
+
             # Try to read telemetry resource directly
             result = await self.read_resource("telemetry://live")
             if result and result.contents:

hud/clients/fastmcp.py

@@ -143,8 +143,8 @@ class FastMCPHUDClient(BaseHUDClient):
             structuredContent=result.structured_content,
         )
 
-    async def list_resources(self) -> list[types.Resource]:
-        """List all available resources."""
+    async def _list_resources_impl(self) -> list[types.Resource]:
+        """Implementation of resource listing for FastMCP client."""
         if self._client is None:
             raise ValueError("Client is not connected, call initialize() first")
         return await self._client.list_resources()

hud/clients/mcp_use.py

@@ -243,8 +243,8 @@ class MCPUseHUDClient(BaseHUDClient):
             structuredContent=result.structuredContent,
         )
 
-    async def list_resources(self) -> list[types.Resource]:
-        """List all available resources."""
+    async def _list_resources_impl(self) -> list[types.Resource]:
+        """Implementation of resource listing for MCP-use client."""
         if self._client is None or not self._sessions:
             raise ValueError("Client is not connected, call initialize() first")
 

hud/clients/tests/test_protocol.py

@@ -35,9 +35,15 @@ class MockClient(BaseHUDClient):
             raise RuntimeError("Not connected")
         return self._mock_tools
 
-    async def list_resources(self) -> list[types.Resource]:
-        """Minimal list_resources for protocol satisfaction in tests."""
-        return []
+    async def _list_resources_impl(self) -> list[types.Resource]:
+        """Minimal resource listing implementation for tests."""
+        from pydantic import AnyUrl
+
+        return [
+            types.Resource(
+                uri=AnyUrl("telemetry://live"), name="telemetry", description="Live telemetry data"
+            )
+        ]
 
     async def _call_tool(self, tool_call: MCPToolCall) -> MCPToolResult:
         if tool_call.name == "test_tool":

hud/server/server.py

@@ -13,6 +13,7 @@ from typing import TYPE_CHECKING, Any
 
 import anyio
 from fastmcp.server.server import FastMCP, Transport
+from starlette.requests import Request
 from starlette.responses import JSONResponse, Response
 
 from hud.server.low_level import LowLevelServerWithInit
@@ -492,6 +493,7 @@ class MCPServer(FastMCP):
         - GET /docs - Interactive documentation and tool testing
         - POST /api/tools/{name} - REST wrappers for MCP tools
         - GET /openapi.json - OpenAPI spec for REST endpoints
+        - GET /logs - Development log endpoint (when provided by dev runtime)
         """
 
         # Register REST wrapper for each tool
@@ -542,6 +544,63 @@ class MCPServer(FastMCP):
             endpoint = create_tool_endpoint(tool_key)
             self.custom_route(f"/api/tools/{tool_key}", methods=["POST"])(endpoint)
 
+        # Development log endpoint - only if dev runtime set a provider
+        provider = os.environ.get("_HUD_DEV_LOGS_PROVIDER")
+        if provider == "enabled":
+
+            @self.custom_route("/logs", methods=["GET"])
+            async def get_logs(request: Request) -> Response:
+                """Return Docker container logs on demand.
+
+                Query params:
+                  - limit: max number of lines to return (default 100)
+                  - tail: number of lines from end to return (default 100)
+                """
+                import subprocess
+
+                # Get container name from environment
+                container_name = os.environ.get("_HUD_DEV_DOCKER_CONTAINER")
+                if not container_name:
+                    return JSONResponse({"items": [], "next": None})
+
+                # Get query params
+                params = request.query_params
+                tail = params.get("tail", "100")
+
+                try:
+                    # Run docker logs to get recent output
+                    result = subprocess.run(  # noqa: S603, ASYNC221
+                        ["docker", "logs", "--tail", tail, container_name],  # noqa: S607
+                        stdout=subprocess.PIPE,
+                        stderr=subprocess.STDOUT,
+                        text=True,
+                        encoding="utf-8",
+                        errors="replace",
+                        timeout=5,
+                    )
+
+                    # Parse logs into items
+                    items = []
+                    lines = result.stdout.strip().split("\n") if result.stdout else []
+
+                    for i, line in enumerate(lines):
+                        if line.strip():
+                            items.append(
+                                {
+                                    "id": i,
+                                    "stream": "mixed",
+                                    "log": line,
+                                    "container_name": container_name,
+                                }
+                            )
+
+                    return JSONResponse({"items": items, "next": len(items) - 1 if items else None})
+
+                except subprocess.TimeoutExpired:
+                    return JSONResponse({"error": "Docker logs timeout"}, status_code=500)
+                except Exception as e:
+                    return JSONResponse({"error": f"Failed to get logs: {e!s}"}, status_code=500)
+
         @self.custom_route("/openapi.json", methods=["GET"])
         async def openapi_spec(request: Request) -> Response:
             """Generate OpenAPI spec from MCP tools."""

hud/utils/tests/test_version.py

@@ -5,4 +5,4 @@ def test_import():
     """Test that the package can be imported."""
     import hud
 
-    assert hud.__version__ == "0.4.56"
+    assert hud.__version__ == "0.4.57"

hud/version.py

@@ -4,4 +4,4 @@ Version information for the HUD SDK.
 
 from __future__ import annotations
 
-__version__ = "0.4.56"
+__version__ = "0.4.57"

{hud_python-0.4.56.dist-info → hud_python-0.4.57.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hud-python
-Version: 0.4.56
+Version: 0.4.57
 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.4.56.dist-info → hud_python-0.4.57.dist-info}/RECORD

@@ -2,7 +2,7 @@ hud/__init__.py,sha256=0LQ9PyuU6yZx7Fxu8YJXKC1i3TTHjg3UrInThh759QE,653
 hud/__main__.py,sha256=YR8Dq8OhINOsVfQ55PmRXXg4fEK84Rt_-rMtJ5rvhWo,145
 hud/settings.py,sha256=9SPEZcsZGqplw_LuV8RvJisDRdlsbQgxBqG8ifmjGNc,4117
 hud/types.py,sha256=jeC1npyPlno5CYNWBWH06Kxw7VMJld9YLEFBFNtjwoI,11608
-hud/version.py,sha256=5r7gUjXhMnfdXi42tFi9IN4DXbsCYx9soTL0r3ID9IE,105
+hud/version.py,sha256=5oonlS-3cemOdbkDddf3Eg6Wr5IkBtjvigjh9Y3A664,105
 hud/agents/__init__.py,sha256=UoIkljWdbq4bM0LD-mSaw6w826EqdEjOk7r6glNYwYQ,286
 hud/agents/base.py,sha256=nRRnK_kA_PZDT0fepMMTz3QDTHj0jpqvbTqdgRPKSlg,32514
 hud/agents/claude.py,sha256=Lf7p_h5H4sd2w16ZNc2ru3xuxNP7IDeFayrcdePOLSE,16030
@@ -28,7 +28,7 @@ hud/cli/analyze.py,sha256=4u5oYfJMquOjT9PzzRTYVcTZDxDi0ilNP_g532_hpOU,14716
 hud/cli/build.py,sha256=EV6PsJ08p3mZZkfeUFjZ687ithxKGlUZ66yAF9lvtaI,28780
 hud/cli/clone.py,sha256=AwVDIuhr8mHb1oT2Af2HrD25SiTdwATpE6zd93vzLgA,6099
 hud/cli/debug.py,sha256=jtFW8J5F_3rhq1Hf1_SkJ7aLS3wjnyIs_LsC8k5cnzc,14200
-hud/cli/dev.py,sha256=WXxvhqQ2l5gpplJFWtMKnJYycpLyzNAt6x3y3oLa5mk,25379
+hud/cli/dev.py,sha256=dGA8p5DvKFUgcYA9awXbbIfJ8OV04ew_jd0fElfJRoU,26255
 hud/cli/eval.py,sha256=1guW_pNQqFLpF1RylZltBKdXt6iFd_jBNV3Rxy36QRE,29024
 hud/cli/get.py,sha256=sksKrdzBGZa7ZuSoQkc0haj-CvOGVSSikoVXeaUd3N4,6274
 hud/cli/init.py,sha256=D1NS4PBHxNqsl9hz2VsMTj6HSB_teJgCqsyY77T5lLs,10042
@@ -37,7 +37,7 @@ hud/cli/pull.py,sha256=XGEZ8n60tbzLQP_8d9h7XYmzyCW0e2-Rkr3_tLG7jvw,12449
 hud/cli/push.py,sha256=rWJIqHebvp3DchK-00L6G0olD3-klsobLutRW4PP_ts,19488
 hud/cli/remove.py,sha256=8vGQyXDqgtjz85_vtusoIG8zurH4RHz6z8UMevQRYM4,6861
 hud/cli/flows/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-hud/cli/flows/dev.py,sha256=Q6vz9KDfeLHvZNs3Kga7PUTMgt_QEm5J98XP9jRKuhM,5220
+hud/cli/flows/dev.py,sha256=7-Dki2C8MbdcFcHewKhmRfkfjVdo6E4CGmItKVMaUSI,4760
 hud/cli/flows/tasks.py,sha256=SAQzS53g6vBPMvuEaMRsmkYOJMwvy28RQ-miVmVnP_8,18028
 hud/cli/rl/__init__.py,sha256=pGx4WGaL-yGdogJNzgEE7BtjFtT4I9CTI_UdCm49h98,5376
 hud/cli/rl/celebrate.py,sha256=trGEJn3xebexlHwFVKPJKhRujVVV8sy7TQTJvRd2p9A,5947
@@ -64,6 +64,7 @@ hud/cli/tests/test_cli_main.py,sha256=0wMho9p9NcGjp0jLiUtCQh_FYdbMaCJtSY3sBbSgPw
 hud/cli/tests/test_cli_more_wrappers.py,sha256=MdcsGXOwPQOSjDhSm4s7FjiVy1ru8YeRiZxIGVLAgnA,847
 hud/cli/tests/test_cli_root.py,sha256=ifHjb1k9zSRTB3dgOxApmRYulzK_D8cKjI4GPQXNQQI,3972
 hud/cli/tests/test_clone.py,sha256=oC2mf-41QQVc7ODJkjrWbVPNMB2fDW3nZ6jY6w93gvQ,4458
+hud/cli/tests/test_convert.py,sha256=_-W8wLEADUsS9LjaveERJ1i0v8PLP0Oj5Vu7lNp6a_0,12510
 hud/cli/tests/test_cursor.py,sha256=ZfxAFKJesJ3UV1JBoASSRlv6BXbpvVEk_pjxUg1jnf4,9821
 hud/cli/tests/test_debug.py,sha256=bQ76d_0HJfthHBSECmGNv499ZE57CIOKsanMlNfNHGk,18036
 hud/cli/tests/test_eval.py,sha256=2ExXbxnIP8yamQidDAQBQDzF6Y4ZbYGyeOJ3cx84TQI,22380
@@ -93,7 +94,7 @@ hud/cli/utils/runner.py,sha256=16_dXkSZTvT2JQKWbZBCoIz6iiLMhjqgFXvcWr1WS1M,4439
 hud/cli/utils/server.py,sha256=EE5DJ0RAmXCEjMcZycpAsAxxCj6sOdIsXqPh38kK2ew,7416
 hud/cli/utils/source_hash.py,sha256=EDD3KC4pLGBVoSL5UTv1GvF2TAs2ThNHNOhP_5Sbub4,2979
 hud/cli/utils/tasks.py,sha256=lX9SeM5XekrTBx2HWKMA0BQ7R3Q8jqGgi4G5vIHsnJM,994
-hud/cli/utils/version_check.py,sha256=30VgZQqwUb36Fm4dAzKn5HuT0We6OnA-rd0eIqjd5Tc,7271
+hud/cli/utils/version_check.py,sha256=TdsPh7mpPw5giWahiQgpLZVvT6Lex2z2tsMOGCvm0Dc,7268
 hud/cli/utils/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 hud/cli/utils/tests/test_config.py,sha256=dZugvnjXiFNAvcx0nrIp578zmReMBEdupXfxpqHWGAk,1422
 hud/cli/utils/tests/test_docker.py,sha256=WHYg_la0WfIr47Wu7Fmy8BtQrSyiWUdTYccv_DECBvw,2556
@@ -112,14 +113,14 @@ hud/cli/utils/tests/test_source_hash.py,sha256=GGFklT9xrVPMEpPwgiUzr94An66R-nhNn
 hud/cli/utils/tests/test_tasks.py,sha256=FT4smFGUHaJpZGIqj-yevBH8l9ARCu03RoedGxiLc2M,2624
 hud/clients/README.md,sha256=XNE3mch95ozDgVqfwCGcrhlHY9CwT1GKfNANNboowto,3826
 hud/clients/__init__.py,sha256=N5M_gZv4nP7dLRwpAiaqqaxyaLieGW6397FszeG7JGw,364
-hud/clients/base.py,sha256=uvBIjU1K5VZjPtDTG4wk1cV6ysV5gRIAydd5Nke7aqc,14212
-hud/clients/fastmcp.py,sha256=1xaAg7DwMcwt_GRx2n3OsZaX-UMEQCZCaLDK4cr2HhQ,9178
-hud/clients/mcp_use.py,sha256=2Pb8bhAEmD9TJYKb-2JbxmyIsh4ttE_pP-kldrt6AH0,14750
+hud/clients/base.py,sha256=QPFAjWKxczJWQEcsMGULQ9zj_xEMjMK52fWlTZ8rv9c,15274
+hud/clients/fastmcp.py,sha256=_dk1Iczvv_hKhti2z64KLE3cIY93W3vm3cvS8Og3C6w,9209
+hud/clients/mcp_use.py,sha256=Zq_NBFPAMb81qoQa_adCbdTm-yUFjDFCMFG7m8tOlr4,14781
 hud/clients/tests/__init__.py,sha256=sKOtJFFa4mDIXh1U6O8ZUHjigE8CiRMQ2PzJTIBZuVE,33
 hud/clients/tests/test_client_integration.py,sha256=kohU6jfCNfwSnAushHeB1_CmDlRfQc7VBL0GEdJYSeI,4198
 hud/clients/tests/test_fastmcp.py,sha256=4q3TzDjuieTZa89taiNJIrzbUncNkYOG4MaubypA21k,13030
 hud/clients/tests/test_mcp_use_retry.py,sha256=9FxLAz4L5Vv3OTtj4wdhRY23wDYALUpE12TYWl7fbJA,13299
-hud/clients/tests/test_protocol.py,sha256=aK4CS4g3j1D5jPo83ykzZuHUvcZFAulYtIq9T9Hb_fQ,6640
+hud/clients/tests/test_protocol.py,sha256=1JD9Ka-OLiQI6e9xBvoCaWsHXJ_iZQdGliWH5HJsaKc,6826
 hud/clients/utils/__init__.py,sha256=-zZjcKIWGj2tXbVDOW45UgoGghhLJzFQVZ6miKenuA4,595
 hud/clients/utils/mcp_use_retry.py,sha256=knsgOTR3YFXshmPFfPQE6K6C5GpR1ZBJe2J7ozEMikA,6675
 hud/clients/utils/retry.py,sha256=mMs2T_mAlb8AYhSqMR4AmCw7838gqCC4mdG3zjMAYM4,5744
@@ -169,7 +170,7 @@ hud/server/__init__.py,sha256=ZTxwhR7tMtSE14i1sONTz5UaMXURW1AYoFZMbWGBviU,134
 hud/server/context.py,sha256=6bCdSzv1FGyItu9472HbbYef279H7QuMGJDR8EtYg5Y,3210
 hud/server/low_level.py,sha256=XYs2pOJ9kN4OcJ6ahDmXM5mWkzq5wJLpKFInUYrWEok,4701
 hud/server/router.py,sha256=T9hLe08-W8SGvO14RfwY3j2zfcvB3lKWS5sR9h_4awM,5343
-hud/server/server.py,sha256=1IRrHar4OUF4llVsqkwwLvIH8EpgpXTN52XbyG-bbBg,28367
+hud/server/server.py,sha256=zj2FGv1SO8mR_3pjrBzhzN8LT1KpCls7_LCYwSjJ8Nw,30944
 hud/server/helper/__init__.py,sha256=ZxO8VP3RZEBBp-q65VixuhzQgqEPSVzW0hEY9J9QqDA,116
 hud/server/tests/__init__.py,sha256=eEYYkxX5Hz9woXVOBJ2H2_CQoEih0vH6nRt3sH2Z8v8,49
 hud/server/tests/test_add_tool.py,sha256=9Y59LJpow3BQ31Jg7fowhV7nAeyqude9Tap9tEs_vBE,1863
@@ -265,10 +266,10 @@ hud/utils/tests/test_progress.py,sha256=QSF7Kpi03Ff_l3mAeqW9qs1nhK50j9vBiSobZq7T
 hud/utils/tests/test_tasks.py,sha256=Rbbm51vZxygyWlhjunFq4IfFPefVB3qevM9_CZSt5w4,5774
 hud/utils/tests/test_telemetry.py,sha256=5jl7bEx8C8b-FfFUko5pf4UY-mPOR-9HaeL98dGtVHM,2781
 hud/utils/tests/test_tool_shorthand.py,sha256=1p3j3D0G93OXHqnUXbvTs3G4A8awrPvwhPpLi6YPeOM,5458
-hud/utils/tests/test_version.py,sha256=QHrgv-B02epzVPg5ZHHzZOOjcN1W9Ke_8G_eAuDIOGQ,160
+hud/utils/tests/test_version.py,sha256=hsHAkfILDrqA97RyX0l2JapaS40Gi1kJnbThs2QFZHg,160
 hud/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-hud_python-0.4.56.dist-info/METADATA,sha256=TaKPkp8KGeSYMBAJC85GdqT9liQdn3dcUDHNtl105u4,22338
-hud_python-0.4.56.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-hud_python-0.4.56.dist-info/entry_points.txt,sha256=jJbodNFg1m0-CDofe5AHvB4zKBq7sSdP97-ohaQ3ae4,63
-hud_python-0.4.56.dist-info/licenses/LICENSE,sha256=yIzBheVUf86FC1bztAcr7RYWWNxyd3B-UJQ3uddg1HA,1078
-hud_python-0.4.56.dist-info/RECORD,,
+hud_python-0.4.57.dist-info/METADATA,sha256=sHE5ewR3U5SRv-JbKoxZth7mPbXzqn50W6ZR3vl_g6g,22338
+hud_python-0.4.57.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+hud_python-0.4.57.dist-info/entry_points.txt,sha256=jJbodNFg1m0-CDofe5AHvB4zKBq7sSdP97-ohaQ3ae4,63
+hud_python-0.4.57.dist-info/licenses/LICENSE,sha256=yIzBheVUf86FC1bztAcr7RYWWNxyd3B-UJQ3uddg1HA,1078
+hud_python-0.4.57.dist-info/RECORD,,