agentenv-framework-protocol 0.1.448__tar.gz → 0.1.451__tar.gz

{agentenv_framework_protocol-0.1.448 → agentenv_framework_protocol-0.1.451}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: agentenv-framework-protocol
-Version: 0.1.448
+Version: 0.1.451
 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
@@ -42,6 +42,7 @@ Requires-Dist: av>=17; extra == 'computer'
 Requires-Dist: mcp<2,>=1.25; extra == 'computer'
 Requires-Dist: pillow>=10.4; extra == 'computer'
 Requires-Dist: uvicorn>=0.30; extra == 'computer'
+Requires-Dist: websockets>=13; extra == 'computer'
 Provides-Extra: dev
 Requires-Dist: a2a-sdk[http-server]<0.4,>=0.3.26; extra == 'dev'
 Requires-Dist: av>=17; extra == 'dev'
@@ -52,6 +53,7 @@ Requires-Dist: pytest-asyncio>=0.23.0; extra == 'dev'
 Requires-Dist: pytest>=9.0; extra == 'dev'
 Requires-Dist: python-multipart>=0.0.13; extra == 'dev'
 Requires-Dist: regex>=2023.12.25; extra == 'dev'
+Requires-Dist: websockets>=13; extra == 'dev'
 Description-Content-Type: text/markdown
 
 # agentenv-framework-protocol
@@ -826,7 +828,16 @@ launches one at a time, runs a load and a reset with the app stopped and relaunc
 follows a failed load with a reset, and fails a call that runs past `data_timeout_s` (300 s); a sync
 hook runs in a thread, which the reset and relaunch after it wait for. The driver fronts its apps:
 its card lists each one's card as a child environment, rooted at `/svc/<app>/`, where it forwards
-requests to the app's server.
+requests to the app's server, taking the control token:
+
+- every method, its body and the answer's streamed both ways, so a large answer isn't held whole;
+- headers passed on but the hop-by-hop ones, those a `Connection` header names and the control token's
+  `Authorization`; `Host` as the caller sent it, and in place of any address the caller forwarded,
+  the one it reached the driver at: `X-Forwarded-Host`, `X-Forwarded-Proto` and `X-Forwarded-Prefix`
+  (`/svc/<app>`), as the gateway sets them;
+- WebSockets, relayed to the app's server both ways with the subprotocol it picks until either side
+  closes, the other then closed with its code; refused before they open without the token, or with no
+  such app or one not answering. The `computer` extra brings `websockets` for this.
 
 `MailApp.declaration()` returns what the class declares, an `AppDeclaration`, which a `computer_app`
 env stores (`browser: true` for a website browser), and `python -m agentenv_protocol.computer._declare <folder> <file> <class>` prints it as

{agentenv_framework_protocol-0.1.448 → agentenv_framework_protocol-0.1.451}/README.md

@@ -770,7 +770,16 @@ launches one at a time, runs a load and a reset with the app stopped and relaunc
 follows a failed load with a reset, and fails a call that runs past `data_timeout_s` (300 s); a sync
 hook runs in a thread, which the reset and relaunch after it wait for. The driver fronts its apps:
 its card lists each one's card as a child environment, rooted at `/svc/<app>/`, where it forwards
-requests to the app's server.
+requests to the app's server, taking the control token:
+
+- every method, its body and the answer's streamed both ways, so a large answer isn't held whole;
+- headers passed on but the hop-by-hop ones, those a `Connection` header names and the control token's
+  `Authorization`; `Host` as the caller sent it, and in place of any address the caller forwarded,
+  the one it reached the driver at: `X-Forwarded-Host`, `X-Forwarded-Proto` and `X-Forwarded-Prefix`
+  (`/svc/<app>`), as the gateway sets them;
+- WebSockets, relayed to the app's server both ways with the subprotocol it picks until either side
+  closes, the other then closed with its code; refused before they open without the token, or with no
+  such app or one not answering. The `computer` extra brings `websockets` for this.
 
 `MailApp.declaration()` returns what the class declares, an `AppDeclaration`, which a `computer_app`
 env stores (`browser: true` for a website browser), and `python -m agentenv_protocol.computer._declare <folder> <file> <class>` prints it as

{agentenv_framework_protocol-0.1.448 → agentenv_framework_protocol-0.1.451}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "agentenv-framework-protocol"
-version = "0.1.448"
+version = "0.1.451"
 description = "Open data-plane protocol and server SDK for agent environments."
 readme = "README.md"
 license = "Apache-2.0"
@@ -41,13 +41,14 @@ app = [
     "mcp>=1.25,<2",
     "uvicorn>=0.30",
 ]
-# A computer driver: ComputerDriverEnvironment serves its tools over mcp's FastMCP, crops and encodes frames, and
-# records the display as H.264 with PyAV (computer-recording/v1).
+# A computer driver: ComputerDriverEnvironment serves its tools over mcp's FastMCP, crops and encodes frames, records
+# the display as H.264 with PyAV (computer-recording/v1), and relays WebSockets to its apps on /svc/<app>/.
 computer = [
     "av>=17",
     "mcp>=1.25,<2",
     "Pillow>=10.4",
     "uvicorn>=0.30",
+    "websockets>=13",
 ]
 dev = [
     "a2a-sdk[http-server]>=0.3.26,<0.4",
@@ -59,6 +60,7 @@ dev = [
     "fastmcp>=3.4,<4",  # the standalone-fastmcp mount path
     "Pillow>=10.4",  # the computer extra's frame crops and encodings
     "av>=17",  # the computer extra's encoder, and the tests' decoder
+    "websockets>=13",  # the computer extra's /svc/<app>/ relay
 ]
 [project.urls]
 Homepage = "https://www.agentenvframework.com"

{agentenv_framework_protocol-0.1.448 → agentenv_framework_protocol-0.1.451}/src/agentenv_protocol/agent_env_environment.py

@@ -1546,18 +1546,27 @@ def _error_response(error: AgentEnvError) -> Response:
     return _json_response(error_body(**error.fields()), error.status)
 
 
+def control_check() -> Callable[[Any], bool]:
+    """Whether a call's headers carry the env's control token as their bearer, with ``CONTROL_TOKEN_ENV`` set; without
+    it, any do."""
+    token = os.environ.get(CONTROL_TOKEN_ENV)
+    if not token:
+        return lambda headers: True
+    expected = f"Bearer {token}".encode()
+    return lambda headers: hmac.compare_digest(headers.get("authorization", "").encode(), expected)
+
+
 def control_guard() -> Callable[[Callable], Callable]:
     """What wraps a framework-only route, everything an env serves but its MCP endpoint and its card: with
     ``CONTROL_TOKEN_ENV`` set, a call that doesn't carry that token as its bearer is refused before the route runs;
     without it, nothing."""
-    token = os.environ.get(CONTROL_TOKEN_ENV)
-    if not token:
+    if not os.environ.get(CONTROL_TOKEN_ENV):
         return lambda handler: handler
-    expected = f"Bearer {token}".encode()
+    allowed = control_check()
 
     def guard(handler: Callable) -> Callable:
         async def guarded(request: Request) -> Response:
-            if not hmac.compare_digest(request.headers.get("authorization", "").encode(), expected):
+            if not allowed(request.headers):
                 return _error_response(AgentEnvError(
                     "unauthorized", "this route is agent-env's own: it takes the env's control token", status=401))
             return await handler(request)

{agentenv_framework_protocol-0.1.448 → agentenv_framework_protocol-0.1.451}/src/agentenv_protocol/computer/apps.py

@@ -3,7 +3,7 @@ Each app's own server answers on its folder's socket (``serve_app``): its card s
 paths it owns, and its ``computer-app/v1`` ``ready`` whether it's ready. Every app's server must answer before the
 computer is ready; an app that starts with the computer must also be ready, and a ``demand`` app is checked once
 something launches it. The driver lists each app as a child environment named for its folder, its card's paths under
-``/svc/<name>/``, and forwards each request there to the app's server."""
+``/svc/<name>/``, where it forwards each request to the app's server (``svc``)."""
 from __future__ import annotations
 
 import asyncio
@@ -91,15 +91,6 @@ async def owned_paths(folders: list[Path]) -> list[str]:
             for path in client.extension_params(card, COMPUTER_APP).get("paths") or []]
 
 
