hud-python 0.2.1__py3-none-any.whl → 0.2.2__py3-none-any.whl

hud/__init__.py

@@ -5,10 +5,10 @@ HUD Gym SDK - A Python SDK for interacting with HUD environments.
 from __future__ import annotations
 
 from . import agent, env, gym, settings, task, taskset, types, utils
-from .job import create_job, job, load_job
+from .job import create_job, job, load_job, run_job
 from .taskset import load_taskset
 
-__version__ = "0.2.1"
+__version__ = "0.2.2"
 
 __all__ = [
     "agent",
@@ -18,6 +18,7 @@ __all__ = [
     "job",
     "load_job",
     "load_taskset",
+    "run_job",
     "settings",
     "task",
     "taskset",

hud/adapters/__init__.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 from .claude import ClaudeAdapter
 from .common import CLA, Adapter
+from .common.types import ResponseAction
 from .operator import OperatorAdapter
 
-__all__ = ["CLA", "Adapter", "ClaudeAdapter", "OperatorAdapter"]
+__all__ = ["CLA", "Adapter", "ClaudeAdapter", "OperatorAdapter", "ResponseAction"]

hud/adapters/claude/adapter.py

@@ -23,9 +23,13 @@ from hud.adapters.common.types import (
 
 class ClaudeAdapter(Adapter):
     KEY_MAP: ClassVar[dict[str, CLAKey]] = {
-        "Return": "enter",
-        "Super": "win",
-        }
+        "return": "enter",
+        "super": "win",
+        "super_l": "win",
+        "super_r": "win",
+        "right shift": "shift",
+        "left shift": "shift",
+    }
 
     def __init__(self) -> None:
         super().__init__()
@@ -34,7 +38,8 @@ class ClaudeAdapter(Adapter):
 
     def _map_key(self, key: str) -> CLAKey:
         """Map a key to its standardized form."""
-        return self.KEY_MAP.get(key, key.lower())  # type: ignore
+        return self.KEY_MAP.get(key.lower(), key.lower())  # type: ignore
+    
     def convert(self, data: Any) -> CLA:
         try:
             action_type = data.get("action")

hud/adapters/common/types.py

@@ -20,7 +20,6 @@ class Point(BaseModel):
 class ClickAction(CLAAction):
     type: Literal["click"] = "click"
     point: Point | None = None
-    selector: str | None = None
     button: Literal["left", "right", "wheel", "back", "forward"] = "left"
     pattern: list[int] | None = None  # [delay_1, delay_2, ...]
     hold_keys: list[CLAKey] | None = None
@@ -48,7 +47,6 @@ class KeyUpAction(CLAAction):
 class TypeAction(CLAAction):
     type: Literal["type"] = "type"
     text: str
-    selector: str | None = None
     enter_after: bool | None = False
 
 
@@ -64,7 +62,6 @@ class ScrollAction(CLAAction):
 class MoveAction(CLAAction):
     type: Literal["move"] = "move"
     point: Point | None = None
-    selector: str | None = None
     offset: Point | None = None
 
 

hud/adapters/operator/adapter.py

@@ -20,11 +20,11 @@ from hud.adapters.common.types import (
 
 class OperatorAdapter(Adapter):
     KEY_MAP: ClassVar[dict[str, CLAKey]] = {
-        "Return": "enter",
-        "ArrowUp": "up",
-        "ArrowDown": "down",
-        "ArrowLeft": "left",
-        "ArrowRight": "right",
+        "return": "enter",
+        "arrowup": "up",
+        "arrowdown": "down",
+        "arrowleft": "left",
+        "arrowright": "right",
     }
     
     def __init__(self) -> None:
@@ -35,7 +35,7 @@ class OperatorAdapter(Adapter):
         
     def _map_key(self, key: str) -> CLAKey:
         """Map a key to its standardized form."""
-        return self.KEY_MAP.get(key, key.lower())  # type: ignore
+        return self.KEY_MAP.get(key.lower(), key.lower())  # type: ignore
         
     def convert(self, data: Any) -> CLA:
         """Convert a Computer Use action to a HUD action"""

hud/agent/__init__.py

@@ -1,7 +1,8 @@
 from .base import Agent
 from .claude import ClaudeAgent
 from .operator import OperatorAgent
+from .langchain import LangchainAgent
 
 from hud.adapters import OperatorAdapter, ClaudeAdapter
 
-__all__ = ["Agent", "ClaudeAgent", "OperatorAgent", "OperatorAdapter", "ClaudeAdapter"]
+__all__ = ["Agent", "ClaudeAgent", "OperatorAgent", "OperatorAdapter", "ClaudeAdapter", "LangchainAgent"]

hud/agent/langchain.py

@@ -0,0 +1,198 @@
+import logging
+from typing import Any, Generic, List, Optional, TypeVar, Union, cast
+
+# Langchain imports
+from langchain_core.language_models import BaseLanguageModel
+from langchain_core.messages import AIMessage, BaseMessage, HumanMessage, SystemMessage
+from langchain_core.runnables import Runnable, RunnableSerializable
+from pydantic import Field, BaseModel
+
+# HUD imports
+from hud.adapters import Adapter
+from hud.agent.base import Agent
+from hud.env.environment import Observation
+from hud.adapters.common.types import (
+    CLA,
+    ClickAction,
+    TypeAction,
+    ScrollAction,
+    MoveAction,
+    DragAction,
+    PressAction,
+    KeyDownAction,
+    KeyUpAction,
+    WaitAction,
+    ResponseAction,
+    CustomAction,
+    # Exclude ScreenshotFetch, PositionFetch as they are internal
+)
+
+logger = logging.getLogger(__name__)
+
+# Define a Pydantic Union type representing exactly ONE possible CLA action
+# This is what we'll ask the Langchain model to output.
+SingleCLAction = Union[
+    ClickAction,
+    TypeAction,
+    ScrollAction,
+    MoveAction,
+    DragAction,
+    PressAction,
+    KeyDownAction,
+    KeyUpAction,
+    WaitAction,
+    ResponseAction,
+]
+
+# Define a Pydantic model to wrap the single action, potentially making it
+# easier for the LLM to consistently output the desired structure.
+class StepAction(BaseModel):
+    """Wrapper model requesting a single concrete CLA action from the Langchain model."""
+    action: SingleCLAction = Field(..., description="The single CLA action to perform for this step.")
+
+# Generic Type for the Langchain Model/Runnable
+# Allows flexibility in what the user provides (model, chain, etc.)
+# Bound to BaseLanguageModel as .with_structured_output is expected
+LangchainModelOrRunnable = TypeVar("LangchainModelOrRunnable", bound=BaseLanguageModel)
+
+class LangchainAgent(Agent[LangchainModelOrRunnable, Any], Generic[LangchainModelOrRunnable]):
+    """
+    An agent that uses an arbitrary Langchain model or runnable, leveraging
+    Langchain's structured output capabilities to produce a single CLA action per step.
+    """
+
+    def __init__(
+        self,
+        langchain_model: LangchainModelOrRunnable,
+        adapter: Optional[Adapter] = None,
+        system_prompt: str | None = None,
+    ):
+        """
+        Initialize the LangchainAgent.
+
+        Args:
+            langchain_model: The Langchain language model or runnable chain to use.
+                             Must support asynchronous invocation (`ainvoke`) and
+                             `.with_structured_output()`.
+            adapter: An optional HUD adapter. If provided, it will be used for
+                     preprocessing observations (rescaling) and postprocessing
+                     the single CLA action (coordinate rescaling).
+            system_prompt: An optional system prompt to guide the Langchain model.
+                           If None, a default prompt encouraging single CLA output is used.
+        """
+        super().__init__(client=langchain_model, adapter=adapter) # Store model as 'client'
+        self.langchain_model = langchain_model # Also store with specific name
+
+        self.system_prompt_str = system_prompt or self._get_default_system_prompt()
+        self.history: List[BaseMessage] = []
+
+    def _get_default_system_prompt(self) -> str:
+        # TODO: Refine this prompt based on testing.
+        # It needs to strongly encourage outputting *only* the StepAction structure.
+        return (
+            "You are an agent interacting with a computer environment (either a web browser or an OS desktop). "
+            "Your goal is to follow the user's instructions based on the provided text and screenshot observations."
+            "For each step, you must choose exactly ONE action to perform from the available CLA action types."
+            "Output your chosen action using the provided 'StepAction' tool/function."
+            "If you believe the task is complete based on the user's prompt and the observations, use the 'ResponseAction'."
+        )
+
+    async def fetch_response(self, observation: Observation) -> tuple[CLA | None, bool]:
+        """
+        Fetches a response from the configured Langchain model, expecting a single
+        structured CLA action.
+
+        Args:
+            observation: The preprocessed observation (screenshot potentially rescaled by adapter).
+
+        Returns:
+            A tuple containing:
+            - A list with a single dictionary representing the raw CLA action (before adapter postprocessing).
+            - A boolean indicating if the agent chose ResponseAction (task completion).
+        """
+        # 1. Format observation into Langchain message(s)
+        human_content: List[Union[str, dict]] = []
+        if observation.text:
+            human_content.append(observation.text)
+        if observation.screenshot:
+            # Assuming the Langchain model/chain can handle base64 images
+            # This might need adjustment based on the specific model used.
+            human_content.append({
+                "type": "image_url",
+                "image_url": {
+                    "url": f"data:image/png;base64,{observation.screenshot}"
+                }
+            })
+        
+        if not human_content:
+             logger.warning("LangchainAgent received an observation with no text or screenshot.")
+             # Decide how to handle empty observation - perhaps return no action?
+             return [], False # Or raise an error?
+
+        current_human_message = HumanMessage(content=human_content)
+
+        # 2. Prepare message history for the model
+        messages_for_llm: List[BaseMessage] = [
+            SystemMessage(content=self.system_prompt_str),
+            *self.history,
+            current_human_message,
+        ]
+
+        # 3. Configure structured output
+        # We ask for the StepAction wrapper, which contains the actual SingleCLAAction
+        # Explicitly use method="function_calling" to handle schemas with default values
+        structured_llm = self.langchain_model.with_structured_output(
+            schema=StepAction, 
+            method="function_calling"
+        )
+
+        # 4. Invoke Langchain model asynchronously
+        try:
+            ai_response_structured = await structured_llm.ainvoke(messages_for_llm)
+        except Exception as e:
+            logger.error(f"Langchain model invocation failed: {e}", exc_info=True)
+            # Decide how to handle LLM errors - maybe retry or return empty action?
+            return [], False
+
+        # 5. Process the structured response
+        is_done = False
+        ai_message_content_for_history = "" # For storing in history
+
+        if isinstance(ai_response_structured, StepAction):
+            # Successfully got the wrapper, extract the actual action
+            actual_action = ai_response_structured.action
+            ai_message_content_for_history = actual_action.model_dump()
+            if isinstance(actual_action, ResponseAction):
+                is_done = True
+                logger.info(f"LangchainAgent determined task is done with response: {actual_action.text[:100]}...")
+            else:
+                 logger.info(f"LangchainAgent produced action: {type(actual_action).__name__}")
+
+        else:
+            logger.warning(
+                f"Langchain model did not return the expected StepAction structure. "
+                f"Received type: {type(ai_response_structured)}. Value: {ai_response_structured!r}"
+            )
+             # Attempt to add raw response to history for debugging
+            if isinstance(ai_response_structured, BaseMessage):
+                 ai_message_content_for_history = ai_response_structured.content
+            elif isinstance(ai_response_structured, str):
+                 ai_message_content_for_history = ai_response_structured
+            else:
+                 ai_message_content_for_history = repr(ai_response_structured)
+            # Return no action as we didn't get the expected structure
+            return [], False
+
+        # 6. Update history
+        self.history.append(current_human_message)
+        # Add the AI response (containing the structured action dict) to history
+        # Convert dict to string representation for AIMessage content
+        self.history.append(AIMessage(content=repr(ai_message_content_for_history)))
+        # TODO: Consider history truncation/summarization if it grows too long
+
+        if actual_action:
+            # Return the single action dictionary within a list
+            return [actual_action], is_done
+        else:
+            # Should ideally not happen if structure validation worked, but as a fallback
+            return [], is_done 

hud/env/remote_client.py

@@ -74,6 +74,10 @@ class RemoteClient(Client):
         
         build_data = response.get("metadata", {})
         
+        if response.get("readme"):
+            logger.info("[HUD] %s gym created, see how to use it at %s", gym_id,
+                        response.get("readme"))
+        
         return controller, build_data
 
     def __init__(self, env_id: str) -> None:

hud/gym.py

@@ -8,12 +8,12 @@ from hud.env.environment import Environment
 from hud.env.local_docker_client import LocalDockerClient
 from hud.env.remote_client import RemoteClient
 from hud.env.remote_docker_client import RemoteDockerClient
-from hud.task import Task
 from hud.types import CustomGym, Gym
 from hud.utils.common import get_gym_id
 
 if TYPE_CHECKING:
     from hud.job import Job
+    from hud.task import Task
 
 logger = logging.getLogger("hud.gym")
 
@@ -54,9 +54,9 @@ async def make(
     
     gym = None
     task = None
-    if isinstance(env_src, Gym):
+    if isinstance(env_src, str | CustomGym):
         gym = env_src
-    elif isinstance(env_src, Task):
+    else:
         gym = env_src.gym
         task = env_src
 

hud/job.py

@@ -1,17 +1,27 @@
 from __future__ import annotations
 
+import asyncio
 import datetime
 import functools
 import inspect
 import logging
-from collections.abc import Callable
-from typing import Any, TypeVar, cast
+import sys
+from collections.abc import Callable, Coroutine
+from typing import TYPE_CHECKING, Any, TypeVar, cast
 
-from pydantic import BaseModel, TypeAdapter
+from pydantic import BaseModel, PrivateAttr, TypeAdapter
 
+from hud import gym
 from hud.server import make_request
 from hud.settings import settings
+from hud.task import Task
+from hud.taskset import TaskSet
 from hud.trajectory import Trajectory
+from hud.utils.progress import StepProgressTracker
+
+if TYPE_CHECKING:
+    from hud.adapters.common import Adapter
+    from hud.agent.base import Agent
 
 logger = logging.getLogger("hud.job")
 
@@ -25,7 +35,7 @@ class Job(BaseModel):
     """
     A job represents a collection of related trajectories.
     It holds metadata and provides methods to interact with job data.
-    Instances should typically be obtained via `create_job` or `load_job`.
+    Instances should typically be obtained via `create_job`, `load_job`, or the new `run_job`.
     """
 
     id: str
@@ -34,23 +44,85 @@ class Job(BaseModel):
     created_at: datetime.datetime
     status: str
     
-    async def load_trajectories(self, *, api_key: str | None = None) -> list[Trajectory]:
+    # Internal cache for trajectories
+    _trajectories: list[Trajectory] | None = PrivateAttr(default=None)
+    # Store execution errors for debugging
+    errors: list[dict[str, Any]] = []
+
+    async def load_trajectories(
+            self, *, api_key: str | None = None, force_reload: bool = False
+                                ) -> list[Trajectory]:
         """
         Loads the trajectories associated with this job.
+        Uses cached results unless force_reload is True.
+
+        Args:
+            api_key: Optional API key.
+            force_reload: If True, fetches trajectories from the API even if cached.
 
         Returns:
             List[Trajectory]: The trajectories in the job
         """
+        if self._trajectories is not None and not force_reload:
+            logger.debug("Returning cached trajectories for Job %s", self.id)
+            return self._trajectories
+            
+        logger.debug("Fetching trajectories for Job %s from API...", self.id)
         api_key = api_key or settings.api_key
         
-        data = await make_request(
-            method="GET",
-            url=f"{settings.base_url}/v2/jobs/{self.id}/trajectories",
-            api_key=api_key,
-        )
+        try:
+            data = await make_request(
+                method="GET",
+                url=f"{settings.base_url}/v2/jobs/{self.id}/trajectories",
+                api_key=api_key,
+            )
+            self._trajectories = TypeAdapter(list[Trajectory]).validate_python(data)
+            logger.debug("Loaded %d trajectories for Job %s", len(self._trajectories), self.id)
+            return self._trajectories
+        except Exception as e:
+            logger.exception("Failed to load trajectories for Job %s: %s", self.id, e)
+            self._trajectories = None # Ensure cache is cleared on error
+            return [] # Return empty list on error
+
+    async def get_analytics(self, *, force_reload: bool = False) -> dict[str, Any]:
+        """
+        Calculates and returns analytics for the job based on its trajectories.
+
+        Args:
+            force_reload: If True, re-fetches trajectories before calculating.
+
+        Returns:
+            Dictionary containing analytics (e.g., task_count, avg_reward).
+        """
+        trajectories = await self.load_trajectories(force_reload=force_reload)
         
-        return TypeAdapter(list[Trajectory]).validate_python(data)
+        task_count = len(trajectories)
+        if task_count == 0:
+            return {"task_count": 0, "avg_reward": None, "success_rate": None} # Or other default
+
+        total_reward = 0
+        successful_tasks = 0
+        valid_rewards = 0
 
+        for traj in trajectories:
+            # Example: Assume reward is numeric and success is reward >= 1.0
+            # Adjust based on actual trajectory data structure and evaluation logic
+            if isinstance(traj.reward, int | float):
+                total_reward += traj.reward
+                valid_rewards += 1
+                if traj.reward >= 1.0:
+                     successful_tasks += 1
+            # Add more complex logic here if needed based on traj.evaluation_result or metadata
+            
+        avg_reward = (total_reward / valid_rewards) if valid_rewards > 0 else None
+        success_rate = (successful_tasks / task_count) * 100 if task_count > 0 else None
+
+        return {
+            "task_count": task_count,
+            "avg_reward": avg_reward,
+            "success_rate": success_rate,
+            # Add other relevant stats here
+        }
 
 async def create_job(name: str, gym_id: str | None = None,
                      evalset_id: str | None = None,
@@ -84,7 +156,9 @@ async def create_job(name: str, gym_id: str | None = None,
     # or at least the necessary fields (id, name, metadata, created_at, status)
     # If not, we might need to make a subsequent GET request
     job_data = data # Adjust if the API response structure is different
-    
+
+    logger.info("[HUD] View job at https://app.hud.so/jobs/%s.", job_data["id"])
+
     return Job(
         id=job_data["id"],
         name=job_data["name"],
@@ -183,3 +257,337 @@ def get_active_job() -> Job | None:
         frame = frame.f_back
     
     return None
+
+# --- Moved helper functions from runner.py ---
+
+async def _execute_task(
+    agent_cls: type[Agent],
+    adapter_cls: type[Adapter] | None,
+    agent_kwargs: dict[str, Any] | None,
+    adapter_kwargs: dict[str, Any] | None,
+    task: Task,
+    job_name: str,
+    task_id: str,
+    max_steps_per_task: int,
+    job: Job,
+    tracker: StepProgressTracker | None = None,
+    # Use semaphores instead of rate limiter
+    env_creation_semaphore: asyncio.Semaphore | None = None,
+    agent_predict_semaphore: asyncio.Semaphore | None = None,
+) -> None:
+    """Helper function to instantiate/run/evaluate a single task, with concurrency limits via
+    semaphores."""
+    if tracker:
+        tracker.start_task(task_id)
+    env = None
+    agent_instance: Agent | None = None
+    status = "error"
+    error_msg = "Initialization failed"
+    try:
+        adapter_instance = None
+        if adapter_cls:
+            adapter_instance = adapter_cls(**(adapter_kwargs or {}))
+        agent_instance = agent_cls(adapter=adapter_instance, **(agent_kwargs or {}))
+        if agent_instance is None:
+            raise RuntimeError("Agent could not be instantiated")
+
+        # Environment creation with semaphore
+        if env_creation_semaphore:
+            async with env_creation_semaphore:
+                env = await gym.make(task, job=job)
+        else:
+            env = await gym.make(task, job=job)
+
+        obs_tuple = await env.reset()
+        if obs_tuple is None:
+            raise ValueError(f"env.reset() returned None for task {task_id}")
+        obs, _ = obs_tuple
+
+        step_error = None
+        for step in range(max_steps_per_task):
+            action, done = (None, False)
+            try:
+                # Agent prediction with semaphore
+                if agent_predict_semaphore:
+                    async with agent_predict_semaphore:
+                        action, done = await agent_instance.predict(obs)
+                else:
+                    action, done = await agent_instance.predict(obs)
+
+                if tracker:
+                    tracker.increment_step(task_id)
+
+                if action is None and not done:
+                    done = True
+
+                step_result = await env.step(action)
+                if step_result is None:
+                    terminated = True
+                else:
+                    obs, _, terminated, _ = step_result
+                if terminated or done:
+                    break
+
+            except Exception as agent_step_err:
+                logger.exception("[Job: %s/%s, Task: %s] Step %d Error: %s", job.name, job.id,
+                                 task_id, step + 1, agent_step_err)
+                step_error = f"Error at step {step + 1}: {agent_step_err}"
+                # Store step error in job
+                job.errors.append({
+                    "task_id": task_id,
+                    "type": "step_error",
+                    "step": step + 1,
+                    "error": str(agent_step_err),
+                    "timestamp": datetime.datetime.now().isoformat()
+                })
+                break
+        else:
+            logger.warning("[Job: %s/%s, Task: %s] Max steps reached.", job.name, job.id, task_id)
+
+        # --- Evaluate Task ---
+        evaluation_result = None
+        if step_error:
+            status = "error"
+            error_msg = step_error
+        else:
+            try:
+                evaluation_result = await env.evaluate()
+                status = "completed"
+                error_msg = None
+            except Exception as eval_err:
+                logger.exception("[Job: %s/%s, Task: %s] Evaluation Error: %s", job.name,
+                                 job.id, task_id, eval_err)
+                status = "error"
+                error_msg = f"Evaluation failed: {eval_err}"
+                # Store evaluation error in job
+                job.errors.append({
+                    "task_id": task_id,
+                    "type": "evaluation_error",
+                    "error": str(eval_err),
+                    "timestamp": datetime.datetime.now().isoformat()
+                })
+
+    except Exception as e:
+        logger.exception("[Job: %s/%s, Task: %s] Setup/Run Error: %s", job.name, job.id, task_id, e)
+        status = "error"
+        error_msg = str(e)
+        # Store setup/initialization error in job
+        job.errors.append({
+            "task_id": task_id,
+            "type": "setup_error",
+            "error": str(e),
+            "timestamp": datetime.datetime.now().isoformat()
+        })
+
+    finally:
+        if tracker:
+            tracker.finish_task(task_id)
+        if env:
+            try:
+                await env.close()
+            except Exception as close_err:
+                logger.exception("[Job: %s/%s, Task: %s] Close Error: %s", job.name, job.id,
+                                 task_id, close_err)
+                # Store environment close error in job
+                job.errors.append({
+                    "task_id": task_id,
+                    "type": "env_close_error",
+                    "error": str(close_err),
+                    "timestamp": datetime.datetime.now().isoformat()
+                })
+
+    log_suffix = f" Error: {error_msg}" if status == "error" else f" Eval: {evaluation_result}"
+    logger.info("[Job: %s/%s, Task: %s] Finished local execution. Status: %s.%s", job.name,
+                job.id, task_id, status, log_suffix)
+
+async def _progress_monitor(tracker: StepProgressTracker, interval: float = 1.0) -> None:
+    """Coroutine to periodically display progress using the tracker."""
+    try:
+        while not tracker.is_finished():
+            sys.stderr.write(f"\r{tracker.display()}")
+            sys.stderr.flush()
+            await asyncio.sleep(interval)
+        sys.stderr.write(f"\r{tracker.display()}\n")
+        sys.stderr.flush()
+        logger.debug("Progress monitor finished.")
+    except asyncio.CancelledError:
+        sys.stderr.write("\nProgress monitor cancelled.\n")
+        sys.stderr.flush()
+        logger.debug("Progress monitor cancelled.")
+    except Exception as e:
+        sys.stderr.write(f"\nProgress monitor error: {e}\n")
+        sys.stderr.flush()
+        logger.exception("Progress monitor error: %s", e)
+
+
+# --- New run_job function ---
+
+async def run_job(
+    agent_cls: type[Agent],
+    task_or_taskset: Task | TaskSet,
+    job_name: str,
+    adapter_cls: type[Adapter] | None = None,
+    agent_kwargs: dict[str, Any] | None = None,
+    adapter_kwargs: dict[str, Any] | None = None,
+    max_steps_per_task: int = 20,
+    run_parallel: bool = True,
+    job_metadata: dict[str, Any] | None = None,
+    show_progress: bool = True,
+    # Concurrency control with semaphores
+    max_concurrent_env_creations: int | None = 30,  # Limits env.make calls
+    max_concurrent_agent_predictions: int | None = 30,  # Limits agent.predict calls
+    max_concurrent_tasks: int | None = 30,  # Limits overall task concurrency
+) -> Job:
+    """
+    Creates Job, executes tasks locally, linking them to the Job.
+    Instantiates agent/adapter per task. Shows step-based progress.
+    
+    Controls concurrency in three ways:
+    1. Limits concurrent environment creations
+    2. Limits concurrent agent predictions
+    3. Limits overall concurrent tasks (when run_parallel=True)
+    
+    All concurrency controls use semaphores for reliability.
+    Tracks all errors that occur during execution in job.errors.
+
+    Args:
+        agent_cls: Agent class to instantiate.
+        task_or_taskset: Task or TaskSet to run.
+        job_name: Name for the Job.
+        adapter_cls: Optional Adapter class.
+        agent_kwargs: Optional kwargs for agent constructor.
+        adapter_kwargs: Optional kwargs for adapter constructor.
+        max_steps_per_task: Step limit per task.
+        run_parallel: Run TaskSet tasks concurrently if True (limited by max_concurrent_tasks).
+        job_metadata: Metadata for the created Job.
+        show_progress: Display the step-based progress tracker.
+        max_concurrent_env_creations: Max concurrent environment creation calls.
+        max_concurrent_agent_predictions: Max concurrent agent prediction calls.
+        max_concurrent_tasks: Max number of tasks to run actively at the same time.
+
+    Returns:
+        The created Job object with errors stored in job.errors.
+    """
+    tasks_to_run: list[Task] = []
+    created_job: Job | None = None
+
+    # --- Create Job ---
+    try:
+        logger.info("Creating job with name: '%s'", job_name)
+        created_job = await create_job(name=job_name, metadata=job_metadata)
+        logger.info("Created job with ID: %s", created_job.id)
+    except Exception as e:
+        logger.exception("Failed to create job '%s': %s", job_name, e)
+        raise
+
+    # --- Task Setup ---
+    is_taskset = isinstance(task_or_taskset, TaskSet)
+    if is_taskset:
+        tasks_to_run = task_or_taskset.tasks if task_or_taskset.tasks else []
+    elif isinstance(task_or_taskset, Task):
+        tasks_to_run = [task_or_taskset]
+        run_parallel = False
+    else:
+        raise TypeError("task_or_taskset must be either a Task or a TaskSet")
+
+    if not tasks_to_run:
+        logger.warning("Job '%s' (%s): No tasks found to run.", created_job.name, created_job.id)
+        return created_job
+        
+    task_ids = [(str(task.id) if task.id else f"task_{i}") for i, task in enumerate(tasks_to_run)]
+    num_tasks = len(tasks_to_run)
+
+    # --- Create semaphores for concurrency control ---
+    env_creation_sema = None
+    if max_concurrent_env_creations and max_concurrent_env_creations > 0:
+        env_creation_sema = asyncio.Semaphore(max_concurrent_env_creations)
+        logger.info("Limiting concurrent environment creations to %d.",
+                    max_concurrent_env_creations)
+    
+    agent_predict_sema = None
+    if max_concurrent_agent_predictions and max_concurrent_agent_predictions > 0:
+        agent_predict_sema = asyncio.Semaphore(max_concurrent_agent_predictions)
+        logger.info("Limiting concurrent agent predictions to %d.",
+                    max_concurrent_agent_predictions)
+    
+    task_execution_sema = None
+    effective_concurrency = num_tasks  # Default to running all if parallel
+    if run_parallel and max_concurrent_tasks and max_concurrent_tasks > 0:
+        effective_concurrency = min(num_tasks, max_concurrent_tasks)
+        task_execution_sema = asyncio.Semaphore(effective_concurrency)
+        logger.info("Limiting concurrent task executions to %d.", effective_concurrency)
+    elif not run_parallel:
+        effective_concurrency = 1  # Sequential means concurrency of 1
+        
+    # --- Instantiate Tracker & Start Monitor ---
+    tracker = None
+    monitor_task = None
+    if show_progress and num_tasks > 0:
+        tracker = StepProgressTracker(total_tasks=num_tasks, max_steps_per_task=max_steps_per_task)
+        monitor_task = asyncio.create_task(_progress_monitor(tracker))
+
+    # --- Execute Tasks ---
+    job_desc_suffix = f" (Job ID: {created_job.id})"
+    
+    async def task_wrapper(task_coro: Coroutine, semaphore: asyncio.Semaphore | None) -> None:
+        if semaphore:
+            async with semaphore:
+                await task_coro
+        else:
+             await task_coro
+
+    try:
+        if run_parallel and is_taskset:
+            logger.info("Job '%s'%s: Running %d tasks with concurrency %d.", created_job.name,
+                        job_desc_suffix, num_tasks, effective_concurrency)
+            
+            task_coroutines = [
+                _execute_task(
+                    agent_cls=agent_cls, adapter_cls=adapter_cls, agent_kwargs=agent_kwargs,
+                    adapter_kwargs=adapter_kwargs, task=task, job_name=created_job.name,
+                    task_id=task_id,
+                    max_steps_per_task=max_steps_per_task, job=created_job, tracker=tracker,
+                    env_creation_semaphore=env_creation_sema,
+                    agent_predict_semaphore=agent_predict_sema,
+                )
+                for task, task_id in zip(tasks_to_run, task_ids, strict=True)
+            ]
+            
+            # Wrap coroutines with semaphore management if limiting concurrency
+            wrapped_tasks = [
+                task_wrapper(coro, task_execution_sema)
+                for i, coro in enumerate(task_coroutines)
+            ]
+            
+            # Run all wrapped tasks
+            await asyncio.gather(*wrapped_tasks)
+            
+        else:
+            # SEQUENTIAL (or single task)
+            logger.info("Job '%s'%s: Running %d tasks sequentially.", created_job.name,
+                        job_desc_suffix, num_tasks)
+            for i, task in enumerate(tasks_to_run):
+                task_id = task_ids[i]
+                await _execute_task(
+                    agent_cls=agent_cls, adapter_cls=adapter_cls, agent_kwargs=agent_kwargs,
+                    adapter_kwargs=adapter_kwargs, task=task, job_name=created_job.name,
+                    task_id=task_id,
+                    max_steps_per_task=max_steps_per_task, job=created_job, tracker=tracker,
+                    env_creation_semaphore=env_creation_sema,
+                    agent_predict_semaphore=agent_predict_sema,
+                )
+
+    finally:
+        # Ensure monitor task is stopped and awaited cleanly
+        if monitor_task is not None and not monitor_task.done():
+            monitor_task.cancel()
+            try:
+                await monitor_task
+            except asyncio.CancelledError:
+                pass
+            except Exception as e:
+                logger.error("Error awaiting progress monitor task: %s", e)
+
+    logger.info("Job '%s'%s finished local execution phase for %d tasks.", created_job.name,
+                job_desc_suffix, num_tasks)
+    return created_job

hud/task.py

@@ -112,7 +112,7 @@ class Task(BaseModel):
         if sandbox:
             if isinstance(sandbox, str):
                 if sandbox == "docker":
-                    dockerfile = UBUNTU_DOCKERFILE 
+                    dockerfile = UBUNTU_DOCKERFILE
                     use_qa_gym = False
             elif isinstance(sandbox, tuple) and len(sandbox) == 2:
                 sandbox_type, sandbox_config = sandbox
@@ -122,7 +122,7 @@ class Task(BaseModel):
 
         if use_qa_gym:
             task_gym = "qa"
-            task_setup = None 
+            task_setup = None
         else:
             task_gym = CustomGym(
                 dockerfile=dockerfile or UBUNTU_DOCKERFILE,
@@ -138,7 +138,7 @@ class Task(BaseModel):
             setup=task_setup,
             metadata=sample.metadata,
             choices=sample.choices,
-            evaluate=evaluate_config, 
+            evaluate=evaluate_config,
             gym=task_gym,
             # files=sample.files, # TODO: Decide how/if to handle files
         )

hud/types.py

@@ -44,9 +44,6 @@ class CustomGym(BaseModel):
             # Read the Dockerfile content
             self.dockerfile = dockerfile_path.read_text()
 
-# Strings are identifiers for gyms on the HUD server
-Gym = CustomGym | str
-
 class EnvironmentStatus(str, enum.Enum):
     """
     Status of the environment.
@@ -63,3 +60,8 @@ class EnvironmentStatus(str, enum.Enum):
     COMPLETED = "completed"
     ERROR = "error"
 
+# Available HUD gyms
+ServerGym = Literal["qa", "hud-browser", "hud-ubuntu", "OSWorld-Ubuntu"]
+
+# Gyms can be either custom or server-side
+Gym = CustomGym | ServerGym

hud/utils/common.py

@@ -38,7 +38,10 @@ class HudStyleConfig(BaseModel):
 ShorthandConfig = tuple[str | dict[str, Any] | list[str] | list[dict[str, Any]], ...]
 
 # Type alias for multiple config formats
-HudStyleConfigs = ShorthandConfig | HudStyleConfig | list[HudStyleConfig] | dict[str, Any] | str
+HudStyleConfigs = (
+    ShorthandConfig | HudStyleConfig | list[HudStyleConfig] | list[ShorthandConfig]
+    | dict[str, Any] | str
+)
 
 class ExecuteResult(TypedDict):
     """

hud/utils/config.py

@@ -65,7 +65,7 @@ def expand_config(config: HudStyleConfigs) -> list[HudStyleConfig]:
     
     # If it's a list of HudStyleConfigs, return as is
     if isinstance(config, list) and all(isinstance(item, HudStyleConfig) for item in config):
-        return config
+        return config # type: ignore
     
     # Handle dictionary configuration
     if isinstance(config, dict):

hud/utils/progress.py

@@ -0,0 +1,136 @@
+from __future__ import annotations
+
+import time
+from collections import defaultdict
+
+
+class StepProgressTracker:
+    """
+    Tracks progress across potentially parallel async tasks based on steps completed.
+    Provides estimates assuming tasks run up to max_steps_per_task.
+    """
+    def __init__(self, total_tasks: int, max_steps_per_task: int) -> None:
+        if total_tasks <= 0:
+            raise ValueError("total_tasks must be positive")
+        if max_steps_per_task <= 0:
+            raise ValueError("max_steps_per_task must be positive")
+            
+        self.total_tasks = total_tasks
+        self.max_steps_per_task = max_steps_per_task
+        self.total_potential_steps = total_tasks * max_steps_per_task
+
+        # Use asyncio.Lock for potentially concurrent updates/reads if needed,
+        # but start without for simplicity in single-threaded asyncio.
+        # self._lock = asyncio.Lock()
+        self._task_steps: dict[str, int] = defaultdict(int)
+        self._finished_tasks: dict[str, bool] = defaultdict(bool)
+        self._tasks_started = 0
+        self._tasks_finished = 0
+        
+        self.start_time: float | None = None
+        self.current_total_steps = 0
+
+    def start_task(self, task_id: str) -> None:
+        # async with self._lock: # If using lock
+        if self.start_time is None:
+            self.start_time = time.monotonic()
+        self._task_steps[task_id] = 0
+        self._finished_tasks[task_id] = False
+        self._tasks_started += 1
+
+    def increment_step(self, task_id: str) -> None:
+        # async with self._lock:
+        if (not self._finished_tasks[task_id] and
+            self._task_steps[task_id] < self.max_steps_per_task):
+            self._task_steps[task_id] += 1
+            # Update overall progress immediately
+            self._update_total_steps()
+
+    def finish_task(self, task_id: str) -> None:
+        # async with self._lock:
+        if not self._finished_tasks[task_id]:
+            # For calculation, consider a finished task as having completed max steps
+            self._task_steps[task_id] = self.max_steps_per_task
+            self._finished_tasks[task_id] = True
+            self._tasks_finished += 1
+            # Update overall progress
+            self._update_total_steps()
+            
+    def _update_total_steps(self) -> None:
+        # This could be expensive if called extremely frequently.
+        # Called after increment or finish.
+        # async with self._lock:
+        self.current_total_steps = sum(self._task_steps.values())
+
+    def get_progress(self) -> tuple[int, int, float]:
+        """Returns (current_steps, total_potential_steps, percentage)."""
+        # async with self._lock:
+        # Recalculate here for safety, though _update_total_steps should keep it current
+        # current_steps = sum(self._task_steps.values())
+        current_steps = self.current_total_steps
+        
+        percentage = 0.0
+        if self.total_potential_steps > 0:
+            percentage = (current_steps / self.total_potential_steps) * 100
+        return current_steps, self.total_potential_steps, percentage
+
+    def get_stats(self) -> tuple[float, float | None]:
+        """Returns (rate_steps_per_minute, eta_seconds_upper_bound)."""
+        # async with self._lock:
+        if self.start_time is None or self._tasks_started == 0:
+            return 0.0, None # No rate or ETA yet
+
+        elapsed_time = time.monotonic() - self.start_time
+        current_steps = self.current_total_steps
+
+        rate_sec = 0.0
+        if elapsed_time > 0:
+            rate_sec = current_steps / elapsed_time
+        
+        rate_min = rate_sec * 60 # Convert rate to steps per minute
+
+        eta = None
+        # ETA calculation still uses rate_sec (steps/second) for time estimation in seconds
+        if rate_sec > 0:
+            remaining_steps = self.total_potential_steps - current_steps
+            eta = remaining_steps / rate_sec if remaining_steps > 0 else 0.0
+        
+        return rate_min, eta # Return rate in steps/min
+
+    def is_finished(self) -> bool:
+         # async with self._lock:
+         return self._tasks_finished >= self.total_tasks
+
+    def display(self, bar_length: int = 40) -> str:
+        """Generates a progress string similar to tqdm."""
+        current_steps, total_steps, percentage = self.get_progress()
+        rate_min, eta = self.get_stats() # Rate is now per minute
+        
+        # Ensure valid values for display
+        current_steps = min(current_steps, total_steps)
+        percentage = max(0.0, min(100.0, percentage))
+
+        filled_length = int(bar_length * current_steps // total_steps) if total_steps else 0
+        bar = "█" * filled_length + "-" * (bar_length - filled_length)
+
+        # Format time
+        elapsed_str = "0:00"
+        eta_str = "??:??"
+        if self.start_time:
+            elapsed_seconds = int(time.monotonic() - self.start_time)
+            elapsed_str = f"{elapsed_seconds // 60}:{elapsed_seconds % 60:02d}"
+            if eta is not None:
+                 eta_seconds = int(eta)
+                 eta_str = f"{eta_seconds // 60}:{eta_seconds % 60:02d}"
+            elif self.is_finished():
+                 eta_str = "0:00"
+        
+        # Update rate string format
+        rate_str = f"{rate_min:.1f} steps/min" if rate_min > 0 else "?? steps/min"
+        
+        # Format steps - use K/M for large numbers if desired, keep simple for now
+        steps_str = f"{current_steps}/{total_steps}"
+
+        # tasks_str = f" {self._tasks_finished}/{self.total_tasks} tasks" # Optional tasks counter
+        
+        return f"{percentage:3.0f}%|{bar}| {steps_str} [{elapsed_str}<{eta_str}, {rate_str}]"

{hud_python-0.2.1.dist-info → hud_python-0.2.2.dist-info}/METADATA

@@ -1,11 +1,11 @@
 Metadata-Version: 2.4
 Name: hud-python
-Version: 0.2.1
+Version: 0.2.2
 Summary: SDK for the HUD evaluation platform.
 Project-URL: Homepage, https://github.com/hud-evals/hud-sdk
 Project-URL: Bug Tracker, https://github.com/hud-evals/hud-sdk/issues
 Project-URL: Documentation, https://hud.so
-Author-email: Human Union Data SDK <founders@hud.so>
+Author-email: HUD SDK <founders@hud.so>
 License: MIT License
         
         Copyright (c) 2025 Human Union Data, Inc
@@ -37,8 +37,14 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Requires-Python: <3.14,>=3.10
 Requires-Dist: aiodocker>=0.24.0
+Requires-Dist: anthropic
 Requires-Dist: httpx<1,>=0.23.0
 Requires-Dist: inspect-ai>=0.3.80
+Requires-Dist: ipykernel
+Requires-Dist: langchain
+Requires-Dist: langchain-openai
+Requires-Dist: numpy
+Requires-Dist: openai
 Requires-Dist: pillow>=11.1.0
 Requires-Dist: pydantic-settings<3,>=2
 Requires-Dist: pydantic<3,>=2
@@ -117,10 +123,9 @@ async def main():
     obs, _ = await env.reset() # Gets first observation
     for i in range(5):
         actions, done = await agent.predict(obs)
-        if done:
-            break
-        
+
         obs, reward, terminated, info = await env.step(actions)
+        if done or terminated: break
     
     # Evaluate and close
     result = await env.evaluate()
@@ -132,22 +137,37 @@ if __name__ == "__main__":
 
 ```
 
+Alternatively, run a full evaluation set via the ```run_job``` command:
+
+```python
+from hud import load_taskset, run_job, ClaudeAgent
+
+# load
+taskset = load_taskset("GAIA")
+
+# evaluate
+job = await run_job(ClaudeAgent, taskset, "test-gaia-job")
+
+# get results OR view them in app.hud.so
+print(await job.get_analytics())
+```
+
 ## Documentation Sections
 
 Explore the core concepts and features of the SDK:
 
-*   **[Tasks and TaskSets](/concepts/task)**: Define goals, context, setup, and evaluation criteria for agent scenarios. This includes both interactive and **question-answering (QA)** style tasks.
-*   **[Environments](/concepts/environment)**: Understand the browser and OS runtimes where agents interact.
-*   **[Agents](/concepts/agent)**: Learn about the agent architecture (Claude, Operator) and how they process observations and predict actions.
-*   **[Adapters](/concepts/adapter)**: See how actions and observations are translated between agents and environments.
-*   **[Jobs](/concepts/job)**: Group related runs for analysis and viewing on the HUD platform.
-*   **[Trajectories](/concepts/trajectory)**: Understand the recorded data from each agent run.
+*   **[Tasks and TaskSets](https://documentation.hud.so/concepts/task)**: Define goals, context, setup, and evaluation criteria for agent scenarios. This includes both interactive and **question-answering (QA)** style tasks.
+*   **[Environments](https://documentation.hud.so/concepts/environment)**: Understand the browser and OS runtimes where agents interact.
+*   **[Agents](https://documentation.hud.so/concepts/agent)**: Learn about the agent architecture (Claude, Operator) and how they process observations and predict actions.
+*   **[Adapters](https://documentation.hud.so/concepts/adapter)**: See how actions and observations are translated between agents and environments.
+*   **[Jobs](https://documentation.hud.so/concepts/job)**: Group related runs for analysis and viewing on the HUD platform.
+*   **[Trajectories](https://documentation.hud.so/concepts/trajectory)**: Understand the recorded data from each agent run.
 *   **Advanced Topics**:
-    *   **[CLA Action Details](/advanced/cla-details)**: Explore the standardized action format.
-    *   **[Custom Environments](/advanced/custom-environments)**: Build your own Docker-based local or remote environments.
-    *   **[Advanced Environment Control](/advanced/environment-control)**: Use `invoke`, `execute`, and `_setup` for finer control.
+    *   **[CLA Action Details](https://documentation.hud.so/advanced/cla-details)**: Explore the standardized action format.
+    *   **[Custom Environments](https://documentation.hud.so/advanced/custom-environments)**: Build your own Docker-based local or remote environments.
+    *   **[Advanced Environment Control](https://documentation.hud.so/advanced/environment-control)**: Use `invoke`, `execute`, and `_setup` for finer control.
 
-*   **[Full API Reference](/api-reference/gym)**: Detailed specifications for all modules and classes.
+*   **[Full API Reference](https://documentation.hud.so/api-reference/gym)**: Detailed specifications for all modules and classes.
 
 ## [Examples](examples/)
 
@@ -160,7 +180,7 @@ We recommend you first take a look at the example notebooks showing how to use t
 
 ## Documentation
 
-For comprehensive guides, examples, and API reference, visit [our docs](https://docs.hud.so/introduction)
+For comprehensive guides, examples, and API reference, visit [our docs](https://documentation.hud.so/introduction)
 
 ## License
 

{hud_python-0.2.1.dist-info → hud_python-0.2.2.dist-info}/RECORD

@@ -1,29 +1,30 @@
-hud/__init__.py,sha256=HFL1iwPhLZd7z--2QADzipur68XlekwGrOzU2vWL-Vw,464
-hud/gym.py,sha256=cKjIuJS7A0vJx4K7fctpUjIEv8TkW5x6aB_PRrODrDY,3651
-hud/job.py,sha256=E4RN1CkppRQVy46RWCUDjNIyhMa7lNlFfCgpky2vKFk,5463
+hud/__init__.py,sha256=XJXuALIb-pRnnVdfEkjpuiLtS77WD3Idv5VOLECY3eo,488
+hud/gym.py,sha256=ErNwJgCJVhWZHzMILfzVXX0Dawh5Cy0nIQWWh7fsKW4,3641
+hud/job.py,sha256=IvW2sBFoQpExXVi2FL3cEwnrxVIGp8RBfVj2s8edn20,22387
 hud/settings.py,sha256=rv8TiZx4wmBzIoEEkOzoywC0nt8UZXlHxIa_LW4tWAg,1346
-hud/task.py,sha256=aNbHMlO7r1cm5DcO0QLU1SZ7EawOFw9W6DZwTNy72-4,5383
+hud/task.py,sha256=kuP69hIxV0ZsHRsZ1XEq6lzYnUSD3b6ywWzloCGW5DU,5380
 hud/taskset.py,sha256=xDPBXeDm4AlSOwl-MM98lN0x6PmGV8t9jv7sNyS_u0c,2426
 hud/trajectory.py,sha256=PA-sE2iyt2BctO2Dex-2ZaRmS95AkEXTicZjHCVCYqE,3749
-hud/types.py,sha256=fJZnzK3j3mq7G0gO5TbqRaN92qT4xAb4jUNOXIX8ZZ0,2395
-hud/adapters/__init__.py,sha256=0RNQgrzBCkhNBq1Q7JRESN1WfUVLs_99fR5g1re3APs,207
+hud/types.py,sha256=D_OGPutR55PlWrUDqehYLlR-FqQp9GyKlxJhNmCRyFE,2485
+hud/adapters/__init__.py,sha256=zz24KdC_e9TJPgWo6y57_8SzevEE5ak4Cm6tXzMxwRk,266
 hud/adapters/claude/__init__.py,sha256=i7QEF-29FLb9qxp1eYtXs-adIk_tG54tL-9g6d3xodk,100
-hud/adapters/claude/adapter.py,sha256=x0qQglWsg7n8DJ_NacsymlUQBnkpqNVguUlkQRpYX-A,5955
+hud/adapters/claude/adapter.py,sha256=viZDCNjM6aCCfpxt3PIxfVOz3rrlOgZli5WyHUxEGjc,6079
 hud/adapters/common/__init__.py,sha256=BjdZWJVs_AKtpFrt-tNsdQRjnz7D97DFEQirJ-r0mp8,118
 hud/adapters/common/adapter.py,sha256=ls-gXtg1N_SQc211rkDb3LL511HNZv6etm1nx2ZtrkQ,5808
-hud/adapters/common/types.py,sha256=APxGEmoePwjF7OYXAKqBTVT73PJTFV0eBmbURbaT5xk,5091
+hud/adapters/common/types.py,sha256=9RWLZp6sViu9uPSU5K8-TRaQkdirunxZfDsPIxAR_TM,4995
 hud/adapters/operator/__init__.py,sha256=31vTRs268_TOLd-TeQRKau5bDYy78wxCNpJFhD5_l8U,104
-hud/adapters/operator/adapter.py,sha256=svHgjCdUeMyfgfGzRO3ItGWTKGkm3tmldO2zfjX_sGI,3301
-hud/agent/__init__.py,sha256=cI3bqfmG2_Lwzn2RjrxV0X9qIxCRDiffwd1UaWToct4,238
+hud/adapters/operator/adapter.py,sha256=NNbNYPqSquIh4KHCk9aN7dARe7yPUx0J2kDIk-N015s,3309
+hud/agent/__init__.py,sha256=qdCWY6wthkTpyq7SWT1JYAYu1eXk4LfdSAcAfKt0Ohs,294
 hud/agent/base.py,sha256=RThJ_h4A3oU23zyvvKtxY2a_YM03Vd1XYDXdY3bAf8g,3881
 hud/agent/claude.py,sha256=tbDKAzGCLJPnUnHc8eV-zZmj3ZG6QQx0ukWKoO4Ekec,7445
+hud/agent/langchain.py,sha256=9ow74ENcJmZ_muzoMdG2tz5VhvAHm2zKiemphHZm-Pg,8683
 hud/agent/operator.py,sha256=44t19TzcCrS1N3-rnD25ZLXx5s4Io8On27LomALuugs,8185
 hud/env/__init__.py,sha256=BHFY_N0kEI142pjWtMyqUb3BGnoiekY8evRCIbSbO2w,271
 hud/env/client.py,sha256=SPR6ct6NFxmIrgIi3K8tEC-vnqOmCbCBtuT81PaVjuY,869
 hud/env/docker_client.py,sha256=56_u3Ri4NulGcBumAg-7-KilmFmBKthOwEIM5bOLOZc,10418
 hud/env/environment.py,sha256=Xyq4KQO9aWYPwZ0uESAetB5EEZgmlEnZVc7sA0DLz2c,13706
 hud/env/local_docker_client.py,sha256=TCD9z1qjafxjwAWLatAL8d587_ioMDHjs8T5cBgusr8,7789
-hud/env/remote_client.py,sha256=iJiwueuf98xOx0_Y2ltu_63BwKIKNvohhim73Goq74E,5804
+hud/env/remote_client.py,sha256=XDKmr5ImLBMZn-ToPrXnc4iBNRwDwzPtQIXEcgShbhE,5977
 hud/env/remote_docker_client.py,sha256=FwaO7NyygDt9oe3pDD7PwUS21pxzc465mwcXk-Cx-60,6838
 hud/evaluators/__init__.py,sha256=XophB666xPnurhQ_ygfW44h0Jh0BQGCgUzCXEOG2Q1g,158
 hud/evaluators/base.py,sha256=CNbrvFWQfl1YuBxJKzuG4_TBAdAf0TOQA3hl7eGsbaA,782
@@ -34,11 +35,12 @@ hud/evaluators/remote.py,sha256=NVUJJvrpGQj2eL-aFxzTEnAWW7iuSI9eDWtar54dc6E,2174
 hud/server/__init__.py,sha256=cxDKTwMdGzhj7bYajtejN8XCt7K8Xq3eKB2No0qBpoY,169
 hud/server/requests.py,sha256=s8LZZYWT1wl7lPu2vwRaYPZs9_gjKwSg3LZLvS5-s6E,9085
 hud/utils/__init__.py,sha256=LnoI2tQUnd-mQ4eg-gpJJgmHBBIhggJ6c9ap7MBgrfs,260
-hud/utils/common.py,sha256=XJZ-hKJkeaNmelG2QD5ybi9FpZQS1ErA40fAYzUSHVE,2742
-hud/utils/config.py,sha256=ePi3GDo8mDUnOZ5G5HyMprqGRvxrxCMfixGNuTOA8rQ,3266
+hud/utils/common.py,sha256=xJWBF2KTAQKYMGFq5hJWcwpcHAEYY3so4ZqvZYf1BjU,2778
+hud/utils/config.py,sha256=Evu2nUCYaujpWXXwLprsgr_KFUkWuSdkibmLRJ_iq64,3281
+hud/utils/progress.py,sha256=gP7_NXG0m_bhNaYPwrwUOeNumwjx4ewjXP7v-_0Lsj0,5684
 hud/utils/telemetry.py,sha256=md7AuKxtDqsONMeeTOHen1XpmNds8CbXROX_PnkDxFc,1993
 hud/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-hud_python-0.2.1.dist-info/METADATA,sha256=f2lyqGmu9L7_zgCOqrhZ6ZX1JUU6Z0e92bRTfmojSqQ,7219
-hud_python-0.2.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-hud_python-0.2.1.dist-info/licenses/LICENSE,sha256=yIzBheVUf86FC1bztAcr7RYWWNxyd3B-UJQ3uddg1HA,1078
-hud_python-0.2.1.dist-info/RECORD,,
+hud_python-0.2.2.dist-info/METADATA,sha256=I26pZPqv8O5r36BNehTmJuYQjtbRu-C3bCjt37Iwync,7963
+hud_python-0.2.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+hud_python-0.2.2.dist-info/licenses/LICENSE,sha256=yIzBheVUf86FC1bztAcr7RYWWNxyd3B-UJQ3uddg1HA,1078
+hud_python-0.2.2.dist-info/RECORD,,