hud 0.6.13.dev1__tar.gz → 0.6.13.dev2__tar.gz

{hud-0.6.13.dev1 → hud-0.6.13.dev2}/.gitignore

@@ -56,6 +56,7 @@ hud/rl/checkpoints_test/
 
 .ck/
 
+.hud/
 .hud_eval_config
 .hud_eval.toml
 

{hud-0.6.13.dev1 → hud-0.6.13.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hud
-Version: 0.6.13.dev1
+Version: 0.6.13.dev2
 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
@@ -65,12 +65,12 @@ Requires-Dist: dotenv>=0.9.9; extra == 'dev'
 Requires-Dist: gymnasium>=1.0; extra == 'dev'
 Requires-Dist: numpy>=1.24; extra == 'dev'
 Requires-Dist: openpi-client>=0.1.2; extra == 'dev'
-Requires-Dist: pyright==1.1.407; extra == 'dev'
 Requires-Dist: pytest-asyncio; extra == 'dev'
 Requires-Dist: pytest-cov; extra == 'dev'
 Requires-Dist: pytest-mock; extra == 'dev'
 Requires-Dist: pytest>=8.1.1; extra == 'dev'
-Requires-Dist: ruff<0.15.0,>=0.11.8; extra == 'dev'
+Requires-Dist: ruff==0.16.1; extra == 'dev'
+Requires-Dist: ty==0.0.67; extra == 'dev'
 Provides-Extra: modal
 Requires-Dist: modal>=1.0; extra == 'modal'
 Provides-Extra: robot
@@ -185,11 +185,13 @@ from hud import Environment
 
 env = Environment(name="letter-count")
 
+
 @env.template()
 async def count_letter(word: str = "strawberry", letter: str = "r"):
     answer = yield f"How many '{letter}'s are in '{word}'? Reply with just the number."
     yield 1.0 if answer and str(word.count(letter)) in answer else 0.0
 
+
 tasks = [count_letter(word=w) for w in ("strawberry", "raspberry", "blueberry")]
 ```
 
@@ -203,6 +205,19 @@ Each graded evaluation is a **trace** (the SDK's live handle is a `Run`). With `
 
 → [Quickstart](https://docs.hud.ai/v6/start/quickstart) · [Tasks & tasksets](https://docs.hud.ai/v6/reference/tasks)
 
+## Existing benchmarks
+
+The experimental `hud.integrations.harbor` adapter turns Harbor task directories into runnable HUD
+tasksets and can export authored HUD tasks back to Harbor folders.
+
+```python
+from hud.integrations import harbor
+
+taskset = await harbor.adapt("./benchmark")
+```
+
+→ [Harbor interop](https://docs.hud.ai/v6/advanced/harbor-convert)
+
 ## Capabilities & harnesses
 
 A **capability** is a connection the environment exposes; a **harness** attaches its own tools to it. The same environment serves a one-shot Q&A or a full computer-use rollout, depending on which capabilities the harness opens.
@@ -269,7 +284,7 @@ Building agents at scale? We work with teams on custom environments, benchmarks,
 
 We welcome contributions! See [CONTRIBUTING.md](CONTRIBUTING.md).
 
-Key areas: [Agents](hud/agents/) · [Environments](hud/environment/) · [Capabilities](hud/capabilities/) · [Eval](hud/eval/)
+Key areas: [Agents](hud/agents/) · [Environments](hud/environment/) · [Capabilities](hud/capabilities/) · [Eval](hud/eval/) · [Integrations](hud/integrations/)
 
 <a href="https://github.com/hud-evals/hud-python/graphs/contributors">
   <img src="https://contrib.rocks/image?repo=hud-evals/hud-python&max=50" />

{hud-0.6.13.dev1 → hud-0.6.13.dev2}/README.md

@@ -101,11 +101,13 @@ from hud import Environment
 
 env = Environment(name="letter-count")
 
+
 @env.template()
 async def count_letter(word: str = "strawberry", letter: str = "r"):
     answer = yield f"How many '{letter}'s are in '{word}'? Reply with just the number."
     yield 1.0 if answer and str(word.count(letter)) in answer else 0.0
 
+
 tasks = [count_letter(word=w) for w in ("strawberry", "raspberry", "blueberry")]
 ```
 
@@ -119,6 +121,19 @@ Each graded evaluation is a **trace** (the SDK's live handle is a `Run`). With `
 
 → [Quickstart](https://docs.hud.ai/v6/start/quickstart) · [Tasks & tasksets](https://docs.hud.ai/v6/reference/tasks)
 
+## Existing benchmarks
+
+The experimental `hud.integrations.harbor` adapter turns Harbor task directories into runnable HUD
+tasksets and can export authored HUD tasks back to Harbor folders.
+
+```python
+from hud.integrations import harbor
+
+taskset = await harbor.adapt("./benchmark")
+```
+
+→ [Harbor interop](https://docs.hud.ai/v6/advanced/harbor-convert)
+
 ## Capabilities & harnesses
 
 A **capability** is a connection the environment exposes; a **harness** attaches its own tools to it. The same environment serves a one-shot Q&A or a full computer-use rollout, depending on which capabilities the harness opens.
@@ -185,7 +200,7 @@ Building agents at scale? We work with teams on custom environments, benchmarks,
 
 We welcome contributions! See [CONTRIBUTING.md](CONTRIBUTING.md).
 
-Key areas: [Agents](hud/agents/) · [Environments](hud/environment/) · [Capabilities](hud/capabilities/) · [Eval](hud/eval/)
+Key areas: [Agents](hud/agents/) · [Environments](hud/environment/) · [Capabilities](hud/capabilities/) · [Eval](hud/eval/) · [Integrations](hud/integrations/)
 
 <a href="https://github.com/hud-evals/hud-python/graphs/contributors">
   <img src="https://contrib.rocks/image?repo=hud-evals/hud-python&max=50" />

{hud-0.6.13.dev1 → hud-0.6.13.dev2}/hud/__init__.py

@@ -7,7 +7,6 @@ from __future__ import annotations
 
 # Apply patches to third-party libraries early, before other imports
 from . import patches as _patches  # noqa: F401
-from ._legacy import install as _install_v5_compat
 from .clients import connect
 from .environment import Environment
 from .eval import (
@@ -34,8 +33,6 @@ from .train import TrainingClient
 from .types import Trace
 from .version import __version__
 
-_install_v5_compat()
-
 __all__ = [
     "Chat",
     "DockerRuntime",

{hud-0.6.13.dev1 → hud-0.6.13.dev2}/hud/agents/browser_use/agent.py

@@ -15,13 +15,10 @@ optional dependency
 
 from __future__ import annotations
 
-# browser-use is an optional, untyped dependency (lazy __getattr__ exports), so
-# its symbols and members resolve as Unknown under strict checking. This whole
-# module is the boundary around that SDK; contain the unknowns here.
-# pyright: reportAttributeAccessIssue=false, reportUnknownVariableType=false, reportUnknownMemberType=false
 import contextlib
+import importlib
 import logging
-from typing import TYPE_CHECKING, Any, cast
+from typing import TYPE_CHECKING, Protocol, cast
 from urllib.parse import urlsplit, urlunsplit
 
 from hud.agents.base import Agent
@@ -37,6 +34,44 @@ LOGGER = logging.getLogger("hud.agents.browser_use")
 CDP_PROTOCOL = "cdp/1.3"
 
 
+class _Browser(Protocol):
+    async def stop(self) -> None: ...
+
+
+class _History(Protocol):
+    def is_successful(self) -> bool | None: ...
+
+    def final_result(self) -> str | None: ...
+
+    def number_of_steps(self) -> int: ...
+
+    def urls(self) -> list[str]: ...
+
+    def is_done(self) -> bool: ...
+
+
+class _BrowserAgent(Protocol):
+    async def run(self, *, max_steps: int) -> _History: ...
+
+
+class _ChatAnthropicFactory(Protocol):
+    def __call__(self, *, model: str, api_key: str, base_url: str | None) -> object: ...
+
+
+class _BrowserFactory(Protocol):
+    def __call__(self, *, cdp_url: str) -> _Browser: ...
+
+
+class _AgentFactory(Protocol):
+    def __call__(self, *, task: str, llm: object, browser: _Browser) -> _BrowserAgent: ...
+
+
+class _BrowserUseModule(Protocol):
+    ChatAnthropic: _ChatAnthropicFactory
+    Browser: _BrowserFactory
+    Agent: _AgentFactory
+
+
 class BrowserUseAgent(Agent):
     """Run the ``browser-use`` agent against an env's ``cdp/1.3`` capability."""
 
@@ -52,8 +87,7 @@ class BrowserUseAgent(Agent):
         loop, and writes the final answer + trajectory metadata onto ``run.trace``
         (graded on exit).
         """
-        from browser_use import Agent as BrowserUseSdkAgent
-        from browser_use import Browser, ChatAnthropic
+        browser_use = cast("_BrowserUseModule", importlib.import_module("browser_use"))
 
         trace = run.trace
         cdp_url = _ws_to_http(run.client.binding(CDP_PROTOCOL).url)
@@ -63,12 +97,16 @@ class BrowserUseAgent(Agent):
         if not api_key:
             raise ValueError("BrowserUseAgent needs an Anthropic API key (set ANTHROPIC_API_KEY)")
 
-        llm = ChatAnthropic(model=self.config.model, api_key=api_key, base_url=self.config.base_url)
-        browser: Any = Browser(cdp_url=cdp_url)
-        sdk_agent = cast("Any", BrowserUseSdkAgent(task=run.prompt_text, llm=llm, browser=browser))
+        llm = browser_use.ChatAnthropic(
+            model=self.config.model,
+            api_key=api_key,
+            base_url=self.config.base_url,
+        )
+        browser = browser_use.Browser(cdp_url=cdp_url)
+        sdk_agent = browser_use.Agent(task=run.prompt_text, llm=llm, browser=browser)
 
         try:
-            history: Any = await sdk_agent.run(max_steps=self.config.max_steps)
+            history = await sdk_agent.run(max_steps=self.config.max_steps)
         except Exception as exc:
             LOGGER.exception("browser-use run failed")
             trace.status = "error"

{hud-0.6.13.dev1 → hud-0.6.13.dev2}/hud/agents/claude/agent.py

@@ -35,7 +35,7 @@ from .tools.computer import ClaudeComputerTool
 from .tools.mcp_proxy import ClaudeMCPProxyTool
 
 if TYPE_CHECKING:
-    from anthropic.types.beta import BetaTextBlock, BetaTextCitation
+    from anthropic.types.beta import BetaTextCitation
 
 logger = logging.getLogger(__name__)
 
@@ -284,7 +284,7 @@ class ClaudeAgent(ToolAgent[BetaMessageParam, ClaudeConfig]):
                     )
                     result.done = False
                 case "text":
-                    text_block = cast("BetaTextBlock", block)
+                    text_block = block
                     text_parts.append(text_block.text)
                     citations.extend(self._citation(c) for c in (text_block.citations or []))
                 case "thinking":

{hud-0.6.13.dev1 → hud-0.6.13.dev2}/hud/agents/claude/sdk/agent.py

@@ -99,7 +99,7 @@ class ClaudeSDKAgent(Agent):
             family = cap.protocol.split("/", 1)[0]
             if family == "mcp":
                 token = cap.params.get("auth_token")
-                transport = "http" if cap.url.startswith("http") else "sse"
+                transport = "http" if cap.params["transport"] == "streamable-http" else "sse"
                 server_config: dict[str, Any] = {"type": transport, "url": cap.url}
                 if token:
                     server_config["headers"] = {"Authorization": f"Bearer {token}"}
@@ -108,7 +108,7 @@ class ClaudeSDKAgent(Agent):
                 from hud.agents.claude.sdk.computer_mcp import serve_computer_mcp
 
                 rfb = cast("RFBClient", await run.client.open("rfb"))
-                port = await serve_computer_mcp(rfb)
+                port = await serve_computer_mcp(rfb, self.config.screenshot_encoding)
                 self._mcp_servers["computer-use"] = {
                     "type": "http",
                     "url": f"http://127.0.0.1:{port}/mcp",

{hud-0.6.13.dev1 → hud-0.6.13.dev2}/hud/agents/claude/sdk/computer_mcp.py

@@ -12,6 +12,8 @@ from typing import TYPE_CHECKING, Any
 
 import fastmcp
 
+from hud.capabilities.rfb import ScreenshotEncoding, WebPScreenshotEncoding
+
 if TYPE_CHECKING:
     from hud.capabilities.rfb import RFBClient
 
@@ -19,15 +21,19 @@ logger = logging.getLogger(__name__)
 
 #: Keep references to background server tasks so they aren't garbage-collected.
 _BACKGROUND_TASKS: set[asyncio.Task[None]] = set()
+_DEFAULT_SCREENSHOT_ENCODING = WebPScreenshotEncoding()
 
 
-def create_computer_mcp(rfb: RFBClient) -> fastmcp.FastMCP:
+def create_computer_mcp(
+    rfb: RFBClient,
+    screenshot_encoding: ScreenshotEncoding = _DEFAULT_SCREENSHOT_ENCODING,
+) -> fastmcp.FastMCP:
     """Build a FastMCP server with one ``computer`` tool backed by ``rfb``."""
 
     mcp = fastmcp.FastMCP("computer-use")
 
     @mcp.tool()
-    async def computer(  # pyright: ignore[reportUnusedFunction]
+    async def computer(
         action: str,
         coordinate: str | None = None,
         text: str | None = None,
@@ -79,7 +85,11 @@ def create_computer_mcp(rfb: RFBClient) -> fastmcp.FastMCP:
                 arguments["region"] = region
 
         spec = AgentToolSpec(api_type="computer", api_name="computer")
-        tool = ClaudeComputerTool(spec=spec, client=rfb)
+        tool = ClaudeComputerTool(
+            spec=spec,
+            client=rfb,
+            screenshot_encoding=screenshot_encoding,
+        )
         result = await tool.execute(arguments)
 
         # Return content blocks directly so the CLI/model sees real images.
@@ -106,6 +116,7 @@ def create_computer_mcp(rfb: RFBClient) -> fastmcp.FastMCP:
 
 async def serve_computer_mcp(
     rfb: RFBClient,
+    screenshot_encoding: ScreenshotEncoding = _DEFAULT_SCREENSHOT_ENCODING,
     host: str = "127.0.0.1",
     port: int = 0,
 ) -> int:
@@ -115,7 +126,7 @@ async def serve_computer_mcp(
         port = srv.sockets[0].getsockname()[1]
         srv.close()
 
-    mcp = create_computer_mcp(rfb)
+    mcp = create_computer_mcp(rfb, screenshot_encoding)
     task = asyncio.create_task(_run(mcp, host, port))
     _BACKGROUND_TASKS.add(task)
     task.add_done_callback(_BACKGROUND_TASKS.discard)

{hud-0.6.13.dev1 → hud-0.6.13.dev2}/hud/agents/claude/tools/computer.py

@@ -16,6 +16,7 @@ import mcp.types as mcp_types
 
 from hud.agents.tools import RFBTool
 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
@@ -279,11 +280,7 @@ class ClaudeComputerTool(RFBTool):
         except (TypeError, ValueError):
             return tool_err("region must contain 4 integers")
         screenshot, _ = await self.client.screenshot_png("image/png")
-        cropped, mime_type = _crop_png(
-            screenshot,
-            (x0, y0, x1, y1),
-            self.screenshot_mime_type,
-        )
+        cropped, mime_type = _crop_png(screenshot, (x0, y0, x1, y1), self.screenshot_encoding)
         return MCPToolResult(
             content=[
                 mcp_types.ImageContent(
@@ -356,18 +353,18 @@ def _drag_path(arguments: dict[str, Any]) -> list[tuple[int, int]]:
 def _crop_png(
     png: bytes,
     region: tuple[int, int, int, int],
-    mime_type: str,
+    encoding: ScreenshotEncoding,
 ) -> tuple[bytes, str]:
     from PIL import Image
 
     image = Image.open(BytesIO(png))
     cropped = image.crop(region)
     buf = BytesIO()
-    if mime_type == "image/webp":
-        cropped.save(buf, format="WEBP", quality=85)
+    if isinstance(encoding, WebPScreenshotEncoding):
+        cropped.save(buf, format="WEBP", quality=encoding.quality)
     else:
         cropped.save(buf, format="PNG")
-    return buf.getvalue(), mime_type
+    return buf.getvalue(), encoding.mime_type
 
 
 __all__ = ["CLAUDE_COMPUTER_SPECS", "ClaudeComputerTool"]

{hud-0.6.13.dev1 → hud-0.6.13.dev2}/hud/agents/claude/tools/tests/test_computer.py

@@ -1,13 +1,12 @@
 """``ClaudeComputerTool`` — key translation, per-model spec gating, and the
 computer-use action dispatch (translation to RFB primitives), without a live VNC.
 """
-# pyright: reportPrivateUsage=false, reportIncompatibleMethodOverride=false
 
 from __future__ import annotations
 
 from io import BytesIO
 from types import SimpleNamespace
-from typing import Any
+from typing import TYPE_CHECKING, Any
 from unittest.mock import AsyncMock, patch
 
 import mcp.types as mcp_types
@@ -21,7 +20,11 @@ from hud.agents.claude.tools.computer import (
     _split_keys,
     _translate_key,
 )
+
+if TYPE_CHECKING:
+    from collections.abc import Iterable
 from hud.agents.tools.base import result_text, tool_ok
+from hud.capabilities.rfb import WebPScreenshotEncoding
 
 
 class RecordingComputer(ClaudeComputerTool):
@@ -31,23 +34,41 @@ class RecordingComputer(ClaudeComputerTool):
 
     def __init__(self) -> None:
         self.calls: list[tuple[Any, ...]] = []
-        self.screenshot_mime_type = "image/webp"
+        self.screenshot_encoding = WebPScreenshotEncoding(quality=42)
         self.client = SimpleNamespace(width=200, height=100)
 
     async def screenshot(self) -> Any:
         self.calls.append(("screenshot",))
         return tool_ok("shot")
 
-    async def click(self, x: Any, y: Any, **kw: Any) -> None:
+    async def click(
+        self,
+        x: int | None = None,
+        y: int | None = None,
+        *,
+        button: Any = "left",
+        hold_keys: Iterable[str] | None = None,
+        count: int = 1,
+        interval_ms: int = 0,
+    ) -> None:
+        kw: dict[str, Any] = {}
+        if button != "left":
+            kw["button"] = button
+        if hold_keys is not None:
+            kw["hold_keys"] = hold_keys
+        if count != 1:
+            kw["count"] = count
+        if interval_ms:
+            kw["interval_ms"] = interval_ms
         self.calls.append(("click", x, y, kw))
 
     async def move(self, x: Any, y: Any) -> None:
         self.calls.append(("move", x, y))
 
-    async def mouse_down(self, button: Any) -> None:
+    async def mouse_down(self, button: Any = "left") -> None:
         self.calls.append(("down", button))
 
-    async def mouse_up(self, button: Any) -> None:
+    async def mouse_up(self, button: Any = "left") -> None:
         self.calls.append(("up", button))
 
     async def type_text(self, text: Any) -> None:
@@ -59,15 +80,21 @@ class RecordingComputer(ClaudeComputerTool):
     async def hold_key(self, key: Any, **kw: Any) -> None:
         self.calls.append(("hold", key, kw))
 
-    async def scroll(self, x: Any, y: Any, **kw: Any) -> None:
+    async def scroll(
+        self,
+        x: int | None = None,
+        y: int | None = None,
+        *,
+        scroll_x: int = 0,
+        scroll_y: int = 0,
+        hold_keys: Iterable[str] | None = None,
+    ) -> None:
+        kw = {"scroll_x": scroll_x, "scroll_y": scroll_y, "hold_keys": hold_keys}
         self.calls.append(("scroll", x, y, kw))
 
     async def drag(self, path: Any, **kw: Any) -> None:
         self.calls.append(("drag", tuple(path), kw))
 
-    async def wait(self, ms: Any) -> None:
-        self.calls.append(("wait", ms))
-
 
 # ─── key translation helpers ──────────────────────────────────────────
 
@@ -160,7 +187,11 @@ def test_crop_reports_encoded_mime_type() -> None:
     source = BytesIO()
     Image.effect_noise((128, 128), 100).convert("RGB").save(source, format="PNG")
 
-    cropped, mime_type = _crop_png(source.getvalue(), (0, 0, 128, 128), "image/webp")
+    cropped, mime_type = _crop_png(
+        source.getvalue(),
+        (0, 0, 128, 128),
+        WebPScreenshotEncoding(quality=42),
+    )
 
     assert mime_type == "image/webp"
     assert cropped.startswith(b"RIFF")
@@ -177,6 +208,6 @@ async def test_zoom_reports_encoded_mime_type() -> None:
         result = await tool._zoom({"region": [0, 0, 10, 10]})
 
     tool.client.screenshot_png.assert_awaited_once_with("image/png")
-    crop.assert_called_once_with(b"png", (0, 0, 10, 10), "image/webp")
+    crop.assert_called_once_with(b"png", (0, 0, 10, 10), tool.screenshot_encoding)
     image = next(block for block in result.content if isinstance(block, mcp_types.ImageContent))
     assert image.mimeType == "image/webp"

{hud-0.6.13.dev1 → hud-0.6.13.dev2}/hud/agents/gemini/tools/tests/test_computer.py

@@ -2,16 +2,19 @@
 
 No live VNC: a recording subclass captures the primitive calls.
 """
-# pyright: reportPrivateUsage=false, reportIncompatibleMethodOverride=false
 
 from __future__ import annotations
 
 from types import SimpleNamespace
-from typing import Any
+from typing import TYPE_CHECKING, Any
+from unittest.mock import AsyncMock, patch
 
 from hud.agents.gemini.tools.computer import GEMINI_COMPUTER_SPEC, GeminiComputerTool
 from hud.agents.tools.base import tool_ok
 
+if TYPE_CHECKING:
+    from collections.abc import Iterable
+
 
 class RecordingGemini(GeminiComputerTool):
     client: Any
@@ -25,7 +28,16 @@ class RecordingGemini(GeminiComputerTool):
         self.calls.append(("screenshot",))
         return tool_ok("shot")
 
-    async def click(self, x: Any, y: Any, **kw: Any) -> None:
+    async def click(
+        self,
+        x: int | None = None,
+        y: int | None = None,
+        *,
+        button: Any = "left",
+        hold_keys: Iterable[str] | None = None,
+        count: int = 1,
+        interval_ms: int = 0,
+    ) -> None:
         self.calls.append(("click", x, y))
 
     async def move(self, x: Any, y: Any) -> None:
@@ -37,15 +49,21 @@ class RecordingGemini(GeminiComputerTool):
     async def press_keys(self, keys: Any, **kw: Any) -> None:
         self.calls.append(("keys", tuple(keys)))
 
-    async def scroll(self, x: Any, y: Any, **kw: Any) -> None:
+    async def scroll(
+        self,
+        x: int | None = None,
+        y: int | None = None,
+        *,
+        scroll_x: int = 0,
+        scroll_y: int = 0,
+        hold_keys: Iterable[str] | None = None,
+    ) -> None:
+        kw = {"scroll_x": scroll_x, "scroll_y": scroll_y, "hold_keys": hold_keys}
         self.calls.append(("scroll", x, y, kw))
 
     async def drag(self, path: Any, **kw: Any) -> None:
         self.calls.append(("drag", tuple(path)))
 
-    async def wait(self, ms: Any) -> None:
-        self.calls.append(("wait", ms))
-
 
 def test_default_spec() -> None:
     assert GeminiComputerTool.default_spec("any") is GEMINI_COMPUTER_SPEC
@@ -87,11 +105,12 @@ async def test_key_combination_requires_string() -> None:
 
 async def test_wait_and_drag() -> None:
     tool = RecordingGemini()
-    await tool.execute({"action": "wait_5_seconds"})
+    with patch("hud.agents.tools.rfb.asyncio.sleep", new_callable=AsyncMock) as sleep:
+        await tool.execute({"action": "wait_5_seconds"})
     await tool.execute(
         {"action": "drag_and_drop", "x": 50, "y": 50, "destination_x": 100, "destination_y": 100}
     )
-    assert ("wait", 5000) in tool.calls
+    sleep.assert_awaited_once_with(5)
     assert any(c[0] == "drag" for c in tool.calls)
 
 

{hud-0.6.13.dev1 → hud-0.6.13.dev2}/hud/agents/openai/tools/apply_patch.py

@@ -1,4 +1,3 @@
-# pyright: reportUnusedFunction=false
 """OpenAI apply_patch parser helpers."""
 
 from __future__ import annotations

{hud-0.6.13.dev1 → hud-0.6.13.dev2}/hud/agents/openai/tools/computer.py

@@ -148,14 +148,14 @@ class OpenAIComputerTool(RFBTool):
             if button_raw == "wheel":
                 button = "middle"
             elif isinstance(button_raw, str):
-                button = button_raw  # type: ignore[assignment]
+                button = button_raw
             else:
                 button = "left"
             hold = _hold_keys(args.get("keys"))
             await self.click(
                 args.get("x"),
                 args.get("y"),
-                button=button,  # type: ignore[arg-type]
+                button=button,
                 hold_keys=hold,
             )
 

{hud-0.6.13.dev1 → hud-0.6.13.dev2}/hud/agents/openai/tools/tests/test_computer.py

@@ -2,12 +2,12 @@
 
 No live VNC: a recording subclass captures the primitive calls.
 """
-# pyright: reportPrivateUsage=false, reportIncompatibleMethodOverride=false
 
 from __future__ import annotations
 
 from types import SimpleNamespace
-from typing import Any
+from typing import TYPE_CHECKING, Any
+from unittest.mock import AsyncMock, patch
 
 from hud.agents.openai.tools.computer import (
     OpenAIComputerTool,
@@ -16,6 +16,9 @@ from hud.agents.openai.tools.computer import (
 )
 from hud.agents.tools.base import result_text, tool_ok
 
+if TYPE_CHECKING:
+    from collections.abc import Iterable
+
 
 class RecordingOpenAI(OpenAIComputerTool):
     client: Any
@@ -28,7 +31,21 @@ class RecordingOpenAI(OpenAIComputerTool):
         self.calls.append(("screenshot",))
         return tool_ok("shot")
 
-    async def click(self, x: Any, y: Any, **kw: Any) -> None:
+    async def click(
+        self,
+        x: int | None = None,
+        y: int | None = None,
+        *,
+        button: Any = "left",
+        hold_keys: Iterable[str] | None = None,
+        count: int = 1,
+        interval_ms: int = 0,
+    ) -> None:
+        kw = {"button": button, "hold_keys": hold_keys}
+        if count != 1:
+            kw["count"] = count
+        if interval_ms:
+            kw["interval_ms"] = interval_ms
         self.calls.append(("click", x, y, kw))
 
     async def move(self, x: Any, y: Any) -> None:
@@ -40,15 +57,21 @@ class RecordingOpenAI(OpenAIComputerTool):
     async def press_keys(self, keys: Any, **kw: Any) -> None:
         self.calls.append(("keys", tuple(keys)))
 
-    async def scroll(self, x: Any, y: Any, **kw: Any) -> None:
+    async def scroll(
+        self,
+        x: int | None = None,
+        y: int | None = None,
+        *,
+        scroll_x: int = 0,
+        scroll_y: int = 0,
+        hold_keys: Iterable[str] | None = None,
+    ) -> None:
+        kw = {"scroll_x": scroll_x, "scroll_y": scroll_y, "hold_keys": hold_keys}
         self.calls.append(("scroll", x, y, kw))
 
     async def drag(self, path: Any, **kw: Any) -> None:
         self.calls.append(("drag", tuple(path)))
 
-    async def wait(self, ms: Any) -> None:
-        self.calls.append(("wait", ms))
-
 
 def test_key_mapping() -> None:
     assert _map_key("ctrl") == "Control_L"
@@ -79,9 +102,10 @@ async def test_type_and_keypress() -> None:
 async def test_drag_and_wait() -> None:
     tool = RecordingOpenAI()
     await tool.execute({"type": "drag", "path": [{"x": 0, "y": 0}, {"x": 5, "y": 5}]})
-    await tool.execute({"type": "wait", "ms": 500})
+    with patch("hud.agents.tools.rfb.asyncio.sleep", new_callable=AsyncMock) as sleep:
+        await tool.execute({"type": "wait", "ms": 500})
     assert ("drag", ((0, 0), (5, 5))) in tool.calls
-    assert ("wait", 500) in tool.calls
+    sleep.assert_awaited_once_with(0.5)
 
 
 async def test_response_action_returns_text() -> None: