hud-python 0.3.5__py3-none-any.whl → 0.4.1__py3-none-any.whl

hud/__init__.py

@@ -1,89 +1,22 @@
-"""
-HUD SDK for interacting with the HUD evaluation platform.
-"""
-
-from __future__ import annotations
-
-import warnings
-from typing import Any
-
-from . import agent, datasets, env, gym, settings, task, taskset, types, utils
-from .adapters import ResponseAction as Response
-from .datasets import run_dataset, to_taskconfigs
-from .job import create_job, load_job, run_job
-
-# Import deprecated items with deferred warning
-from .task import Task as _Task
-from .taskset import load_taskset as _load_taskset
-from .telemetry import flush, job, trace, trace_open  # New context-based job
-from .version import __version__
-
-
-def __getattr__(name: str) -> Any:
-    """Emit deprecation warnings for deprecated imports."""
-    if name == "Task":
-        warnings.warn(
-            "Importing Task from hud is deprecated. "
-            "Use hud.datasets.TaskConfig instead. "
-            "Task will be removed in v0.4.0.",
-            DeprecationWarning,
-            stacklevel=2,
-        )
-        return _Task
-    elif name == "load_taskset":
-        warnings.warn(
-            "Importing load_taskset from hud is deprecated. "
-            "Use hud-evals HuggingFace datasets instead. "
-            "load_taskset will be removed in v0.4.0.",
-            DeprecationWarning,
-            stacklevel=2,
-        )
-        return _load_taskset
-    raise AttributeError(f"module 'hud' has no attribute '{name}'")
-
-
-def init_telemetry() -> None:
-    from .telemetry import init_telemetry as _init_telemetry
-
-    _init_telemetry()
-
-
-if settings.settings.fancy_logging:
-    import logging
-    import sys
-
-    hud_logger = logging.getLogger("hud")
-    hud_logger.setLevel(logging.INFO)
-
-    if not hud_logger.handlers:
-        # Use the configured stream (defaults to stderr)
-        stream = sys.stderr if settings.settings.log_stream.lower() == "stderr" else sys.stdout
-        handler = logging.StreamHandler(stream)
-        formatter = logging.Formatter("[%(levelname)s] %(asctime)s | %(name)s | %(message)s")
-        handler.setFormatter(formatter)
-        hud_logger.addHandler(handler)
-        hud_logger.propagate = False
-
-__all__ = [
-    "Response",
-    "__version__",
-    "agent",
-    "create_job",
-    "datasets",
-    "env",
-    "flush",
-    "gym",
-    "init_telemetry",
-    "job",
-    "load_job",
-    "run_dataset",
-    "run_job",
-    "settings",
-    "task",
-    "taskset",
-    "to_taskconfigs",
-    "trace",
-    "trace_open",
-    "types",
-    "utils",
-]
+"""hud-python.
+
+tools for building, evaluating, and training AI agents.
+"""
+
+from __future__ import annotations
+
+from .telemetry import clear_trace, create_job, get_trace, instrument, job, trace
+
+__all__ = [
+    "clear_trace",
+    "create_job",
+    "get_trace",
+    "instrument",
+    "job",
+    "trace",
+]
+
+try:
+    from .version import __version__
+except ImportError:
+    __version__ = "unknown"

hud/agents/__init__.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+from .art import ArtHUDAgent
+from .base import MCPAgent
+from .claude import ClaudeAgent
+from .openai import OperatorAgent
+from .openai_chat_generic import GenericOpenAIChatAgent
+
+__all__ = [
+    "ArtHUDAgent",
+    "ClaudeAgent",
+    "GenericOpenAIChatAgent",
+    "MCPAgent",
+    "OperatorAgent",
+]

hud/agents/art.py

@@ -0,0 +1,101 @@
+"""Adapter that plugs a *Trainable* ART model into the HUD MCPAgent stack.
+
+This extends GenericOpenAIChatAgent to collect messages_and_choices during
+execution for ART training.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING, Any
+
+import hud
+
+from .openai_chat_generic import GenericOpenAIChatAgent
+
+if TYPE_CHECKING:
+    import mcp.types as types
+
+    from hud.clients import AgentMCPClient
+    from hud.types import AgentResponse
+
+logger = logging.getLogger(__name__)
+
+
+system_prompt = (
+    "You are an MCP (Model Context Protocol) agent.\n\n"
+    "Use MCP tools through the server to complete your task.\n\n"
+    "You have a total of {MAX_STEPS} steps."
+)
+
+
+class ArtHUDAgent(GenericOpenAIChatAgent):
+    """Use an ART *TrainableModel* as the LLM behind a HUD `MCPAgent`.
+
+    This agent collects messages_and_choices during execution for ART training.
+    """
+
+    def __init__(self, art_model: Any, mcp_client: AgentMCPClient, **agent_kwargs: Any) -> None:
+        # Use ART's openai_client() method to get proper timeouts and patching
+        openai_client = art_model.openai_client()
+
+        super().__init__(
+            mcp_client=mcp_client,
+            openai_client=openai_client,
+            model_name=art_model.get_inference_name(),
+            logprobs=True,
+            **agent_kwargs,
+        )
+        self.system_prompt = system_prompt
+
+        self.art_model = art_model
+        self.messages_and_choices: list[Any] = []  # Collect for ART training
+
+        logger.info(
+            "ArtHUDAgent initialised with model '%s' (project=%s)",
+            art_model.name,
+            getattr(art_model, "project", "unknown"),
+        )
+
+    async def get_system_messages(self) -> list[Any]:
+        """Get system messages for ART."""
+        messages = await super().get_system_messages()
+        # Store initial messages as dicts for ART
+        self.messages_and_choices.extend(messages)
+        return messages
+
+    async def format_blocks(self, blocks: list[types.ContentBlock]) -> list[Any]:
+        """Format blocks for ART."""
+        messages = await super().format_blocks(blocks)
+        # Store initial messages as dicts for ART
+        self.messages_and_choices.extend(messages)
+        return messages
+
+    @hud.instrument(
+        span_type="agent",
+        record_args=False,  # Messages can be large
+        record_result=True,
+    )
+    async def get_response(self, messages: list[Any]) -> AgentResponse:
+        """Get model response and store the Choice for ART."""
+        # Call parent's get_model_response
+        result = await super().get_response(messages)
+
+        # Extract and store the Choice from the raw response
+        if result.raw and hasattr(result.raw, "choices") and result.raw.choices:
+            choice = result.raw.choices[0]
+            # Ensure the message has content (required for ART tokenization)
+            if choice.message and choice.message.content is None:
+                choice.message.content = ""
+            self.messages_and_choices.append(choice)
+
+        return result
+
+    async def format_tool_results(
+        self, tool_calls: list[Any], tool_results: list[Any]
+    ) -> list[Any]:
+        """Format tool results and store them for ART."""
+        tool_messages = await super().format_tool_results(tool_calls, tool_results)
+        # Store tool messages for ART
+        self.messages_and_choices.extend(tool_messages)
+        return tool_messages