meshagent-computers 0.45.4__tar.gz → 0.45.6__tar.gz

{meshagent_computers-0.45.4 → meshagent_computers-0.45.6}/CHANGELOG.md

@@ -1,3 +1,12 @@
+## [0.45.6]
+- Added strict dataset prompt rendering with escaped-brace support and simple field placeholders, replacing generic `str.format` expansion.
+- Tightened OpenAI adapter handling so code-interpreter results must be structured objects with required string fields, and invalid payloads now error out earlier.
+- Aligned computer/browser tooling with Python behavior for Browserbase setup, Docker geometry handling, and optional rule initialization.
+- Synchronized Python package dependencies and release metadata across the API, agents, CLI, OpenAI, tools, computers, codex, and related companion packages.
+
+## [0.45.5]
+- Shell command analysis now handles mixed absolute and dynamic write targets more safely, keeping generated file previews and path grouping accurate.
+
 ## [0.45.4]
 - Stability
 

{meshagent_computers-0.45.4/meshagent_computers.egg-info → meshagent_computers-0.45.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshagent-computers
-Version: 0.45.4
+Version: 0.45.6
 Summary: Computer Building Blocks for Meshagent
 License-Expression: Apache-2.0
 Project-URL: Documentation, https://docs.meshagent.com
@@ -12,9 +12,9 @@ License-File: LICENSE
 Requires-Dist: pytest~=8.4
 Requires-Dist: pytest-asyncio~=0.26
 Requires-Dist: openai~=2.25.0
-Requires-Dist: meshagent-api==0.45.4
-Requires-Dist: meshagent-agents==0.45.4
-Requires-Dist: meshagent-tools==0.45.4
+Requires-Dist: meshagent-api==0.45.6
+Requires-Dist: meshagent-agents==0.45.6
+Requires-Dist: meshagent-tools==0.45.6
 Requires-Dist: playwright~=1.58.0
 Requires-Dist: stagehand~=3.6.0
 Requires-Dist: browserbase~=1.2

{meshagent_computers-0.45.4 → meshagent_computers-0.45.6}/meshagent/computers/agent.py

@@ -45,7 +45,7 @@ class ComputerTool(OpenAIResponsesTool):
         computer: Computer,
         title="computer_call",
         description="handle computer tool calls",
-        rules=[],
+        rules: Optional[list[str]] = None,
         render_screen: Optional[Callable[[bytes], Awaitable[None] | None]] = None,
         toolkit: "ComputerToolkit",
     ):
@@ -54,7 +54,7 @@ class ComputerTool(OpenAIResponsesTool):
             # TODO: give a correct schema
             title=title,
             description=description,
-            rules=rules,
+            rules=[] if rules is None else rules,
         )
         self.operator = operator
         self.computer = computer

{meshagent_computers-0.45.4 → meshagent_computers-0.45.6}/meshagent/computers/agent_test.py

@@ -7,7 +7,7 @@ from meshagent.computers import agent as agent_module
 from meshagent.computers import base_playwright as base_playwright_module
 from meshagent.computers.agent import ComputerToolkit
 from meshagent.computers.base_playwright import BasePlaywrightComputer
-from meshagent.computers.computer import ComputerContext
+from meshagent.computers.computer import Computer, ComputerContext
 from meshagent.tools import ToolContext
 
 
@@ -43,6 +43,20 @@ class _FakeRoom:
         self.local_participant = _FakeParticipant(name=name)
 
 
+class _FakeStorage:
+    def __init__(self) -> None:
+        self.uploads: list[dict[str, Any]] = []
+
+    async def upload(self, **kwargs: Any) -> None:
+        self.uploads.append(kwargs)
+
+
+class _FakeRoomWithStorage(_FakeRoom):
+    def __init__(self, name: str):
+        super().__init__(name=name)
+        self.storage = _FakeStorage()
+
+
 class _FakeOperator:
     def __init__(self):
         self.calls: list[dict[str, Any]] = []
@@ -67,6 +81,204 @@ def test_computer_toolkit_has_no_default_render_screen():
     assert toolkit.render_screen is None
 
 