-async def forward(folder: Path, method: str, path: str, query: str, body: bytes,
-                  content_type: Optional[str]) -> httpx.Response:
-    """The app's server's answer to the request, sent on as it came; it takes as long as the app does."""
-    async with httpx.AsyncClient(transport=httpx.AsyncHTTPTransport(uds=str(folder / SOCKET)), base_url="http://app",
-                                 timeout=None) as http:
-        return await http.request(method, f"/{path}" + (f"?{query}" if query else ""), content=body,
-                                  headers={"content-type": content_type} if content_type else None)
-
-
 def endpoint(card: dict, method: str) -> str:
     """The path of a ``computer-app/v1`` method, as the app's card advertises it."""
     return client.find_extension_method(card, COMPUTER_APP, method)["endpoint"]

{agentenv_framework_protocol-0.1.448 → agentenv_framework_protocol-0.1.451}/src/agentenv_protocol/computer/conformance/fixture.py

@@ -1,9 +1,11 @@
-"""The Linux fixture the conformance probe stages with data/add and launches with computer-exec: a Tk window, the
-Fixture Desk, whose widgets' screen boxes are written to <state-dir>/layout.json and every effect that reaches it,
-with whatever lands in <state-dir>/inbox.txt, to <state-dir>/state.json, so the probe can aim at it and read back
-what arrived. Run as ``python3 fixture.py <state-dir>``; it needs a 1280x800 screen or larger."""
+"""The fixture the conformance probe stages with data/add and launches with computer-exec: a Tk window, the Fixture
+Desk, whose widgets' screen boxes are written to <state-dir>/layout.json and every effect that reaches it, with
+whatever lands in <state-dir>/inbox.txt, to <state-dir>/state.json, so the probe can aim at it and read back what
+arrived. It records the same effects under X11, macOS's Aqua and Windows, whose Tk names keys, binds select-all and
+reports the wheel differently. Run as ``python3 fixture.py <state-dir>``; it needs a 1280x800 screen or larger."""
 from __future__ import annotations
 
+import ctypes
 import json
 import os
 import sys
@@ -19,6 +21,14 @@ MARKERS = ((11, 11, "#ff0000"), (12, 11, "#00ff00"), (11, 12, "#0000ff"), (12, 1
            (20, 37, "#00ffff"))
 CLIPBOARD = "agentenv-probe clipboard"
 MIN_SIZE = (1280, 800)
+#: X11's keysyms for the keys Aqua's Tk names by their character.
+KEYSYMS = {",": "comma", " ": "space"}
+#: A wheel notch's <MouseWheel> delta where Tk scales the wheel: Windows', and Tk 9's everywhere.
+NOTCH_DELTA = 120
+#: Tk 9 packs a <TouchpadScroll>'s distances into its delta: y, a signed 16-bit number, in the low bits, x above.
+Y_BITS = 16
+#: The pixels of a scrolled line, macOS's for a scroll posted in lines.
+LINE_PX = 10
 
 
 def main(state_dir: Path) -> None:
@@ -32,7 +42,7 @@ def main(state_dir: Path) -> None:
     state: dict = {"name": "", "notes": "", "keys": [], "saved_count": 0, "subscribed": False, "selected": None,
                    "scroll_top": 0.0, "cells": {}, "right_clicks": 0, "double_clicks": 0, "drags": [],
                    "wheel": {"up": 0, "down": 0, "left": 0, "right": 0}, "clipboard": None, "loaded": None,
-                   "screen": [width, height]}
+                   "screen": [width, height], "windowing": root.tk.call("tk", "windowingsystem")}
 
     def save() -> None:
         part = state_dir / ".state.json.part"
@@ -52,12 +62,20 @@ def main(state_dir: Path) -> None:
 
     def key(event) -> None:
         state["name"] = name.get()
-        state["keys"] = (state["keys"] + [event.keysym])[-100:]
+        state["keys"] = (state["keys"] + [KEYSYMS.get(event.keysym, event.keysym)])[-100:]
         state["clipboard"] = _clipboard(root)
         save()
 
     name.bind("<KeyRelease>", key)
 
+    def select_all(event) -> str:
+        name.selection_range(0, "end")
+        name.icursor("end")
+        return "break"
+
+    # Tk binds Ctrl+/ to select-all on X11 alone; Aqua's is Cmd+A.
+    name.bind("<Control-slash>", select_all)
+
     def on_save() -> None:
         state["saved_count"] += 1
         save()
@@ -157,14 +175,25 @@ def main(state_dir: Path) -> None:
     wheel = tk.Canvas(root, width=200, height=120, bg="#e6f0ff", highlightthickness=0)
     wheel.place(x=840, y=500)
 
-    def wheeled(event, button: int) -> None:
-        # Tk 8.6 delivers X buttons 6 and 7 (horizontal) as 4 and 5 with Shift held.
-        horizontal = bool(event.state & 1)
-        state["wheel"][("left" if horizontal else "up") if button == 4 else ("right" if horizontal else "down")] += 1
+    def wheeled(horizontal: bool, steps: int) -> None:
+        way = ("left" if horizontal else "up") if steps > 0 else ("right" if horizontal else "down")
+        state["wheel"][way] += abs(steps)
         save()
 
-    wheel.bind("<Button-4>", lambda e: wheeled(e, 4))
-    wheel.bind("<Button-5>", lambda e: wheeled(e, 5))
+    def scrolled(delta: int) -> None:
+        if steps := touchpad_steps(delta):
+            wheeled(*steps)
+
+    # Tk 8.6 on X11 reports the wheel as buttons 4 and 5, Aqua, Windows and Tk 9 as <MouseWheel>, a horizontal scroll
+    # (X's buttons 6 and 7) as a vertical one with Shift held. Tk 9 reports a scroll in pixels, a trackpad's or one a
+    # driver posts as Aqua's do, as <TouchpadScroll>.
+    if root.tk.call("tk", "windowingsystem") == "x11" and tk.TkVersion < 8.7:
+        wheel.bind("<Button-4>", lambda e: wheeled(bool(e.state & 1), 1))
+        wheel.bind("<Button-5>", lambda e: wheeled(bool(e.state & 1), -1))
+    else:
+        wheel.bind("<MouseWheel>", lambda e: wheeled(bool(e.state & 1), wheel_steps(e.delta)))
+    if tk.TkVersion >= 8.7:
+        wheel.bind("<TouchpadScroll>", lambda e: scrolled(e.delta))
 
     field = tk.Canvas(root, width=48, height=48, bg="#000000", highlightthickness=0, bd=0)
     field.place(x=1080, y=500)
@@ -198,6 +227,22 @@ def main(state_dir: Path) -> None:
     root.mainloop()
 
 
+def wheel_steps(delta: int) -> int:
+    """The wheel steps a <MouseWheel> event's ``delta`` holds, up positive: whole notches of 120 where Tk scales them
+    so (Windows, and Tk 9 everywhere), else one a unit (Aqua's Tk 8.6)."""
+    return int(delta / NOTCH_DELTA) if abs(delta) >= NOTCH_DELTA else delta
+
+
+def touchpad_steps(delta: int) -> tuple[bool, int] | None:
+    """The steps a <TouchpadScroll> event's ``delta`` holds, as horizontal or not and up or left positive, or None
+    when it moves nothing. A step is a line, LINE_PX, and macOS may coalesce several into one event."""
+    dx, dy = delta >> Y_BITS, ctypes.c_int16(delta).value
+    if not (dx or dy):
+        return None
+    distance = dy or dx
+    return not dy, (1 if distance > 0 else -1) * max(1, round(abs(distance) / LINE_PX))
+
+
 def _clipboard(root: tk.Tk) -> str | None:
     try:
         return root.clipboard_get()

{agentenv_framework_protocol-0.1.448 → agentenv_framework_protocol-0.1.451}/src/agentenv_protocol/computer/driver.py

@@ -4,21 +4,22 @@ computer's apps as child environments, each reached at ``/svc/<name>/`` through
 from __future__ import annotations
 
 import asyncio
