hud-python 0.4.29__py3-none-any.whl → 0.4.31__py3-none-any.whl

hud/agents/base.py

@@ -153,16 +153,24 @@ class MCPAgent(ABC):
             if task.setup_tool:
                 if isinstance(task.setup_tool, list):
                     for tool in task.setup_tool:
-                        if self.agent_tools and tool.name not in self.agent_tools:
+                        if not self.agent_tools or (
+                            self.agent_tools and tool.name not in self.agent_tools
+                        ):
                             self.lifecycle_tools.append(tool.name)
-                elif self.agent_tools and task.setup_tool.name not in self.agent_tools:
+                elif not self.agent_tools or (
+                    self.agent_tools and task.setup_tool.name not in self.agent_tools
+                ):
                     self.lifecycle_tools.append(task.setup_tool.name)
             if task.evaluate_tool:
                 if isinstance(task.evaluate_tool, list):
                     for tool in task.evaluate_tool:
-                        if self.agent_tools and tool.name not in self.agent_tools:
+                        if not self.agent_tools or (
+                            self.agent_tools and tool.name not in self.agent_tools
+                        ):
                             self.lifecycle_tools.append(tool.name)
-                elif self.agent_tools and task.evaluate_tool.name not in self.agent_tools:
+                elif not self.agent_tools or (
+                    self.agent_tools and task.evaluate_tool.name not in self.agent_tools
+                ):
                     self.lifecycle_tools.append(task.evaluate_tool.name)
             if task.system_prompt:
                 self.system_prompt += "\n\n" + task.system_prompt

hud/agents/openai_chat_generic.py

@@ -230,7 +230,8 @@ class GenericOpenAIChatAgent(MCPAgent):
         if msg.tool_calls:
             for tc in msg.tool_calls:
                 if tc.function.name is not None:  # type: ignore
-                    tool_calls.extend(self._oai_to_mcp(tc))
+                    # _oai_to_mcp returns a single MCPToolCall; append it
+                    tool_calls.append(self._oai_to_mcp(tc))  # noqa: PERF401
 
         # Only stop on length (token limit), never on "stop"
         done = choice.finish_reason == "length"

hud/cli/flows/tasks.py

