agentenv-framework 0.9.1502__tar.gz → 0.9.1506__tar.gz

{agentenv_framework-0.9.1502 → agentenv_framework-0.9.1506}/.github/scripts/infra_build.py

@@ -57,7 +57,7 @@ IMAGES = {
     "agentenv-pydantic-ai": "src/agent_env/agents/agents/pydantic-ai/Dockerfile",
     "agentenv-mail-mcp": "src/agent_env/examples/mail-mcp/envs/mail/Dockerfile",
     "agentenv-ubuntu-24.04": "src/agent_env/computers/artifacts/ubuntu-24.04/Dockerfile",
-    "agentenv-ubuntu-24.04-headless": "src/agent_env/computers/artifacts/ubuntu-24.04-headless/Dockerfile",
+    "agentenv-ubuntu-24.04-browser": "src/agent_env/computers/artifacts/ubuntu-24.04-browser/Dockerfile",
     "agentenv-disk-tools": "src/agent_env/computers/disk/linux/tools/Dockerfile",
     "agentenv-qemu-launcher": "src/agent_env/computers/disk/linux/launcher/Dockerfile",
     "agentenv-ubuntu-24.04-disk": "src/agent_env/computers/disk/linux/boot/Dockerfile",
@@ -125,7 +125,7 @@ _SMOKES = {
                               " s=$(supervisorctl -c /etc/supervisor/supervisord.conf status);"
                               " echo \"$s\" | grep -q ' RUNNING ' && ! echo \"$s\" | grep -qv ' RUNNING ' && exit 0;"
                               " done; supervisorctl -c /etc/supervisor/supervisord.conf status; exit 1"],
-    "agentenv-ubuntu-24.04-headless": [
+    "agentenv-ubuntu-24.04-browser": [
         "docker", "run", "--rm", "--entrypoint", "sh", "{image}", "-c",
         "start-computer & for _ in $(seq 60); do sleep 1;"
         " s=$(supervisorctl -c /etc/supervisor/supervisord.conf status);"

{agentenv_framework-0.9.1502 → agentenv_framework-0.9.1506}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: agentenv-framework
-Version: 0.9.1502
+Version: 0.9.1506
 Summary: SDK and CLI for building, deploying and running agent environments and the tasks that grade agents in them.
 Project-URL: Homepage, https://www.agentenvframework.com
 Project-URL: Documentation, https://www.agentenvframework.com/docs
@@ -29,7 +29,7 @@ Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
 Classifier: Typing :: Typed
 Requires-Python: >=3.11.4
 Requires-Dist: a2a-sdk==0.3.26
-Requires-Dist: agentenv-framework-protocol[computer]==0.1.517
+Requires-Dist: agentenv-framework-protocol[computer]==0.1.521
 Requires-Dist: certifi>=2024.2.2
 Requires-Dist: click>=8.0.0
 Requires-Dist: cryptography>=42
@@ -39,7 +39,7 @@ Requires-Dist: httpx>=0.27.0
 Requires-Dist: huggingface-hub>=1.0
 Requires-Dist: idna>=3.0
 Requires-Dist: jsonschema>=4.20
-Requires-Dist: litellm<1.97,>=1.96.0
+Requires-Dist: litellm<1.107,>=1.104.0
 Requires-Dist: mcp<2,>=1.25
 Requires-Dist: modal>=1.6.3
 Requires-Dist: packaging>=22
@@ -92,6 +92,7 @@ Requires-Dist: pytest-socket>=0.7.0; extra == 'dev'
 Requires-Dist: pytest-timeout>=2.3.0; extra == 'dev'
 Requires-Dist: pytest-xdist>=3.0.0; extra == 'dev'
 Requires-Dist: pytest>=9.0; extra == 'dev'
+Requires-Dist: regex>=2023.12.25; extra == 'dev'
 Requires-Dist: requests>=2.31; extra == 'dev'
 Requires-Dist: ruff==0.16.10; extra == 'dev'
 Requires-Dist: sail~=0.12.8; extra == 'dev'

{agentenv_framework-0.9.1502 → agentenv_framework-0.9.1506}/packages/agentenv-protocol/pyproject.toml

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

{agentenv_framework-0.9.1502 → agentenv_framework-0.9.1506}/packages/agentenv-protocol/src/agentenv_protocol/browser_cdp.py

@@ -59,11 +59,13 @@ GUARDED = {"refuse": "refused", "send": "changed", "answer": "answered", "close"
 
 @dataclass
 class Address:
-    """A user's CDP address: ``http_url``, the base clients discover from, and ``ws_url``, the browser's WebSocket."""
+    """A user's CDP address: ``http_url``, the base clients discover from, and ``ws_url``, the browser's WebSocket;
+    ``named`` when it's under an origin the caller named, where its agent reaches the env."""
 
     user: str
     http_url: str
     ws_url: str
+    named: bool = False
 
 
 def reached(request: Request) -> str:
@@ -74,6 +76,12 @@ def reached(request: Request) -> str:
     return f"{proto}://{host}{request.headers.get('x-forwarded-prefix', '')}".rstrip("/")
 
 
+def under(origin: str, request: Request) -> str:
+    """The address a request reached the browser at, under ``origin``, where the caller's agent reaches the env: the
+    origin, then the path prefix the driver forwarded."""
+    return f"{origin.rstrip('/')}{request.headers.get('x-forwarded-prefix', '')}".rstrip("/")
+
+
 def websocket_form(url: str) -> str:
     return "wss://" + url.removeprefix("https://") if url.startswith("https://") else \
         "ws://" + url.removeprefix("http://")
@@ -83,31 +91,33 @@ def _hash(token: str) -> str:
     return hashlib.sha256(token.encode()).hexdigest()
 
 
-def _address(user: str, base: str, token: str) -> Address:
+def _address(user: str, base: str, named: bool, token: str) -> Address:
     root = f"{base}{ROUTE}{token}"
-    return Address(user, f"{root}/", f"{websocket_form(root)}/devtools/browser")
+    return Address(user, f"{root}/", f"{websocket_form(root)}/devtools/browser", named)
 
 
 class Tokens:
     """The tokens minted, one per user: in memory, so asking twice gives the same address, and in ``path`` only by
-    hash, with the user and the base address, so an address still works after the server restarts while the
-    computer's session, which can read the file, can't use one."""
+    hash, with the user, the base address and whether its caller named it, so an address still works after the server
+    restarts while the computer's session, which can read the file, can't use one."""
 
     def __init__(self, path: Path) -> None:
         self.path = path
         self._minted: dict[str, Address] = {}
         try:
             stored = json.loads(path.read_text())
-            self._known = {digest: (entry["user"], entry["base"]) for digest, entry in stored.items()}
+            self._known = {digest: (entry["user"], entry["base"], entry["named"])
+                           for digest, entry in stored.items()}
         except (OSError, ValueError, TypeError, KeyError):
             self._known = {}
 
-    def mint(self, user: str, base: str) -> Address:
-        """``user``'s address under ``base``: the one minted before, else a new one."""
+    def mint(self, user: str, base: str, *, named: bool = False) -> Address:
+        """``user``'s address under ``base``, ``named`` when its caller named where its agent reaches the env: the one
+        minted before, else a new one."""
         if user not in self._minted:
             token = secrets.token_urlsafe(TOKEN_BYTES)
-            self._minted[user] = _address(user, base, token)
-            self._known[_hash(token)] = (user, base)
+            self._minted[user] = _address(user, base, named, token)
+            self._known[_hash(token)] = (user, base, named)
             self._save()
         return self._minted[user]
 
@@ -124,8 +134,8 @@ class Tokens:
     def _save(self) -> None:
         self.path.parent.mkdir(parents=True, exist_ok=True)
         part = self.path.with_name(f".{self.path.name}.part")
-        part.write_text(json.dumps({digest: {"user": user, "base": base}
-                                    for digest, (user, base) in self._known.items()}))
+        part.write_text(json.dumps({digest: {"user": user, "base": base, "named": named}
+                                    for digest, (user, base, named) in self._known.items()}))
         os.replace(part, self.path)
 
 

{agentenv_framework-0.9.1502 → agentenv_framework-0.9.1506}/packages/agentenv-protocol/src/agentenv_protocol/website_browser/__init__.py

@@ -2,9 +2,9 @@
 its build installs and starts; this class adds what agentenv owns, the same in both: its flags after the subclass's
 command, the unattended-use policies, a CDP connection over the browser's debugging pipe, the settings every browser
 takes, a fresh cache and the deploy's prompt answers at every launch, another window for a launch while it runs, its
-skill and ``browser/v1`` on its card. It runs alone, headless, on a computer with no display, a browser computer's,
-whose screen is its page; which site proxy it goes through comes from a variable agentenv sets, never from its
-settings."""
+skill and ``browser/v1`` on its card. It runs alone on a computer with no display, a browser computer's, whose screen
+is its page, headful on an X server that computer gives it alone, else headless; which site proxy it goes through comes
+from a variable agentenv sets, never from its settings."""
 from .control import (ACTIVE_CHECK_TIMEOUT_S, AGENT, AGENTENV, CAPTURE_TIMEOUT_S, DOWNLOADS, EXIT, FAILED,
                       HASH_CHUNK_BYTES, LIVE_START_TAB_TIMEOUT_S, LOADED, PAGE_INPUT, PAGES, PIN_TIMEOUT_S, STOP,
                       TIMED_OUT, UNKNOWN, UNNAVIGATED_CAPTURE_TIMEOUT_S, UPLOADS, BrowserControl)

{agentenv_framework-0.9.1502 → agentenv_framework-0.9.1506}/packages/agentenv-protocol/src/agentenv_protocol/website_browser/control.py

@@ -26,7 +26,7 @@ logger = logging.getLogger(__name__)
 AGENTENV, UNKNOWN, EXIT, STOP = "agentenv", "unknown", "exit", "stop"
 #: How long the active tab's check waits on each page.
 ACTIVE_CHECK_TIMEOUT_S = 2.0
-#: How long a tab opened headless may take to be attached and held to its window's size, which is also how long a page
+#: How long a tab opened alone may take to be attached and held to its window's size, which is also how long a page
 #: of agentenv's own may take to reach an origin, and how often it's asked meanwhile.
 PIN_TIMEOUT_S = 10.0
 ARRIVAL_POLL_S = 0.05
@@ -75,7 +75,7 @@ class BrowserControl:
         self._closing: set[str] = set()
         self._open_dialogs: dict[str, dict] = {}
         self._answering: set[str] = set()
-        #: The file chooser each page's session opened that waits, headless, and the tab agentenv last brought to the
+        #: The file chooser each page's session opened that waits, alone, and the tab agentenv last brought to the
         #: front.
         self._choosers: dict[str, dict] = {}
         self._front: Optional[str] = None
@@ -132,7 +132,7 @@ class BrowserControl:
 
     async def open_tab(self, url: Optional[str] = None, background: bool = False) -> str:
         """A new tab at ``url``, else blank, brought to the front, or with ``background`` behind the active tab, which
-        stays active, brought back only if the new tab took its place; its id. Headless, it opens blank and goes to
+        stays active, brought back only if the new tab took its place; its id. Alone, it opens blank and goes to
         ``url`` once it's held to the window's size, so its page loads at that size."""
         active = await self.active_tab() if background else None
         held = self.viewport is not None and url
@@ -151,7 +151,7 @@ class BrowserControl:
     async def load_start_tabs(self, urls: list[str], site_of: Callable[[str], Optional[str]], own_timeout_s: float,
                               live_timeout_s: float = LIVE_START_TAB_TIMEOUT_S) -> list[dict]:
         """Each of ``urls`` in a start tab, in order, the first then active: in the tabs open now, in opened order, and
-        in tabs it opens blank after them; each held to the window's size, headless, before it goes to its URL, and
+        in tabs it opens blank after them; each held to the window's size, alone, before it goes to its URL, and
         all loading at once. A tab settles once it has loaded, once it has failed, which on one of the env's own sites,
         as ``site_of`` names them, an error status is too, or once it has been waited on ``own_timeout_s`` on such a
         site, else ``live_timeout_s``. Each tab's outcome, in order, kept though the browser has gone and the first
@@ -635,8 +635,8 @@ class BrowserControl:
             self._spawn(self._let_run(params["sessionId"]))
 
     async def _let_run(self, session: str) -> None:
-        """A page it attached to, enabled and, headless, held to its window's size, then told to run: a page attached as
-        it opens, a popup say, or any new page headless, waits for that before it runs."""
+        """A page it attached to, enabled and, alone, held to its window's size, then told to run: a page attached as
+        it opens, a popup say, or any new page alone, waits for that before it runs."""
         target = self._sessions.get(session)
         try:
             await self.devtools.call("Page.enable", session_id=session)

{agentenv_framework-0.9.1502 → agentenv_framework-0.9.1506}/packages/agentenv-protocol/src/agentenv_protocol/website_browser/environment.py

@@ -18,7 +18,7 @@ from starlette.websockets import WebSocket
 
 from ..agent_env_environment import (OP_ADD_DATA, add_data, add_websocket_route, agent_skill, extension, get_data,
                                      reset_data)
-from ..browser_cdp import ROUTE, Relay, Tokens, reached, websocket_form
+from ..browser_cdp import ROUTE, Relay, Tokens, reached, under, websocket_form
 from ..computer import AppDeclaration, ComputerAppEnvironment, Launch, install_step, ready_check
 from ..computer import app as computer_app
 from ..computer import app_data
@@ -42,7 +42,7 @@ SITES = SOCKET.parent / "sites.json"
 #: port, since the browser is reached only over its pipe.
 OWNED_FLAGS = ("--user-data-dir", "--remote-debugging-", "--remote-allow-origins", "--proxy-", "--no-proxy-server",
                "--headless", "--window-size", "--lang", "--force-webrtc-ip-handling-policy", "--disk-cache-dir",
-               "--disable-dev-shm-usage")
+               "--disable-dev-shm-usage", "--enable-unsafe-swiftshader")
 #: Below this much /dev/shm, as Docker's 64 MiB default, the browser keeps its shared memory in files instead.
 SHM_MIN_BYTES = 1 << 30
 #: Chromium's content setting that denies a permission without a prompt.
@@ -163,7 +163,8 @@ class WebsiteBrowserEnvironment(ComputerAppEnvironment):
 
     def agentenv_flags(self) -> list[str]:
         """The flags agentenv owns. A browser alone goes out only through its site proxy, so it won't launch without
-        one; in a computer it goes through one when the computer has one, loopback aside."""
+        one; in a computer it goes through one when the computer has one, loopback aside. Alone it runs headful on the
+        X server its computer gives it, where WebGL draws with SwiftShader since no GPU is there, else headless."""
         settings, alone, proxy = self.settings, _alone(), os.environ.get(SITE_PROXY_ENV)
         flags = [f"--user-data-dir={self.profile_dir()}", f"--disk-cache-dir={self.cache_dir()}",
                  "--remote-debugging-pipe", "--no-first-run", "--no-default-browser-check", f"--lang={settings.locale}"]
@@ -179,8 +180,7 @@ class WebsiteBrowserEnvironment(ComputerAppEnvironment):
                              "names none")
         if alone:
             flags.append(f"--window-size={settings.window.width},{settings.window.height}")
-        if alone:
-            flags.append("--headless=new")
+            flags.append("--enable-unsafe-swiftshader" if _x_server() else "--headless=new")
         return flags
 
     def _launch_for(self, launch: Launch) -> Launch:
@@ -304,12 +304,13 @@ class WebsiteBrowserEnvironment(ComputerAppEnvironment):
         "is its window's, a PNG of it, and CDP input calls sent to it in order. navigate and history open a URL in "
         "the active tab, or go back, forward or reload; tabs/list, tabs/open, tabs/activate and tabs/close manage "
         "its tabs by their ids; dialog/answer answers the dialog open on the active tab; files/choose gives the file "
-        "chooser open on it files in ~/Uploads, headless; and page/state is the active tab's id, URL and title and "
+        "chooser open on it files in ~/Uploads, alone; and page/state is the active tab's id, URL and title and "
         "what is open on it. cookies/get, cookies/set and cookies/delete, and local_storage/get, local_storage/set and "
         "local_storage/clear, read and change its default context's cookies and local storage as Playwright's "
         "storageState has them, a cookie's max_age set as an expiry on the browser's clock; downloads/list and "
         "downloads/get are its downloads, get with its file, uploaded under a write_namespace grant or inline. cdp "
-        "returns a user's CDP address, http_url to discover from and ws_url to connect to, "
+        "returns a user's CDP address, http_url to discover from and ws_url to connect to, under origin, where the "
+        "caller's agent reaches the env, when it names one, else at the address the call reached the browser at, "
         "with a token agentenv mints in its path: each connection to it gets its own browser-level session behind a "
         "guard, and record lists them as cdp_connections, each with the commands the guard refused or changed. "
         "sites/set hands it the env's own sites, by name and domains: a start tab on one must load, its document's "
@@ -333,11 +334,14 @@ class WebsiteBrowserEnvironment(ComputerAppEnvironment):
         return {}
 
     @extension(BROWSER, op="cdp")
-    async def browser_cdp(self, user: str, request: Request) -> dict:
-        """``user``'s CDP address at the address this call reached the browser at, once it's ready: the same one each
-        time it's asked for, as the server that minted it keeps it."""
+    async def browser_cdp(self, user: str, request: Request, origin: Optional[str] = None) -> dict:
+        """``user``'s CDP address once the browser's ready, the same one each time it's asked for, as the server that
+        minted it keeps it: under ``origin``, where the caller's agent reaches the env, when the caller names it, as a
+        deploy names the env's other addresses, since a tunnel in front of the env may not say how it was reached;
+        else at the address this call reached the browser at."""
+        base = under(_origin(origin), request) if origin is not None else reached(request)
         await self._until_ready()
-        address = self.cdp_tokens.mint(user, reached(request))
+        address = self.cdp_tokens.mint(user, base, named=origin is not None)
         return {"http_url": address.http_url, "ws_url": address.ws_url}
 
     def create_app(self) -> Any:
@@ -349,11 +353,11 @@ class WebsiteBrowserEnvironment(ComputerAppEnvironment):
         return app
 
     async def _cdp_discovery(self, request: Request) -> Response:
-        """``json/version`` and ``json/list`` under a CDP address, answered from the browser, with its WebSocket at the
-        address the client reached: a browser on a pipe has no endpoints of its own. 403 for a token agentenv didn't
-        mint."""
+        """``json/version`` and ``json/list`` under a CDP address, answered from the browser, with its WebSocket as
+        minted when its caller named the origin, else at the address the client reached: a browser on a pipe has no
+        endpoints of its own. 403 for a token agentenv didn't mint."""
         token = request.path_params["token"]
-        if self.cdp_tokens.address(token) is None:
+        if (address := self.cdp_tokens.address(token)) is None:
             return JSONResponse({"error": "agentenv didn't mint this CDP address"}, status_code=403)
         try:
             version = await self.devtools.call("Browser.getVersion")
@@ -362,7 +366,8 @@ class WebsiteBrowserEnvironment(ComputerAppEnvironment):
                     "Browser": version.get("product"), "Protocol-Version": version.get("protocolVersion"),
                     "User-Agent": version.get("userAgent"), "V8-Version": version.get("jsVersion"),
                     "WebKit-Version": version.get("revision"),
-                    "webSocketDebuggerUrl": f"{websocket_form(reached(request))}{ROUTE}{token}/devtools/browser"})
+                    "webSocketDebuggerUrl": address.ws_url if address.named else
+                    f"{websocket_form(reached(request))}{ROUTE}{token}/devtools/browser"})
             tabs = await self.control.tab_list()
         except (ConnectionError, DevToolsError, asyncio.TimeoutError) as e:
             return JSONResponse({"error": f"the browser isn't answering: {e}"}, status_code=503)
