hud 0.6.16.dev2__tar.gz → 0.6.16.dev4__tar.gz

{hud-0.6.16.dev2 → hud-0.6.16.dev4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: hud
-Version: 0.6.16.dev2
+Version: 0.6.16.dev4
 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
@@ -39,6 +39,7 @@ Requires-Dist: asyncssh>=2.23.0
 Requires-Dist: asyncvnc>=1.3.0
 Requires-Dist: fastmcp==3.2.0
 Requires-Dist: google-genai
+Requires-Dist: httpx2<3,>=2.0.0
 Requires-Dist: httpx<1,>=0.23.0
 Requires-Dist: mcp<2.0,>=1.24.0
 Requires-Dist: openai>=2.45.0

{hud-0.6.16.dev2 → hud-0.6.16.dev4}/hud/agents/claude/agent.py

@@ -2,13 +2,25 @@
 
 from __future__ import annotations
 
+import asyncio
 import copy
 import json
 import logging
+import math
+from random import SystemRandom
 from typing import TYPE_CHECKING, Literal, cast
 
+import httpx
+import httpx2
 import mcp.types as mcp_types
-from anthropic import AsyncAnthropic, AsyncAnthropicBedrock, Omit
+from anthropic import (
+    APIConnectionError,
+    APIStatusError,
+    APITimeoutError,
+    AsyncAnthropic,
+    AsyncAnthropicBedrock,
+    Omit,
+)
 from anthropic.types import CacheControlEphemeralParam
 from anthropic.types.beta import (
     BetaBase64ImageSourceParam,
@@ -42,6 +54,42 @@ logger = logging.getLogger(__name__)
 ClaudeImageMediaType = Literal["image/jpeg", "image/png", "image/gif", "image/webp"]
 ClaudeToolResultContent = BetaTextBlockParam | BetaImageBlockParam | BetaRequestDocumentBlockParam
 
+_RETRYABLE_STREAM_ERROR_TYPES = frozenset(
+    {
+        "api_error",
+        "gateway_error",
+        "gateway_timeout",
+        "overloaded_error",
+        "rate_limit_error",
+        "timeout_error",
+        "upstream_error",
+    }
+)
+_STREAM_MAX_ATTEMPTS = 3
+_STREAM_RETRY_BASE_DELAY_SECONDS = 1.0
+_STREAM_RETRY_MAX_DELAY_SECONDS = 5.0
+_STREAM_JITTER = SystemRandom()
+
+
+def _stream_retry_delay(attempt: int, error: Exception) -> float:
+    if isinstance(error, APIStatusError):
+        for header, divisor in (("retry-after-ms", 1000.0), ("retry-after", 1.0)):
+            value = error.response.headers.get(header)
+            if value is None:
+                continue
+            try:
+                retry_after = float(value) / divisor
+            except ValueError:
+                continue
+            if math.isfinite(retry_after):
+                return min(max(retry_after, 0.0), _STREAM_RETRY_MAX_DELAY_SECONDS)
+
+    backoff_limit = min(
+        _STREAM_RETRY_BASE_DELAY_SECONDS * (2 ** (attempt - 1)),
+        _STREAM_RETRY_MAX_DELAY_SECONDS,
+    )
+    return _STREAM_JITTER.uniform(0.0, backoff_limit)
+
 
 class ClaudeAgent(ToolAgent[BetaMessageParam, ClaudeConfig]):
     """Anthropic Claude agent. Drives SSH (coding), RFB (computer), and MCP capabilities."""
@@ -168,6 +216,67 @@ class ClaudeAgent(ToolAgent[BetaMessageParam, ClaudeConfig]):
 
     # ─── Anthropic call ───────────────────────────────────────────────
 
+    async def _stream_response(
+        self,
+        client: AsyncAnthropic,
+        *,
+        messages: list[BetaMessageParam],
+        system: str | Omit,
+        tools: list[BetaToolUnionParam],
+        tool_choice: BetaToolChoiceAutoParam,
+        betas: list[str] | Omit,
+    ) -> BetaMessage:
+        attempt = 1
+        while True:
+            stream_opened = False
+            try:
+                async with client.beta.messages.stream(
+                    model=self.config.model,
+                    system=system,
+                    max_tokens=self.config.max_tokens,
+                    messages=messages,
+                    tools=tools,
+                    tool_choice=tool_choice,
+                    betas=betas,
+                ) as stream:
+                    stream_opened = True
+                    async for _ in stream:
+                        pass
+                    return await stream.get_final_message()
+            except (
+                APIConnectionError,
+                APIStatusError,
+                APITimeoutError,
+                httpx.TransportError,
+                httpx2.TransportError,
+            ) as exc:
+                inline_error = (
+                    isinstance(exc, APIStatusError)
+                    and exc.status_code == 200
+                    and exc.type in _RETRYABLE_STREAM_ERROR_TYPES
+                )
+                interrupted_stream = stream_opened and isinstance(
+                    exc,
+                    APIConnectionError
+                    | APITimeoutError
+                    | httpx.TransportError
+                    | httpx2.TransportError,
+                )
+                if attempt >= _STREAM_MAX_ATTEMPTS or not (inline_error or interrupted_stream):
+                    raise
+
+                retry_delay = _stream_retry_delay(attempt, exc)
+                error_type = exc.type if isinstance(exc, APIStatusError) else type(exc).__name__
+                logger.warning(
+                    "Claude stream failed with %s; retrying in %.2fs (attempt %d/%d)",
+                    error_type,
+                    retry_delay,
+                    attempt + 1,
+                    _STREAM_MAX_ATTEMPTS,
+                )
+                attempt += 1
+                await asyncio.sleep(retry_delay)
+
     async def get_response(
         self,
         state: RunState[BetaMessageParam],
@@ -202,18 +311,14 @@ class ClaudeAgent(ToolAgent[BetaMessageParam, ClaudeConfig]):
                     )
                 else:
                     client = cast("AsyncAnthropic", self.anthropic_client)
-                    async with client.beta.messages.stream(
-                        model=self.config.model,
-                        system=system,
-                        max_tokens=self.config.max_tokens,
+                    response = await self._stream_response(
+                        client,
                         messages=messages_cached,
+                        system=system,
                         tools=tools,
                         tool_choice=tool_choice,
                         betas=betas,
-                    ) as stream:
-                        async for _ in stream:
-                            pass
-                        response = await stream.get_final_message()
+                    )
 
                 state.messages.append(
                     BetaMessageParam(role="assistant", content=response.content),

hud-0.6.16.dev4/hud/agents/claude/tools/base.py

@@ -0,0 +1,26 @@
+"""Claude-specific tool spec."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from hud.agents.tools.base import AgentToolSpec
+
+
+@dataclass(frozen=True)
+class ClaudeToolSpec(AgentToolSpec):
+    """Claude tool spec — adds the optional Anthropic beta flag."""
+
+    beta: str | None = None
+
+
+def is_anthropic_model(model: str | None) -> bool:
+    """Whether the model accepts Anthropic server-tool shorthands (``bash_20250124`` etc.).
+
+    Non-Anthropic models served over Anthropic-compatible endpoints (e.g. OpenRouter)
+    reject those shorthands, so tools fall back to plain ``input_schema`` definitions.
+    """
+    return bool(model) and "claude" in model.lower()
+
+
+__all__ = ["ClaudeToolSpec", "is_anthropic_model"]

{hud-0.6.16.dev2 → hud-0.6.16.dev4}/hud/agents/claude/tools/coding.py

@@ -10,12 +10,13 @@ from hud.agents.tools import SSHTool
 from hud.agents.tools.base import result_text, tool_err
 from hud.types import MCPToolResult
 
-from .base import ClaudeToolSpec
+from .base import ClaudeToolSpec, is_anthropic_model
 
 if TYPE_CHECKING:
     from anthropic.types.beta import (
         BetaToolBash20250124Param,
         BetaToolTextEditor20250728Param,
+        BetaToolUnionParam,
     )
 
 
@@ -24,11 +25,64 @@ CLAUDE_BASH_SPEC = ClaudeToolSpec(
     api_name="bash",
 )
 
+GENERIC_BASH_SPEC = ClaudeToolSpec(
+    api_type="function",
+    api_name="bash",
+)
+
 CLAUDE_TEXT_EDITOR_SPEC = ClaudeToolSpec(
     api_type="text_editor_20250728",
     api_name="str_replace_based_edit_tool",
 )
 
+GENERIC_TEXT_EDITOR_SPEC = ClaudeToolSpec(
+    api_type="function",
+    api_name="str_replace_based_edit_tool",
+)
+
+_BASH_INPUT_SCHEMA: dict[str, Any] = {
+    "type": "object",
+    "properties": {
+        "command": {
+            "type": "string",
+            "description": "The bash command to run.",
+        },
+    },
+    "required": ["command"],
+}
+
+_TEXT_EDITOR_INPUT_SCHEMA: dict[str, Any] = {
+    "type": "object",
+    "properties": {
+        "command": {
+            "type": "string",
+            "enum": ["view", "create", "str_replace", "insert"],
+            "description": "The editor operation to run.",
+        },
+        "path": {
+            "type": "string",
+            "description": "Absolute path to the file.",
+        },
+        "file_text": {
+            "type": "string",
+            "description": "Full file contents for `create`.",
+        },
+        "old_str": {
+            "type": "string",
+            "description": "Exact existing text to replace for `str_replace`; must be unique.",
+        },
+        "new_str": {
+            "type": "string",
+            "description": "Replacement text for `str_replace`, or text to insert for `insert`.",
+        },
+        "insert_line": {
+            "type": "integer",
+            "description": "Line number after which to insert for `insert` (0 = top of file).",
+        },
+    },
+    "required": ["command", "path"],
+}
+
 
 class ClaudeBashTool(SSHTool):
     """Claude's native ``bash_20250124`` schema, executed over SSH."""
@@ -37,10 +91,18 @@ class ClaudeBashTool(SSHTool):
 
     @classmethod
     def default_spec(cls, model: str) -> ClaudeToolSpec:
-        del model
-        return CLAUDE_BASH_SPEC
-
-    def to_params(self) -> BetaToolBash20250124Param:
+        return CLAUDE_BASH_SPEC if is_anthropic_model(model) else GENERIC_BASH_SPEC
+
+    def to_params(self) -> BetaToolUnionParam:
+        if self.spec.api_type == "function":
+            return cast(
+                "BetaToolUnionParam",
+                {
+                    "name": self.name,
+                    "description": "Run a command in a bash shell on the remote machine.",
+                    "input_schema": _BASH_INPUT_SCHEMA,
+                },
+            )
         return cast(
             "BetaToolBash20250124Param",
             {"type": self.spec.api_type, "name": self.name},
@@ -77,14 +139,25 @@ class ClaudeTextEditorTool(SSHTool):
 
     @classmethod
     def default_spec(cls, model: str) -> ClaudeToolSpec:
-        del model
-        return CLAUDE_TEXT_EDITOR_SPEC
+        return CLAUDE_TEXT_EDITOR_SPEC if is_anthropic_model(model) else GENERIC_TEXT_EDITOR_SPEC
 
     @property
     def provider_name(self) -> str:
         return self.spec.api_name
 
-    def to_params(self) -> BetaToolTextEditor20250728Param:
+    def to_params(self) -> BetaToolUnionParam:
+        if self.spec.api_type == "function":
+            return cast(
+                "BetaToolUnionParam",
+                {
+                    "name": self.provider_name,
+                    "description": (
+                        "View, create, and edit files on the remote machine "
+                        "(view/create/str_replace/insert)."
+                    ),
+                    "input_schema": _TEXT_EDITOR_INPUT_SCHEMA,
+                },
+            )
         return cast(
             "BetaToolTextEditor20250728Param",
             {"type": self.spec.api_type, "name": self.provider_name},
@@ -142,4 +215,11 @@ class ClaudeTextEditorTool(SSHTool):
         return await self.file_write(path, "".join(lines))
 
 
-__all__ = ["CLAUDE_BASH_SPEC", "CLAUDE_TEXT_EDITOR_SPEC", "ClaudeBashTool", "ClaudeTextEditorTool"]
+__all__ = [
+    "CLAUDE_BASH_SPEC",
+    "CLAUDE_TEXT_EDITOR_SPEC",
+    "GENERIC_BASH_SPEC",
+    "GENERIC_TEXT_EDITOR_SPEC",
+    "ClaudeBashTool",
+    "ClaudeTextEditorTool",
+]

{hud-0.6.16.dev2 → hud-0.6.16.dev4}/hud/agents/claude/tools/computer.py

@@ -19,12 +19,13 @@ from hud.agents.tools.base import tool_err, tool_ok
 from hud.capabilities.rfb import ScreenshotEncoding, WebPScreenshotEncoding
 from hud.types import MCPToolResult
 
-from .base import ClaudeToolSpec
+from .base import ClaudeToolSpec, is_anthropic_model
 
 if TYPE_CHECKING:
     from anthropic.types.beta import (
         BetaToolComputerUse20250124Param,
         BetaToolComputerUse20251124Param,
+        BetaToolUnionParam,
     )
 
     from hud.agents.tools.rfb import Button
@@ -110,9 +111,89 @@ CLAUDE_COMPUTER_SPECS: tuple[ClaudeToolSpec, ...] = (
     ),
 )
 
-# Fallback for unknown models — use the latest version.
+# Fallback for unknown Claude models — use the latest version.
 _DEFAULT_COMPUTER_SPEC = CLAUDE_COMPUTER_SPECS[0]
 
+GENERIC_COMPUTER_SPEC = ClaudeToolSpec(
+    api_type="function",
+    api_name="computer",
+)
+
+_COMPUTER_INPUT_SCHEMA: dict[str, Any] = {
+    "type": "object",
+    "properties": {
+        "action": {
+            "type": "string",
+            "enum": [
+                "screenshot",
+                "zoom",
+                "left_click",
+                "right_click",
+                "middle_click",
+                "double_click",
+                "triple_click",
+                "mouse_move",
+                "left_mouse_down",
+                "left_mouse_up",
+                "type",
+                "key",
+                "hold_key",
+                "scroll",
+                "left_click_drag",
+                "wait",
+                "cursor_position",
+            ],
+            "description": "The action to perform on the screen.",
+        },
+        "coordinate": {
+            "type": "array",
+            "items": {"type": "integer"},
+            "minItems": 2,
+            "maxItems": 2,
+            "description": "[x, y] pixel coordinate for click/move/scroll, or drag end point.",
+        },
+        "start_coordinate": {
+            "type": "array",
+            "items": {"type": "integer"},
+            "minItems": 2,
+            "maxItems": 2,
+            "description": "[x, y] drag start point for `left_click_drag`.",
+        },
+        "text": {
+            "type": "string",
+            "description": (
+                "Text to type for `type`; key chord (xdotool syntax, e.g. `ctrl+s`) for "
+                "`key`/`hold_key`; optional modifier keys held during clicks and scrolls."
+            ),
+        },
+        "duration": {
+            "type": "number",
+            "description": "Seconds to hold for `hold_key` or pause for `wait`.",
+        },
+        "scroll_direction": {
+            "type": "string",
+            "enum": ["up", "down", "left", "right"],
+            "description": "Direction for `scroll`.",
+        },
+        "scroll_amount": {
+            "type": "integer",
+            "description": "Number of scroll clicks for `scroll`.",
+        },
+        "repeat": {
+            "type": "integer",
+            "description": "Times to repeat the key chord for `key`.",
+        },
+        "region": {
+            "type": "array",
+            "items": {"type": "integer"},
+            "minItems": 4,
+            "maxItems": 4,
+            "description": "[x0, y0, x1, y1] region to magnify for `zoom`.",
+        },
+    },
+    "required": ["action"],
+}
+
 
 class ClaudeComputerTool(RFBTool):
     """Claude's native ``computer_use`` schema, executed over an RFB capability."""
@@ -121,12 +202,29 @@ class ClaudeComputerTool(RFBTool):
 
     @classmethod
     def default_spec(cls, model: str) -> ClaudeToolSpec | None:
+        if not is_anthropic_model(model):
+            return GENERIC_COMPUTER_SPEC
         for candidate in CLAUDE_COMPUTER_SPECS:
             if candidate.supports_model(model):
                 return candidate
         return _DEFAULT_COMPUTER_SPEC
 
-    def to_params(self) -> BetaToolComputerUse20250124Param | BetaToolComputerUse20251124Param:
+    def to_params(
+        self,
+    ) -> BetaToolComputerUse20250124Param | BetaToolComputerUse20251124Param | BetaToolUnionParam:
+        if self.spec.api_type == "function":
+            return cast(
+                "BetaToolUnionParam",
+                {
+                    "name": self.name,
+                    "description": (
+                        "Control the remote computer's screen, mouse, and keyboard. "
+                        f"The display is {self.display_width}x{self.display_height} pixels. "
+                        "Most actions return a screenshot of the result."
+                    ),
+                    "input_schema": _COMPUTER_INPUT_SCHEMA,
+                },
+            )
         if self.spec.api_type == "computer_20251124":
             return cast(
                 "BetaToolComputerUse20251124Param",
@@ -375,4 +473,4 @@ def _crop_png(
     return buf.getvalue(), encoding.mime_type
 
 
-__all__ = ["CLAUDE_COMPUTER_SPECS", "ClaudeComputerTool"]
+__all__ = ["CLAUDE_COMPUTER_SPECS", "GENERIC_COMPUTER_SPEC", "ClaudeComputerTool"]

{hud-0.6.16.dev2 → hud-0.6.16.dev4}/hud/agents/claude/tools/tests/test_computer.py

@@ -14,6 +14,7 @@ from PIL import Image
 
 from hud.agents.claude.tools.computer import (
     CLAUDE_COMPUTER_SPECS,
+    GENERIC_COMPUTER_SPEC,
     ClaudeComputerTool,
     _crop_png,
     _hold_keys,
@@ -120,18 +121,31 @@ def test_default_spec_per_model() -> None:
     spec_45 = ClaudeComputerTool.default_spec("claude-sonnet-4-5-20250101")
     assert spec_45 is not None
     assert spec_45.api_type == "computer_20250124"
-    # Unknown model falls back to the latest spec.
-    spec_unknown = ClaudeComputerTool.default_spec("totally-unknown")
+    # Unknown Claude model falls back to the latest spec.
+    spec_unknown = ClaudeComputerTool.default_spec("claude-totally-unknown")
     assert spec_unknown is not None
     assert spec_unknown.api_type == "computer_20251124"
+    # Non-Anthropic models get the generic input_schema spec.
+    assert ClaudeComputerTool.default_spec("qwen/qwen3.8-max") is GENERIC_COMPUTER_SPEC
 
 
 def test_to_params_reflects_spec_version() -> None:
     tool = RecordingComputer()
     tool.spec = CLAUDE_COMPUTER_SPECS[0]
-    assert tool.to_params()["type"] == "computer_20251124"
+    assert tool.to_params().get("type") == "computer_20251124"
     tool.spec = CLAUDE_COMPUTER_SPECS[1]
-    assert tool.to_params()["type"] == "computer_20250124"
+    assert tool.to_params().get("type") == "computer_20250124"
+
+
+def test_to_params_generic_spec_uses_input_schema() -> None:
+    tool = RecordingComputer()
+    tool.spec = GENERIC_COMPUTER_SPEC
+    params: Any = tool.to_params()
+    assert "type" not in params
+    assert params["name"] == "computer"
+    assert "200x100" in params["description"]
+    assert params["input_schema"]["required"] == ["action"]
+    assert "left_click" in params["input_schema"]["properties"]["action"]["enum"]
 
 
 # ─── action dispatch ──────────────────────────────────────────────────