-from typing import Any, Callable, ClassVar, Literal
+from pathlib import Path
+from typing import Any, Callable, ClassVar, Literal, Optional
 
-import httpx
 from pydantic import BaseModel, ConfigDict
 from starlette.requests import Request
 from starlette.responses import Response
+from starlette.websockets import WebSocket
 
 from ..agent_env_environment import (_CARD_CONFIG_ATTR, AgentEnvEnvironment, AgentEnvFastMCPApplication,
                                      _error_response, control_guard, environment_card)
 from ..tool_context import ToolContext
 from ..types import EnvironmentCard, EnvironmentExtension, EnvironmentTool
-from . import _linux, apps, card
+from . import _linux, apps, card, svc
 from .checks import check_features, check_names
 from .dataplane import DataPlane
-from .errors import DeliveryFailed, TargetUnavailable
+from .errors import TargetUnavailable
 from .extensions import Extensions
 from .operations import ReadyCheck, check_class, default_for
 from .platform import Platform, detect
@@ -138,21 +139,28 @@ class ComputerDriverEnvironment(Tools, Extensions, DataPlane, AgentEnvEnvironmen
         return await apps.children(self._computer.apps) if self._computer.apps else None
 
     def _computer_front_apps(self, app: Any) -> Any:
-        app.custom_route("/svc/{name}/{path:path}", methods=["GET", "POST"])(control_guard()(self._computer_forward))
+        app.custom_route("/svc/{name}/{path:path}", methods=svc.METHODS)(control_guard()(self._computer_forward))
+        svc.websocket_route(app, "/svc/{name}/{path:path}", self._computer_relay)
         return app
 
+    def _computer_app_folder(self, name: str) -> Optional[Path]:
+        return next((folder for folder in self._computer.apps if folder.name == name), None)
+
     async def _computer_forward(self, request: Request) -> Response:
         """A request under ``/svc/<name>/``, sent on to the app named so: its own server answers it."""
         name = request.path_params["name"]
-        folder = next((folder for folder in self._computer.apps if folder.name == name), None)
-        if folder is None:
+        if (folder := self._computer_app_folder(name)) is None:
             return _error_response(TargetUnavailable(f"this computer has no app named {name!r}"))
-        try:
-            answer = await apps.forward(folder, request.method, request.path_params["path"], request.url.query,
-                                        await request.body(), request.headers.get("content-type"))
-        except (httpx.HTTPError, OSError) as e:
-            return _error_response(DeliveryFailed(f"app {name}'s server isn't answering: {type(e).__name__}: {e}"))
-        return Response(answer.content, status_code=answer.status_code, media_type=answer.headers.get("content-type"))
+        return await svc.forward(folder, name, request)
+
+    async def _computer_relay(self, websocket: WebSocket) -> None:
+        """A WebSocket under ``/svc/<name>/``, relayed both ways to the app named so; refused, before it opens, with no
+        such app."""
+        name = websocket.path_params["name"]
+        if (folder := self._computer_app_folder(name)) is None:
+            await websocket.close(code=1008)
+            return
+        await svc.relay(folder, name, websocket)
 
     # The card: what the driver's operations support.
 

agentenv_framework_protocol-0.1.451/src/agentenv_protocol/computer/svc.py

@@ -0,0 +1,182 @@
+"""The driver's ``/svc/<name>/`` route to each app on its computer: a request sent on to the app's server with its body
+and its answer streamed, and a WebSocket relayed to it both ways. It needs the ``computer`` extra's ``websockets``, so
+only the driver imports it; an app's venv, with the ``app`` extra, imports ``apps`` and never this."""
+from __future__ import annotations
+
+import asyncio
+import contextlib
+import re
+from collections.abc import AsyncIterator, Iterable
+from pathlib import Path
+from typing import Any, Callable
+from urllib.parse import quote, unquote
+
+import httpx
+import websockets
+from starlette.background import BackgroundTask
+from starlette.requests import Request
+from starlette.responses import Response, StreamingResponse
+from starlette.routing import WebSocketRoute
+from starlette.websockets import WebSocket, WebSocketDisconnect
+from websockets.asyncio.client import ClientConnection, unix_connect
+
+from ..agent_env_environment import _error_response, control_check
+from .app import SOCKET
+from .errors import DeliveryFailed
+
+#: The methods the route forwards.
+METHODS = ["GET", "HEAD", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"]
+#: The headers that belong to one connection, which a proxy doesn't pass on.
+HOP_HEADERS = frozenset({"connection", "keep-alive", "proxy-authenticate", "proxy-authorization", "proxy-connection",
+                         "te", "trailer", "transfer-encoding", "upgrade"})
+#: The address a request reached the driver at, which the driver sets for the app in place of any the caller sent.
+FORWARDED = ("x-forwarded-host", "x-forwarded-proto", "x-forwarded-prefix")
+#: A WebSocket close code that means the connection ended without one, which a close can't send on.
+UNSENDABLE_CLOSES = (1005, 1006, 1015)
+#: A Host header that names a host, and its port or not, and nothing else.
+HOST = re.compile(r"(?:[A-Za-z0-9.-]+|\[[0-9A-Fa-f:.]+\])(?::[0-9]{1,5})?")
+#: What a path's segments may hold unescaped, besides letters, digits and ``_.-~``.
+PATH_SAFE = "/:@!$&'()*+,;="
+
+
+def passed_on(headers: Iterable[tuple[str, str]], *dropped: str) -> list[tuple[str, str]]:
+    """``headers`` as a proxy passes them on: without the hop-by-hop ones, those a ``Connection`` header names, and
+    ``dropped``."""
+    headers = list(headers)
+    named = {token.strip().lower() for name, value in headers if name.lower() == "connection"
+             for token in value.split(",")}
+    skipped = HOP_HEADERS | named | set(dropped)
+    return [(name, value) for name, value in headers if name.lower() not in skipped]
+
+
+def to_app(headers: Iterable[tuple[str, str]], host: str, scheme: str, prefix: str) -> list[tuple[str, str]]:
+    """A caller's headers as the app gets them: passed on without the control token's ``Authorization`` or any address
+    the caller forwarded, and with the one it reached the driver at, its ``host``, ``scheme`` and the app's
+    ``prefix``."""
+    return passed_on(headers, "authorization", *FORWARDED) + [
+        ("x-forwarded-host", host), ("x-forwarded-proto", scheme), ("x-forwarded-prefix", prefix)]
+
+
+def target(connection: Request | WebSocket) -> str:
+    """The path and query a request under ``/svc/<name>/`` asks its app for, as it came: still percent-encoded, so an
+    escaped ``?``, ``#`` or ``/`` stays one. The raw path's segments past any the driver is mounted under must be
+    ``svc`` and the app's name, else the routed path is escaped again."""
+    mounted = len([segment for segment in connection.scope.get("root_path", "").split("/") if segment])
+    parts = (connection.scope.get("raw_path") or b"").decode("latin-1").split("/")[1 + mounted:]
+    if len(parts) > 2 and [unquote(part) for part in parts[:2]] == ["svc", connection.path_params["name"]]:
+        tail = "/".join(parts[2:])
+    else:
+        tail = quote(connection.path_params["path"], safe=PATH_SAFE)
+    query = connection.scope.get("query_string", b"").decode("latin-1")
+    return f"/{tail}" + (f"?{query}" if query else "")
+
+
+def _bytes(headers: Iterable[tuple[str, str]]) -> list[tuple[bytes, bytes]]:
+    """Headers decoded as Latin-1, as Starlette and the helpers here hold them, as the bytes they came as."""
+    return [(name.encode("latin-1"), value.encode("latin-1")) for name, value in headers]
+
+
+def websocket_route(app: Any, path: str, endpoint: Callable) -> None:
+    """``endpoint`` served at ``path`` as a WebSocket route of ``app``, an mcp or a standalone fastmcp FastMCP, which
+    have no API for one."""
+    for routes in ("_custom_starlette_routes", "_additional_http_routes"):
+        if isinstance(getattr(app, routes, None), list):
+            getattr(app, routes).append(WebSocketRoute(path, endpoint))
+            return
+    raise TypeError(f"a driver's app takes WebSocket routes on an mcp or a fastmcp FastMCP, not a {type(app).__name__}")
+
+
+async def forward(folder: Path, name: str, request: Request) -> Response:
+    """``request`` sent on to the app ``name``'s server in ``folder`` with the caller's headers and none of the
+    client's own, its body and its answer streamed; it takes as long as the app does."""
+    headers = to_app(request.headers.items(), request.headers.get("host", ""), request.url.scheme, f"/svc/{name}")
+    has_body = request.headers.get("content-length", "0") != "0" or "transfer-encoding" in request.headers
+    http = httpx.AsyncClient(transport=httpx.AsyncHTTPTransport(uds=str(folder / SOCKET)), base_url="http://app",
+                             timeout=None)
+    http.headers.clear()
+    try:
+        answer = await http.send(http.build_request(request.method, target(request), headers=_bytes(headers),
+                                                    content=request.stream() if has_body else None), stream=True)
+    except (httpx.HTTPError, OSError) as e:
+        await http.aclose()
+        return _error_response(DeliveryFailed(f"app {name}'s server isn't answering: {type(e).__name__}: {e}"))
+    except BaseException:
+        await http.aclose()
+        raise
+
+    async def close() -> None:
+        await answer.aclose()
+        await http.aclose()
+
+    async def streamed() -> AsyncIterator[bytes]:
+        try:
+            async for chunk in answer.aiter_raw():
+                yield chunk
+        finally:
+            await close()
+
+    response = StreamingResponse(streamed(), status_code=answer.status_code, background=BackgroundTask(close))
+    response.raw_headers = _bytes(passed_on((name.decode("latin-1"), value.decode("latin-1"))
+                                            for name, value in answer.headers.raw))
+    return response
+
+
+async def relay(folder: Path, name: str, websocket: WebSocket) -> None:
+    """``websocket`` relayed both ways to the app ``name``'s server in ``folder`` until either side closes; refused,
+    before it opens, without the control token, with a Host that isn't a host and port, or with the app's server not
+    answering."""
+    host = websocket.headers.get("host", "")
+    if not control_check()(websocket.headers) or (host and not HOST.fullmatch(host)):
+        await websocket.close(code=1008)
+        return
+    headers = [(key, _utf8(value)) for key, value in to_app(
+        websocket.headers.items(), host, "https" if websocket.url.scheme == "wss" else "http", f"/svc/{name}")
+        if key.lower() != "host" and not key.lower().startswith("sec-websocket-")]
+    offered = [p.strip() for p in websocket.headers.get("sec-websocket-protocol", "").split(",") if p.strip()]
+    try:
+        upstream = await unix_connect(str(folder / SOCKET), f"ws://{host or 'app'}{target(websocket)}",
+                                      additional_headers=headers, subprotocols=offered or None, max_size=None,
+                                      compression=None, ping_interval=None, user_agent_header=None)
+    except (OSError, ValueError, asyncio.TimeoutError, websockets.WebSocketException):
+        await websocket.close(code=1011)
+        return
+    async with upstream:
+        await websocket.accept(subprotocol=upstream.subprotocol)
+        await _both_ways(websocket, upstream)
+
+
+def _utf8(value: str) -> str:
+    """A header value decoded as Latin-1 as the string ``websockets`` sends as the same bytes, which it encodes as
+    UTF-8; bytes that aren't UTF-8 become replacement characters."""
+    return value.encode("latin-1").decode("utf-8", "replace")
+
+
+async def _both_ways(client: WebSocket, app: ClientConnection) -> None:
+    """Each message from either side sent to the other until one side closes, then the other closed with its code."""
+    async def inbound() -> None:
+        while True:
+            message = await client.receive()
+            if message["type"] == "websocket.disconnect":
+                code = message.get("code") or 1000
+                await app.close(1000 if code in UNSENDABLE_CLOSES else code)
+                return
+            await app.send(message["text"] if message.get("text") is not None else message["bytes"])
+
+    async def outbound() -> None:
+        with contextlib.suppress(websockets.ConnectionClosed):
+            async for message in app:
+                if isinstance(message, str):
+                    await client.send_text(message)
+                else:
+                    await client.send_bytes(message)
+        code = app.close_code or 1000
+        with contextlib.suppress(RuntimeError, WebSocketDisconnect):
+            await client.close(1000 if code in UNSENDABLE_CLOSES else code)
+
+    tasks = [asyncio.ensure_future(inbound()), asyncio.ensure_future(outbound())]
+    try:
+        await asyncio.wait(tasks, return_when=asyncio.FIRST_COMPLETED)
+    finally:
+        for task in tasks:
+            task.cancel()
+        await asyncio.gather(*tasks, return_exceptions=True)

{agentenv_framework_protocol-0.1.448 → agentenv_framework_protocol-0.1.451}/src/agentenv_protocol/website_browser.py

@@ -430,7 +430,10 @@ class BrowserControl:
         return {**({"png": png} if png is not None else {"blank": True}), "page": self._state_of(target)}
 
     async def _capture(self, session: str) -> Optional[str]:
+        """The tab's page as it shows now; with a dialog open on it, which keeps it from painting, the last it took."""
         target = self._sessions[session]
+        if session in self._open_dialogs:
+            return self._shots.get(target)
         navigated = self.tabs.get(target, {}).get("url")
         try:
             shot = await self.devtools.call("Page.captureScreenshot", {"format": "png", "optimizeForSpeed": True},

{agentenv_framework_protocol-0.1.448 → agentenv_framework_protocol-0.1.451}/tests/test_computer_conformance.py

@@ -4,8 +4,10 @@ full needs gets those checks unverified; a driver broken one way fails the check
 fronts that exports is asked for its export once; the report's verdicts and the CLI."""
 from __future__ import annotations
 
+import importlib
 import json
-from types import SimpleNamespace
+import sys
+from types import ModuleType, SimpleNamespace
 
 import pytest
 
@@ -284,6 +286,29 @@ async def test_a_fixture_that_doesnt_start_leaves_full_unverified_and_is_cleaned
     assert (["kill", "4243"] in probed.commands) is (driver is SilentFixture)
 
 
+@pytest.mark.parametrize("delta, steps", [(1, 1), (-3, -3), (120, 1), (-360, -3), (240, 2)],
+                         ids=["aqua-up", "aqua-down-3", "scaled-up", "scaled-down-3", "scaled-up-2"])
+def test_the_fixture_counts_a_wheel_events_steps_whether_tk_scales_them_by_120_or_not(delta, steps, monkeypatch):
+    """Aqua's Tk 8.6 reports a step as a delta of 1; Windows, and Tk 9 everywhere, as 120."""
+    assert _fixture(monkeypatch).wheel_steps(delta) == steps
+
+
+@pytest.mark.parametrize("delta, steps", [(10, (False, 1)), (65526, (False, -1)), (65516, (False, -2)),
+                                          (655360, (True, 1)), (-655360, (True, -1)), (0, None)],
+                         ids=["up", "down", "down-2-coalesced", "left", "right", "still"])
+def test_the_fixture_counts_a_scroll_tk_9_reports_in_pixels_by_the_lines_it_moves(delta, steps, monkeypatch):
+    """The deltas Tk 9 on macOS gave cua-driver's scrolls: 10 pixels a line, two lines at once where macOS coalesced
+    them."""
+    assert _fixture(monkeypatch).touchpad_steps(delta) == steps
+
+
+def _fixture(monkeypatch):
+    """The fixture module, which runs in the computer, read with Tk stood in for, as this Python may have none."""
+    monkeypatch.setitem(sys.modules, "tkinter", ModuleType("tkinter"))
+    monkeypatch.delitem(sys.modules, "agentenv_protocol.computer.conformance.fixture", raising=False)
+    return importlib.import_module("agentenv_protocol.computer.conformance.fixture")
+
+
 def test_a_refusal_must_carry_the_code_and_applied_no():
     def result(error: bool, **data) -> CallToolResult:
         return CallToolResult(content=[TextContent(type="text", text="x")], structuredContent=data, isError=error)