@@ -600,7 +605,7 @@ class WebsiteBrowserEnvironment(ComputerAppEnvironment):
 
     def extension_params(self, uri: str) -> dict:
         if uri == BROWSER:
-            params: dict[str, Any] = {"chromium": self.version, "clock": "real"}
+            params: dict[str, Any] = {"chromium": self.version, "clock": "real", "mode": _mode()}
             if _alone():
                 params["window"] = self.settings.window.model_dump()
             return params
@@ -650,10 +655,36 @@ def start_tab_why(tab: dict) -> str:
 
 
 def _alone() -> bool:
-    """Whether it runs on a computer with no display, a browser computer's, alone and headless."""
+    """Whether it runs on a computer with no display, a browser computer's, alone: its page is that computer's screen."""
     return computer_app.detect().display == "none"
 
 
+def _x_server() -> bool:
+    """Whether an X server is there for it, as a browser computer gives its browser one no agent sees."""
+    return bool(os.environ.get("DISPLAY"))
+
+
+def _mode() -> str:
+    """How it runs: headless alone with no X server, else headful, on its own X server alone or on the desktop."""
+    return "headless" if _alone() and not _x_server() else "headful"
+
+
+def _origin(value: Any) -> str:
+    """``value`` as an origin a CDP address is minted under, its scheme in lower case as the address's WebSocket form
+    reads it: an http or https URL, a path allowed, with no query, fragment or credentials; InvalidArgument for anything
+    else."""
+    try:
+        parts = urlsplit(value)
+        valid = (value.isprintable() and parts.scheme in ("http", "https") and bool(parts.hostname)
+                 and "@" not in parts.netloc and not parts.query and not parts.fragment
+                 and (parts.port is None or 0 < parts.port))
+    except (AttributeError, TypeError, ValueError):
+        valid = False
+    if not valid:
+        raise InvalidArgument("origin is an http or https URL with no query, fragment or credentials")
+    return f"{parts.scheme}://{parts.netloc}{parts.path}"
+
+
 def _parsed(model: type[BaseModel], items: Any, what: str) -> list:
     """Each of ``items`` as ``model``; InvalidArgument naming the fields that don't fit and never their values, which
     for a cookie are its credentials."""