@@ -0,0 +1,185 @@
+from __future__ import annotations
+
+import json
+import re
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+
+import typer
+import yaml
+
+from hud.cli.build import build_environment
+from hud.cli.push import push_environment
+from hud.cli.utils.docker import require_docker_running
+from hud.cli.utils.environment import is_environment_directory
+from hud.cli.utils.registry import extract_name_and_tag
+from hud.utils.hud_console import hud_console
+from hud.utils.tasks import load_tasks
+
+if TYPE_CHECKING:
+    from hud.types import Task
+
+
+def _is_remote_url(url: str) -> bool:
+    """Match the remote url."""
+    # See if a url is a remote url
+    return bool(re.match(r"^(https?:\/\/)?(www\.)?[a-zA-Z0-9\-\.]+\.[a-zA-Z]{2,}(\/\S*)?$", url))
+
+
+def _validate_tasks(tasks: list[Task]) -> bool:
+    """Validate the tasks file."""
+    for task in tasks:
+        if not task.mcp_config or (not _is_remote_url(task.mcp_config.get("url", ""))):
+            return False
+    return True
+
+
+def _find_environment_dir(tasks_path: Path) -> Path | None:
+    """Find the environment directory related to a tasks file.
+
+    Strategy:
+    - Prefer a directory containing hud.lock.yaml
+    - Fallback to a directory that looks like an environment (Dockerfile + pyproject.toml)
+    - Search the tasks file directory, CWD, and a couple of parents
+    """
+    candidates: list[Path] = []
+    cwd = Path.cwd()
+    candidates.extend([tasks_path.parent, cwd])
+
+    # Add parents (up to 2 levels for each)
+    for base in list(candidates):
+        p = base
+        for _ in range(2):
+            p = p.parent
+            if p not in candidates:
+                candidates.append(p)
+
+    # Prefer those with hud.lock.yaml
+    for d in candidates:
+        if (d / "hud.lock.yaml").exists():
+            return d
+
+    # Otherwise, find a plausible environment dir
+    for d in candidates:
+        try:
+            if is_environment_directory(d):
+                return d
+        except Exception as e:
+            hud_console.debug(f"Skipping path {d}: {e}")
+            continue
+
+    return None
+
+
+def _ensure_built(env_dir: Path) -> dict[str, Any]:
+    """Ensure the environment is built and a lock file exists; return lock data."""
+    lock_path = env_dir / "hud.lock.yaml"
+    if not lock_path.exists():
+        hud_console.warning("No hud.lock.yaml found. The environment hasn't been built.")
+        if not hud_console.confirm("Build the environment now (runs 'hud build')?", default=True):
+            raise typer.Exit(1)
+        # Check Docker availability before attempting a build
+        require_docker_running()
+        # Run build (non-interactive). If Docker isn't running, this will raise and stop the flow.
+        build_environment(str(env_dir))
+
+    # Load lock file
+    with open(lock_path) as f:
+        lock_data = yaml.safe_load(f) or {}
+    return lock_data
+
+
+def _ensure_pushed(env_dir: Path, lock_data: dict[str, Any]) -> dict[str, Any]:
+    """Ensure the environment is pushed to a registry; return updated lock data."""
+    pushed = bool(lock_data.get("push"))
+    if not pushed:
+        hud_console.warning("Environment not pushed to a registry yet.")
+        if not hud_console.confirm("Push to a registry now (runs 'hud push')?", default=True):
+            raise typer.Exit(1)
+        # Check Docker availability before attempting a push
+        require_docker_running()
+
+        # If Docker or login is not configured, the push function will fail and halt.
+        push_environment(str(env_dir))
+
+        # Reload lock after push
+        lock_path = env_dir / "hud.lock.yaml"
+        with open(lock_path) as f:
+            lock_data = yaml.safe_load(f) or {}
+
+    return lock_data
+
+
+def _derive_remote_image(lock_data: dict[str, Any]) -> str:
+    """Derive org/name:tag from lock file image field for MCP header."""
+    image_ref = str(lock_data.get("image", "")).strip()
+    if not image_ref:
+        raise typer.Exit("Lock file missing image reference")
+    name, tag = extract_name_and_tag(image_ref)
+    return f"{name}:{tag}"
+
+
+def convert_tasks_to_remote(tasks_file: str) -> str:
+    """Convert a local tasks file to remote MCP tasks and return new filename.
+
+    Steps:
+    1) Find env dir; ensure built (hud.lock.yaml), otherwise build
+    2) Ensure pushed to registry, otherwise push
+    3) Create remote_[tasks].json with mcp_config pointing to mcp.hud.so and Mcp-Image
+    4) Return the new tasks file path
+    """
+    tasks_path = Path(tasks_file).resolve()
+
+    tasks = load_tasks(str(tasks_path))
+
+    # Ensure HUD_API_KEY is available: prefer process env, else load from env_dir/.env
+    from hud.settings import settings
+
+    if not settings.api_key or not settings.api_key.strip():
+        hud_console.error("HUD_API_KEY is not set")
+        raise typer.Exit(1)
+
+    # Load tasks (supports .json and .jsonl)
+    if _validate_tasks(tasks):
+        return str(tasks_path)
+
+    # Locate environment
+    env_dir = _find_environment_dir(tasks_path)
+    if not env_dir:
+        hud_console.error("Could not locate an environment directory (Dockerfile + pyproject.toml)")
+        hud_console.hint("Ensure you're in or near your environment folder before running 'hud rl'")
+        raise typer.Exit(1)
+
+    # Ensure built and pushed
+    lock_data = _ensure_built(env_dir)
+    lock_data = _ensure_pushed(env_dir, lock_data)
+
+    # Derive remote image name org/name:tag
+    remote_image = _derive_remote_image(lock_data)
+
+    # Convert to list[dict]
+    tasks_payload: list[dict[str, Any]] = []
+    for t in tasks:
+        item = t.model_dump()
+        item["mcp_config"] = {
+            "hud": {
+                "url": "https://mcp.hud.so/v3/mcp",
+                "headers": {
+                    "Authorization": "Bearer ${HUD_API_KEY}",
+                    "Mcp-Image": remote_image,
+                },
+            }
+        }
+        tasks_payload.append(item)
+
+    # Write new file: remote_<name>.json (always JSON array)
+    remote_name = f"remote_{tasks_path.stem}.json"
+    remote_path = tasks_path.parent / remote_name
+    with open(remote_path, "w", encoding="utf-8") as f:
+        json.dump(tasks_payload, f, ensure_ascii=False, indent=2)
+        f.write("\n")
+
+    hud_console.success(f"Created remote tasks file: {remote_path.name}")
+    hud_console.hint("Proceeding with RL training on the remote environment")
+
+    return str(remote_path)

hud/cli/init.py

@@ -433,11 +433,11 @@ NOTEBOOK_TEMPLATE = """{{
 
 ENV_FILE_TEMPLATE = """# HUD API Configuration
 # Get your API key from https://app.hud.so/account
-HUD_API_KEY=your_hud_api_key_here
+HUD_API_KEY=""
 
 # Anthropic API Configuration (optional)
 # Required for using Claude agents - get from https://console.anthropic.com/
-ANTHROPIC_API_KEY=your_anthropic_api_key_here
+ANTHROPIC_API_KEY=""
 """
 
 README_TEMPLATE = """# {title}