agentenv-framework-protocol 0.1.453__tar.gz → 0.1.456__tar.gz

{agentenv_framework_protocol-0.1.453 → agentenv_framework_protocol-0.1.456}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: agentenv-framework-protocol
-Version: 0.1.453
+Version: 0.1.456
 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
@@ -258,6 +258,16 @@ with any other transport are kept beside the SDK's entry. Card URLs are paths, r
 address the card was fetched from. On the client side, `client.mcp_path(card)` returns the
 declared path, or `/mcp` for a card without one.
 
+A composed card, such as a gateway's, nests each backing environment's card under
+`children_environments`, its `url` and endpoints rooted at the route the composer serves it at.
+`client.children(card)` returns each as a `ChildEnv` (its `name`, `url` and `card`, with its
+`extensions`, `operations` and `serves(method)`, and `base_url(address)`, its data plane resolved
+against the composed card's address). Two children may share a name, as a website and an MCP
+server can, so `client.child_at(card, url)` finds one by its url or route; `client.child_named(card,
+name)` raises `AmbiguousChildError` for a shared name, and `client.find_child` returns the first.
+`client.serves(card, method)` says whether a card serves a data-plane method by its declared
+`operations`, None for a card that declares none.
+
 Extensions are invoked from what the card advertises. `client.find_extension_method(card, uri,
 method)` returns one advertised method, whose `endpoint` is the method's own or else the
 extension's, and `client.invoke_extension(base_url, card, uri, params, method=...)` calls it with

{agentenv_framework_protocol-0.1.453 → agentenv_framework_protocol-0.1.456}/README.md

@@ -199,6 +199,16 @@ with any other transport are kept beside the SDK's entry. Card URLs are paths, r
 address the card was fetched from. On the client side, `client.mcp_path(card)` returns the
 declared path, or `/mcp` for a card without one.
 
+A composed card, such as a gateway's, nests each backing environment's card under
+`children_environments`, its `url` and endpoints rooted at the route the composer serves it at.
+`client.children(card)` returns each as a `ChildEnv` (its `name`, `url` and `card`, with its
+`extensions`, `operations` and `serves(method)`, and `base_url(address)`, its data plane resolved
+against the composed card's address). Two children may share a name, as a website and an MCP
+server can, so `client.child_at(card, url)` finds one by its url or route; `client.child_named(card,
+name)` raises `AmbiguousChildError` for a shared name, and `client.find_child` returns the first.
+`client.serves(card, method)` says whether a card serves a data-plane method by its declared
+`operations`, None for a card that declares none.
+
 Extensions are invoked from what the card advertises. `client.find_extension_method(card, uri,
 method)` returns one advertised method, whose `endpoint` is the method's own or else the
 extension's, and `client.invoke_extension(base_url, card, uri, params, method=...)` calls it with

{agentenv_framework_protocol-0.1.453 → agentenv_framework_protocol-0.1.456}/pyproject.toml

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

{agentenv_framework_protocol-0.1.453 → agentenv_framework_protocol-0.1.456}/src/agentenv_protocol/client.py

@@ -7,6 +7,7 @@ import contextlib
 import logging
 from collections.abc import Iterator
 from contextvars import ContextVar
+from dataclasses import dataclass, field
 
 import httpx
 
@@ -210,6 +211,83 @@ def find_tool(card: dict, name: str) -> dict | None:
     return None
 
 
+def serves(card: dict, method: str) -> bool | None:
+    """Whether a card serves the data-plane ``method`` (``data/get`` say): True or False by its declared
+    ``capabilities.operations``, or None when it declares none, as an older card doesn't, so the caller decides as it
+    did before cards declared them (a probe, say)."""
+    declared = operations(card)
+    return None if declared is None else method in declared
+
+
+@dataclass(frozen=True)
+class ChildEnv:
+    """One child env a composed card nests under ``children_environments``: its ``name`` and ``url`` as its card gives
+    them, and that ``card``, which says what it offers. A composer roots each child's ``url`` (and its endpoints) at
+    the route it serves the child at, so two children sharing a name have distinct urls; ``url`` is None for a child
+    whose card names none."""
+
+    name: str | None
+    url: str | None
+    card: dict = field(hash=False, repr=False)
+
+    @property
+    def extensions(self) -> list[dict]:
+        """The extensions the child's card advertises (``capabilities.extensions``)."""
+        return list((self.card.get("capabilities") or {}).get("extensions") or [])
+
+    @property
+    def operations(self) -> list[str] | None:
+        """The data-plane methods the child's card declares (``operations``), or None when it declares none."""
+        return operations(self.card)
+
+    def find_extension(self, uri: str) -> dict | None:
+        """The extension the child's card advertises under ``uri``, or None (``find_extension``)."""
+        return find_extension(self.card, uri)
+
+    def serves(self, method: str) -> bool | None:
+        """Whether the child's card serves the data-plane ``method``, None when it declares no operations (``serves``)."""
+        return serves(self.card, method)
+
+    def base_url(self, address: str) -> str:
+        """Where the child's data plane is, its ``url`` without the RPC path, resolved against ``address``, the composed
+        card's: a path joins onto it, a full URL stands alone, and a child naming no url is at ``address`` itself."""
+        url = (self.url or RPC_PATH).removesuffix(RPC_PATH)
+        return url if "://" in url else f"{address.rstrip('/')}{url}"
+
+
+def children(card: dict) -> list[ChildEnv]:
+    """Each child env a composed card nests under ``children_environments``, in its order; none for a leaf card, or
+    one whose ``children_environments`` is missing or null. An entry that isn't an object is skipped."""
+    return [ChildEnv(name=child.get("name"), url=child.get("url"), card=child)
+            for child in card.get("children_environments") or [] if isinstance(child, dict)]
+
+
+def child_at(card: dict, url: str) -> ChildEnv | None:
+    """The child env of a composed card at ``url``: the one whose ``url`` is ``url``, or whose data plane is there
+    (``url`` without the RPC path, ``/svc/mcp-slack`` for ``/svc/mcp-slack/agentenv`` say), a trailing slash aside;
+    None when no child is. A composer serves each child at its own route, so this is the lookup two children sharing a
+    name can't confuse."""
+    wanted = url.rstrip("/")
+    for child in children(card):
+        if child.url is not None and wanted in (child.url.rstrip("/"), child.url.removesuffix(RPC_PATH).rstrip("/")):
+            return child
+    return None
+
+
+class AmbiguousChildError(LookupError):
+    """More than one child env of a composed card has the name asked for, so the name can't say which is meant."""
+
+
+def child_named(card: dict, name: str) -> ChildEnv | None:
+    """The one child env of a composed card named ``name``, or None when none is; raises ``AmbiguousChildError`` when
+    several are, as a website and an MCP server sharing a name are, which ``child_at`` tells apart by their urls."""
+    found = [child for child in children(card) if child.name == name]
+    if len(found) > 1:
+        raise AmbiguousChildError(f"{len(found)} child envs are named {name!r} ({', '.join(str(c.url) for c in found)}); "
+                                  "look one up by its url")
+    return found[0] if found else None
+
+
 def find_child(card: dict, name: str) -> dict | None:
     """Return the nested child EnvironmentCard named `name`, or None.
 
@@ -218,6 +296,8 @@ def find_child(card: dict, name: str) -> dict | None:
     rewritten to be reachable from the composed card's base_url. Callers resolve a service by
     name here, then use the child card with `find_extension`/`invoke_extension`. Tolerates a
     missing/null `children_environments` so single/leaf cards return None rather than raising.
+    Two children sharing `name` return the first; `child_named` refuses that, and `child_at`
+    finds a child by its url, which tells them apart.
     """
     for child in card.get("children_environments") or []:
         if child.get("name") == name:

{agentenv_framework_protocol-0.1.453 → agentenv_framework_protocol-0.1.456}/src/agentenv_protocol/computer/_linux.py

@@ -1,5 +1,6 @@
-"""The base class's Linux defaults for the OS operations. The driver runs as the session user inside the desktop
-session, so both act directly: a command inherits the session's environment, a file lands as that user."""
+"""The base class's defaults for the OS operations on Linux and macOS, which use POSIX alone. The driver runs as the
+session user inside the desktop session, so both act directly: a command inherits the session's environment, a file
+lands as that user."""
 from __future__ import annotations
 
 import asyncio

{agentenv_framework_protocol-0.1.453 → agentenv_framework_protocol-0.1.456}/src/agentenv_protocol/computer/app.py

@@ -251,6 +251,15 @@ class AppDeclaration(BaseModel):
     ready_checks: list[AppReadyCheck]
     browser: Optional[bool] = None
 
+    @model_validator(mode="after")
+    def _no_window_wait_on_macos(self) -> AppDeclaration:
+        """A window's readiness is read from X11's windows, which macOS hasn't."""
+        launch = self.os["macos"].launch if "macos" in self.os else None
+        if launch is not None and launch.ready is not None and launch.ready.window:
+            raise ValueError("on macos an app's launch can't wait on its window, which is read from X11; wait on a "
+                             "port, a command or a @ready_check")
+        return self
+
     @model_validator(mode="before")
     @classmethod
     def _stored_before_each_os(cls, data: Any) -> Any:

{agentenv_framework_protocol-0.1.453 → agentenv_framework_protocol-0.1.456}/src/agentenv_protocol/computer/app_runtime.py

@@ -9,6 +9,7 @@ import json
 import os
 import shlex
 import signal
+import sys
 import time
 from collections.abc import Awaitable, Callable
 from datetime import datetime, timezone
@@ -22,8 +23,9 @@ from . import session
 if TYPE_CHECKING:
     from .app import Launch
 
-#: Where an app's server marks that it launched the app since the computer booted, at boot or on demand.
-LAUNCHED = Path("/run/agentenv/apps")
+#: Where an app's server marks that it launched the app since the computer booted, at boot or on demand: a folder a
+#: boot clears, under /tmp on macOS, which has no /run and lets the session user write nothing at its root.
+LAUNCHED = Path("/tmp/agentenv/apps" if sys.platform == "darwin" else "/run/agentenv/apps")
 #: How long one readiness check may take; an app's checks run at once.
 CHECK_TIMEOUT_S = 10.0
 #: Where an app's server keeps the pid of the app it launched last, in the app's folder, so a server that restarts can

{agentenv_framework_protocol-0.1.453 → agentenv_framework_protocol-0.1.456}/src/agentenv_protocol/computer/conformance/checks.py

@@ -48,6 +48,8 @@ MINIMUM_TOOLS = ("computer_screenshot", "computer_click", "computer_drag", "comp
 DATA_PLANE = (INTAKE_EXTENSION_URI, DATA_OBJECTS_EXTENSION_URI)
 #: Where the fixture is staged and keeps its state, relative to the session user's home.
 STAGE = ".agentenv-probe"
+#: How the probe reads a staged file's owner: through the python3 the fixture runs on, the same on every OS.
+OWNER = ("python3", "-c", "import os, sys; print(os.stat(sys.argv[1]).st_uid)")
 #: Where a page driver's computer_upload takes files from, relative to the session user's home.
 UPLOADS = "Uploads"
 #: What the probe answers the page fixture's prompt with.
@@ -605,7 +607,7 @@ class Probe:
     async def _security(self) -> None:
         async def one_user() -> str | None:
             uid = (await self.driver.run("id", "-u"))["stdout"].strip()
-            owner = (await self.driver.run("stat", "-c", "%u", f"{STAGE}/{self.fixture}"))["stdout"].strip()
+            owner = (await self.driver.run(*OWNER, f"{STAGE}/{self.fixture}"))["stdout"].strip()
             if uid == "0":
                 return "commands run as root"
             return None if owner == uid else f"data/add wrote as uid {owner}, commands run as uid {uid}"

{agentenv_framework_protocol-0.1.453 → agentenv_framework_protocol-0.1.456}/src/agentenv_protocol/computer/driver.py

@@ -205,13 +205,13 @@ class ComputerDriverEnvironment(Tools, Extensions, DataPlane, AgentEnvEnvironmen
         if self._computer is None:
             raise TypeError(f"{type(self).__qualname__}.__init__ must call super().__init__()")
 
-    # The Linux defaults for the OS operations.
+    # The defaults for the OS operations on Linux and macOS, POSIX alike.
 
-    @default_for("run_in_session", os="linux")
+    @default_for("run_in_session", os=["linux", "macos"])
     async def _computer_linux_run_in_session(self, argv: list, cwd: str | None, env: dict | None, timeout_s: float):
         return await _linux.run_in_session(argv, cwd, env, timeout_s, output_bytes=self.settings.exec_output_bytes)
 
-    @default_for("write_files", os="linux")
+    @default_for("write_files", os=["linux", "macos"])
     async def _computer_linux_write_files(self, files: dict) -> None:
         await asyncio.to_thread(_linux.write_files, files)
 

{agentenv_framework_protocol-0.1.453 → agentenv_framework_protocol-0.1.456}/src/agentenv_protocol/computer/platform.py

@@ -27,13 +27,15 @@ class Platform:
 
 
 def detect(environ: dict | None = None, os_release: Path = Path("/etc/os-release")) -> Platform:
-    """The running platform: the OS, ``/etc/os-release``'s ID and VERSION_ID on Linux, the machine, and the
-    display from ``XDG_SESSION_TYPE``, ``none`` for a computer with no display, else ``DISPLAY`` (x11) or
-    ``WAYLAND_DISPLAY`` (wayland)."""
+    """The running platform: the OS, ``/etc/os-release``'s ID and VERSION_ID on Linux and the macOS version on macOS,
+    the machine, and the display: on Linux from ``XDG_SESSION_TYPE``, ``none`` for a computer with no display, else
+    ``DISPLAY`` (x11) or ``WAYLAND_DISPLAY`` (wayland); on macOS Aqua."""
     environ = os.environ if environ is None else environ
     name = _OS.get(sys.platform, sys.platform)
     release = _os_release(os_release) if name == "linux" else {}
-    display = None
+    if name == "macos":
+        release = {"VERSION_ID": _platform.mac_ver()[0] or None}
+    display = "aqua" if name == "macos" else None
     if name == "linux":
         session = (environ.get("XDG_SESSION_TYPE") or "").strip().lower()
         if session in ("x11", "wayland", "none"):

{agentenv_framework_protocol-0.1.453 → agentenv_framework_protocol-0.1.456}/tests/probe_fake.py

@@ -39,7 +39,7 @@ from agentenv_protocol.computer import (
     upload,
 )
 from agentenv_protocol.computer import _linux as linux
-from agentenv_protocol.computer.conformance.checks import STAGE
+from agentenv_protocol.computer.conformance.checks import OWNER, STAGE
 from agentenv_protocol.computer.conformance.page_fixture import QUESTION, TITLE, TWO, TWO_TITLE
 
 CLIPBOARD = "agentenv-probe clipboard"
@@ -56,6 +56,7 @@ DESK_URL = "http://127.0.0.1:4343/"
 TITLES = {DESK_URL: TITLE, DESK_URL + TWO.lstrip("/"): TWO_TITLE}
 
 
+
 class FakeDesk:
     """What the Fixture Desk would record of the input the fake screen gets."""
 
@@ -202,7 +203,7 @@ class FixtureDriver(FakeDriver):
         if f"python3 {STAGE}/fixture.py" in text:
             self.desk.start()
             return ExecResult(0, b"4242\n")
-        if argv in (["id", "-u"], ["stat", "-c", "%u", f"{STAGE}/fixture.py"]):
+        if argv in (["id", "-u"], [*OWNER, f"{STAGE}/fixture.py"]):
             return ExecResult(0, b"1000\n")
         if argv[:1] in (["kill"], ["tail"]) or f"rm -rf {STAGE}/state" in text:
             return ExecResult(0)
@@ -320,10 +321,10 @@ class PageFixtureDriver(FixtureDriver):
             return ExecResult(0, b"4343") if self.desk.started else ExecResult(1)
         if argv[:1] == ["cat"] and argv[1].endswith("layout.json") and self.desk.started:
             return ExecResult(0, json.dumps(PAGE_LAYOUT).encode())
-        if argv == ["stat", "-c", "%u", f"{STAGE}/page_fixture.py"]:
+        if argv == [*OWNER, f"{STAGE}/page_fixture.py"]:
             return ExecResult(0, b"1000\n")
-        if argv == ["stat", "-c", "%u", f"{STAGE}/fixture.py"]:
-            return ExecResult(1, b"", b"stat: cannot statx: No such file or directory")
+        if argv == [*OWNER, f"{STAGE}/fixture.py"]:
+            return ExecResult(1, b"", b"FileNotFoundError: [Errno 2] No such file or directory")
         return super()._fixture(argv)
 
 

{agentenv_framework_protocol-0.1.453 → agentenv_framework_protocol-0.1.456}/tests/test_client.py

@@ -190,6 +190,58 @@ def test_find_child_tolerates_missing_children():
     assert protocol_v1.find_child({"children_environments": None}, "slack") is None
 
 
+_SHARED_NAME = {"name": "gw", "children_environments": [
+    {"name": "mail", "url": "/svc/mcp-mail/agentenv", "capabilities": {"operations": ["data/get"], "extensions": [
+        {"uri": "urn:agentenv:clock/v1"}]}},
+    {"name": "mail", "url": "/svc/mail/agentenv", "capabilities": {"operations": []}},
+    {"name": "docs", "capabilities": {}},
+    "not a card",
+]}
+
+
+def test_children_are_each_nested_card_by_its_name_url_and_card():
+    found = protocol_v1.children(_SHARED_NAME)
+
+    assert [(c.name, c.url) for c in found] == [("mail", "/svc/mcp-mail/agentenv"), ("mail", "/svc/mail/agentenv"), ("docs", None)]
+    assert found[0].card is _SHARED_NAME["children_environments"][0]
+    assert [c.extensions for c in found] == [[{"uri": "urn:agentenv:clock/v1"}], [], []]
+    assert [c.operations for c in found] == [["data/get"], [], None]
+    assert [c.serves("data/get") for c in found] == [True, False, None]
+    assert found[0].find_extension("urn:agentenv:clock/v1") is not None and found[1].find_extension("urn:agentenv:clock/v1") is None
+    assert protocol_v1.children({"name": "leaf"}) == [] and protocol_v1.children({"children_environments": None}) == []
+
+
+def test_a_childs_base_url_is_its_url_without_the_rpc_path_against_the_composed_cards_address():
+    mcp, website, docs = protocol_v1.children(_SHARED_NAME)
+
+    assert mcp.base_url("https://env.example/") == "https://env.example/svc/mcp-mail"
+    assert website.base_url("https://env.example") == "https://env.example/svc/mail"
+    assert docs.base_url("https://env.example") == "https://env.example"
+    assert protocol_v1.ChildEnv("x", "https://x.example/agentenv", {}).base_url("https://env.example") == "https://x.example"
+
+
+def test_child_at_finds_a_child_by_its_url_or_data_plane_route_where_two_share_a_name():
+    assert protocol_v1.child_at(_SHARED_NAME, "/svc/mail").url == "/svc/mail/agentenv"
+    assert protocol_v1.child_at(_SHARED_NAME, "/svc/mcp-mail/").url == "/svc/mcp-mail/agentenv"
+    assert protocol_v1.child_at(_SHARED_NAME, "/svc/mail/agentenv").url == "/svc/mail/agentenv"
+    assert protocol_v1.child_at(_SHARED_NAME, "/svc/docs") is None
+    assert protocol_v1.child_at({"name": "leaf"}, "/svc/mail") is None
+
+
+def test_child_named_refuses_a_name_two_children_share():
+    assert protocol_v1.child_named(_SHARED_NAME, "docs").name == "docs"
+    assert protocol_v1.child_named(_SHARED_NAME, "gmail") is None
+    with pytest.raises(protocol_v1.AmbiguousChildError, match="2 child envs are named 'mail'"):
+        protocol_v1.child_named(_SHARED_NAME, "mail")
+    assert protocol_v1.find_child(_SHARED_NAME, "mail")["url"] == "/svc/mcp-mail/agentenv"
+
+
+def test_serves_is_what_a_card_declares_of_a_method_and_none_when_it_declares_no_operations():
+    assert protocol_v1.serves({"capabilities": {"operations": ["data/get"]}}, "data/get") is True
+    assert protocol_v1.serves({"capabilities": {"operations": ["data/add"]}}, "data/get") is False
+    assert protocol_v1.serves({"capabilities": {}}, "data/get") is None
+
+
 def test_find_extension_ignores_children():
     # set-errors/v1 is advertised only on the children, never at the top level
     assert protocol_v1.find_extension(_CARD_WITH_CHILDREN, "urn:agentenv:set-errors/v1") is None

{agentenv_framework_protocol-0.1.453 → agentenv_framework_protocol-0.1.456}/tests/test_computer_app_server.py

@@ -6,6 +6,7 @@ from __future__ import annotations
 
 import asyncio
 import contextlib
+import importlib.util
 import os
 import shlex
 import signal
@@ -109,6 +110,16 @@ async def test_an_apps_server_is_ready_once_it_launched_the_app_and_each_check_p
     assert after["ready"] is True and after["problems"] == []
 
 
+
+@pytest.mark.parametrize("platform, folder", [("linux", "/run/agentenv/apps"), ("darwin", "/tmp/agentenv/apps")])
+def test_a_launch_is_marked_in_a_folder_a_boot_clears_and_the_session_user_writes(monkeypatch, platform, folder):
+    monkeypatch.setattr(sys, "platform", platform)
+    spec = importlib.util.spec_from_file_location(f"agentenv_protocol.computer._app_runtime_on_{platform}",
+                                                  app_runtime.__file__)
+    loaded = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(loaded)
+    assert loaded.LAUNCHED == Path(folder)
+
 @pytest.mark.asyncio
 async def test_checks_that_fail_hang_or_raise_say_so_at_once_without_holding_up_the_server(desktop, monkeypatch):
     monkeypatch.setattr(app_runtime, "CHECK_TIMEOUT_S", 1.0)

{agentenv_framework_protocol-0.1.453 → agentenv_framework_protocol-0.1.456}/tests/test_computer_conformance.py

@@ -167,7 +167,7 @@ async def test_each_app_a_driver_fronts_that_exports_is_asked_for_its_export_onc
 
 @pytest.mark.asyncio
 async def test_a_driver_without_exec_or_data_add_passes_basic_and_leaves_full_unverified():
-    report = await _probe(MinimalDriver(FakeScreen(640, 400), platform=Platform(os="macos")))
+    report = await _probe(MinimalDriver(FakeScreen(640, 400), platform=Platform(os="windows")))
     assert report.passed, _failed(report)
     unverified = [c for c in report.checks if c.status == "unverified"]
     assert {c.check for c in unverified} == {"P3", "P4", "P5", "P6", "P7", "P9"}

{agentenv_framework_protocol-0.1.453 → agentenv_framework_protocol-0.1.456}/tests/test_computer_declare.py

@@ -264,6 +264,9 @@ def test_an_app_declaring_its_skill_twice_is_refused(folder):
      "Changed.fonts runs on 'windows', which Changed declares no install for; it declares freebsd, linux"),
     ('@ready_check(os="macos")\n    def window_shown(self): return True',
      "Changed.window_shown runs on 'macos', which Changed declares no install for"),
+    ('@install("macos", FreeBSD(), launch=Launch(command=["mail"], window={"class": "Mail"}, '
+     'ready=Ready(window=True)))',
+     "on macos an app's launch can't wait on its window, which is read from X11"),
     ('class BuildSettings(BaseModel): key: SecretStr = SecretStr("")',
      "Changed.BuildSettings holds a secret at properties.key, which its computer's image would keep; declare it in "
      "Settings"),
@@ -273,9 +276,9 @@ def test_an_app_declaring_its_skill_twice_is_refused(folder):
      "Changed.BuildSettings holds a secret at $defs.Settings.properties.password, which"),
 ], ids=["no-wait", "no-window", "window-key", "download-sha", "script-escape", "os-skill-twice", "os-build-secret",
         "step-os",
-        "check-os", "build-secret", "build-secrets-listed", "build-secret-nested"])
+        "check-os", "macos-window-wait", "build-secret", "build-secrets-listed", "build-secret-nested"])
 def test_an_app_whose_declaration_cant_be_checked_is_refused_saying_why(folder, capsys, change, problem):