+def test_computer_tool_does_not_share_default_rules_list():
+    first = ComputerToolkit(
+        computer=_FakeComputer(),
+        operator=_FakeOperator(),
+        room=_FakeRoom(name="agent"),
+    )
+    second = ComputerToolkit(
+        computer=_FakeComputer(),
+        operator=_FakeOperator(),
+        room=_FakeRoom(name="agent"),
+    )
+    first_tool = next(tool for tool in first.tools if tool.name == "computer_call")
+    second_tool = next(tool for tool in second.tools if tool.name == "computer_call")
+
+    first_tool.rules.append("first only")
+
+    assert first_tool.rules == ["first only"]
+    assert second_tool.rules == []
+
+
+def test_computer_tool_preserves_explicit_rules_list_reference():
+    rules: list[str] = []
+    toolkit = ComputerToolkit(
+        computer=_FakeComputer(),
+        operator=_FakeOperator(),
+        room=_FakeRoom(name="agent"),
+    )
+    tool = type(next(tool for tool in toolkit.tools if tool.name == "computer_call"))(
+        computer=_FakeComputer(),
+        operator=_FakeOperator(),
+        toolkit=toolkit,
+        rules=rules,
+    )
+
+    rules.append("later")
+
+    assert tool.rules is rules
+    assert tool.rules == ["later"]
+
+
+def test_computer_context_emit_invokes_event_handler_like_python():
+    events: list[dict[str, Any]] = []
+    room = _FakeRoom(name="agent")
+    context = ComputerContext(
+        room=room,
+        caller=room.local_participant,
+        event_handler=events.append,
+    )
+
+    event = {"type": "custom", "nested": {"value": 1}}
+    context.emit(event)
+    ComputerContext(room=room, caller=room.local_participant).emit({"ignored": True})
+
+    assert events == [event]
+
+
+def test_computer_context_startup_events_match_python_dedupe_and_details():
+    events: list[dict[str, Any]] = []
+    room = _FakeRoom(name="agent")
+
+    def make_startup_event(state: str, details: tuple[str, ...]) -> dict[str, Any]:
+        return {"type": "startup", "state": state, "details": list(details)}
+
+    context = ComputerContext(
+        room=room,
+        caller=room.local_participant,
+        event_handler=events.append,
+        startup_event_factory=make_startup_event,
+    )
+
+    assert context.room is room
+    assert context.caller is room.local_participant
+    assert context.on_behalf_of is None
+    assert context.last_startup_state is None
+    assert context.last_startup_details == ()
+
+    context.emit_startup(state="queued", details=[" one ", "", 7, "two"])  # type: ignore[list-item]
+    context.emit_startup(state="queued", details=("one", "two"))
+    context.emit_startup(state="in_progress")
+
+    assert events == [
+        {"type": "startup", "state": "queued", "details": ["one", "two"]},
+        {"type": "startup", "state": "in_progress", "details": []},
+    ]
+    assert context.last_startup_state == "in_progress"
+    assert context.last_startup_details == ()
+
+    no_factory = ComputerContext(room=room, caller=room.local_participant)
+    no_factory.emit_startup(state="completed", details=["ignored"])
+    assert no_factory.last_startup_state is None
+    assert no_factory.last_startup_details == ()
+
+
+@pytest.mark.asyncio
+async def test_computer_protocol_default_context_manager_returns_self() -> None:
+    class _DefaultContextManagerComputer(Computer):
+        environment = "browser"
+        dimensions = (1, 1)
+
+    computer = _DefaultContextManagerComputer()
+
+    assert await computer.__aenter__(object()) is computer  # type: ignore[arg-type]
+    assert (
+        await computer.__aexit__(Exception, Exception("boom"), object())  # type: ignore[arg-type]
+        is computer
+    )
+
+
+def test_base_playwright_constructor_helpers_match_python_branches(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    assert base_playwright_module._parse_dimensions("") is None  # noqa: SLF001
+    assert base_playwright_module._parse_dimensions(" 1440x900 ") == (  # noqa: SLF001
+        1440,
+        900,
+    )
+    assert base_playwright_module._parse_dimensions("1440X900") == (  # noqa: SLF001
+        1440,
+        900,
+    )
+    assert base_playwright_module._parse_dimensions("1600, 900") == (  # noqa: SLF001
+        1600,
+        900,
+    )
+    assert base_playwright_module._parse_dimensions("1600:900") is None  # noqa: SLF001
+    assert base_playwright_module._parse_dimensions("1x2x3") is None  # noqa: SLF001
+    assert base_playwright_module._parse_dimensions("1,2,3") is None  # noqa: SLF001
+    assert base_playwright_module._parse_dimensions("wide x 900") is None  # noqa: SLF001
+
+    monkeypatch.delenv("MESHAGENT_PLAYWRIGHT_DIMENSIONS", raising=False)
+    assert base_playwright_module._resolve_playwright_dimensions() == (  # noqa: SLF001
+        1440,
+        900,
+    )
+    monkeypatch.setenv("MESHAGENT_PLAYWRIGHT_DIMENSIONS", "1600x900")
+    assert base_playwright_module._resolve_playwright_dimensions() == (  # noqa: SLF001
+        1600,
+        900,
+    )
+    monkeypatch.setenv("MESHAGENT_PLAYWRIGHT_DIMENSIONS", "1200x800")
+    assert base_playwright_module._resolve_playwright_dimensions() == (  # noqa: SLF001
+        1440,
+        900,
+    )
+
+    default_computer = BasePlaywrightComputer(starting_url=" ")
+    assert default_computer.dimensions == (1440, 900)
+    assert default_computer.starting_url == "https://google.com"
+    custom_computer = BasePlaywrightComputer(
+        dimensions=(1600, 900),
+        starting_url="  https://example.test  ",
+    )
+    assert custom_computer.dimensions == (1600, 900)
+    assert custom_computer.starting_url == "  https://example.test  "
+    with pytest.raises(
+        ValueError,
+        match=r"playwright dimensions must be one of: \(1440, 900\), \(1600, 900\)",
+    ):
+        BasePlaywrightComputer(dimensions=(1200, 800))
+
+    for input_key, expected in [
+        ("/", "Divide"),
+        ("\\", "Backslash"),
+        ("alt", "Alt"),
+        ("arrowdown", "ArrowDown"),
+        ("arrowleft", "ArrowLeft"),
+        ("arrowright", "ArrowRight"),
+        ("arrowup", "ArrowUp"),
+        ("backspace", "Backspace"),
+        ("capslock", "CapsLock"),
+        ("cmd", "Meta"),
+        ("ctrl", "Control"),
+        ("delete", "Delete"),
+        ("end", "End"),
+        ("enter", "Enter"),
+        ("esc", "Escape"),
+        ("home", "Home"),
+        ("insert", "Insert"),
+        ("option", "Alt"),
+        ("pagedown", "PageDown"),
+        ("pageup", "PageUp"),
+        ("shift", "Shift"),
+        ("space", " "),
+        ("super", "Meta"),
+        ("tab", "Tab"),
+        ("win", "Meta"),
+        ("CTRL", "Control"),
+        ("A", "A"),
+    ]:
+        assert (
+            base_playwright_module.CUA_KEY_TO_PLAYWRIGHT_KEY.get(
+                input_key.lower(),
+                input_key,
+            )
+            == expected
+        )
+
+
 @pytest.mark.asyncio
 async def test_computer_tool_emits_startup_progress_events():
     computer = _FakeComputer()
@@ -148,6 +360,172 @@ async def test_computer_tool_propagates_computer_startup_events_via_tool_context
     assert events[2]["state"] == "completed"
 
 
+@pytest.mark.asyncio
+async def test_computer_tool_startup_failure_event_matches_python_suppression():
+    class _FailingComputer(_FakeComputer):
+        def __init__(self, emitted_state: str | None) -> None:
+            super().__init__()
+            self.emitted_state = emitted_state
+
+        async def __aenter__(
+            self,
+            context: ComputerContext,
+        ):
+            self.enter_contexts.append(context)
+            if self.emitted_state is not None:
+                context.emit_startup(state=self.emitted_state)
+            raise RuntimeError("boom")
+
+    for emitted_state, expected_states in (
+        (None, ["in_progress", "failed"]),
+        ("failed", ["in_progress", "failed"]),
+        ("cancelled", ["in_progress", "cancelled"]),
+    ):
+        computer = _FailingComputer(emitted_state=emitted_state)
+        room = _FakeRoom(name="agent")
+        toolkit = ComputerToolkit(
+            computer=computer,
+            operator=_FakeOperator(),
+            room=room,
+            render_screen=None,
+        )
+        events: list[dict[str, Any]] = []
+        context = ToolContext(
+            caller=room.local_participant,
+            event_handler=events.append,
+        )
+
+        computer_tool = next(
+            tool for tool in toolkit.tools if tool.name == "computer_call"
+        )
+        with pytest.raises(RuntimeError, match="boom"):
+            await computer_tool.handle_computer_call(
+                context=context,
+                type="computer_call",
+                action={"type": "wait"},
+            )
+
+        assert [event["state"] for event in events] == expected_states
+
+
+@pytest.mark.asyncio
+async def test_screenshot_tool_execute_matches_python_side_effects():
+    class _ScreenshotComputer(_FakeComputer):
+        def __init__(self) -> None:
+            super().__init__()
+            self.screenshot_calls: list[dict[str, Any]] = []
+
+        async def screenshot_bytes(
+            self,
+            context: ComputerContext,
+            *,
+            full_page: bool,
+        ) -> bytes:
+            self.screenshot_calls.append(
+                {"context": context, "full_page": full_page},
+            )
+            return b"png-bytes"
+
+    computer = _ScreenshotComputer()
+    room = _FakeRoomWithStorage(name="agent")
+    toolkit = ComputerToolkit(
+        computer=computer,
+        operator=_FakeOperator(),
+        room=room,
+        render_screen=None,
+    )
+    events: list[dict[str, Any]] = []
+    context = ToolContext(caller=room.local_participant, event_handler=events.append)
+    tool = agent_module.ScreenshotTool(
+        room=room,
+        computer=computer,
+        toolkit=toolkit,
+    )
+
+    result = await tool.execute(context=context, save_path="screen.png", full_page=True)
+
+    assert result == "saved screenshot to screen.png"
+    assert len(computer.enter_contexts) == 1
+    assert computer.screenshot_calls == [
+        {"context": computer.enter_contexts[0], "full_page": True},
+    ]
+    assert room.storage.uploads == [
+        {"path": "screen.png", "data": b"png-bytes", "overwrite": True},
+    ]
+    assert [event["state"] for event in events] == ["in_progress", "completed"]
+
+
+@pytest.mark.asyncio
+async def test_goto_tool_execute_matches_python_navigation_and_rendering():
+    class _GotoComputer(_FakeComputer):
+        def __init__(self) -> None:
+            super().__init__()
+            self.goto_calls: list[dict[str, Any]] = []
+            self.screenshot_calls: list[dict[str, Any]] = []
+
+        async def goto(
+            self,
+            context: ComputerContext,
+            *,
+            url: str,
+        ) -> None:
+            self.goto_calls.append({"context": context, "url": url})
+
+        async def screenshot_bytes(
+            self,
+            context: ComputerContext,
+            *,
+            full_page: bool,
+        ) -> bytes:
+            self.screenshot_calls.append(
+                {"context": context, "full_page": full_page},
+            )
+            return b"rendered-png"
+
+    computer = _GotoComputer()
+    room = _FakeRoom(name="agent")
+    rendered: list[bytes] = []
+    render_called = asyncio.Event()
+
+    async def render_screen(data: bytes) -> None:
+        rendered.append(data)
+        render_called.set()
+
+    toolkit = ComputerToolkit(
+        computer=computer,
+        operator=_FakeOperator(),
+        room=room,
+        render_screen=render_screen,
+    )
+    events: list[dict[str, Any]] = []
+    context = ToolContext(caller=room.local_participant, event_handler=events.append)
+    tool = agent_module.GotoURL(
+        computer=computer,
+        toolkit=toolkit,
+        render_screen=render_screen,
+    )
+
+    result = await tool.execute(context=context, url="example.test/path")
+
+    assert result is None
+    assert render_called.is_set()
+    assert rendered == [b"rendered-png"]
+    assert len(computer.enter_contexts) == 1
+    assert computer.goto_calls == [
+        {
+            "context": computer.enter_contexts[0],
+            "url": "https://example.test/path",
+        },
+    ]
+    assert computer.screenshot_calls == [
+        {"context": computer.enter_contexts[0], "full_page": False},
+    ]
+    assert [event["state"] for event in events] == ["in_progress", "completed"]
+
+    await tool.execute(context=context, url="http://example.test/next")
+    assert computer.goto_calls[-1]["url"] == "http://example.test/next"
+
+
 @pytest.mark.asyncio
 async def test_computer_tool_render_screen_uses_python_lenient_base64_decode():
     class _OutputOperator:

meshagent_computers-0.45.6/meshagent/computers/browserbase_test.py

@@ -0,0 +1,133 @@
+from types import SimpleNamespace
+
+import pytest
+
+from meshagent.computers import browserbase as browserbase_module
+from meshagent.computers.browserbase import BrowserbaseBrowser
+from meshagent.computers.computer import ComputerContext
+
+
+class _FakeParticipant:
+    def get_attribute(self, key: str):
+        del key
+        return None
+
+
+class _FakeRoom:
+    local_participant = _FakeParticipant()
+
+
+class _FakeBrowserbaseSessions:
+    def __init__(self) -> None:
+        self.create_calls: list[dict[str, object]] = []
+
+    async def create(self, **kwargs):
+        self.create_calls.append(kwargs)
+        return SimpleNamespace(id="session-1", connect_url="wss://connect.test")
+
+
+class _FakeBrowserbase:
+    instances: list["_FakeBrowserbase"] = []
+
+    def __init__(self, *, api_key: str | None = None):
+        self.api_key = api_key
+        self.sessions = _FakeBrowserbaseSessions()
+        self.instances.append(self)
+
+
+class _FakePage:
+    def __init__(self) -> None:
+        self.goto_calls: list[str] = []
+        self.handlers: list[tuple[str, object]] = []
+
+    def on(self, event: str, handler) -> None:
+        self.handlers.append((event, handler))
+
+    async def goto(self, url: str) -> None:
+        self.goto_calls.append(url)
+
+
+class _FakeBrowserContext:
+    def __init__(self, page: _FakePage) -> None:
+        self.pages = [page]
+        self.handlers: list[tuple[str, object]] = []
+        self.init_scripts: list[str] = []
+
+    def on(self, event: str, handler) -> None:
+        self.handlers.append((event, handler))
+
+    async def add_init_script(self, script: str) -> None:
+        self.init_scripts.append(script)
+
+
+class _FakeBrowser:
+    def __init__(self, context: _FakeBrowserContext) -> None:
+        self.contexts = [context]
+
+
+class _FakeChromium:
+    def __init__(self, browser: _FakeBrowser) -> None:
+        self.browser = browser
+        self.connect_calls: list[dict[str, object]] = []
+
+    async def connect_over_cdp(self, connect_url: str, *, timeout: int):
+        self.connect_calls.append({"connect_url": connect_url, "timeout": timeout})
+        return self.browser
+
+
+def _make_context() -> ComputerContext:
+    room = _FakeRoom()
+    return ComputerContext(room=room, caller=room.local_participant)
+
+
+@pytest.mark.asyncio
+async def test_browserbase_get_browser_and_page_matches_python_session_shape(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    _FakeBrowserbase.instances.clear()
+    monkeypatch.setenv("BROWSERBASE_API_KEY", "api-key")
+    monkeypatch.setenv("BROWSERBASE_PROJECT_ID", "project-id")
+    monkeypatch.setattr(browserbase_module, "AsyncBrowserbase", _FakeBrowserbase)
+
+    page = _FakePage()
+    browser_context = _FakeBrowserContext(page)
+    browser = _FakeBrowser(browser_context)
+    chromium = _FakeChromium(browser)
+
+    computer = BrowserbaseBrowser(
+        width=1200,
+        height=700,
+        region="eu-central-1",
+        proxy=True,
+        virtual_mouse=True,
+        ad_blocker=True,
+        starting_url="  https://browserbase.test  ",
+    )
+    computer._playwright = SimpleNamespace(chromium=chromium)
+
+    returned_browser, returned_page = await computer._get_browser_and_page(
+        _make_context()
+    )
+
+    assert returned_browser is browser
+    assert returned_page is page
+    assert computer.session.id == "session-1"
+    assert _FakeBrowserbase.instances[0].api_key == "api-key"
+    assert _FakeBrowserbase.instances[0].sessions.create_calls == [
+        {
+            "project_id": "project-id",
+            "browser_settings": {
+                "viewport": {"width": 1200, "height": 700},
+                "blockAds": True,
+            },
+            "region": "eu-central-1",
+            "proxies": True,
+        }
+    ]
+    assert chromium.connect_calls == [
+        {"connect_url": "wss://connect.test", "timeout": 60000}
+    ]
+    assert browser_context.handlers == [("page", computer._handle_new_page)]
+    assert len(browser_context.init_scripts) == 1
+    assert page.handlers == [("close", computer._handle_page_close)]
+    assert page.goto_calls == ["  https://browserbase.test  "]

{meshagent_computers-0.45.4 → meshagent_computers-0.45.6}/meshagent/computers/container_playwright_test.py

@@ -350,7 +350,7 @@ async def test_container_playwright_uses_custom_starting_url() -> None:
     computer = ContainerPlaywrightComputer(
         room=room,
         headless=True,
-        starting_url="https://example.com",
+        starting_url="  https://example.com  ",
     )
 
     async def _ensure_container(context: ComputerContext) -> str:
@@ -378,7 +378,7 @@ async def test_container_playwright_uses_custom_starting_url() -> None:
     assert connected_browser is browser
     assert connected_page is page
     assert page.viewport_calls == [{"width": 1440, "height": 900}]
-    assert page.goto_calls == ["https://example.com"]
+    assert page.goto_calls == ["  https://example.com  "]
 
 
 @pytest.mark.asyncio

{meshagent_computers-0.45.4 → meshagent_computers-0.45.6}/meshagent/computers/docker.py

@@ -63,8 +63,8 @@ class DockerComputer:
             )
 
         # Fetch display geometry
-        geometry = await self._exec(
-            f"DISPLAY={self.display} xdotool getdisplaygeometry"
+        geometry = (
+            await self._exec(f"DISPLAY={self.display} xdotool getdisplaygeometry")
         ).strip()
         if geometry:
             w, h = geometry.split()

meshagent_computers-0.45.6/meshagent/computers/docker_test.py

@@ -0,0 +1,167 @@
+import subprocess
+
+import pytest
+
+from meshagent.computers import docker as docker_module
+from meshagent.computers.docker import DockerComputer, _async_check_output
+
+
+@pytest.mark.asyncio
+async def test_async_check_output_shell_executes_and_preserves_failure_fields():
+    assert await _async_check_output("printf stdout", shell=True) == b"stdout"
+
+    with pytest.raises(subprocess.CalledProcessError) as exc_info:
+        await _async_check_output(
+            "printf stdout; printf stderr >&2; exit 7",
+            shell=True,
+        )
+
+    exc = exc_info.value
+    assert exc.returncode == 7
+    assert exc.cmd == ("printf stdout; printf stderr >&2; exit 7",)
+    assert exc.output == b"stdout"
+    assert exc.stderr == b"stderr"
+
+
+@pytest.mark.asyncio
+async def test_docker_computer_aenter_awaits_exec_before_stripping_geometry(
+    monkeypatch,
+):
+    class Result:
+        stdout = "container-id\n"
+
+    run_calls = []
+
+    def fake_run(*args, **kwargs):
+        run_calls.append((args, kwargs))
+        return Result()
+
+    async def fake_exec(self, cmd):
+        exec_calls.append(cmd)
+        return "1600 900\n"
+
+    exec_calls = []
+    monkeypatch.setattr(docker_module.subprocess, "run", fake_run)
+    monkeypatch.setattr(DockerComputer, "_exec", fake_exec)
+
+    computer = DockerComputer()
+    result = await computer.__aenter__(context=object())
+
+    assert result is computer
+    assert computer.dimensions == (1600, 900)
+    assert run_calls == [
+        (
+            (
+                [
+                    "docker",
+                    "ps",
+                    "-q",
+                    "-f",
+                    "name=cua-sample-app",
+                ],
+            ),
+            {"capture_output": True, "text": True},
+        )
+    ]
+    assert exec_calls == ["DISPLAY=:99 xdotool getdisplaygeometry"]
+
+
+@pytest.mark.asyncio
+async def test_docker_computer_commands_match_python_source(monkeypatch) -> None:
+    calls: list[tuple[tuple, dict]] = []
+
+    async def fake_check_output(*args, **kwargs):
+        calls.append((args, kwargs))
+        return b"ok"
+
+    monkeypatch.setattr(docker_module, "_async_check_output", fake_check_output)
+    computer = DockerComputer()
+
+    assert await computer._exec('echo "hi"') == "ok"
+    assert calls.pop(0) == (
+        ('docker exec cua-sample-app sh -c "echo \\"hi\\""',),
+        {"shell": True},
+    )
+
+    assert await computer.screenshot(context=object()) == "ok"
+    assert calls.pop(0) == (
+        (
+            'docker exec cua-sample-app sh -c "export DISPLAY=:99 && import -window root png:- | base64 -w 0"',
+        ),
+        {"shell": True},
+    )
+
+    await computer.click(context=object(), x=10, y=20, button="middle")
+    await computer.click(context=object(), x=10, y=20, button="unknown")
+    await computer.double_click(context=object(), x=3, y=4)
+    await computer.scroll(context=object(), x=1, y=2, scroll_x=99, scroll_y=-2)
+    await computer.type(context=object(), text="don't")
+    await computer.move(context=object(), x=5, y=6)
+    await computer.keypress(context=object(), keys=["ENTER", "SPACE", "x"])
+
+    assert calls == [
+        (
+            (
+                'docker exec cua-sample-app sh -c "DISPLAY=:99 xdotool mousemove 10 20 click 2"',
+            ),
+            {"shell": True},
+        ),
+        (
+            (
+                'docker exec cua-sample-app sh -c "DISPLAY=:99 xdotool mousemove 10 20 click 1"',
+            ),
+            {"shell": True},
+        ),
+        (
+            (
+                'docker exec cua-sample-app sh -c "DISPLAY=:99 xdotool mousemove 3 4 click --repeat 2 1"',
+            ),
+            {"shell": True},
+        ),
+        (
+            ('docker exec cua-sample-app sh -c "DISPLAY=:99 xdotool mousemove 1 2"',),
+            {"shell": True},
+        ),
+        (
+            ('docker exec cua-sample-app sh -c "DISPLAY=:99 xdotool click 4"',),
+            {"shell": True},
+        ),
+        (
+            ('docker exec cua-sample-app sh -c "DISPLAY=:99 xdotool click 4"',),
+            {"shell": True},
+        ),
+        (
+            (
+                "docker exec cua-sample-app sh -c \"DISPLAY=:99 xdotool type -- 'don'\\''t'\"",
+            ),
+            {"shell": True},
+        ),
+        (
+            ('docker exec cua-sample-app sh -c "DISPLAY=:99 xdotool mousemove 5 6"',),
+            {"shell": True},
+        ),
+        (
+            (
+                'docker exec cua-sample-app sh -c "DISPLAY=:99 xdotool key Return+space+x"',
+            ),
+            {"shell": True},
+        ),
+    ]
+
+
+@pytest.mark.asyncio
+async def test_docker_computer_unsupported_url_methods_raise_runtime_error() -> None:
+    computer = DockerComputer()
+
+    with pytest.raises(
+        RuntimeError, match="get_current_url is not supported by DockerComputer"
+    ):
+        await computer.get_current_url(context=object())
+    with pytest.raises(RuntimeError, match="goto is not supported by DockerComputer"):
+        await computer.goto(context=object(), url="https://example.test")
+    with pytest.raises(RuntimeError, match="back is not supported by DockerComputer"):
+        await computer.back(context=object())
+    with pytest.raises(
+        RuntimeError, match="forward is not supported by DockerComputer"
+    ):
+        await computer.forward(context=object())

{meshagent_computers-0.45.4 → meshagent_computers-0.45.6}/meshagent/computers/stagehand_test.py

@@ -61,6 +61,41 @@ class _FakeChromium:
         return self.browser
 
 
+class _FakeRemoteBrowserContext:
+    def __init__(self, page: _FakePage | None = None) -> None:
+        self.pages = [] if page is None else [page]
+        self.new_context_calls: list[dict[str, object]] = []
+        self.new_page_calls = 0
+        self.page = page or _FakePage()
+
+    async def new_page(self) -> _FakePage:
+        self.new_page_calls += 1
+        self.pages.append(self.page)
+        return self.page
+
+
+class _FakeRemoteBrowser:
+    def __init__(self, context: _FakeRemoteBrowserContext | None = None) -> None:
+        self.contexts = [] if context is None else [context]
+        self.context = context or _FakeRemoteBrowserContext()
+        self.new_context_calls: list[dict[str, object]] = []
+
+    async def new_context(self, **kwargs) -> _FakeRemoteBrowserContext:
+        self.new_context_calls.append(kwargs)
+        self.contexts.append(self.context)
+        return self.context
+
+
+class _FakeRemoteChromium:
+    def __init__(self, browser: _FakeRemoteBrowser) -> None:
+        self.browser = browser
+        self.connect_calls: list[dict[str, object]] = []
+
+    async def connect_over_cdp(self, cdp_url: str, **kwargs):
+        self.connect_calls.append({"cdp_url": cdp_url, **kwargs})
+        return self.browser
+
+
 class _FakeStagehandSessions:
     def __init__(self) -> None:
         self.start_calls: list[dict[str, object]] = []
@@ -126,7 +161,7 @@ async def test_stagehand_computer_uses_room_runtime_for_local_stagehand(
 
     computer = StagehandComputer(
         dimensions=(1600, 900),
-        starting_url="https://example.com",
+        starting_url="  https://example.com  ",
     )
     computer._playwright = SimpleNamespace(chromium=chromium)
 
@@ -151,7 +186,7 @@ async def test_stagehand_computer_uses_room_runtime_for_local_stagehand(
     assert page.viewport_calls == [{"width": 1600, "height": 900}]
     assert page.goto_calls == [
         ("about:blank", "domcontentloaded"),
-        ("https://example.com", None),
+        ("  https://example.com  ", None),
     ]
 
     assert len(_FakeStagehand.init_calls) == 1
@@ -188,6 +223,67 @@ async def test_stagehand_computer_uses_room_runtime_for_local_stagehand(
     assert stagehand.closed is True
 
 
+@pytest.mark.asyncio
+async def test_stagehand_computer_remote_session_plan_matches_python(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    _FakeStagehand.init_calls.clear()
+    remote_browser = _FakeRemoteBrowser()
+    chromium = _FakeRemoteChromium(browser=remote_browser)
+
+    monkeypatch.setattr(
+        stagehand_module, "_require_stagehand_class", lambda: _FakeStagehand
+    )
+    monkeypatch.setattr(
+        stagehand_module,
+        "stagehand_available",
+        lambda **_: True,
+    )
+
+    computer = StagehandComputer(
+        dimensions=(1600, 900),
+        starting_url="https://remote.example",
+        stagehand_config=StagehandComputerConfig(
+            server="remote",
+            browser={"type": "browserbase"},
+        ),
+    )
+    computer._playwright = SimpleNamespace(chromium=chromium)
+
+    browser, page = await computer._get_browser_and_page(_make_context())
+
+    assert browser is remote_browser
+    assert page is remote_browser.context.page
+    assert chromium.connect_calls == [
+        {
+            "cdp_url": "ws://127.0.0.1:9222/devtools/browser/example",
+            "timeout": 60_000,
+        }
+    ]
+    assert remote_browser.new_context_calls == [
+        {"viewport": {"width": 1600, "height": 900}}
+    ]
+    assert remote_browser.context.new_page_calls == 1
+    assert page.viewport_calls == [{"width": 1600, "height": 900}]
+    assert page.goto_calls == [("https://remote.example", None)]
+
+    assert len(_FakeStagehand.init_calls) == 1
+    init_call = _FakeStagehand.init_calls[0]
+    assert init_call["server"] == "remote"
+    assert init_call["model_api_key"] == "room_token"
+    assert init_call["local_openai_api_key"] == "room_token"
+
+    stagehand = computer._stagehand
+    assert isinstance(stagehand, _FakeStagehand)
+    assert stagehand.sessions.start_calls == [
+        {
+            "model_name": "openai/gpt-5.4",
+            "browser": {"type": "browserbase"},
+        }
+    ]
+    assert computer._stagehand_session_id == "stagehand_session_1"
+
+
 def test_stagehand_computer_can_update_config() -> None:
     computer = StagehandComputer()
 
@@ -202,6 +298,49 @@ def test_stagehand_computer_can_update_config() -> None:
     )
 
 
+def test_stagehand_start_kwargs_and_update_conflict_match_python() -> None:
+    computer = StagehandComputer(
+        stagehand_config=StagehandComputerConfig(
+            model_name="openai/custom",
+            browserbase_session_create_params={"keepAlive": True},
+            browserbase_session_id="session-1",
+            dom_settle_timeout_ms=1234.0,
+            experimental=True,
+            self_heal=False,
+            system_prompt="system",
+            verbose=2,
+        )
+    )
+
+    assert computer._runtime_stagehand_start_kwargs(browser={"type": "remote"}) == {
+        "model_name": "openai/custom",
+        "browser": {"type": "remote"},
+        "browserbase_session_create_params": {"keepAlive": True},
+        "browserbase_session_id": "session-1",
+        "dom_settle_timeout_ms": 1234.0,
+        "experimental": True,
+        "self_heal": False,
+        "system_prompt": "system",
+        "verbose": 2,
+    }
+    assert computer._runtime_stagehand_start_kwargs(browser=None) == {
+        "model_name": "openai/custom",
+        "browserbase_session_create_params": {"keepAlive": True},
+        "browserbase_session_id": "session-1",
+        "dom_settle_timeout_ms": 1234.0,
+        "experimental": True,
+        "self_heal": False,
+        "system_prompt": "system",
+        "verbose": 2,
+    }
+
+    with pytest.raises(ValueError, match="pass config or keyword changes, not both"):
+        computer.update_stagehand_config(
+            config=StagehandComputerConfig(),
+            model_name="openai/other",
+        )
+
+
 def test_stagehand_local_browser_config_uses_python_dict_coercion() -> None:
     computer = StagehandComputer(
         stagehand_config=StagehandComputerConfig(

meshagent_computers-0.45.6/meshagent/computers/utils_test.py

@@ -0,0 +1,102 @@
+import base64
+
+import pytest
+
+from meshagent.computers import utils as utils_module
+
+
+@pytest.mark.parametrize(
+    "url",
+    [
+        "https://maliciousbook.com",
+        "https://login.maliciousbook.com/path",
+        "https://evilvideos.com/watch?v=1",
+        "https://EVILVIDEOS.COM/watch?v=1",
+        "https://user:pass@evilvideos.com:443/path",
+        "https://user@sub.ilanbigio.com/path",
+        "https://evilvideos.com:bad/path",
+        "//evilvideos.com/path",
+    ],
+)
+def test_check_blocklisted_url_rejects_blocklisted_domains(url: str) -> None:
+    with pytest.raises(ValueError, match="Blocked URL"):
+        utils_module.check_blocklisted_url(url)
+
+
+def test_check_blocklisted_url_allows_other_domains() -> None:
+    utils_module.check_blocklisted_url("https://example.com/path")
+
+
+@pytest.mark.parametrize(
+    "url",
+    [
+        "EVILVIDEOS.COM/path",
+        "evilvideos.com/path",
+        "http://evilvideos.com\\@example.com/path",
+        "http://sub.ilanbigio.com.",
+        "http:// evilvideos.com /path",
+    ],
+)
+def test_check_blocklisted_url_preserves_urlparse_hostname_edges(url: str) -> None:
+    utils_module.check_blocklisted_url(url)
+
+
+def test_check_blocklisted_url_raises_urlparse_errors() -> None:
+    with pytest.raises(ValueError, match="Invalid IPv6 URL"):
+        utils_module.check_blocklisted_url("http://[::1")
+
+
+@pytest.mark.parametrize("value", [None, [], "x", 3])
+def test_sanitize_message_non_dict_inputs_raise_python_get_error(value) -> None:
+    with pytest.raises(AttributeError, match="object has no attribute 'get'"):
+        utils_module.sanitize_message(value)
+
+
+def test_calculate_image_dimensions_supports_xbm_like_pillow() -> None:
+    xbm = (
+        b"#define sample_width 17\n"
+        b"#define sample_height 9\n"
+        b"static unsigned char sample_bits[] = { 0x00 };\n"
+    )
+    assert utils_module.calculate_image_dimensions(base64.b64encode(xbm).decode()) == (
+        17,
+        9,
+    )
+
+
+def test_calculate_image_dimensions_supports_xpm_like_pillow() -> None:
+    xpm = (
+        b"/* XPM */\n"
+        b"static char * sample[] = {\n"
+        b'"13 7 1 1",\n'
+        b'"a c #000000",\n'
+        b'"aaaaaaaaaaaaa",\n'
+        b'"aaaaaaaaaaaaa",\n'
+        b'"aaaaaaaaaaaaa",\n'
+        b'"aaaaaaaaaaaaa",\n'
+        b'"aaaaaaaaaaaaa",\n'
+        b'"aaaaaaaaaaaaa",\n'
+        b'"aaaaaaaaaaaaa"};\n'
+    )
+    assert utils_module.calculate_image_dimensions(base64.b64encode(xpm).decode()) == (
+        13,
+        7,
+    )
+
+
+@pytest.mark.parametrize(
+    "payload",
+    [
+        bytes([0, 0, 1, 0, 1, 0, 16, 10, 0, 0, 1, 0, 32, 0, 4, 0, 0, 0, 22, 0, 0, 0])
+        + b"abcd",
+        bytes([0, 0, 2, 0, 1, 0, 16, 10, 0, 0, 1, 0, 32, 0, 4, 0, 0, 0, 22, 0, 0, 0])
+        + b"abcd",
+        bytes([0, 0, 1, 0, 1, 0, 16, 10, 0, 0, 1, 0, 32, 0, 4, 0, 0, 0, 100, 0, 0, 0])
+        + b"abcd",
+    ],
+)
+def test_calculate_image_dimensions_rejects_invalid_ico_payloads_like_pillow(
+    payload: bytes,
+) -> None:
+    with pytest.raises(Exception):
+        utils_module.calculate_image_dimensions(base64.b64encode(payload).decode())

meshagent_computers-0.45.6/meshagent/computers/version.py

@@ -0,0 +1 @@
+__version__ = "0.45.6"

{meshagent_computers-0.45.4 → meshagent_computers-0.45.6/meshagent_computers.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshagent-computers
-Version: 0.45.4
+Version: 0.45.6
 Summary: Computer Building Blocks for Meshagent
 License-Expression: Apache-2.0
 Project-URL: Documentation, https://docs.meshagent.com
@@ -12,9 +12,9 @@ License-File: LICENSE
 Requires-Dist: pytest~=8.4
 Requires-Dist: pytest-asyncio~=0.26
 Requires-Dist: openai~=2.25.0
-Requires-Dist: meshagent-api==0.45.4
-Requires-Dist: meshagent-agents==0.45.4
-Requires-Dist: meshagent-tools==0.45.4
+Requires-Dist: meshagent-api==0.45.6
+Requires-Dist: meshagent-agents==0.45.6
+Requires-Dist: meshagent-tools==0.45.6
 Requires-Dist: playwright~=1.58.0
 Requires-Dist: stagehand~=3.6.0
 Requires-Dist: browserbase~=1.2

{meshagent_computers-0.45.4 → meshagent_computers-0.45.6}/meshagent_computers.egg-info/SOURCES.txt

@@ -8,6 +8,7 @@ meshagent/computers/agent.py
 meshagent/computers/agent_test.py
 meshagent/computers/base_playwright.py
 meshagent/computers/browserbase.py
+meshagent/computers/browserbase_test.py
 meshagent/computers/computer.py
 meshagent/computers/container_playwright.py
 meshagent/computers/container_playwright_test.py

{meshagent_computers-0.45.4 → meshagent_computers-0.45.6}/meshagent_computers.egg-info/requires.txt

@@ -1,9 +1,9 @@
 pytest~=8.4
 pytest-asyncio~=0.26
 openai~=2.25.0
-meshagent-api==0.45.4
-meshagent-agents==0.45.4
-meshagent-tools==0.45.4
+meshagent-api==0.45.6
+meshagent-agents==0.45.6
+meshagent-tools==0.45.6
 playwright~=1.58.0
 stagehand~=3.6.0
 browserbase~=1.2

{meshagent_computers-0.45.4 → meshagent_computers-0.45.6}/pyproject.toml

@@ -15,9 +15,9 @@ dependencies = [
   "pytest~=8.4",
   "pytest-asyncio~=0.26",
   "openai~=2.25.0",
-  "meshagent-api==0.45.4",
-  "meshagent-agents==0.45.4",
-  "meshagent-tools==0.45.4",
+  "meshagent-api==0.45.6",
+  "meshagent-agents==0.45.6",
+  "meshagent-tools==0.45.6",
   "playwright~=1.58.0",
   "stagehand~=3.6.0",
   "browserbase~=1.2",

meshagent_computers-0.45.4/meshagent/computers/docker_test.py

@@ -1,22 +0,0 @@
-import subprocess
-
-import pytest
-
-from meshagent.computers.docker import _async_check_output
-
-
-@pytest.mark.asyncio
-async def test_async_check_output_shell_executes_and_preserves_failure_fields():
-    assert await _async_check_output("printf stdout", shell=True) == b"stdout"
-
-    with pytest.raises(subprocess.CalledProcessError) as exc_info:
-        await _async_check_output(
-            "printf stdout; printf stderr >&2; exit 7",
-            shell=True,
-        )
-
-    exc = exc_info.value
-    assert exc.returncode == 7
-    assert exc.cmd == ("printf stdout; printf stderr >&2; exit 7",)
-    assert exc.output == b"stdout"
-    assert exc.stderr == b"stderr"

meshagent_computers-0.45.4/meshagent/computers/utils_test.py

@@ -1,47 +0,0 @@
-import pytest
-
-from meshagent.computers import utils as utils_module
-
-
-@pytest.mark.parametrize(
-    "url",
-    [
-        "https://maliciousbook.com",
-        "https://login.maliciousbook.com/path",
-        "https://evilvideos.com/watch?v=1",
-        "https://user:pass@evilvideos.com:443/path",
-        "//evilvideos.com/path",
-    ],
-)
-def test_check_blocklisted_url_rejects_blocklisted_domains(url: str) -> None:
-    with pytest.raises(ValueError, match="Blocked URL"):
-        utils_module.check_blocklisted_url(url)
-
-
-def test_check_blocklisted_url_allows_other_domains() -> None:
-    utils_module.check_blocklisted_url("https://example.com/path")
-
-
-@pytest.mark.parametrize(
-    "url",
-    [
-        "EVILVIDEOS.COM/path",
-        "evilvideos.com/path",
-        "http://evilvideos.com\\@example.com/path",
-        "http://sub.ilanbigio.com.",
-        "http:// evilvideos.com /path",
-    ],
-)
-def test_check_blocklisted_url_preserves_urlparse_hostname_edges(url: str) -> None:
-    utils_module.check_blocklisted_url(url)
-
-
-def test_check_blocklisted_url_raises_urlparse_errors() -> None:
-    with pytest.raises(ValueError, match="Invalid IPv6 URL"):
-        utils_module.check_blocklisted_url("http://[::1")
-
-
-@pytest.mark.parametrize("value", [None, [], "x", 3])
-def test_sanitize_message_non_dict_inputs_raise_python_get_error(value) -> None:
-    with pytest.raises(AttributeError, match="object has no attribute 'get'"):
-        utils_module.sanitize_message(value)

meshagent_computers-0.45.4/meshagent/computers/version.py

@@ -1 +0,0 @@
-__version__ = "0.45.4"