{agentenv_framework-0.9.1502 → agentenv_framework-0.9.1506}/packages/agentenv-protocol/tests/test_browser_cdp.py

@@ -1,7 +1,8 @@
 """A website browser's CDP addresses: a user's token minted once, kept by hash only, so it still works after the server
 restarts and the computer's session can't use the file; the relay giving each WebSocket connection its own
 browser-level session over one pipe, its answers and events and nobody else's, until the browser goes; the guard on
-each command; and the cdp operation and discovery answered at the address the call reached."""
+each command; and the cdp operation and discovery answered at the address the call reached, or under the origin its
+caller names, which behind a tunnel that ends TLS is the only way to an https address."""
 from __future__ import annotations
 
 import asyncio
@@ -30,6 +31,8 @@ from agentenv_protocol.website_browser import SITE_PROXY_ENV, WebsiteBrowserEnvi
 
 FORWARDED = {"x-forwarded-host": "computer.test:443", "x-forwarded-proto": "https",
              "x-forwarded-prefix": "/svc/chromium"}
+#: What the driver forwards behind a tunnel that ends TLS: the tunnel's host, and http, how the tunnel reached it.
+BEHIND_TLS = {"x-forwarded-host": "t.tunnel.test", "x-forwarded-proto": "http", "x-forwarded-prefix": "/svc/chromium"}
 
 
 @computer_app(supports=[{"os": {"type": "linux", "display": ["x11", "none"]}, "arch": ["amd64"]}])
@@ -138,13 +141,15 @@ def test_a_users_token_is_minted_once_kept_by_hash_and_still_known_after_a_resta
     tokens = Tokens(path)
     ada = tokens.mint("ada", "https://computer.test/svc/chromium")
     again, bob = tokens.mint("ada", "https://elsewhere.test"), tokens.mint("bob", "https://computer.test/svc/chromium")
-    token = ada.http_url.split("/cdp/")[1].strip("/")
+    cy = tokens.mint("cy", "https://t.tunnel.test/svc/chromium", named=True)
+    token, cys = (address.http_url.split("/cdp/")[1].strip("/") for address in (ada, cy))
     restarted = Tokens(path)
 
     assert again == ada and bob != ada and ada.http_url == f"https://computer.test/svc/chromium/cdp/{token}/"
     assert ada.ws_url == f"wss://computer.test/svc/chromium/cdp/{token}/devtools/browser"
     assert token not in path.read_text() and restarted.address(token) == ada and tokens.address("guess") is None
     assert restarted.mint("ada", "https://computer.test").http_url != ada.http_url
+    assert not ada.named and restarted.address(cys) == cy and cy.named
 
 
 @pytest.mark.asyncio
@@ -349,4 +354,52 @@ async def test_the_cdp_operation_and_discovery_answer_at_the_address_reached_and
     browser_methods = next(e["params"]["methods"] for e in card["capabilities"]["extensions"]
                            if e["uri"] == "urn:agentenv:browser/v1")
     assert computer_app_params["agent_routes"] == ["/cdp/"]
-    assert browser_methods["cdp"]["request"]["properties"] == {"user": {"type": "string"}}
+    assert browser_methods["cdp"]["request"]["properties"] == {"user": {"type": "string"},
+                                                               "origin": {"type": "string", "default": None}}
+
+
+@pytest.mark.asyncio
+async def test_under_an_origin_its_caller_names_an_address_is_https_and_discovery_answers_wss_though_reached_over_http(
+        monkeypatch, tmp_path):
+    browser = _browser(monkeypatch, tmp_path)
+
+    async def ready():
+        return None
+
+    async def call(method, params=None, *, session_id=None, timeout_s=None):
+        return {"product": "Chrome/156.0.8078.4", "protocolVersion": "1.3"}
+
+    monkeypatch.setattr(browser, "_until_ready", ready)
+    monkeypatch.setattr(browser.devtools, "call", call)
+    asgi = browser.create_app().streamable_http_app()
+    async with httpx.AsyncClient(transport=httpx.ASGITransport(app=asgi), base_url="http://app") as http:
+        ada = (await http.post("/agentenv/ext/browser/cdp", json={"user": "ada", "origin": "https://t.tunnel.test/"},
+                               headers=BEHIND_TLS)).json()
+        bob = (await http.post("/agentenv/ext/browser/cdp", json={"user": "bob"}, headers=BEHIND_TLS)).json()
+        cy = (await http.post("/agentenv/ext/browser/cdp", json={"user": "cy", "origin": "HTTPS://t.tunnel.test"},
+                              headers=BEHIND_TLS)).json()
+        paths = [address["http_url"].split("/svc/chromium", 1)[1] for address in (ada, bob)]
+        seen = [(await http.get(f"{path}json/version", headers=BEHIND_TLS)).json()["webSocketDebuggerUrl"]
+                for path in paths]
+
+    token = ada["http_url"].split("/cdp/")[1].strip("/")
+    assert ada == {"http_url": f"https://t.tunnel.test/svc/chromium/cdp/{token}/",
+                   "ws_url": f"wss://t.tunnel.test/svc/chromium/cdp/{token}/devtools/browser"}
+    assert seen[0] == ada["ws_url"]
+    assert bob["ws_url"].startswith("ws://t.tunnel.test/") and seen[1] == bob["ws_url"]
+    assert cy["http_url"].startswith("https://t.tunnel.test/svc/chromium/cdp/")
+    assert cy["ws_url"].startswith("wss://t.tunnel.test/svc/chromium/cdp/")
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("origin", ["ftp://t.test", "t.test", "https://", "https://t.test/?q=1", "https://t.test/#top",
+                                    "https://ada:pw@t.test", "https://t.test:0", "https://t.test:99999",
+                                    "https://t.test/\n", 7])
+async def test_an_origin_that_isnt_an_http_or_https_url_is_refused_and_mints_nothing(monkeypatch, tmp_path, origin):
+    browser = _browser(monkeypatch, tmp_path)
+    asgi = browser.create_app().streamable_http_app()
+    async with httpx.AsyncClient(transport=httpx.ASGITransport(app=asgi), base_url="http://app") as http:
+        answer = await http.post("/agentenv/ext/browser/cdp", json={"user": "ada", "origin": origin})
+
+    assert answer.status_code == 400 and "origin is an http or https URL" in answer.text, answer.text
+    assert not browser.cdp_tokens.path.exists()

{agentenv_framework-0.9.1502 → agentenv_framework-0.9.1506}/packages/agentenv-protocol/tests/test_website_browser.py

@@ -1,5 +1,5 @@
-"""WebsiteBrowserEnvironment: agentenv's flags after a subclass's command, in a computer and alone, and the proxy rule
-for each; a subclass refused for carrying one of them; the start tabs, the time zone and the window from its settings;
+"""WebsiteBrowserEnvironment: agentenv's flags after a subclass's command, in a computer and alone, headful on an X
+server alone or headless with none, and the proxy rule for each; a subclass refused for carrying one of them; the start tabs, the time zone and the window from its settings;
 its launch run with no desktop when alone; a CDP connection over a new debugging pipe at each launch, which its ready
 check asks, and a browser launched again when its server restarts; its shared memory in files only on a small
 /dev/shm; an empty cache and the deploy's prompt answers in its profile at each launch; its policies, card params and
@@ -121,9 +121,13 @@ def _settings(monkeypatch, **values) -> None:
     monkeypatch.setenv(APP_SETTINGS_ENV, json.dumps({"chromium": values}))
 
 
-def _alone(monkeypatch) -> None:
-    """On a computer with no display, a browser computer's."""
+def _alone(monkeypatch, x_server: bool = False) -> None:
+    """On a computer with no display, a browser computer's, with an X server only the browser uses or none."""
     monkeypatch.setattr(app, "detect", lambda: Platform(os="linux", display="none"))
+    if x_server:
+        monkeypatch.setenv("DISPLAY", ":99")
+    else:
+        monkeypatch.delenv("DISPLAY", raising=False)
 
 
 def test_in_a_computer_its_flags_follow_its_command_then_its_start_tabs_and_its_window_is_waited_for(browser_home):
@@ -161,6 +165,21 @@ def test_alone_it_goes_through_its_proxy_headless_at_its_window_and_its_launch_w
     assert browser._computer_app.desktop is False and browser._computer_app.timeout_s == 30
 
 
+def test_alone_on_an_x_server_it_runs_headful_at_its_window_with_webgl_and_its_launch_waits_on_no_window(monkeypatch):
+    _alone(monkeypatch, x_server=True)
+    monkeypatch.setenv(SITE_PROXY_ENV, PROXY)
+    _settings(monkeypatch, window={"width": 1024, "height": 768})
+
+    browser = Browser()
+    launch = browser.launch
+
+    assert f"--proxy-bypass-list={ALONE_BYPASS}" in launch.command
+    assert launch.command[-3:] == ["--window-size=1024,768", "--enable-unsafe-swiftshader", "about:blank"]
+    assert not any(flag.startswith("--headless") for flag in launch.command)
+    assert launch.window is None and launch.ready is None
+    assert browser._computer_app.desktop is False
+
+
 def test_alone_its_launch_keeps_the_port_and_command_it_waits_on_and_their_timeout(monkeypatch):
     @linux(launch=Launch(command=["chromium/chrome"], window={"class": "Chromium"},
                          ready=Ready(window=True, port=9000, command=["true"], timeout_s=45)))
@@ -186,7 +205,8 @@ def test_alone_it_refuses_to_launch_without_a_site_proxy(monkeypatch):
 
 @pytest.mark.parametrize("flag", ["--remote-debugging-port=9222", "--remote-allow-origins=*", "--headless",
                                   "--proxy-server=http://elsewhere:3128", "--user-data-dir=/tmp/profile",
-                                  "--disk-cache-dir=/tmp/cache", "--disable-dev-shm-usage"])
+                                  "--disk-cache-dir=/tmp/cache", "--disable-dev-shm-usage",
+                                  "--enable-unsafe-swiftshader"])
 def test_a_subclass_whose_command_carries_a_flag_agentenv_owns_is_refused_when_declared(flag):
     @linux(launch=Launch(command=["chromium/chrome", flag]))
     class Widened(WebsiteBrowserEnvironment):
@@ -434,14 +454,18 @@ def test_its_policies_are_agentenvs_with_its_own_over_them_where_its_build_reads
     assert [step.name for step in Browser.declaration().install_steps] == ["write_policies"]
 
 
-def test_its_card_declares_browser_v1_with_its_build_and_clock_and_alone_its_window(monkeypatch):
+def test_its_card_declares_browser_v1_with_its_build_clock_and_mode_and_alone_its_window(monkeypatch):
     in_computer = Browser().extension_params(BROWSER)
