hud-python 0.4.47__py3-none-any.whl → 0.4.49__py3-none-any.whl

hud/cli/tests/test_utils.py

@@ -22,7 +22,7 @@ class TestColors:
         assert Colors.YELLOW == "\033[93m"
         assert Colors.GOLD == "\033[33m"
         assert Colors.RED == "\033[91m"
-        assert Colors.GRAY == "\033[90m"
+        assert Colors.GRAY == "\033[37m"
         assert Colors.ENDC == "\033[0m"
         assert Colors.BOLD == "\033[1m"
 

hud/cli/utils/env_check.py

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

hud/cli/utils/source_hash.py

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

hud/datasets/parallel.py

@@ -261,7 +261,6 @@ async def run_dataset_parallel_manual(
     max_steps: int = 10,
     split: str = "train",
     auto_respond: bool = False,
-    custom_system_prompt: str | None = None,
 ) -> list[Any]:
     """
     Run all tasks in a dataset using process-based parallelism with manual configuration.
@@ -282,7 +281,6 @@ async def run_dataset_parallel_manual(
         max_steps: Maximum steps per task
         split: Dataset split when loading from string
         auto_respond: Whether to use ResponseAgent
-        custom_system_prompt: Override system prompt for all tasks
 
     Returns:
         List of results in the same order as the input dataset
@@ -349,14 +347,6 @@ async def run_dataset_parallel_manual(
     else:
         raise ValueError(f"Dataset must be string, Dataset, or list, got {type(dataset)}")
 
-    # Apply custom system prompt if provided
-    if custom_system_prompt:
-        for task_dict in task_dicts:
-            if "system_prompt" not in task_dict:
-                task_dict["system_prompt"] = custom_system_prompt
-            else:
-                task_dict["system_prompt"] += "\n" + custom_system_prompt
-
     # Prepare job metadata
     job_metadata = metadata or {}
     job_metadata.update(
@@ -380,8 +370,6 @@ async def run_dataset_parallel_manual(
         except Exception:
             logger.warning("Failed to extract dataset verification info")
 
-    # task_dicts = task_dicts[:10]
-
     # Create job context
     with hud.job(name, metadata=job_metadata, dataset_link=dataset_link) as job_obj:
         # Prepare agent class info for pickling

hud/datasets/runner.py

@@ -27,7 +27,6 @@ async def run_dataset(
     max_steps: int = 10,
     split: str = "train",
     auto_respond: bool = False,
-    custom_system_prompt: str | None = None,
 ) -> list[Any]:
     """
     Run all tasks in a dataset with automatic job tracking.
@@ -43,7 +42,6 @@ async def run_dataset(
         max_steps: Maximum steps per task
         split: Dataset split to use when loading from string (default: "train")
         auto_respond: Whether to use auto-response agent
-        custom_system_prompt: Override system prompt for all tasks
 
     Returns:
         List of results from agent.run() in dataset order
@@ -102,8 +100,7 @@ async def run_dataset(
             async with sem:
                 # Create trace for this task
                 task_name = task_dict.get("prompt") or f"Task {index}"
-                if custom_system_prompt and "system_prompt" not in task_dict:
-                    task_dict["system_prompt"] = custom_system_prompt
+
                 # Ensure task_id is a string for baggage propagation
                 raw_task_id = task_dict.get("id")
                 safe_task_id = str(raw_task_id) if raw_task_id is not None else None

hud/rl/actor.py

@@ -37,7 +37,7 @@ class Actor:
         # Match connection limits to parallel_episodes to avoid bottlenecks
         # Use shorter per-request timeout and keep retries modest to avoid long blocking
         http_client = create_retry_httpx_client(
-            timeout=httpx.Timeout(30.0),
+            timeout=httpx.Timeout(60.0),
         )
         return AsyncOpenAI(
             base_url=base_url,
@@ -151,7 +151,9 @@ if __name__ == "__main__":
                 "name": "evaluate",
                 "arguments": {"name": "game_2048_max_number", "arguments": {"target": 128}},
             },
-            "system_prompt": "You are an expert 2048 game player. Use arrow keys to reach the target tile. First take a screenshot, then make strategic moves.",  # noqa: E501
+            "agent_config": {
+                "system_prompt": "You are an expert 2048 game player. Use arrow keys to reach the target tile. First take a screenshot, then make strategic moves.",  # noqa: E501
+            },
         }
 
         task = Task(**task_data)

hud/rl/distributed.py

@@ -81,7 +81,7 @@ def broadcast_object(obj: Any, src: int = 0) -> Any:
         return obj
 
     obj_list = [obj] if dist.get_rank() == src else [None]
-    dist.broadcast_object_list(obj_list, src=src) #, device=torch.device("cpu"))
+    dist.broadcast_object_list(obj_list, src=src)
     return obj_list[0]
 
 

hud/rl/learner.py

@@ -148,11 +148,12 @@ class GRPOLearner:
 
         # Add LoRA adapters or load existing adapter
         policy.config.use_cache = False
-        
+
         if model_cfg.adapter_path:
             # Load existing adapter as baseline
             self.log(f"Loading existing LoRA adapter from: {model_cfg.adapter_path}")
             from peft import PeftModel
+
             policy = PeftModel.from_pretrained(policy, model_cfg.adapter_path)
             # Enable adapter training
             policy.train()

hud/rl/train.py

@@ -95,7 +95,7 @@ async def train(config: Config, tasks: list[Task]) -> None:
         if is_main_process()
         else None
     )
-    
+
     # Load initial adapter if provided
     if is_main_process() and config.model.adapter_path and vllm:
         hud_console.info(f"Loading baseline adapter from: {config.model.adapter_path}")

hud/server/__init__.py

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

hud/server/router.py

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