agentenv-framework-protocol 0.1.419__tar.gz → 0.1.421__tar.gz

{agentenv_framework_protocol-0.1.419 → agentenv_framework_protocol-0.1.421}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: agentenv-framework-protocol
-Version: 0.1.419
+Version: 0.1.421
 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
@@ -283,6 +283,23 @@ async def display_get(self) -> dict: ...
 async def display_set(self, width: int, height: int) -> dict: ...
 ```
 
+### Framework-only routes and the control token
+
+Everything an environment serves but its MCP endpoint and its card is agent-env's own: the data
+plane, every `@extension` route and the tool-access routes. When agent-env deploys an environment
+that takes one, it boots it with a per-deploy token in `AGENTENV_CONTROL_TOKEN`
+(`CONTROL_TOKEN_ENV`), and the SDK then refuses a call to those routes that doesn't carry it as
+`Authorization: Bearer <token>`, answering 401 with the code `unauthorized` before the route runs.
+The MCP endpoint and the card stay open, so an agent reaches the environment's tools as before and
+nothing else. Without the variable, as when the environment runs on its own, every route is open.
+`control_guard()` wraps a route an environment adds itself the same way, as a computer driver does
+its `/svc/<app>/` routes.
+
+On the client side each call takes `headers`, and `client.control_headers(token)` builds them.
+Code that names none runs under `client.authorized({env_url: client.control_headers(token)})`:
+within it, a call to an address under `env_url` sends those headers. agent-env runs every task
+step, a verifier's `verify` included, under such a grant for each environment it deployed.
+
 ### Tool access without a gateway
 
 An environment agents reach directly, with no gateway in front, can enforce per-role tool access
@@ -561,8 +578,8 @@ driver has them, through the `served_tools`, `served_extensions` and `served_ope
   or a `transfers.ReadObject` read grant under the marker's `read`, and writes them atomically.
   `data/get` returns the files under the `paths` it's given, relative to the home, or under the
   card's `default_data_paths` (`Desktop`, `Documents`, `Downloads`) when it's given none, inline or
