agentenv-framework-protocol 0.1.440__tar.gz → 0.1.442__tar.gz

{agentenv_framework_protocol-0.1.440 → agentenv_framework_protocol-0.1.442}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: agentenv-framework-protocol
-Version: 0.1.440
+Version: 0.1.442
 Summary: Open data-plane protocol and server SDK for agent environments.
 Project-URL: Homepage, https://www.agentenvframework.com
 Project-URL: Documentation, https://www.agentenvframework.com/docs

{agentenv_framework_protocol-0.1.440 → agentenv_framework_protocol-0.1.442}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "agentenv-framework-protocol"
-version = "0.1.440"
+version = "0.1.442"
 description = "Open data-plane protocol and server SDK for agent environments."
 readme = "README.md"
 license = "Apache-2.0"

{agentenv_framework_protocol-0.1.440 → agentenv_framework_protocol-0.1.442}/src/agentenv_protocol/computer/conformance/checks.py

@@ -13,6 +13,7 @@ import uuid
 from collections.abc import Awaitable, Callable
 from datetime import datetime
 from importlib import resources
+from typing import Any
 
 from mcp import ClientSession
 from mcp.types import CallToolResult
@@ -152,6 +153,10 @@ class Probe:
             raise AssertionError(f"computer_screenshot failed: {result.content[0].text}")
         return result, image(result)
 
+    async def pixel(self, x: int, y: int) -> tuple[int, int, int]:
+        """The pixel at frame pixel (x, y) of a new frame."""
+        return (await self.shot())[1].getpixel((x, y))
+
     async def act(self, name: str, args: dict) -> None:
         result = await self.tool(name, args)
         if result.isError:
@@ -161,13 +166,15 @@ class Probe:
         out = await self.driver.run("cat", f"{STAGE}/state/state.json")
         return json.loads(out["stdout"])
 
-    async def until(self, holds: Callable[[dict], bool]) -> tuple[bool, dict]:
-        """Whether the fixture's state comes to satisfy ``holds`` within SETTLE_S, and the state it last had."""
+    async def until(self, holds: Callable[[Any], bool],
+                    read: Callable[[], Awaitable[Any]] | None = None) -> tuple[bool, Any]:
+        """Whether what ``read`` gives, the fixture's state unless it's given, comes to satisfy ``holds`` within
+        SETTLE_S, and what it last gave."""
         deadline = time.monotonic() + SETTLE_S
         while True:
-            state = await self.state()
-            if holds(state) or time.monotonic() > deadline:
-                return holds(state), state
+            seen = await (read or self.state)()
+            if holds(seen) or time.monotonic() > deadline:
+                return holds(seen), seen
             await asyncio.sleep(POLL_S)
 
     async def settled(self, holds: Callable[[dict], bool], show: Callable[[dict], object]) -> str | None:
@@ -588,8 +595,8 @@ class Probe:
             problem = await self.settled(lambda s: s["cells"].get("2,3") == 1, lambda s: s["cells"])
             if problem:
                 return problem
-            _, img = await self.shot()
-            return None if img.getpixel((x, y)) == (255, 0, 0) else f"the next frame shows {img.getpixel((x, y))}"
+            shows, pixel = await self.until(lambda p: p == (255, 0, 0), lambda: self.pixel(x, y))
+            return None if shows else f"no frame within {SETTLE_S:g} s shows it: the last shows {pixel}"
 
         async def norm_space() -> str | None:
             x, y = cell(5, 5)
@@ -636,7 +643,7 @@ class Probe:
             return await self.settled(lambda s: s["saved_count"] == 1 and s["subscribed"],
                                       lambda s: (s["saved_count"], s["subscribed"]))
 
-        await self.check("P4", "a click in frame space hits its cell, and the next frame shows it", frame_space)
+        await self.check("P4", "a click in frame space hits its cell, and a frame shows it", frame_space)
         if self.driver.declares(COMPUTER_SPACES):
             await self.check("P4", "a click in norm space hits its cell", norm_space, COMPUTER_SPACES)
         if "right" in buttons:

{agentenv_framework_protocol-0.1.440 → agentenv_framework_protocol-0.1.442}/tests/test_computer_conformance.py

@@ -85,12 +85,43 @@ async def test_a_driver_given_a_control_token_passes_with_it_and_refuses_calls_w
     assert not unauthorized.passed and "401 unauthorized" in _failed(unauthorized)[0]
 
 
+class StaleFrame(FixtureDriver):
+    """Its first ``stale`` captures after a click are from before the click, as when an app records a click before it
+    repaints."""
+
+    def __init__(self, stale: int = 1, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self.stale, self.left, self.before_click = stale, 0, None
+
+    @click
+    async def click_at(self, x, y, button, count, modifiers):
+        self.before_click, self.left = self.screen.image.copy(), self.stale
+        return await super().click_at(x, y, button, count, modifiers)
+
+    @capture
+    async def grab(self):
+        if not self.left:
+            return self.screen.image.copy()
+        self.left -= 1
+        return self.before_click.copy()
+
+
 @pytest.mark.asyncio
-async def test_a_driver_whose_default_space_is_norm_passes_at_full():
-    report = await _probe(FixtureDriver(settings=ComputerSettings(default_space="norm")))
+@pytest.mark.parametrize("driver", [lambda: FixtureDriver(settings=ComputerSettings(default_space="norm")), StaleFrame],
+                         ids=["default-space-norm", "stale-first-frame"])
+async def test_a_driver_whose_default_space_is_norm_or_whose_first_frame_after_a_click_is_stale_passes_at_full(driver):
+    report = await _probe(driver())
     assert report.passed, _failed(report)
 
 
+@pytest.mark.asyncio
+async def test_frames_that_never_show_a_click_the_fixture_saw_fail_p4_with_the_last_pixel(monkeypatch):
+    monkeypatch.setattr(checks, "SETTLE_S", 0.5)
+    report = await _probe(StaleFrame(stale=10**6))
+    failed = next(c for c in report.checks if c.name == "a click in frame space hits its cell, and a frame shows it")
+    assert (failed.status, failed.detail) == ("failed", "no frame within 0.5 s shows it: the last shows (255, 255, 255)")
+
+
 @pytest.mark.asyncio
 async def test_a_tool_already_hidden_from_the_probes_role_stays_hidden():
     with served(FixtureDriver()) as url:
@@ -195,7 +226,7 @@ class ExitZero(FixtureDriver):
 @pytest.mark.asyncio
 @pytest.mark.parametrize("driver, broken", [
     (NeverReady, "computer-ready reports ready"),
-    (ClicksOff, "a click in frame space hits its cell, and the next frame shows it"),
+    (ClicksOff, "a click in frame space hits its cell, and a frame shows it"),
     (ShiftedCapture, "markers at odd and even pixels read back in frame pixels"),
     (AsciiOnly, "Unicode and mixed-case text arrives whole"),
     (SwappedScroll, "scrolls up, down, left and right each arrive that many times"),

{agentenv_framework_protocol-0.1.440 → agentenv_framework_protocol-0.1.442}/tests/test_computer_conformance_checks.py

@@ -229,7 +229,7 @@ async def test_effects_without_spaces_right_or_double_clicks_leave_those_out_and
     assert "a click in norm space hits its cell" not in got and "a right click arrives as one" not in got
     assert "a double click arrives as one" not in got and "norm points land on the same pixels" not in got
     assert got["16 clicks sent at once all land"] == ("failed", "16 of 16 were refused")
-    assert got["a click in frame space hits its cell, and the next frame shows it"][1].startswith("AssertionError")
+    assert got["a click in frame space hits its cell, and a frame shows it"][1].startswith("AssertionError")
 
 
 @pytest.mark.asyncio