-    decorator, body = (change, "pass") if change.startswith("@linux") else ("", change)
+    decorator, body = (change, "pass") if change.startswith(("@linux", "@install(")) else ("", change)
     (folder / "app.py").write_text(APP.format(supports=LINUX, sha='a' * 64) + f"""
 
 @computer_app(supports={LINUX})

{agentenv_framework_protocol-0.1.453 → agentenv_framework_protocol-0.1.456}/tests/test_computer_driver.py

@@ -45,6 +45,8 @@ from agentenv_protocol.computer.settings import load_settings  # noqa: E402
 from agentenv_protocol.computer.tools import _modifiers  # noqa: E402
 
 MACOS = Platform(os="macos", arch="arm64")
+#: A platform the base class has no OS defaults for.
+WINDOWS = Platform(os="windows", arch="amd64")
 
 
 def _required(namespace: dict) -> dict:
@@ -130,7 +132,8 @@ def test_set_display_without_modes_is_refused():
 def test_a_driver_method_replaces_the_linux_default():
     Driver = _define({"run": run_in_session(lambda self, *a: None)})
     assert declared(Driver)["run_in_session"] == [("run", {})]
-    assert declared(MinimalDriver)["run_in_session"] == [("_computer_linux_run_in_session", {"os": frozenset({"linux"})})]
+    assert declared(MinimalDriver)["run_in_session"] == [("_computer_linux_run_in_session",
+                                                         {"os": frozenset({"linux", "macos"})})]
 
 
 def test_the_platform_is_detected(tmp_path, monkeypatch):
@@ -143,7 +146,8 @@ def test_the_platform_is_detected(tmp_path, monkeypatch):
     assert detect({"WAYLAND_DISPLAY": "wayland-0"}, release).display == "wayland"
     assert detect({}, tmp_path / "missing").as_dict() == {"os": "linux", "arch": "arm64"}
     monkeypatch.setattr("agentenv_protocol.computer.platform.sys.platform", "darwin")
-    assert detect({"DISPLAY": ":0"}, release) == Platform("macos", None, None, "arm64", None)
+    monkeypatch.setattr("agentenv_protocol.computer.platform._platform.mac_ver", lambda: ("26.5.2", ("", "", ""), ""))
+    assert detect({"DISPLAY": ":0"}, release) == Platform("macos", None, "26.5.2", "arm64", "aqua")
 
 
 def test_settings_come_from_one_json_value():
@@ -222,7 +226,7 @@ async def test_a_driver_whose_software_ships_a_skill_leads_with_it_and_the_compu
 
 @pytest.mark.asyncio
 async def test_a_minimal_driver_declares_only_what_it_has():
-    async with http_client(MinimalDriver(platform=MACOS)) as http:
+    async with http_client(MinimalDriver(platform=WINDOWS)) as http:
         card = (await http.get("/.well-known/agent-env.json")).json()
         display_set = await http.post("/agentenv/ext/computer-display/set", json={"width": 1, "height": 1})
         exec_run = await http.post("/agentenv/ext/computer-exec/run", json={"argv": ["true"], "request_id": "r"})
@@ -449,14 +453,14 @@ def test_a_driver_class_declares_what_it_serves_on_each_platform(monkeypatch):
             raise AssertionError("declaration builds the card without the subclass's __init__")
 
     linux = Declared.declaration(LINUX)
-    elsewhere = MinimalDriver.declaration(Platform(os="macos"))
+    elsewhere = MinimalDriver.declaration(Platform(os="windows"))
     uris = lambda card: {e.uri for e in card.capabilities.extensions}  # noqa: E731
     assert linux.name == "declared" and len(linux.capabilities.tools) == 14
     assert {"urn:agentenv:computer-pointer/v1", "urn:agentenv:computer-exec/v1"} <= uris(linux)
     assert elsewhere.name == "MinimalDriver" and len(elsewhere.capabilities.tools) == 7
     assert "urn:agentenv:computer-exec/v1" not in uris(elsewhere)
     computer = next(e for e in elsewhere.capabilities.extensions if e.uri == "urn:agentenv:computer/v1")
-    assert computer.params["platform"] == {"os": "macos"}
+    assert computer.params["platform"] == {"os": "windows"}
 
 
 def test_a_supports_entry_names_each_platform_it_covers():

{agentenv_framework_protocol-0.1.453 → agentenv_framework_protocol-0.1.456}/tests/test_computer_recording.py

@@ -94,12 +94,16 @@ def _grant() -> dict:
                       "file_field": "file"}}
 
 
-async def _record(driver, seconds: float, start: dict | None = None, end: dict | None = None) -> tuple[dict, dict]:
-    """A recording that runs ``seconds`` from its first frame, however long that took to come, and then ends."""
+async def _record(driver, seconds: float, start: dict | None = None, end: dict | None = None,
+                  frames: int | None = None) -> tuple[dict, dict]:
+    """A recording that runs ``seconds`` from its first frame, however long that took to come, and, given ``frames``,
+    until its encoder holds that many, and then ends."""
     async with http_client(driver) as http:
         started = (await http.post(START, json={"request_id": "r", "fps": 10, **(start or {})})).json()
         await _first_frame(driver, started)
         await asyncio.sleep(seconds)
+        if frames is not None:
+            await _encoded(driver, started, frames)
         manifest = (await http.post(END, json={"recording_id": started["recording_id"], **(end or {})})).json()
     return started, manifest
 
@@ -237,7 +241,7 @@ async def test_a_stream_that_keeps_failing_ends_the_recording_with_its_error(hom
 
 @pytest.mark.asyncio
 async def test_a_stream_of_frames_keeps_each_frames_capture_time(home):
-    _, manifest = await _record(Streamed(), 0.8, start={"fps": 20, "max_edge": 640})
+    _, manifest = await _record(Streamed(), 0.8, start={"fps": 20, "max_edge": 640}, frames=10)
     (segment,) = manifest["segments"]
     assert manifest["source"] == "stream" and (segment["width"], segment["height"]) == (640, 400)
     frames = _decoded(home / ".agentenv-recordings" / segment["path"])
@@ -511,3 +515,12 @@ async def test_frames_in_thread_keeps_the_latest_frames_for_a_slow_reader_and_cl
     await endless.aclose()
     assert first == 0 and rest == [26, 27, 28, 29]
     assert await asyncio.to_thread(stopped.wait, 5)
+
+
+async def _encoded(driver, started: dict, frames: int) -> None:
+    """Until the recording's encoder holds ``frames`` frames: a busy machine captures fewer a second."""
+    recording = driver._computer.recordings.running[started["recording_id"]]
+    for _ in range(3000):
+        if recording.encoder and recording.encoder.frames >= frames:
+            return
+        await asyncio.sleep(0.01)