-  uploaded under a `write_namespace` grant. An environment whose `@get_data` hook takes no `paths`
-  refuses them.
+  uploaded under a `write_namespace` grant, leaving out the paths its apps keep their data in. An
+  environment whose `@get_data` hook takes no `paths` refuses them.
 - **The card** (the name from `ENVIRONMENT_NAME`, then `@computer_driver`'s), and per-role tool
   access (`tool_access` is on).
 
@@ -644,7 +661,10 @@ report = await run_probe("http://localhost:18765", "full")   # a ProbeReport
 failed = [c for c in report.checks if c.status == "failed"]
 ```
 
-The CLI exits 0 when no check failed, 1 when one did and 2 when it can't reach the driver.
+The CLI exits 0 when no check failed, 1 when one did and 2 when it can't reach the driver. A
+driver booted with a control token is probed with it: `--token`, by default
+`$AGENTENV_CONTROL_TOKEN`, or `run_probe(..., token=...)`. Given one, the probe also checks that
+`computer-ready`'s status refuses a call without it and with a wrong one.
 
 | Level | Checks | Needs on the computer |
 |---|---|---|
@@ -730,8 +750,10 @@ class MailApp(ComputerAppEnvironment):
   naming one the app declares no install for is refused when the class is read. A step reads
   `self.build_settings`; a deploy's `self.settings` aren't known at build, and reading one raises
   `AttributeError` (`python -m agentenv_protocol.computer.run_install_step <file>:<Class> <method>`).
-- **Its skill** is a file of its folder (`skill = "skill.md"`) or an `@agent_skill` method, not both;
-  its data hooks are the usual `@add_data`, `@get_data` and `@reset_data`.
+- **Its skill** is a file of its folder (`skill = "skill.md"`) or an `@agent_skill` method, not both.
+- **Its data** is under the `paths` its OS's decorator names, relative to the session user's home,
+  none inside another (`@linux(..., paths=["Mail", ".config/mail/accounts.json"])`), or what its own
+  `@add_data`, `@get_data` and `@reset_data` hooks serve instead (below).
 - **`Settings`** is typed; a computer hands each app the values a deploy gives it, as one JSON value
   in `APP_SETTINGS_ENV` (`AGENTENV_APP_SETTINGS`, the apps' values by name), and the base class reads
   its own, by `ENVIRONMENT_NAME`, as `self.settings`. A `SecretStr` field is a secret.
@@ -757,6 +779,18 @@ folder: the computer is ready once every app's server answers and each `boot` ap
 no launch, says it's ready; a `demand` app counts once something launches it. What the server does
 in the session (`agentenv_protocol.computer.session`) is Linux's.
 
+The server serves the app's data plane and its skill. With `paths` alone, `data/add` writes the files
+it's given under them and refuses any other path, or one a link leads out of them; `data/get`
+returns the files there, a file tree; and `data/reset` puts them back as the server found them when
+it first started on this boot, which is the app as installed. Hooks serve what they mark instead.
+A hook's `data/add` parts come as they were sent, inline or as a read grant, and
+`part_bytes(part)` returns a part's bytes either way. Either way the base class takes data calls and
+launches one at a time, runs a load and a reset with the app stopped and relaunches it after,
+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.
+
 `MailApp.declaration()` returns what the class declares, an `AppDeclaration`, which a `computer_app`
 env stores, and `python -m agentenv_protocol.computer._declare <folder> <file> <class>` prints it as
 JSON, or a driver's `DriverDeclaration`, without the class's own dependencies installed.

{agentenv_framework_protocol-0.1.419 → agentenv_framework_protocol-0.1.421}/README.md

@@ -227,6 +227,23 @@ async def display_get(self) -> dict: ...
 async def display_set(self, width: int, height: int) -> dict: ...
 ```
 
+### Framework-only routes and the control token
+
+Everything an environment serves but its MCP endpoint and its card is agent-env's own: the data
+plane, every `@extension` route and the tool-access routes. When agent-env deploys an environment
+that takes one, it boots it with a per-deploy token in `AGENTENV_CONTROL_TOKEN`
+(`CONTROL_TOKEN_ENV`), and the SDK then refuses a call to those routes that doesn't carry it as
+`Authorization: Bearer <token>`, answering 401 with the code `unauthorized` before the route runs.
+The MCP endpoint and the card stay open, so an agent reaches the environment's tools as before and
+nothing else. Without the variable, as when the environment runs on its own, every route is open.
+`control_guard()` wraps a route an environment adds itself the same way, as a computer driver does
+its `/svc/<app>/` routes.
+
+On the client side each call takes `headers`, and `client.control_headers(token)` builds them.
+Code that names none runs under `client.authorized({env_url: client.control_headers(token)})`:
+within it, a call to an address under `env_url` sends those headers. agent-env runs every task
+step, a verifier's `verify` included, under such a grant for each environment it deployed.
+
 ### Tool access without a gateway
 
 An environment agents reach directly, with no gateway in front, can enforce per-role tool access
@@ -505,8 +522,8 @@ driver has them, through the `served_tools`, `served_extensions` and `served_ope
   or a `transfers.ReadObject` read grant under the marker's `read`, and writes them atomically.
   `data/get` returns the files under the `paths` it's given, relative to the home, or under the
   card's `default_data_paths` (`Desktop`, `Documents`, `Downloads`) when it's given none, inline or
-  uploaded under a `write_namespace` grant. An environment whose `@get_data` hook takes no `paths`
-  refuses them.
+  uploaded under a `write_namespace` grant, leaving out the paths its apps keep their data in. An
+  environment whose `@get_data` hook takes no `paths` refuses them.
 - **The card** (the name from `ENVIRONMENT_NAME`, then `@computer_driver`'s), and per-role tool
   access (`tool_access` is on).
 
@@ -588,7 +605,10 @@ report = await run_probe("http://localhost:18765", "full")   # a ProbeReport
 failed = [c for c in report.checks if c.status == "failed"]
 ```
 
-The CLI exits 0 when no check failed, 1 when one did and 2 when it can't reach the driver.
+The CLI exits 0 when no check failed, 1 when one did and 2 when it can't reach the driver. A
+driver booted with a control token is probed with it: `--token`, by default
+`$AGENTENV_CONTROL_TOKEN`, or `run_probe(..., token=...)`. Given one, the probe also checks that
+`computer-ready`'s status refuses a call without it and with a wrong one.
 
 | Level | Checks | Needs on the computer |
 |---|---|---|
@@ -674,8 +694,10 @@ class MailApp(ComputerAppEnvironment):
   naming one the app declares no install for is refused when the class is read. A step reads
   `self.build_settings`; a deploy's `self.settings` aren't known at build, and reading one raises
   `AttributeError` (`python -m agentenv_protocol.computer.run_install_step <file>:<Class> <method>`).
-- **Its skill** is a file of its folder (`skill = "skill.md"`) or an `@agent_skill` method, not both;
-  its data hooks are the usual `@add_data`, `@get_data` and `@reset_data`.
+- **Its skill** is a file of its folder (`skill = "skill.md"`) or an `@agent_skill` method, not both.
+- **Its data** is under the `paths` its OS's decorator names, relative to the session user's home,
+  none inside another (`@linux(..., paths=["Mail", ".config/mail/accounts.json"])`), or what its own
+  `@add_data`, `@get_data` and `@reset_data` hooks serve instead (below).
 - **`Settings`** is typed; a computer hands each app the values a deploy gives it, as one JSON value
   in `APP_SETTINGS_ENV` (`AGENTENV_APP_SETTINGS`, the apps' values by name), and the base class reads
   its own, by `ENVIRONMENT_NAME`, as `self.settings`. A `SecretStr` field is a secret.
@@ -701,6 +723,18 @@ folder: the computer is ready once every app's server answers and each `boot` ap
 no launch, says it's ready; a `demand` app counts once something launches it. What the server does
 in the session (`agentenv_protocol.computer.session`) is Linux's.
 
+The server serves the app's data plane and its skill. With `paths` alone, `data/add` writes the files
+it's given under them and refuses any other path, or one a link leads out of them; `data/get`
+returns the files there, a file tree; and `data/reset` puts them back as the server found them when
+it first started on this boot, which is the app as installed. Hooks serve what they mark instead.
+A hook's `data/add` parts come as they were sent, inline or as a read grant, and
+`part_bytes(part)` returns a part's bytes either way. Either way the base class takes data calls and
+launches one at a time, runs a load and a reset with the app stopped and relaunches it after,
+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.
+
 `MailApp.declaration()` returns what the class declares, an `AppDeclaration`, which a `computer_app`
 env stores, and `python -m agentenv_protocol.computer._declare <folder> <file> <class>` prints it as
 JSON, or a driver's `DriverDeclaration`, without the class's own dependencies installed.

{agentenv_framework_protocol-0.1.419 → agentenv_framework_protocol-0.1.421}/pyproject.toml

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

{agentenv_framework_protocol-0.1.419 → agentenv_framework_protocol-0.1.421}/src/agentenv_protocol/__init__.py

@@ -53,6 +53,7 @@ from .manifest import (
     manifest_compatible,
 )
 from .types import (
+    CONTROL_TOKEN_ENV,
     DATA_OBJECTS_EXTENSION_URI,
     INTAKE_EXTENSION_URI,
     MCP_PATH,
@@ -161,6 +162,7 @@ __all__ = [
     "ExtensionCallError",
     "PROTOCOL_VERSION",
     "RPC_PATH",
+    "CONTROL_TOKEN_ENV",
     "WELL_KNOWN_PATH",
     "METHOD_RESET",
     "METHOD_ADD",

{agentenv_framework_protocol-0.1.419 → agentenv_framework_protocol-0.1.421}/src/agentenv_protocol/agent_env_environment.py

@@ -5,6 +5,7 @@ import datetime
 import decimal
 import enum
 import functools
+import hmac
 import inspect
 import json
 import logging
@@ -14,7 +15,8 @@ import sys
 import types
 import uuid
 from abc import ABC, abstractmethod
-from typing import Annotated, Any, Callable, ClassVar, Literal, NamedTuple, Union, get_args, get_origin, get_type_hints
+from typing import (Annotated, Any, Callable, ClassVar, Literal, NamedTuple, Optional, Union, get_args, get_origin,
+                    get_type_hints)
 
 from pydantic import TypeAdapter, ValidationError
 from pydantic.fields import FieldInfo
@@ -27,7 +29,7 @@ from .tool_access import DISABLE as TOOL_DISABLE, ENABLE as TOOL_ENABLE, PATHS a
 from .tool_access import extensions as tool_access_extensions
 from .tool_context import EMPTY, ToolContext, bound, context_from_http, context_from_mcp
 from .transfers import WriteNamespaceGrant
-from .types import DATA_OBJECTS_EXTENSION_URI, MCP_TRANSPORT, SKILL_EXTENSION_URI, METHOD_ADD, METHOD_GET, METHOD_RESET, RPC_PATH, WELL_KNOWN_PATH, AddDataRequest, AddDataResponse, EnvironmentCapabilities, EnvironmentCard, EnvironmentExtension, EnvironmentInterface, EnvironmentTool, GetDataResponse, ResetDataResponse, error_body
+from .types import CONTROL_TOKEN_ENV, DATA_OBJECTS_EXTENSION_URI, MCP_TRANSPORT, SKILL_EXTENSION_URI, METHOD_ADD, METHOD_GET, METHOD_RESET, RPC_PATH, WELL_KNOWN_PATH, AddDataRequest, AddDataResponse, EnvironmentCapabilities, EnvironmentCard, EnvironmentExtension, EnvironmentInterface, EnvironmentTool, GetDataResponse, ResetDataResponse, error_body
 
 logger = logging.getLogger(__name__)
 
@@ -342,10 +344,11 @@ class AgentEnvApplication(ABC):
         if isinstance(self.handler, AgentEnvEnvironment):
             self.handler._application = self
         self.environment_card = self._card_for(app)
-        self._add_route(app, rpc_url, ["POST"], self._dispatch)
+        guard = control_guard()
+        self._add_route(app, rpc_url, ["POST"], guard(self._dispatch))
         self._add_route(app, card_url, ["GET"], self._serve_card)
         for path, method, handler in self._ext_routes:
-            self._add_route(app, path, [method], handler)
+            self._add_route(app, path, [method], guard(handler))
         for descriptor, fn in self._tools:
             self._register_tool(app, descriptor, fn)
         for resource in self._resources:
@@ -376,7 +379,10 @@ class AgentEnvApplication(ABC):
         return self.environment_card
 
     async def _serve_card(self, request: Request) -> Response:
-        return _json_response(self.environment_card.model_dump())
+        card = self.environment_card
+        if isinstance(self.handler, AgentEnvEnvironment) and (children := await self.handler.children_environments()):
+            card = card.model_copy(update={"children_environments": children})
+        return _json_response(card.model_dump())
 
     async def update_tool(self, name: str, *, description: str) -> None:
         """Change a served tool's description after the mount: on the card and in tools/list alike."""
@@ -662,6 +668,11 @@ class AgentEnvEnvironment:
         """Declaration-only extensions to advertise, like ``intake/v1``: a promise with params and no handler."""
         return []
 
+    async def children_environments(self) -> Optional[list[EnvironmentCard]]:
+        """The environments this one fronts, as each serves its card with its paths under this one's, listed on the card
+        each time it's served; None for none."""
+        return None
+
     def served_extensions(self, extensions: list[EnvironmentExtension]) -> list[EnvironmentExtension]:
         """The ``@extension`` handlers' extensions to serve, chosen at mount: one left out is not served, and of one served
         with ``op``, only the methods its returned descriptor still lists."""
@@ -1535,6 +1546,25 @@ def _error_response(error: AgentEnvError) -> Response:
     return _json_response(error_body(**error.fields()), error.status)
 
 
+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:
+        return lambda handler: handler
+    expected = f"Bearer {token}".encode()
+
+    def guard(handler: Callable) -> Callable:
+        async def guarded(request: Request) -> Response:
+            if not hmac.compare_digest(request.headers.get("authorization", "").encode(), expected):
+                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)
+        return guarded
+    return guard
+
+
 def _tool_access_handler(access: ToolAccess, action: str) -> Callable:
     async def handler(request: Request) -> Response:
         raw = await request.body()

{agentenv_framework_protocol-0.1.419 → agentenv_framework_protocol-0.1.421}/src/agentenv_protocol/client.py

@@ -1,7 +1,12 @@
-"""Data-plane wire protocol client (JSON-RPC) for servers implementing the AgentEnv protocol."""
+"""Data-plane wire protocol client (JSON-RPC) for servers implementing the AgentEnv protocol. A call to an env's
+framework-only routes carries its control token: as the call's ``headers`` (``control_headers``), or, for code that
+names none, from the grant it runs under (``authorized``)."""
 from __future__ import annotations
 
+import contextlib
 import logging
+from collections.abc import Iterator
+from contextvars import ContextVar
 
 import httpx
 
@@ -11,6 +16,9 @@ from .types import INTAKE_EXTENSION_URI, MCP_PATH, MCP_TRANSPORT, METHOD_ADD, ME
 
 logger = logging.getLogger(__name__)
 
+#: The headers that carry the control token of each env address the running code is granted, by address.
+_GRANTS: ContextVar[dict[str, dict[str, str]]] = ContextVar("agentenv_control_grants", default={})
+
 
 class ExtensionCallError(httpx.HTTPStatusError):
     """A non-2xx answer from an extension method, with the error fields the server sent. A body without them
@@ -35,10 +43,45 @@ def _error_fields(response: httpx.Response) -> dict:
     return error if isinstance(error, dict) else {}
 
 
-async def _rpc(base_url: str, method: str, params: dict, timeout: int, verify: bool) -> dict:
+def control_headers(token: str | None) -> dict[str, str]:
+    """The headers that carry an env's control token to its framework-only routes; none without one."""
+    return {"Authorization": f"Bearer {token}"} if token else {}
+
+
+@contextlib.contextmanager
+def authorized(grants: dict[str | None, dict[str, str]]) -> Iterator[None]:
+    """Within it, a call to an address under one of ``grants``, an env's address and the headers that carry its
+    control token (``control_headers``), sends those headers when the call names none of its own: how the steps
+    agent-env runs, and the verifiers they call, reach an env's framework-only routes as written."""
+    granted = _GRANTS.set({**_GRANTS.get(),
+                           **{url.rstrip("/"): sent for url, sent in grants.items() if url and sent}})
+    try:
+        yield
+    finally:
+        _GRANTS.reset(granted)
+
+
+def request_headers(url: str, headers: dict[str, str] | None = None) -> dict[str, str]:
+    """What a call to ``url`` sends: ``headers`` when it names them, else the headers its grant gives
+    (``authorized``), if any."""
+    if headers is not None:
+        return headers
+    return granted_headers(url, _GRANTS.get())
+
+
+def granted_headers(url: str, grants: dict[str | None, dict[str, str]]) -> dict[str, str]:
+    """What ``grants``, env addresses and the headers that carry their control tokens, give a call to ``url``: those of
+    the address it is or is under, and none anywhere else."""
+    return next((sent for base, sent in grants.items()
+                 if base and (url == base.rstrip("/") or url.startswith(f"{base.rstrip('/')}/"))), {})
+
+
+async def _rpc(base_url: str, method: str, params: dict, timeout: int, verify: bool,
+               headers: dict[str, str] | None) -> dict:
     request = {"jsonrpc": "2.0", "id": 1, "method": method, "params": params}
+    url = f"{base_url}{RPC_PATH}"
     async with httpx.AsyncClient(verify=verify) as client:
-        response = await client.post(f"{base_url}{RPC_PATH}", json=request, timeout=timeout)
+        response = await client.post(url, json=request, timeout=timeout, headers=request_headers(url, headers))
         response.raise_for_status()
         body = response.json()
     if "error" in body:
@@ -47,18 +90,20 @@ async def _rpc(base_url: str, method: str, params: dict, timeout: int, verify: b
     return body["result"]
 
 
-async def reset_data(base_url: str, timeout: int = 30, verify: bool = True) -> ResetDataResponse:
-    return ResetDataResponse.model_validate(await _rpc(base_url, METHOD_RESET, {}, timeout, verify))
+async def reset_data(base_url: str, timeout: int = 30, verify: bool = True, *,
+                     headers: dict[str, str] | None = None) -> ResetDataResponse:
+    return ResetDataResponse.model_validate(await _rpc(base_url, METHOD_RESET, {}, timeout, verify, headers))
 
 
-async def add_data(base_url: str, parts: list[Part], timeout: int = 120, verify: bool = True) -> AddDataResponse:
+async def add_data(base_url: str, parts: list[Part], timeout: int = 120, verify: bool = True, *,
+                   headers: dict[str, str] | None = None) -> AddDataResponse:
     params = {"parts": [p.model_dump(mode="json", exclude_none=True) for p in parts]}
-    return AddDataResponse.model_validate(await _rpc(base_url, METHOD_ADD, params, timeout, verify))
+    return AddDataResponse.model_validate(await _rpc(base_url, METHOD_ADD, params, timeout, verify, headers))
 
 
 async def get_data(
     base_url: str, timeout: int = 30, verify: bool = True, *, write_namespace: WriteNamespaceGrant | None = None,
-    paths: list[str] | None = None,
+    paths: list[str] | None = None, headers: dict[str, str] | None = None,
 ) -> GetDataResponse:
     """`data/get`. A server advertising `DATA_OBJECTS_EXTENSION_URI` may be handed `write_namespace` to upload
     its export under; `uploaded_object_path` reads from the answer where it did. `paths` names what a computer
@@ -66,7 +111,7 @@ async def get_data(
     params = {} if write_namespace is None else {"write_namespace": write_namespace.model_dump(mode="json", exclude_none=True)}
     if paths is not None:
         params["paths"] = paths
-    return GetDataResponse.model_validate(await _rpc(base_url, METHOD_GET, params, timeout, verify))
+    return GetDataResponse.model_validate(await _rpc(base_url, METHOD_GET, params, timeout, verify, headers))
 
 
 async def get_card(base_url: str, timeout: int = 10, verify: bool = True) -> dict:
@@ -147,6 +192,12 @@ def intake_declaration(card: dict) -> dict | None:
     return params if params else None
 
 
+def operations(card: dict) -> list[str] | None:
+    """The data-plane methods a card declares it serves (``capabilities.operations``), or None when it declares none,
+    as an older card doesn't."""
+    return (card.get("capabilities") or {}).get("operations")
+
+
 def find_tool(card: dict, name: str) -> dict | None:
     """Return the MCP tool advertised under `name`, or None.
 
@@ -174,7 +225,8 @@ def find_child(card: dict, name: str) -> dict | None:
     return None
 
 
-async def get_interface_manifest(base_url: str, interface: str, endpoint: str = INTERFACE_MANIFEST_PATH, timeout: int = 30, verify: bool = True):
+async def get_interface_manifest(base_url: str, interface: str, endpoint: str = INTERFACE_MANIFEST_PATH, timeout: int = 30, verify: bool = True, *,
+                                 headers: dict[str, str] | None = None):
     """Fetch one interface's manifest from a server's manifest index endpoint.
 
     ``endpoint`` is the index path — pass the one advertised on the card under
@@ -185,12 +237,13 @@ async def get_interface_manifest(base_url: str, interface: str, endpoint: str =
     """
     url = f"{base_url.rstrip('/')}{endpoint}/{interface}"
     async with httpx.AsyncClient(verify=verify) as client:
-        response = await client.get(url, timeout=timeout)
+        response = await client.get(url, timeout=timeout, headers=request_headers(url, headers))
         response.raise_for_status()
         return response.json()
 
 
-async def invoke_extension(base_url: str, card: dict, uri: str, params: dict | None = None, timeout: int = 30, verify: bool = True, *, method: str | None = None):
+async def invoke_extension(base_url: str, card: dict, uri: str, params: dict | None = None, timeout: int = 30, verify: bool = True, *, method: str | None = None,
+                           headers: dict[str, str] | None = None):
     """Invoke a card extension via its advertised REST endpoint.
 
     Reads the endpoint and HTTP verb of the extension method named `method` from the card, so the
@@ -209,11 +262,12 @@ async def invoke_extension(base_url: str, card: dict, uri: str, params: dict | N
     if not op["endpoint"]:
         raise ValueError(f"extension {uri} has no endpoint in params")
     url = f"{base_url}{op['endpoint']}"
+    sent = request_headers(url, headers)
     async with httpx.AsyncClient(verify=verify) as client:
         if op["method"] == "GET":
-            response = await client.get(url, params=params or {}, timeout=timeout)
+            response = await client.get(url, params=params or {}, timeout=timeout, headers=sent)
         else:
-            response = await client.request(op["method"], url, json=params or {}, timeout=timeout)
+            response = await client.request(op["method"], url, json=params or {}, timeout=timeout, headers=sent)
         if response.status_code >= 400:
             raise ExtensionCallError(response)
         return response.json()

{agentenv_framework_protocol-0.1.419 → agentenv_framework_protocol-0.1.421}/src/agentenv_protocol/computer/__init__.py

@@ -67,6 +67,7 @@ from .operations import (
     type_text,
     write_files,
 )
+from .dataplane import part_bytes
 from .keys import PRINTABLE_KEYS
 from .manifest import ManifestSegment, RecordingManifest
 from .platform import Platform
@@ -107,7 +108,7 @@ __all__ = [
     "ComputerAppEnvironment", "computer_app", "install", "linux", "install_step", "ready_check", "Linux", "Service",
     "Launch", "Ready", "Packages", "AptSource", "Download", "RunScript",
     "AppDeclaration", "AppOs",
-    "APP_SETTINGS_ENV",
+    "APP_SETTINGS_ENV", "part_bytes",
     "Display", "Image", "Effect", "ExecResult", "ReadyCheck", "Platform", "ComputerSettings", "SETTINGS_ENV",
     "PRINTABLE_KEYS",
     "display", "set_display", "capture", "click", "drag", "scroll", "type_text", "press",