-    _alone(monkeypatch)
     monkeypatch.setenv(SITE_PROXY_ENV, PROXY)
-    alone = Browser().extension_params(BROWSER)
-
-    assert in_computer == {"chromium": "156.0.8078.4", "clock": "real"}
-    assert alone == {"chromium": "156.0.8078.4", "clock": "real", "window": {"width": 1280, "height": 800}}
+    _alone(monkeypatch)
+    headless = Browser().extension_params(BROWSER)
+    _alone(monkeypatch, x_server=True)
+    headful = Browser().extension_params(BROWSER)
+
+    window = {"width": 1280, "height": 800}
+    assert in_computer == {"chromium": "156.0.8078.4", "clock": "real", "mode": "headful"}
+    assert headless == {"chromium": "156.0.8078.4", "clock": "real", "mode": "headless", "window": window}
+    assert headful == {"chromium": "156.0.8078.4", "clock": "real", "mode": "headful", "window": window}
 
 
 @pytest.mark.asyncio

{agentenv_framework-0.9.1502 → agentenv_framework-0.9.1506}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "agentenv-framework"
-version = "0.9.1502"
+version = "0.9.1506"
 description = "SDK and CLI for building, deploying and running agent environments and the tasks that grade agents in them."
 readme = "README.md"
 license = "Apache-2.0"
@@ -29,7 +29,7 @@ classifiers = [
     "Typing :: Typed",
 ]
 dependencies = [
-    "agentenv-framework-protocol[computer]==0.1.517",  # a computer_driver env's put reads the driver class with it
+    "agentenv-framework-protocol[computer]==0.1.521",  # a computer_driver env's put reads the driver class with it
     "certifi>=2024.2.2",  # the public roots the local transfer CA's trust bundle carries
     "click>=8.0.0",
     "cryptography>=42",  # the local transfer CA
@@ -37,7 +37,7 @@ dependencies = [
     "huggingface_hub>=1.0",  # agent-env run hf:// resolves and downloads a Hub bundle; checked on 1.0, 1.33 and 2.4
     "idna>=3.0",  # a browser tab step matches a URL's host as Chromium spells it, by UTS 46
     "jsonschema>=4.20",  # checks an app's settings against its Settings' schema before a deploy
-    "litellm>=1.96.0,<1.97",
+    "litellm>=1.104.0,<1.107",  # 1.104.0 is past every range GHSA-7hp6-4w63-5g45 lists (a proxy-server advisory; only the client is used); checked on 1.104.0 and 1.106.6
     "mcp>=1.25,<2",  # same floor as env/gateway/requirements.txt and agentenv-protocol; 2.0.0 removed mcp.server.fastmcp, imported at module scope by env/gateway
     "packaging>=22",  # parses a bundle.toml's requires; evaluates a plugin's requirement markers with no extra
     "a2a-sdk==0.3.26",
@@ -161,6 +161,7 @@ dev = [
     "hypothesis>=6.100",  # the property tests of the judge score parse
     "moto>=5.0.0",
     "psycopg2-binary>=2.9.0",  # the gateway server module's driver; outside its container only the tests import it
+    "regex>=2023.12.25",  # the gateway's trigger predicates, matched under a timeout; outside its container only the tests import it
     "websockets>=13",  # the gateway's WebSocket relay to a website; outside its container only the tests import it
     "pytest>=9.0",
     "pytest-asyncio>=0.23.0",

{agentenv_framework-0.9.1502 → agentenv_framework-0.9.1506}/src/agent_env/browsers/README.md

@@ -1,7 +1,7 @@
 The website browsers that come with agent-env, today `chromium`, a `computer_app` env a computer env lists in its
-`apps`. Deployed alone, `chromium` is a browser computer, `chromium-driver`: the `ubuntu-24.04-headless` base, with no
-display, and the `page` driver, whose screen is the browser's active tab, headless; the browser on it keeps its name,
-`chromium`.
+`apps`. Deployed alone, `chromium` is a browser computer, `chromium-driver`: the `ubuntu-24.04-browser` base, with no
+desktop, and the `page` driver, whose screen is the browser's active tab; the browser runs headful there, on an X
+server only it uses, and keeps its name, `chromium`.
 
 `envs/chromium/` is Chromium for an X11 desktop or a computer with no display on Linux (`amd64` and `arm64`): Chrome for Testing 156.0.8078.4, the
 build Playwright 1.64.1 pins, fetched by sha256 when a computer env that lists it is put and unpacked into

{agentenv_framework-0.9.1502 → agentenv_framework-0.9.1506}/src/agent_env/browsers/envs/chromium/env.toml

@@ -1,6 +1,6 @@
 type = "computer_app"
 module = "chromium.py:Chromium"
-computer = "ubuntu-24.04-headless"
+computer = "ubuntu-24.04-browser"
 driver = "page"
 
 [settings]

{agentenv_framework-0.9.1502 → agentenv_framework-0.9.1506}/src/agent_env/bundle/installed.py

@@ -40,16 +40,30 @@ def locate_bundle(
     on_progress: Callable[[str], None] | None = None,
 ) -> Located:
     """The bundle ``text`` names, as ``agent-env run BUNDLE`` reads it: an ``hf://`` reference, fetched first; else a folder,
-    when it starts like a path or exists spelled as written; else a bundle ``installed`` lists. Raises BundleError."""
+    when it starts like a path or exists spelled as written; else a bundle ``installed`` lists. A name that is both a
+    folder here and an installed bundle is refused, so a folder in the current directory never stands in for the
+    bundle meant. Raises BundleError."""
     if is_hub_reference(text):
         hub = fetch_bundle(text, on_progress=on_progress)
         return Located(hub.root, hub.id_root, hub)
-    if path_like(text) or _spelled_folder(text):
+    if path_like(text):
+        return Located(Path(text), None, None)
+    if _spelled_folder(text):
+        if namesakes := _installed_as(text, installed()):
+            raise BundleError([f"{text!r} is both a folder here and the installed bundle {namesakes[0].qualified}: run "
+                               f"agent-env run ./{text} for the folder or agent-env run {namesakes[0].qualified} for "
+                               "the bundle"])
         return Located(Path(text), None, None)
     found = find_bundle(text, installed())
     return Located(found.root, found.id_root, None)
 
 
+def _installed_as(text: str, bundles: tuple[InstalledBundle, ...]) -> list[InstalledBundle]:
+    """The installed bundles ``text`` could name, as ``<name>`` or ``<dist>/<name>``."""
+    dist, _, name = text.rpartition("/")
+    return [bundle for bundle in bundles if bundle.name == name and (not dist or bundle.dist == canonicalize_name(dist))]
+
+
 def path_like(text: str) -> bool:
     """Text that names a folder even when there is none there."""
     return text.startswith((".", "/", "~"))
@@ -86,7 +100,7 @@ def find_bundle(text: str, bundles: tuple[InstalledBundle, ...] | None = None) -
     """The installed bundle ``text`` names, as ``<name>`` or ``<dist>/<name>``. Raises BundleError."""
     bundles = installed_bundles() if bundles is None else bundles
     dist, _, name = text.rpartition("/")
-    matches = [bundle for bundle in bundles if bundle.name == name and (not dist or bundle.dist == canonicalize_name(dist))]
+    matches = _installed_as(text, bundles)
     if not dist and len({bundle.dist for bundle in matches}) > 1:
         matches = [bundle for bundle in matches if bundle.dist == CORE]
         if not matches: