hud-python 0.4.12__py3-none-any.whl → 0.4.14__py3-none-any.whl

hud/cli/__init__.py

@@ -348,6 +348,11 @@ def dev(
     ),
     port: int = typer.Option(8765, "--port", "-p", help="HTTP server port (ignored for stdio)"),
     no_reload: bool = typer.Option(False, "--no-reload", help="Disable hot-reload"),
+    full_reload: bool = typer.Option(
+        False,
+        "--full-reload",
+        help="Restart entire container on file changes (instead of just server process)",
+    ),
     verbose: bool = typer.Option(False, "--verbose", "-v", help="Show server logs"),
     inspector: bool = typer.Option(
         False, "--inspector", help="Launch MCP Inspector (HTTP mode only)"
@@ -375,12 +380,13 @@ def dev(
         hud dev . --inspector        # Launch MCP Inspector (HTTP mode only)
         hud dev . --interactive      # Launch interactive testing mode (HTTP mode only)
         hud dev . --no-logs          # Disable Docker log streaming
+        hud dev . --full-reload      # Restart entire container on file changes (instead of just server)
 
         # With Docker arguments (after all options):
         hud dev . -e BROWSER_PROVIDER=anchorbrowser -e ANCHOR_API_KEY=xxx
         hud dev . -e API_KEY=secret -v /tmp/data:/data --network host
         hud dev . --build -e DEBUG=true --memory 2g
-    """
+    """  # noqa: E501
     # Parse directory and Docker arguments
     if params:
         directory = params[0]
@@ -397,6 +403,7 @@ def dev(
         transport,
         port,
         no_reload,
+        full_reload,
         verbose,
         inspector,
         no_logs,

hud/cli/dev.py

@@ -35,6 +35,7 @@ def create_proxy_server(
     directory: str | Path,
     image_name: str,
     no_reload: bool = False,
+    full_reload: bool = False,
     verbose: bool = False,
     docker_args: list[str] | None = None,
     interactive: bool = False,
@@ -48,8 +49,12 @@ def create_proxy_server(
         design.warning(f"Could not extract CMD from {image_name}, using default")
         original_cmd = ["python", "-m", "hud_controller.server"]
 
-    # Generate container name from image
-    container_name = f"{image_name.replace(':', '-').replace('/', '-')}"
+    # Generate unique container name from image to avoid conflicts between multiple instances
+    import os
+
+    pid = str(os.getpid())[-6:]  # Last 6 digits of process ID for uniqueness
+    base_name = image_name.replace(":", "-").replace("/", "-")
+    container_name = f"{base_name}-{pid}"
 
     # Build the docker run command
     docker_cmd = [
@@ -73,14 +78,20 @@ def create_proxy_server(
     if interactive:
         no_reload = True
 
-    if not no_reload:
-        # Inject our supervisor into the CMD
+    # Validate reload options
+    if no_reload and full_reload:
+        design.warning("Cannot use --full-reload with --no-reload, ignoring --full-reload")
+        full_reload = False
+
+    if not no_reload and not full_reload:
+        # Standard hot-reload: inject supervisor for server restart within container
         modified_cmd = inject_supervisor(original_cmd)
         docker_cmd.extend(["--entrypoint", modified_cmd[0]])
         docker_cmd.append(image_name)
         docker_cmd.extend(modified_cmd[1:])
     else:
-        # No reload - use original CMD
+        # No reload or full reload: use original CMD without supervisor
+        # Note: Full reload logic (container restart) would be implemented here in the future
         docker_cmd.append(image_name)
 
     # Create configuration following MCPConfig schema
@@ -96,9 +107,14 @@ def create_proxy_server(
 
     # Debug output - only if verbose
     if verbose:
-        if not no_reload:
+        if not no_reload and not full_reload:
+            design.info("Mode: Hot-reload (server restart within container)")
             design.info("Watching: /app/src for changes")
+        elif full_reload:
+            design.info("Mode: Full reload (container restart on file changes)")
+            design.info("Note: Full container restart not yet implemented, using no-reload mode")
         else:
+            design.info("Mode: No reload")
             design.info("Container will run without hot-reload")
         design.command_example(f"docker logs -f {container_name}", "View container logs")
 
@@ -127,6 +143,7 @@ async def start_mcp_proxy(
     transport: str,
     port: int,
     no_reload: bool = False,
+    full_reload: bool = False,
     verbose: bool = False,
     inspector: bool = False,
     no_logs: bool = False,
@@ -212,8 +229,12 @@ async def start_mcp_proxy(
         design.error(f"Source directory not found: {src_path}")
         raise click.Abort
 
-    # Extract container name from the proxy configuration
-    container_name = f"{image_name.replace(':', '-').replace('/', '-')}"
+    # Extract container name from the proxy configuration (must match create_proxy_server naming)
+    import os
+
+    pid = str(os.getpid())[-6:]  # Last 6 digits of process ID for uniqueness
+    base_name = image_name.replace(":", "-").replace("/", "-")
+    container_name = f"{base_name}-{pid}"
 
     # Remove any existing container with the same name (silently)
     # Note: The proxy creates containers on-demand when clients connect
@@ -347,6 +368,7 @@ async def start_mcp_proxy(
         # Always show waiting message
         log_design.info("")  # Empty line for spacing
         log_design.progress_message("⏳ Waiting for first client connection to start container...")
+        log_design.info(f"📋 Looking for container: {container_name}")  # noqa: G004
 
         # Keep trying to stream logs - container is created on demand
         has_shown_started = False
@@ -397,7 +419,8 @@ async def start_mcp_proxy(
 
                         # Show all logs with gold formatting like hud debug
                         # Format all logs in gold/dim style like hud debug's stderr
-                        log_design.console.print(
+                        # Use stdout console to avoid stderr redirection when not verbose
+                        log_design._stdout_console.print(
                             f"[rgb(192,150,12)]■[/rgb(192,150,12)] {decoded_line}", highlight=False
                         )
 
@@ -408,16 +431,19 @@ async def start_mcp_proxy(
                 await asyncio.sleep(1)
                 continue  # Loop back to check if container exists
 
-            except Exception:
-                # Some unexpected error
+            except Exception as e:
+                # Some unexpected error - show it so we can debug
+                log_design.warning(f"Failed to stream Docker logs: {e}")  # noqa: G004
                 if verbose:
-                    log_design.warning("Failed to stream logs")
+                    import traceback
+
+                    log_design.warning(f"Traceback: {traceback.format_exc()}")  # noqa: G004
                 await asyncio.sleep(1)
 
     # CRITICAL: Create proxy AFTER all logging setup to prevent it from resetting logging config
     # This is important because FastMCP might initialize loggers during creation
     proxy = create_proxy_server(
-        directory, image_name, no_reload, verbose, docker_args or [], interactive
+        directory, image_name, no_reload, full_reload, verbose, docker_args or [], interactive
     )
 
     # One more attempt to suppress the FastMCP server log
@@ -548,6 +574,7 @@ def run_mcp_dev_server(
     transport: str = "http",
     port: int = 8765,
     no_reload: bool = False,
+    full_reload: bool = False,
     verbose: bool = False,
     inspector: bool = False,
     no_logs: bool = False,
@@ -706,6 +733,7 @@ def run_mcp_dev_server(
                 transport,
                 port,
                 no_reload,
+                full_reload,
                 verbose,
                 inspector,
                 no_logs,

hud/cli/eval.py

@@ -26,15 +26,6 @@ def build_agent(
     """Create and return the requested agent type."""
 
     # Import agents lazily to avoid dependency issues
-    try:
-        from hud.agents.misc.response_agent import ResponseAgent
-    except ImportError as e:
-        design.error(
-            "Agent dependencies are not installed. "
-            "Please install with: pip install 'hud-python[agent]'"
-        )
-        raise typer.Exit(1) from e
-
     if agent_type == "openai":
         try:
             from hud.agents import OperatorAgent
@@ -45,12 +36,12 @@ def build_agent(
             )
             raise typer.Exit(1) from e
 
-        allowed_tools = allowed_tools or ["openai_computer"]
-
-        return OperatorAgent(
-            allowed_tools=allowed_tools,
-            response_agent=ResponseAgent(),
-        )
+        if allowed_tools:
+            return OperatorAgent(
+                allowed_tools=allowed_tools,
+            )
+        else:
+            return OperatorAgent()
 
     # Fallback Claude agent (Anthropic)
     try:
@@ -63,13 +54,16 @@ def build_agent(
         raise typer.Exit(1) from e
 
     model = model or "claude-sonnet-4-20250514"
-    allowed_tools = allowed_tools or ["anthropic_computer"]
 
-    return ClaudeAgent(
-        model=model,
-        allowed_tools=allowed_tools,
-        response_agent=ResponseAgent(),
-    )
+    if allowed_tools:
+        return ClaudeAgent(
+            model=model,
+            allowed_tools=allowed_tools,
+        )
+    else:
+        return ClaudeAgent(
+            model=model,
+        )
 
 
 async def run_single_task(
@@ -100,8 +94,8 @@ async def run_single_task(
         with open(path) as f:  # noqa: ASYNC230
             json_data = json.load(f)
 
-        # Check if JSON contains a list of tasks
-        if isinstance(json_data, list):
+        # Check if JSON contains multiple tasks (list with more than 1 task)
+        if isinstance(json_data, list) and len(json_data) > 1:
             design.info(f"Found {len(json_data)} tasks in JSON file, running as dataset…")
 
             # Build agent class and config for run_dataset
@@ -118,8 +112,10 @@ async def run_single_task(
                     raise typer.Exit(1) from e
 
                 agent_config: dict[str, Any] = {
-                    "allowed_tools": allowed_tools or ["openai_computer"],
                 }
+                if allowed_tools:
+                    agent_config["allowed_tools"] = allowed_tools
+
             else:
                 try:
                     from hud.agents import ClaudeAgent
@@ -134,8 +130,9 @@ async def run_single_task(
 
                 agent_config = {
                     "model": model or "claude-sonnet-4-20250514",
-                    "allowed_tools": allowed_tools or ["anthropic_computer"],
                 }
+                if allowed_tools:
+                    agent_config["allowed_tools"] = allowed_tools
 
             # Run as dataset with single-task concurrency to maintain debug behavior
             results = await run_dataset(
@@ -146,7 +143,6 @@ async def run_single_task(
                 max_concurrent=1,  # Run sequentially for debug mode
                 metadata={"source": str(path)},
                 max_steps=max_steps,
-                auto_respond=True,
             )
 
             # Display summary
@@ -154,8 +150,15 @@ async def run_single_task(
             design.success(f"Completed {len(results)} tasks: {successful} successful")
             return
 
-        # Single task JSON
-        task = Task(**json_data)
+        # Single task JSON (either direct object or list with 1 task)
+        if isinstance(json_data, list) and len(json_data) == 1:
+            design.info("Found 1 task in JSON file, running as single task…")
+            task = Task(**json_data[0])
+        elif isinstance(json_data, dict):
+            task = Task(**json_data)
+        else:
+            design.error("JSON file must contain a list of tasks when using --full flag")
+            raise typer.Exit(1)
     else:
         # Load from HuggingFace dataset
         try:
@@ -238,8 +241,10 @@ async def run_full_dataset(
             raise typer.Exit(1) from e
 
         agent_config: dict[str, Any] = {
-            "allowed_tools": allowed_tools or ["openai_computer"],
         }
+        if allowed_tools:
+            agent_config["allowed_tools"] = allowed_tools
+
     else:
         try:
             from hud.agents import ClaudeAgent
@@ -254,8 +259,9 @@ async def run_full_dataset(
 
         agent_config = {
             "model": model or "claude-sonnet-4-20250514",
-            "allowed_tools": allowed_tools or ["anthropic_computer"],
         }
+        if allowed_tools:
+            agent_config["allowed_tools"] = allowed_tools
 
     design.info("🚀 Running evaluation…")
     return await run_dataset(
@@ -266,7 +272,6 @@ async def run_full_dataset(
         max_concurrent=max_concurrent,
         metadata={"dataset": source},
         max_steps=max_steps,
-        auto_respond=True,
     )
 
 

hud/cli/init.py

@@ -15,20 +15,14 @@ DOCKERFILE_TEMPLATE = """FROM python:3.11-slim
 
 WORKDIR /app
 
-# Install git for hud-python dependency
-RUN apt-get update && apt-get install -y git && rm -rf /var/lib/apt/lists/*
-
 # Copy and install dependencies
 COPY pyproject.toml ./
 COPY src/ ./src/
 RUN pip install --no-cache-dir -e .
 
-# Set logging to stderr
-ENV HUD_LOG_STREAM=stderr
-
 # Start context server in background, then MCP server
-CMD ["sh", "-c", "python -m hud_controller.context & sleep 1 && exec python -m hud_controller.server"]
-"""  # noqa: E501
+CMD ["sh", "-c", "python -m controller.env & sleep 1 && exec python -m controller.server"]
+"""
 
 PYPROJECT_TEMPLATE = """[project]
 name = "{name}"
@@ -50,112 +44,472 @@ image = "{name}:dev"
 allow-direct-references = true
 
 [tool.hatch.build.targets.wheel]
-packages = ["src/hud_controller"]
+packages = ["src/controller"]
 """
 
-CONTEXT_TEMPLATE = '''"""Minimal context that persists across hot-reloads."""
+ENV_TEMPLATE = '''"""Minimal environment that persists across hot-reloads."""
 from hud.server.context import run_context_server
 import asyncio
 
-class Context:
+class Environment:
+    """Simple counter environment."""
+    
     def __init__(self):
         self.count = 0
     
     def act(self):
+        """Increment the counter."""
         self.count += 1
         return self.count
     
     def get_count(self):
+        """Get current counter."""
         return self.count
+    
+    def reset(self):
+        """Reset counter to zero."""
+        self.count = 0
 
 if __name__ == "__main__":
-    asyncio.run(run_context_server(Context()))
+    asyncio.run(run_context_server(Environment(), sock_path="/tmp/hud_ctx.sock"))
 '''
 
 SERVER_TEMPLATE = '''"""Minimal MCP server for HUD."""
+import sys
+import logging
 from hud.server import MCPServer
 from hud.server.context import attach_context
+from hud.tools.types import EvaluationResult
+
+# Configure logging to stderr
+logging.basicConfig(
+    stream=sys.stderr,
+    level=logging.INFO,
+    format='[%(levelname)s] %(asctime)s | %(name)s | %(message)s'
+)
 
 mcp = MCPServer(name="{name}")
-ctx = None
+env = None
 
 @mcp.initialize
-async def init(init_ctx):
-    global ctx
-    ctx = attach_context("/tmp/hud_ctx.sock")
+async def init(ctx):
+    global env
+    env = attach_context("/tmp/hud_ctx.sock")
+    logging.info("Connected to context server")
 
 @mcp.shutdown
 async def cleanup():
-    global ctx
-    ctx = None
+    global env
+    env = None
 
 @mcp.tool()
 async def act() -> str:
-    """Perform an action."""
-    return f"Action #{{ctx.act()}}"
+    """Perform an action that changes the environment state."""
+    if env is None:
+        raise RuntimeError("Context not initialized")
+    count = env.act()
+    return f"Action #{{count}} performed. Current count: {{count}}"
 
 @mcp.tool()
 async def setup() -> str:
-    """Required for HUD environments."""
-    return "Ready"
+    """Reset the environment to initial state."""
+    if env is None:
+        raise RuntimeError("Context not initialized")
+    env.reset()
+    return "Counter reset to 0"
 
 @mcp.tool()
-async def evaluate() -> dict:
-    """Required for HUD environments."""
-    return {{"count": ctx.get_count()}}
+async def evaluate(target: int = 10) -> EvaluationResult:
+    """Check if the counter reached the target value."""
+    if env is None:
+        raise RuntimeError("Context not initialized")
+    current_count = env.get_count()
+    
+    # Calculate reward as progress towards target
+    reward = min(current_count / target, 1.0) if target > 0 else 0.0
+    done = current_count >= target
+    
+    return EvaluationResult(
+        reward=reward,
+        done=done,
+        content=f"Counter at {{current_count}}/{{target}}"
+    )
 
 if __name__ == "__main__":
     mcp.run()
 '''
 
+TASKS_JSON_TEMPLATE = '''[
+  {{
+    "prompt": "Increment the counter to reach 10",
+    "mcp_config": {{
+      "{name}": {{
+        "url": "http://localhost:8765/mcp"
+      }}
+    }},
+    "setup_tool": {{
+      "name": "setup",
+      "arguments": {{}}
+    }},
+    "evaluate_tool": {{
+      "name": "evaluate",
+      "arguments": {{
+        "target": 10
+      }}
+    }}
+  }}
+]
+'''
+
+TEST_TASK_TEMPLATE = '''#!/usr/bin/env python
+"""Simple example of running tasks from tasks.json.
+
+Make sure to run 'hud dev --build' in another terminal first!
+"""
+
+import asyncio
+import json
+from hud.datasets import Task
+from hud.clients import MCPClient
+
+
+async def run_task(task_data: dict):
+    task = Task(**task_data)
+    client = MCPClient(mcp_config=task.mcp_config)
+
+    try:
+        print("Initializing client...")
+        await client.initialize()
+
+        result = await client.call_tool(task.setup_tool) # type: ignore
+        print(f"✅ Setup: {{result.content}}")
+        
+        print("\\n🔄 Performing actions:")
+        for _ in range(10):
+            result = await client.call_tool(name="act", arguments={{}})
+            print(f"  {{result.content}}")
+        
+        result = await client.call_tool(task.evaluate_tool) # type: ignore
+        print(f"\\n📊 Evaluation: {{result.content}}")
+        
+        return result.content
+    except Exception as e:
+        if "connection" in str(e).lower():
+            print("❌ Could not connect. Make sure 'hud dev --build' is running in another terminal.")
+        else:
+            raise e
+    finally:
+        await client.shutdown()
+
+
+async def main():
+    for task_data in json.load(open("tasks.json")):
+        await run_task(task_data)
+
+if __name__ == "__main__":
+    asyncio.run(main())
+'''
+
+NOTEBOOK_TEMPLATE = '''{{
+ "cells": [
+  {{
+   "cell_type": "markdown",
+   "metadata": {{}},
+   "source": [
+    "### Step 1: Create a Task\\n",
+    "\\n",
+    "A Task combines:\\n",
+    "- **Prompt**: What we want an agent to accomplish\\n",
+    "- **MCP Config**: How to spawn the environment\\n",
+    "- **Setup Tool**: How to prepare the environment\\n",
+    "- **Evaluate Tool**: How to check if the task succeeded"
+   ]
+  }},
+  {{
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {{}},
+   "outputs": [],
+   "source": [
+    "from hud.datasets import Task\\n",
+    "from hud.types import MCPToolCall\\n",
+    "\\n",
+    "# Create a task that uses our {name} environment\\n",
+    "# See tasks.json for how to build a loadable task dataset\\n",
+    "task = Task(\\n",
+    "    prompt=\\"Increment the counter to reach 10\\",\\n",
+    "    mcp_config={{\\n",
+    "        \\"{name}\\": {{\\n",
+    "            \\"url\\": \\"http://localhost:8765/mcp\\"\\n",
+    "        }},\\n",
+    "    }},\\n",
+    "    setup_tool=MCPToolCall(name=\\"setup\\", arguments={{}}),\\n",
+    "    evaluate_tool=MCPToolCall(name=\\"evaluate\\", arguments={{\\"target\\": 10}}),\\n",
+    ")"
+   ]
+  }},
+  {{
+   "cell_type": "markdown",
+   "metadata": {{}},
+   "source": [
+    "### Step 2: Initialize MCP Client\\n",
+    "\\n",
+    "Run `hud dev --build` before this cell to intialize the server at `http://localhost:8765/mcp`"
+   ]
+  }},
+  {{
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {{}},
+   "outputs": [],
+   "source": [
+    "from hud.clients import MCPClient\\n",
+    "\\n",
+    "# Create the client\\n",
+    "client = MCPClient(mcp_config=task.mcp_config, auto_trace=False)\\n",
+    "\\n",
+    "# Initialize it (this connects to our dev server)\\n",
+    "await client.initialize()"
+   ]
+  }},
+  {{
+   "cell_type": "markdown",
+   "metadata": {{}},
+   "source": [
+    "### Step 3: Run Setup\\n",
+    "\\n",
+    "Call the setup tool to prepare the environment according to the task."
+   ]
+  }},
+  {{
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {{}},
+   "outputs": [],
+   "source": [
+    "# Run the setup from our task\\n",
+    "setup_result = await client.call_tool(task.setup_tool) # type: ignore\\n",
+    "print(f\\"Setup result: {{setup_result}}\\")"
+   ]
+  }},
+  {{
+   "cell_type": "markdown",
+   "metadata": {{}},
+   "source": [
+    "### Step 4: Perform Actions\\n",
+    "\\n",
+    "Now we'll manually perform actions to complete the task. In a real scenario, an AI agent would figure out what actions to take."
+   ]
+  }},
+  {{
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {{}},
+   "outputs": [],
+   "source": [
+    "# Increment the counter 10 times\\n",
+    "for i in range(10):\\n",
+    "    result = await client.call_tool(name=\\"act\\", arguments={{}})\\n",
+    "    print(f\\"Step {{i+1}}: {{result.content}}\\")"
+   ]
+  }},
+  {{
+   "cell_type": "markdown",
+   "metadata": {{}},
+   "source": [
+    "## Step 5: Evaluate Success\\n",
+    "\\n",
+    "Check if we completed the task according to the evaluation criteria."
+   ]
+  }},
+  {{
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {{}},
+   "outputs": [],
+   "source": [
+    "# Run the evaluation from our task\\n",
+    "eval_result = await client.call_tool(task.evaluate_tool) # type: ignore\\n",
+    "\\n",
+    "# The result is a list with one TextContent item containing JSON\\n",
+    "print(eval_result)"
+   ]
+  }},
+  {{
+   "cell_type": "markdown",
+   "metadata": {{}},
+   "source": [
+    "### Step 6: Cleanup\\n",
+    "\\n",
+    "Always shut down the client when done to stop the Docker container. Either stop hud dev in the terminal, or run this command:"
+   ]
+  }},
+  {{
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {{}},
+   "outputs": [],
+   "source": [
+    "await client.shutdown()"
+   ]
+  }},
+  {{
+   "cell_type": "markdown",
+   "metadata": {{}},
+   "source": [
+    "### Bonus: Running with an AI Agent\\n",
+    "\\n",
+    "Instead of manually calling tools, you can have an AI agent solve the task automatically."
+   ]
+  }},
+  {{
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {{}},
+   "outputs": [],
+   "source": [
+    "# Uncomment to run with Claude (requires ANTHROPIC_API_KEY)\\n",
+    "from hud.agents import ClaudeAgent\\n",
+    "\\n",
+    "# Create an agent\\n",
+    "agent = ClaudeAgent(\\n",
+    "    model=\\"claude-sonnet-4-20250514\\",\\n",
+    "    allowed_tools=[\\"act\\"]  # Only allow the act tool\\n",
+    ")\\n",
+    "\\n",
+    "# Run the task\\n",
+    "result = await agent.run(task)\\n",
+    "print(f\\"Final reward: {{result.reward}}\\")"
+   ]
+  }},
+  {{
+   "cell_type": "markdown",
+   "metadata": {{}},
+   "source": [
+    "### Next Steps\\n",
+    "\\n",
+    "1. **Create your own evaluators**: Add new evaluation functions to `server.py`\\n",
+    "2. **Build complex environments**: Replace the simple counter with your actual application\\n",
+    "3. **Test with agents**: Use different AI models to solve your tasks\\n",
+    "\\n",
+    "For more examples, check out:\\n",
+    "- `environments/text_2048/` - A complete 2048 game environment\\n",
+    "- `environments/browser/` - A full browser automation environment with GUI"
+   ]
+  }},
+  {{
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {{}},
+   "outputs": [],
+   "source": []
+  }}
+ ],
+ "metadata": {{
+  "kernelspec": {{
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  }},
+  "language_info": {{
+   "codemirror_mode": {{
+    "name": "ipython",
+    "version": 3
+   }},
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.0"
+  }}
+ }},
+ "nbformat": 4,
+ "nbformat_minor": 4
+}}
+'''
+
 README_TEMPLATE = '''# {title}
 
-A minimal HUD environment created with `hud init`.
+A minimal HUD environment demonstrating the Task pattern with a simple counter.
 
 ## Quick Start
 
+### Interactive Development
 ```bash
-# Build and run locally
-hud dev
+# 1. Start the environment (optional: with inspector)
+hud dev --build --inspector
+
+# 2. Choose your preferred way to test:
+
+# Option A: Interactive notebook test_env.ipynb (great for learning!)
 
-# Or build first
-docker build -t {name}:dev .
-hud dev --image {name}:dev
+# Option B: Simple Python script (runs all tasks from tasks.json)
+python test_task.py
 ```
 
-## Structure
+### Run with an Agent
+```bash
+# Run the task with Claude
+hud eval tasks.json --agent claude
+```
 
-- `src/hud_controller/server.py` - MCP server with tools
-- `src/hud_controller/context.py` - Persistent state across hot-reloads
-- `Dockerfile` - Container configuration
-- `pyproject.toml` - Python dependencies
+## How HUD Environments Work
 
-## Adding Tools
+The environment is split into two components:
 
-Add new tools to `server.py`:
+- **`env.py`** - Stateful logic that persists across reloads
+- **`server.py`** - MCP server with tools (reloads on file changes)
 
-```python
-@mcp.tool()
-async def my_tool(param: str) -> str:
-    """Tool description."""
-    return f"Result: {{param}}"
+This separation is crucial for `hud dev` - it allows you to modify the MCP tools and see changes immediately without losing the environment state. The environment runs as a separate process and communicates via socket, while the server can be restarted freely.
+
+If you are ever seeing issues with the environment itself, running `hud dev --full-reload` will reload both the environment and the server.
+
+## Publishing Your Environment
+
+Once your environment is ready, you can share it with the community:
+
+### 1. Push to Registry
+```bash
+# Build and push your environment (this requires docker hub login and hud api key)
+hud build
+hud push
 ```
 
-## Adding State
+### 2. Create a Dataset
 
-Extend the `Context` class in `context.py`:
+Create a dataset on HuggingFace with your tasks:
 
+**Option A: Upload manually**
+1. Upload your `tasks.json` to HuggingFace
+2. Make sure it's **public** to appear on leaderboards
+
+**Option B: Use the SDK**
 ```python
-class Context:
-    def __init__(self):
-        self.count = 0
-        self.data = {{}}  # Add your state
+from hud.datasets import save_tasks
+import json
+
+# Load your tasks
+with open("tasks.json") as f:
+    tasks = json.load(f)
+
+# Push to HuggingFace
+save_tasks(tasks, repo_id="your-org/your-dataset")
 ```
 
-## Learn More
+### 3. Run and Track Performance
 
-- [HUD Documentation](https://docs.hud.so)
-- [MCP Specification](https://modelcontextprotocol.io)
+```bash
+# Run Claude on your benchmark
+hud eval "your-org/your-dataset" --agent claude
+
+# View results at:
+# app.hud.so/leaderboards/your-org/your-dataset
+```
+
+**Note**: Only public HuggingFace datasets appear as leaderboards!
+
+📚 Learn more: [Creating Benchmarks](https://docs.hud.so/evaluate-agents/create-benchmarks) | [Leaderboards](https://docs.hud.so/evaluate-agents/leaderboards)
 '''
 
 
@@ -202,7 +556,7 @@ def create_environment(name: str | None, directory: str, force: bool) -> None:
             design.warning(f"Overwriting existing files in {target_dir}")
 
     # Create directory structure
-    src_dir = target_dir / "src" / "hud_controller"
+    src_dir = target_dir / "src" / "controller"
     src_dir.mkdir(parents=True, exist_ok=True)
 
     # Write files with proper formatting
@@ -210,37 +564,54 @@ def create_environment(name: str | None, directory: str, force: bool) -> None:
 
     # Dockerfile
     dockerfile_path = target_dir / "Dockerfile"
-    dockerfile_path.write_text(DOCKERFILE_TEMPLATE.strip() + "\n")
+    dockerfile_path.write_text(DOCKERFILE_TEMPLATE.strip() + "\n", encoding="utf-8")
     files_created.append("Dockerfile")
 
     # pyproject.toml
     pyproject_path = target_dir / "pyproject.toml"
     pyproject_content = PYPROJECT_TEMPLATE.format(name=package_name).strip() + "\n"
-    pyproject_path.write_text(pyproject_content)
+    pyproject_path.write_text(pyproject_content, encoding="utf-8")
     files_created.append("pyproject.toml")
 
     # README.md
     readme_path = target_dir / "README.md"
     readme_content = README_TEMPLATE.format(name=package_name, title=name).strip() + "\n"
-    readme_path.write_text(readme_content)
+    readme_path.write_text(readme_content, encoding="utf-8")
     files_created.append("README.md")
 
     # Python files
     # __init__.py
     init_path = src_dir / "__init__.py"
-    init_path.write_text('"""HUD Controller Package"""\n')
-    files_created.append("src/hud_controller/__init__.py")
+    init_path.write_text('"""Controller Package"""\n', encoding="utf-8")
+    files_created.append("src/controller/__init__.py")
 
-    # context.py
-    context_path = src_dir / "context.py"
-    context_path.write_text(CONTEXT_TEMPLATE.strip() + "\n")
-    files_created.append("src/hud_controller/context.py")
+    # env.py
+    env_path = src_dir / "env.py"
+    env_path.write_text(ENV_TEMPLATE.strip() + "\n", encoding="utf-8")
+    files_created.append("src/controller/env.py")
 
     # server.py (need to escape the double braces for .format())
     server_path = src_dir / "server.py"
     server_content = SERVER_TEMPLATE.format(name=package_name).strip() + "\n"
-    server_path.write_text(server_content)
-    files_created.append("src/hud_controller/server.py")
+    server_path.write_text(server_content, encoding="utf-8")
+    files_created.append("src/controller/server.py")
+
+    # tasks.json
+    tasks_path = target_dir / "tasks.json"
+    tasks_content = TASKS_JSON_TEMPLATE.format(name=package_name).strip() + "\n"
+    tasks_path.write_text(tasks_content, encoding="utf-8")
+    files_created.append("tasks.json")
+
+    # test_task.py
+    test_task_path = target_dir / "test_task.py"
+    test_task_path.write_text(TEST_TASK_TEMPLATE.strip() + "\n", encoding="utf-8")
+    files_created.append("test_task.py")
+
+    # notebook.ipynb
+    notebook_path = target_dir / "test_env.ipynb"
+    notebook_content = NOTEBOOK_TEMPLATE.format(name=package_name).strip() + "\n"
+    notebook_path.write_text(notebook_content, encoding="utf-8")
+    files_created.append("test_env.ipynb")
 
     # Success message
     design.header(f"Created HUD Environment: {name}")
@@ -264,16 +635,24 @@ def create_environment(name: str | None, directory: str, force: bool) -> None:
     design.info("\n3. Connect from Cursor or test via the MCP inspector:")
     design.info("   Follow the instructions shown by hud dev --inspector")
 
-    design.info("\n4. Customize your environment:")
-    design.info("   - Add tools to src/hud_controller/server.py")
-    design.info("   - Add state to src/hud_controller/context.py")
+    design.info("\n4. Test your environment:")
+    design.command_example("python test_task.py")
+
+    design.info("\n5. Customize your environment:")
+    design.info("   - Add tools to src/controller/server.py")
+    design.info("   - Add state to src/controller/env.py")
+    design.info("   - Modify tasks in tasks.json")
+    design.info("   - Experiment in test_env.ipynb")
 
     # Show a sample of the server code
     design.section_title("Your MCP server")
     sample_code = '''@mcp.tool()
 async def act() -> str:
-    """Perform an action."""
-    return f"Action #{ctx.act()}"'''
+    """Perform an action that changes the environment state."""
+    if env is None:
+        raise RuntimeError("Context not initialized")
+    count = env.act()
+    return f"Action #{count} performed. Current count: {count}"'''
 
     syntax = Syntax(sample_code, "python", theme="monokai", line_numbers=False)
     design.console.print(Panel(syntax, border_style="dim"))

hud/cli/list_func.py

@@ -169,7 +169,7 @@ def list_environments(
 
         table.add_row(*row)
 
-    design.print(str(table))
+    design.print(table)  # type: ignore
     design.info("")
 
     # Show usage hints

hud/clients/fastmcp.py

@@ -106,19 +106,9 @@ class FastMCPHUDClient(BaseHUDClient):
 
             # Configure validation for output schemas based on client setting
             try:
-                from hud_mcp.client.session import (  # type: ignore[import-not-found]
-                    ValidationOptions,  # type: ignore[import-not-found]
-                )
-
-                if (
-                    hasattr(self._client, "_session_state")
-                    and self._client._session_state.session is not None
-                ):
-                    self._client._session_state.session._validation_options = ValidationOptions(  # type: ignore[attr-defined]
-                        strict_output_validation=self._strict_validation
-                    )
+                if hasattr(self._client, "_session_state") and self._client._session_state.session is not None:  # noqa: E501
+                    self._client._session_state.session._validate_structured_outputs = self._strict_validation  # noqa: E501
             except ImportError:
-                # ValidationOptions may not be available in some mcp versions
                 pass
 
             logger.info("FastMCP client connected")

hud/clients/mcp_use.py

@@ -73,19 +73,13 @@ class MCPUseHUDClient(BaseHUDClient):
 
             # Configure validation for all sessions based on client setting
             try:
-                from hud_mcp.client.session import (  # type: ignore[import-not-found]
-                    ValidationOptions,  # type: ignore[import-not-found]
-                )
-
                 for session in self._sessions.values():
                     if (
                         hasattr(session, "connector")
                         and hasattr(session.connector, "client_session")
                         and session.connector.client_session is not None
                     ):
-                        session.connector.client_session._validation_options = ValidationOptions(
-                            strict_output_validation=self._strict_validation
-                        )
+                        session.connector.client_session._validate_structured_outputs = self._strict_validation  # noqa: E501
             except ImportError:
                 # ValidationOptions may not be available in some mcp versions
                 pass

hud/otel/instrumentation.py

@@ -30,11 +30,15 @@ def install_mcp_instrumentation(provider: TracerProvider) -> None:
     logger = logging.getLogger(__name__)
 
     try:
+        # First, patch the _instruments to use our fork
+        import opentelemetry.instrumentation.mcp.instrumentation as mcp_inst
+        mcp_inst._instruments = ("hud-mcp-python-sdk >= 3.13.1",)
+        
         from opentelemetry.instrumentation.mcp.instrumentation import (
             McpInstrumentor,
         )
 
-        # First, patch the instrumentation to handle 3-value transports correctly
+        # Then, patch the instrumentation to handle 3-value transports correctly
         _patch_mcp_instrumentation()
 
         McpInstrumentor().instrument(tracer_provider=provider)

hud/server/server.py

@@ -116,7 +116,7 @@ class MCPServer(FastMCP):
 
         # Replace FastMCP's low-level server with our version that supports
         # per-server initialization hooks
-        def _run_init(ctx: RequestContext) -> Any:
+        def _run_init(ctx: RequestContext | None = None) -> Any:
             if self._initializer_fn is not None and not self._did_init:
                 self._did_init = True
                 # Redirect stdout to stderr during initialization to prevent

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.12"
+    assert hud.__version__ == "0.4.14"

hud/version.py

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

{hud_python-0.4.12.dist-info → hud_python-0.4.14.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hud-python
-Version: 0.4.12
+Version: 0.4.14
 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
@@ -35,10 +35,9 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Requires-Python: <3.14,>=3.11
-Requires-Dist: fastmcp>=2.11.2
 Requires-Dist: httpx<1,>=0.23.0
-Requires-Dist: hud-mcp-python-sdk>=0.1.0
-Requires-Dist: mcp>=1.13.1
+Requires-Dist: hud-fastmcp-python-sdk>=0.1.2
+Requires-Dist: hud-mcp-python-sdk>=3.13.2
 Requires-Dist: opentelemetry-api>=1.34.1
 Requires-Dist: opentelemetry-exporter-otlp-proto-http>=1.34.1
 Requires-Dist: opentelemetry-instrumentation-mcp>=0.44.1
@@ -56,6 +55,7 @@ Provides-Extra: agent
 Requires-Dist: anthropic; extra == 'agent'
 Requires-Dist: datasets>=2.14.0; extra == 'agent'
 Requires-Dist: dotenv>=0.9.9; extra == 'agent'
+Requires-Dist: hud-mcp-use-python-sdk>=2.3.13; extra == 'agent'
 Requires-Dist: ipykernel; extra == 'agent'
 Requires-Dist: ipython<9; extra == 'agent'
 Requires-Dist: jupyter-client; extra == 'agent'
@@ -63,13 +63,13 @@ Requires-Dist: jupyter-core; extra == 'agent'
 Requires-Dist: langchain; extra == 'agent'
 Requires-Dist: langchain-anthropic; extra == 'agent'
 Requires-Dist: langchain-openai; extra == 'agent'
-Requires-Dist: mcp-use; extra == 'agent'
 Requires-Dist: numpy>=1.24.0; extra == 'agent'
 Requires-Dist: openai; extra == 'agent'
 Provides-Extra: agents
 Requires-Dist: anthropic; extra == 'agents'
 Requires-Dist: datasets>=2.14.0; extra == 'agents'
 Requires-Dist: dotenv>=0.9.9; extra == 'agents'
+Requires-Dist: hud-mcp-use-python-sdk>=2.3.13; extra == 'agents'
 Requires-Dist: ipykernel; extra == 'agents'
 Requires-Dist: ipython<9; extra == 'agents'
 Requires-Dist: jupyter-client; extra == 'agents'
@@ -77,7 +77,6 @@ Requires-Dist: jupyter-core; extra == 'agents'
 Requires-Dist: langchain; extra == 'agents'
 Requires-Dist: langchain-anthropic; extra == 'agents'
 Requires-Dist: langchain-openai; extra == 'agents'
-Requires-Dist: mcp-use; extra == 'agents'
 Requires-Dist: numpy>=1.24.0; extra == 'agents'
 Requires-Dist: openai; extra == 'agents'
 Provides-Extra: dev
@@ -85,6 +84,7 @@ Requires-Dist: aiodocker>=0.24.0; extra == 'dev'
 Requires-Dist: anthropic; extra == 'dev'
 Requires-Dist: datasets>=2.14.0; extra == 'dev'
 Requires-Dist: dotenv>=0.9.9; extra == 'dev'
+Requires-Dist: hud-mcp-use-python-sdk>=2.3.13; extra == 'dev'
 Requires-Dist: inspect-ai>=0.3.80; extra == 'dev'
 Requires-Dist: ipykernel; extra == 'dev'
 Requires-Dist: ipython<9; extra == 'dev'
@@ -93,7 +93,6 @@ Requires-Dist: jupyter-core; extra == 'dev'
 Requires-Dist: langchain; extra == 'dev'
 Requires-Dist: langchain-anthropic; extra == 'dev'
 Requires-Dist: langchain-openai; extra == 'dev'
-Requires-Dist: mcp-use; extra == 'dev'
 Requires-Dist: numpy>=1.24.0; extra == 'dev'
 Requires-Dist: openai; extra == 'dev'
 Requires-Dist: pillow>=11.1.0; extra == 'dev'

{hud_python-0.4.12.dist-info → hud_python-0.4.14.dist-info}/RECORD

@@ -3,7 +3,7 @@ hud/__main__.py,sha256=YR8Dq8OhINOsVfQ55PmRXXg4fEK84Rt_-rMtJ5rvhWo,145
 hud/datasets.py,sha256=8lqC840kcNx01D2CcWZCd1j0eZTpepILmQrvohZIZYU,12056
 hud/settings.py,sha256=WIJDsyrfwBZGcaGT46YUOpW8xjBZl3siXXprd92ASAg,2039
 hud/types.py,sha256=pQWOPYXUZ2hhK0h-AHBc3DCj5tkbRXHqKZnsQQIcSFA,4237
-hud/version.py,sha256=9ZxDFavFCdgSfY_Jd59VomoRB2HCKh4pQnAZlzaXWJ4,105
+hud/version.py,sha256=EujFSzlsB3e5WmhxNLuJ-8DYtTfWdY6iOL9lPpx0r5U,105
 hud/agents/__init__.py,sha256=UoIkljWdbq4bM0LD-mSaw6w826EqdEjOk7r6glNYwYQ,286
 hud/agents/base.py,sha256=M2g7Cj5InE4EsXpmxqURprC3IHNGvNZFBZ8HPIQxz-A,24574
 hud/agents/claude.py,sha256=snbYFPW-KAkw4n9Rdz7dC2f46RuSHJKC53HPm8SucFM,14273
@@ -17,16 +17,16 @@ hud/agents/tests/test_base.py,sha256=F39ajSqASGUbPyPoWSY9KARFav62qNTK74W11Tr1Tg4
 hud/agents/tests/test_claude.py,sha256=wqEKlzEvx8obz1sSm4NY0j-Zyt1qWNfDOmRqYIuAEd0,13069
 hud/agents/tests/test_client.py,sha256=Sk5bGZw2hL5GsVi2LMp9tsLngl5ZQ18pkpeeQmts0ao,13908
 hud/agents/tests/test_openai.py,sha256=ZJqctxCbJtKw6TkJCP4D2xAcG8CkxzDXO7dh5IIWN_M,9175
-hud/cli/__init__.py,sha256=SwRcyG1UtyXqdai-kWduvyJvpo2WJmI9AffzmqUprzs,29987
+hud/cli/__init__.py,sha256=ecjrYlswQB9JJsbxQFcKZVD0fn0ZWneKSLm_kBYWpQ0,30302
 hud/cli/__main__.py,sha256=fDH7XITyuDITwSDIVwRso06aouADO0CzTHKqp5TOwJE,143
 hud/cli/analyze.py,sha256=G-tjT1xLPLcYhDhZEaI7TAIS0z0OACUksnGFoAWd2ag,14416
 hud/cli/build.py,sha256=c8pg8iUlCT1-E4koEKFX1Nx8oGaB2ln57pHdOCCDAvs,19126
 hud/cli/clone.py,sha256=AwVDIuhr8mHb1oT2Af2HrD25SiTdwATpE6zd93vzLgA,6099
 hud/cli/debug.py,sha256=FNzg9-_ZzUJA1nJfubmop7_2OT5mqnWsdpZyi4AVSXA,14163
-hud/cli/dev.py,sha256=Tx0Pf54oeHJQytVRx4up3mYE9m_Gxo3esSkhTRTCVX8,27074
-hud/cli/eval.py,sha256=yBHwekweC2orpWRVpPBAFSgWtpKpz8Dsa5drla-iTpI,12425
-hud/cli/init.py,sha256=GH6ls9JZ_pXaiVmsLwfv45rdRXa1tAfAMybvQX9Ooqg,7659
-hud/cli/list_func.py,sha256=0pEC4XD1ReUza0EFfK4dFXAbUAwyVavm6zI9Z3bpPAw,7054
+hud/cli/dev.py,sha256=ANsd34gHX08eQxeXz6atIuDyi7Tw8qngqvmDPAx-PI0,28640
+hud/cli/eval.py,sha256=zrUoXYdSe5cVbWa5fc9-tNK9syBCtKOpKDvc0ApeYQU,12604
+hud/cli/init.py,sha256=guJbNkVuFhc-c2jTEx_jZxzzPkJRtGTJapWk5hyuyd8,18710
+hud/cli/list_func.py,sha256=ENxLL4X5uuqAASWZdQuI0k-tEzmlhUn5LATgz3QPQqQ,7065
 hud/cli/pull.py,sha256=JHwCwUwRO0Nzbgm9mkjsz6EpxbxgwQVhgNSY64nNZ-s,11969
 hud/cli/push.py,sha256=4KrEHj0_i3xJNCB3eRjANmHFhSW4MFfpnld3nfVYENs,17904
 hud/cli/remove.py,sha256=USAvB6pbMA3jd19xUtLEBiMsklVTEfE2Maw9nYcpSAE,6619
@@ -60,8 +60,8 @@ hud/cli/utils/server.py,sha256=uSx2DjG5vX-PFoD8zNH-gBHbkTNSHveFSVdAfmp09Tc,7341
 hud/clients/README.md,sha256=XNE3mch95ozDgVqfwCGcrhlHY9CwT1GKfNANNboowto,3826
 hud/clients/__init__.py,sha256=bcPIa7dwH5ENsjh7CzjsJ84fm7Ma93NBc2lGfSjGAKM,328
 hud/clients/base.py,sha256=ob8G7_Gi-aENnc0yxHpZmzuqBD-swn_jVWkY2Iw7F4k,13995
-hud/clients/fastmcp.py,sha256=w7psl3JRIGxyqznxHYyhsptY6d1obPfz6y7jpJimC7E,9502
-hud/clients/mcp_use.py,sha256=7yDzv_w0mmDbOWMIN0_AGuzeDiBWwq27tcoVkZJXhk4,12174
+hud/clients/fastmcp.py,sha256=b1Q5HltWWmnAhj-Nv6T4T5gitDn5bEfqiLy5PU5yD9g,9102
+hud/clients/mcp_use.py,sha256=qRHDJ6ELRISD4V9NVPAX5SNE3NZqyunPAqDdpBtaslg,11920
 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
@@ -75,14 +75,14 @@ hud/otel/collector.py,sha256=jLZymZ8r7xt2VDuWexfbnT7PY1-0aiyLMgjBy8KDY1M,4497
 hud/otel/config.py,sha256=6np_C2UXhtKHHjY41HQxZElua2Eh_EUCBiRB_YuiSuc,6249
 hud/otel/context.py,sha256=C9MvO99cRSNNDEDC7ehO3eoTPnb6J7AemUYvEp57yEU,17774
 hud/otel/exporters.py,sha256=TP7SF6ySCP-gFV1i-u5-HbpYsK3n9GP3OjW_ZBfsj-w,14246
-hud/otel/instrumentation.py,sha256=ieKHEnMMSMZxPYvZokYJG-UQYXTNyEnaYG1lGY4zIHA,3575
+hud/otel/instrumentation.py,sha256=xbRRmTDwDyCvJVm4iWmB65kXOhotTnv9GjwkufARBuk,3782
 hud/otel/processors.py,sha256=yI5BWsDBMEPfwMzD-iWbJd4KWH3qUDSe-5-C1yT6fjU,4615
 hud/otel/tests/__init__.py,sha256=VNJKBMaxTtbn7trW-1Ph50zCvCok_wTSGcI1HD6GOLA,43
 hud/otel/tests/test_processors.py,sha256=np0R4ssd9j6LJSJykJ5bNjl0POwNYNhgb7BqOZHwcMY,6778
 hud/server/__init__.py,sha256=8LUwgsXO8xiViWP7uImDwcOsWLu01r5F4r8U8qH3rSY,91
 hud/server/context.py,sha256=6bCdSzv1FGyItu9472HbbYef279H7QuMGJDR8EtYg5Y,3210
 hud/server/low_level.py,sha256=XYs2pOJ9kN4OcJ6ahDmXM5mWkzq5wJLpKFInUYrWEok,4701
-hud/server/server.py,sha256=q6JdnsnzX4WwBLTQCCuH0pjbYaRtbuQ9xtYuHiHpa6U,7999
+hud/server/server.py,sha256=jx2JEGeVkV5wDVKM7Sb474uY4fd-c6azo7HS_SFYDxo,8013
 hud/server/helper/__init__.py,sha256=ZxO8VP3RZEBBp-q65VixuhzQgqEPSVzW0hEY9J9QqDA,116
 hud/server/tests/__init__.py,sha256=eEYYkxX5Hz9woXVOBJ2H2_CQoEih0vH6nRt3sH2Z8v8,49
 hud/shared/__init__.py,sha256=IPxPCqtPLguryN-nBq78Sakypw2bRiE2iHv3SXG8YRk,139
@@ -144,10 +144,10 @@ hud/utils/tests/test_init.py,sha256=2QLQSGgyP9wJhOvPCusm_zjJad0qApOZi1BXpxcdHXQ,
 hud/utils/tests/test_mcp.py,sha256=0pUa16mL-bqbZDXp5NHBnt1gO5o10BOg7zTMHZ1DNPM,4023
 hud/utils/tests/test_progress.py,sha256=QSF7Kpi03Ff_l3mAeqW9qs1nhK50j9vBiSobZq7T4f4,7394
 hud/utils/tests/test_telemetry.py,sha256=5jl7bEx8C8b-FfFUko5pf4UY-mPOR-9HaeL98dGtVHM,2781
-hud/utils/tests/test_version.py,sha256=uZwA5AKQVF3B6Tzw5vdMCGZlCKLkw6ZSQ9nnR6nk8XQ,160
+hud/utils/tests/test_version.py,sha256=JXMZuhuGL6fqB8mARikOgFFMpmq1Y0rG-7kz7V43w5k,160
 hud/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-hud_python-0.4.12.dist-info/METADATA,sha256=SEioaFSGeMPXozmr2ePFpd-daQbRp8rnk-kYiGx1ETs,20176
-hud_python-0.4.12.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-hud_python-0.4.12.dist-info/entry_points.txt,sha256=jJbodNFg1m0-CDofe5AHvB4zKBq7sSdP97-ohaQ3ae4,63
-hud_python-0.4.12.dist-info/licenses/LICENSE,sha256=yIzBheVUf86FC1bztAcr7RYWWNxyd3B-UJQ3uddg1HA,1078
-hud_python-0.4.12.dist-info/RECORD,,
+hud_python-0.4.14.dist-info/METADATA,sha256=e7OCOwaSi0F_gPdM0CUg2buSpTx0wd9w4uny00NH2xM,20233
+hud_python-0.4.14.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+hud_python-0.4.14.dist-info/entry_points.txt,sha256=jJbodNFg1m0-CDofe5AHvB4zKBq7sSdP97-ohaQ3ae4,63
+hud_python-0.4.14.dist-info/licenses/LICENSE,sha256=yIzBheVUf86FC1bztAcr7RYWWNxyd3B-UJQ3uddg1HA,1078
+hud_python-0.4.14.dist-info/RECORD,,