From 5824772ab0c367602c6b927667046e8c4d99f43d Mon Sep 17 00:00:00 2001 From: Edgar Arakelyan Date: Sun, 8 Nov 2026 10:47:19 -0800 Subject: [PATCH 1/7] feat(multi): load, snapshot and reset reach a multi env's computers (FD-4935) An environment artifact named for a computer, or for one of its apps, loads into that computer; a universe load loads each computer's environments after the services, in the computer's own order, after a snapshot restore too. reset_env resets each computer as it resets alone. snapshot_env, sync_env_clock and apply_server_config reach a computer and its apps at the computer's own address with its control token, from the multi env's record (legacy_protocol.backing_servers), rather than through the gateway's /svc route. A computer's apps' names are no other child env's. Co-Authored-By: Claude Opus 5.5 --- src/agent_env/bundle/plan.py | 24 +++- src/agent_env/env/envs/_multi_computers.py | 42 +++++- src/agent_env/env/envs/computer/env.py | 11 +- src/agent_env/env/envs/multi_env.py | 28 +++- src/agent_env/env/legacy_protocol.py | 31 ++++- .../task_steps/apply_server_config.py | 7 +- .../task_step/task_steps/snapshot_env.py | 4 +- .../task_step/task_steps/sync_env_clock.py | 6 +- .../computer/multi_env_computers_test.py | 51 ++++++- tst/unit/bundle/computer_env_folder_test.py | 36 +++++ tst/unit/env/envs/test_multi_env_computers.py | 130 +++++++++++++++++- tst/unit/env/test_legacy_protocol.py | 25 ++++ tst/unit/task_step/sync_env_clock_test.py | 27 ++++ .../task_step/test_apply_server_config.py | 37 +++++ 14 files changed, 435 insertions(+), 24 deletions(-) diff --git a/src/agent_env/bundle/plan.py b/src/agent_env/bundle/plan.py index fe8e76278..8bde4f3a3 100644 --- a/src/agent_env/bundle/plan.py +++ b/src/agent_env/bundle/plan.py @@ -896,7 +896,8 @@ def _check_multi_names(self, closure: set[_Key], store_latest: dict[tuple[Entity website as its backend's and frontend's. No two of a multi's envs may name one container, and a provider other than the core's, which gives a multi one env card, can't tell an MCP server and a website of one name apart. Nor may two of its websites claim one name. A computer runs on a sandbox of its own, which the gateway - knows by its name alone, and serves its tools under it (``_multi_computers.name_problems``).""" + knows by its name alone, and serves its tools under it (``_multi_computers.name_problems``); its apps' names + are no other child env's, since loads and snapshots find an environment by its name.""" for key in sorted(closure, key=self.rank.__getitem__): source = self.nodes[key] if isinstance(source, BundleImage) or source.entry.kind is not BundleKind.ENV: @@ -907,6 +908,7 @@ def _check_multi_names(self, closure: set[_Key], store_latest: dict[tuple[Entity taken: dict[str, str] = {} # each container a child runs as, by the field naming the child named: dict[str, set[str]] = {} # the environment_names of each list's envs computers: list[str] = [] # the computers' environment_names, in order + apps: dict[str, set[str]] = {} # each computer's apps' environment_names, when they're known claimed = [sites.Claim(domain, sites.SYNTHETIC, ref.where) for ref in source.references if ref.where.startswith("website_envs[") for domain in dict.fromkeys(self._domains(ref, store_latest))] @@ -921,6 +923,8 @@ def _check_multi_names(self, closure: set[_Key], store_latest: dict[tuple[Entity named.setdefault(group, set()).add(name) if group == "computer_envs": computers.append(name) + if (held := self._server_names(ref, store_latest)) is not None: + apps[name] = held - {name} continue containers = [name] if group == "mcp_server_envs" else [ f"{name}-{AGENT_ENV_WEBSITE_BACKEND_SUFFIX}", f"{name}-{AGENT_ENV_WEBSITE_FRONTEND_SUFFIX}"] @@ -932,6 +936,8 @@ def _check_multi_names(self, closure: set[_Key], store_latest: dict[tuple[Entity taken.update(dict.fromkeys(containers, ref.where)) self.problems += [f"{where}: computer_envs: {problem}" for problem in _multi_computers.name_problems( computers, mcp_servers=named.get("mcp_server_envs", ()), websites=named.get("website_envs", ()))] + self.problems += [f"{where}: computer_envs: {problem}" for problem in _multi_computers.app_name_problems( + apps, [*named.get("mcp_server_envs", ()), *named.get("website_envs", ()), *computers])] provider_type = source.config.get("env_provider_type", EnvironmentGatewayProvider.type) try: provider = _env_provider_class(provider_type) @@ -1012,13 +1018,19 @@ def _check_loaded_environments(self, closure: set[_Key], def _server_names(self, ref: Reference, store_latest: dict[tuple[EntityKind, str], int] | None) -> set[str] | None: """The environment_names of the servers the env ``ref`` names runs: an MCP server's or a website's own, each - of a multi's envs', or a computer's own and each of its apps'. None when they aren't all known.""" + of a multi's envs', its computers' apps' too, or a computer's own and each of its apps'. None when they aren't + all known.""" if isinstance(ref.local, BundleEntry): cls = get_env_registry().get(ref.local.type) children = self.nodes[_key(ref.local)].references if cls is not None and issubclass(cls, MultiEnv): - names = {self._environment_name(child, store_latest) for child in children - if child.kind is EntityKind.ENV} + names = set() + for child in children: + if child.kind is not EntityKind.ENV: + continue + held = (self._server_names(child, store_latest) if child.where.startswith("computer_envs[") else + {self._environment_name(child, store_latest)}) + names |= held if held is not None else {None} else: names = {self.accepted.get(_key(ref.local), {}).get("environment_name")} if cls is not None and issubclass(cls, ComputerEnv): @@ -1032,7 +1044,9 @@ def _server_names(self, ref: Reference, store_latest: dict[tuple[EntityKind, str except (NotFoundError, ValueError, KeyError, TypeError): return None # reported by the store ref check if isinstance(env, MultiEnv): - return {child.environment_name for child in [*env.mcp_server_envs, *env.website_envs]} + return {*(child.environment_name for child in [*env.mcp_server_envs, *env.website_envs]), + *(name for computer in env.computer_envs + for name in (computer.environment_name, *(app.environment_name for app in computer.composed_apps())))} if isinstance(env, ComputerEnv): return {env.environment_name, *(app.environment_name for app in env.composed_apps())} name = getattr(env, "environment_name", None) diff --git a/src/agent_env/env/envs/_multi_computers.py b/src/agent_env/env/envs/_multi_computers.py index 907f0acba..e1199cbd3 100644 --- a/src/agent_env/env/envs/_multi_computers.py +++ b/src/agent_env/env/envs/_multi_computers.py @@ -7,7 +7,7 @@ import dataclasses import logging from collections import Counter -from collections.abc import Awaitable, Callable, Iterable +from collections.abc import Awaitable, Callable, Iterable, Mapping from typing import TYPE_CHECKING, Optional from agentenv_protocol.computer import tool_prefix_problem @@ -17,6 +17,7 @@ from agent_env.providers.sandbox_providers.sandbox_provider import build_sandbox_provider, get_env_sandbox_provider if TYPE_CHECKING: + from agent_env.artifact import EnvironmentArtifact from agent_env.attribution import Attribution from agent_env.env.envs.computer.env import ComputerEnv @@ -40,6 +41,18 @@ def name_problems(computers: Iterable[str], *, mcp_servers: Iterable[str] = (), return problems +def app_name_problems(apps: Mapping[str, Iterable[str]], others: Iterable[str]) -> list[str]: + """What's wrong with the names of each computer's apps, ``apps`` by the computer's name, beside ``others``, every + other name the multi env's child envs go by: loads and snapshots find an environment by its name, so an app's must + be no other's.""" + apps = {computer: list(dict.fromkeys(names)) for computer, names in apps.items()} + taken = Counter(set(others)) + for names in apps.values(): + taken.update(names) + return [f"app {name!r} of computer {computer!r} has the name of another of its child envs, and loads and snapshots " + "find an environment by its name" for computer, names in apps.items() for name in names if taken[name] > 1] + + def deploy_options(entry: Optional[dict], sandbox_type: str | None) -> dict: """A computer's deploy options from its child_envs entry: on ``sandbox_type``, the multi env's, unless it names one.""" return {"sandbox_type": sandbox_type, **(entry or {})} @@ -88,6 +101,23 @@ def commit(self) -> None: (earlier, replaced), self._earlier = self._earlier, None self._replaced = [*replaced, *(earlier if self.envs is not earlier else [])] + def holding(self, environment_name: str) -> Optional[ComputerEnv]: + """The computer a load of ``environment_name`` reaches: the one of that name, or with an app of it.""" + return next((env for env in self.envs if env.holds(environment_name)), None) + + async def load(self, environments: list[EnvironmentArtifact]) -> None: + """Load each computer's of ``environments`` into it, in its own order, the computers at once.""" + loads = [(env, held) for env in self.envs if (held := [e for e in environments if env.holds(e.environment_name)])] + await _all(self._owner, "load into", [env for env, _ in loads], + [env.load_environments(held) for env, held in loads]) + + async def reset(self, deployed: DeployedEnv) -> None: + """Reset each computer ``deployed``, the multi env's record, holds, from its own record, as it resets alone.""" + records = getattr(deployed, "child_envs", None) or {} + envs = [env for env in self.envs if env.environment_name in records] + await _all(self._owner, "reset", envs, + [env.reset(DeployedEnv.from_dict(records[env.environment_name])) for env in envs]) + def deployer(self, child_envs: Optional[dict], *, sandbox_type: str | None, ttl_seconds: int, attribution: Optional[Attribution]) -> Callable[[Optional[str]], Awaitable[list[ExternalChild]]]: """The gateway's ``children``: every computer deployed as its child_envs entry says, its tools served under its @@ -142,3 +172,13 @@ async def close(self) -> None: logger.warning(f"multi env '{self._owner}': failed to close computer {env.environment_name!r}: {result!r}") elif isinstance(result, BaseException): raise result + + +async def _all(owner: str, what: str, envs: list[ComputerEnv], calls: list[Awaitable]) -> None: + """Await ``calls``, one per computer of ``envs``, at once, then raise the first failure, each other one logged.""" + results = await asyncio.gather(*calls, return_exceptions=True) + failed = [(env, result) for env, result in zip(envs, results) if isinstance(result, BaseException)] + for env, error in failed[1:]: + logger.warning(f"multi env '{owner}': failed to {what} computer {env.environment_name!r} too: {error!r}") + if failed: + raise failed[0][1] diff --git a/src/agent_env/env/envs/computer/env.py b/src/agent_env/env/envs/computer/env.py index 4b039e9c8..010b86b3d 100644 --- a/src/agent_env/env/envs/computer/env.py +++ b/src/agent_env/env/envs/computer/env.py @@ -385,7 +385,16 @@ async def load_environment_universe_artifact(self, environment_universe_artifact if environment.environment_name not in names]: logger.warning(f"[{self.id}] loading only {[environment.environment_name for environment in known]} from " f"'{environment_universe_artifact.id}'; leaving out {others}") - await self._load(sorted(known, key=lambda environment: environment.environment_name != self.computer_name)) + await self.load_environments(known) + + def holds(self, environment_name: str) -> bool: + """Whether a load reaches ``environment_name`` in this computer: its own, or one of its apps'.""" + return environment_name in self._environment_names() + + async def load_environments(self, environments: list[EnvironmentArtifact]) -> None: + """Load ``environments``, each named after the computer or one of its apps: its own first, then its apps', so + what an app keeps ends as its own export has it.""" + await self._load(sorted(environments, key=lambda environment: environment.environment_name != self.computer_name)) async def reset(self, deployed: DeployedEnv) -> None: """Return the computer to boot state: its recordings ended, its container replaced with a fresh one of the same diff --git a/src/agent_env/env/envs/multi_env.py b/src/agent_env/env/envs/multi_env.py index df7a769a3..46600c333 100644 --- a/src/agent_env/env/envs/multi_env.py +++ b/src/agent_env/env/envs/multi_env.py @@ -102,9 +102,14 @@ def __init__(self, id: str, version: Optional[int], mcp_server_envs: list[MCPSer for name in dict.fromkeys(env.domains)]): raise sites.SiteConflict(f"multi env {id!r}: its websites claim names twice: {'; '.join(conflicts)}") self._computers = _multi_computers.Computers(computer_envs or [], owner=id) - if problems := _multi_computers.name_problems([env.environment_name for env in self.computer_envs], - mcp_servers=[env.environment_name for env in self.mcp_server_envs], - websites=[env.environment_name for env in self.website_envs]): + servers = [env.environment_name for env in (*self.mcp_server_envs, *self.website_envs)] + computers = [env.environment_name for env in self.computer_envs] + if problems := [*_multi_computers.name_problems(computers, + mcp_servers=[env.environment_name for env in self.mcp_server_envs], + websites=[env.environment_name for env in self.website_envs]), + *_multi_computers.app_name_problems({env.environment_name: [app.environment_name + for app in env.composed_apps()] + for env in self.computer_envs}, [*servers, *computers])]: raise ValueError(f"multi env {id!r}: {'; '.join(problems)}") self._sandbox = None self._gateway_url = None @@ -290,6 +295,9 @@ async def load_environment_artifact(self, environment_artifact: EnvironmentArtif if env.environment_name == environment_artifact.environment_name: await env.load_environment_artifact(environment_artifact) return + if (computer := self._computers.holding(environment_artifact.environment_name)) is not None: + await computer.load_environment_artifact(environment_artifact) + return logger.warning(f"No env with environment_name '{environment_artifact.environment_name}' — skipping") async def load_environment_universe_artifact( @@ -301,6 +309,7 @@ async def load_environment_universe_artifact( A snapshot restore swaps a pre-ingested servicedb image; a miss re-ingests every service over HTTP under a fixed 600s per-service cap. + Either way each computer's environments then load into it, in its own order. Restore is NOT reliably faster. Measured on a 13-service / ~8.7GB universe: restore ~4min (an image pull plus recreating every service container) versus @@ -361,7 +370,9 @@ async def load_environment_universe_artifact( else: import asyncio import time - environment_artifacts = environment_universe_artifact.get_environment_artifacts() + # The services' alone: the computers' load after them, in each computer's own order. + environment_artifacts = [artifact for artifact in environment_universe_artifact.get_environment_artifacts() + if self._computers.holding(artifact.environment_name) is None] total = len(environment_artifacts) # WARNING, not info: this is the path that can FAIL. Every service is # re-ingested over HTTP under a fixed per-service timeout, and one service @@ -450,6 +461,8 @@ async def _load_one(idx: int, artifact): for i, name, e in failed ) ) + # Every time, never skipped as a resumed service is: the changelog a resume reads doesn't see a computer's files. + await self._computers.load(environment_universe_artifact.get_environment_artifacts()) if self._instance_id: from agent_env.env.store import update_env_instance_environment_universe update_env_instance_environment_universe(self._instance_id, environment_universe_artifact.id, environment_universe_artifact.version) @@ -867,6 +880,13 @@ async def validate_universe_compatibility(self, universe_artifact_id: str, unive # (the final task step), so it persists wherever the Task runs — not only via this method. return context.instance_id + async def reset(self, deployed: DeployedEnv) -> None: + """Reset each computer as it resets alone: rebooted, and its ``tools`` given again. Its MCP servers and websites + have no reset alone, so they stay as they are, and a multi env with no computers has none.""" + if not self.computer_envs: + raise NotImplementedError(f"multi env '{self.id}' has no computers to reset") + await self._computers.reset(deployed) + async def close(self) -> None: await self._computers.close() await close_replaced(self) diff --git a/src/agent_env/env/legacy_protocol.py b/src/agent_env/env/legacy_protocol.py index df302b5e9..0b6d0a154 100644 --- a/src/agent_env/env/legacy_protocol.py +++ b/src/agent_env/env/legacy_protocol.py @@ -42,12 +42,16 @@ class BackingServer: One the env's card lists (``card_servers``) carries that ``child`` and the ``address`` its paths resolve against. One the card lists none for, a server serving no card, carries the ``address`` alone: it has no card, and none is read for it. One named by the env definition of a record whose card can't be read carries neither, so its card is - read live at its gateway path, ``/svc/mcp-{name}`` or a website's ``/svc/{name}`` (``server_card``).""" + read live at its gateway path, ``/svc/mcp-{name}`` or a website's ``/svc/{name}`` (``server_card``). One on a + sandbox of its own, a multi env's computer or one of its apps, carries the ``record`` of the env it runs in, whose + card lists it and whose control token its routes take, which the env's own doesn't.""" environment_name: str mcp: bool = True child: Optional[protocol_v1.ChildEnv] = None address: Optional[str] = None + # Not compared: a record isn't hashable, and a server's address already tells it apart. + record: Optional[DeployedEnv] = dataclasses.field(default=None, compare=False) @property def card(self) -> Optional[dict]: @@ -113,15 +117,34 @@ async def backing_servers(deployed: Optional[DeployedEnv], gateway_url: Optional elif deployed is not None: why = "its record has no card URL" named = definition_servers(env) + own = getattr(deployed, "child_envs", None) or {} if not isinstance(card, dict): logger.info(f"env {getattr(env, 'id', None)!r}: {why}, so its servers are the ones its definition names, " f"each read live at its gateway path: {[(s.environment_name, s.mcp) for s in named]}") - return named + return _on_own_sandboxes(named, own) servers = card_servers(card, address) if not gateway: - return servers + return _on_own_sandboxes(servers, own) listed = {(s.environment_name, s.mcp) for s in servers} - return servers + [dataclasses.replace(s, address=address) for s in named if (s.environment_name, s.mcp) not in listed] + return _on_own_sandboxes(servers + [dataclasses.replace(s, address=address) for s in named + if (s.environment_name, s.mcp) not in listed], own) + + +def _on_own_sandboxes(servers: list[BackingServer], child_envs: dict[str, dict]) -> list[BackingServer]: + """``servers``, each child env on a sandbox of its own (``DeployedGatewayEnv.child_envs``, a multi env's computers) + listed from its own record instead of as the gateway fronts it: its card's servers at its address, each carrying the + record, whose control token the gateway doesn't send. One whose record keeps no card is left out, and logged.""" + from agent_env.env.env import DeployedEnv + + own = [] + for name, data in child_envs.items(): + record = DeployedEnv.from_dict(data) + if not record.environment_card or not record.environment_url: + logger.warning(f"child env {name!r}: its record keeps no card, so none of its servers is listed") + continue + own += [dataclasses.replace(server, record=record) + for server in card_servers(record.environment_card, record.environment_url)] + return [server for server in servers if server.environment_name not in child_envs] + own async def server_card(server: BackingServer, gateway_url: Optional[str], timeout: int = 10) -> tuple[Optional[str], Optional[dict]]: diff --git a/src/agent_env/task_step/task_steps/apply_server_config.py b/src/agent_env/task_step/task_steps/apply_server_config.py index 91cc24167..038c9f582 100644 --- a/src/agent_env/task_step/task_steps/apply_server_config.py +++ b/src/agent_env/task_step/task_steps/apply_server_config.py @@ -143,8 +143,8 @@ async def _expand_directives(self, deployed) -> list[tuple[ConfigDirective, Opti skipped, as under ``tolerate_unadvertised``, when the website has no card or doesn't advertise the URI, so a website the task didn't name never fails it. A named directive, and every MCP server, stays strict; a named one targets the server of that name, the MCP server when a website shares it, as a MultiEnv's load does, or, without - a broadcast to list them, is looked up by name (None).""" - if not any(d.service == self._BROADCAST for d in self.directives): + a broadcast or a computer of a multi env to list them, is looked up by name (None).""" + if not any(d.service == self._BROADCAST for d in self.directives) and not getattr(deployed, "child_envs", None): return [(d, None, False) for d in self.directives] from agent_env.env import legacy_protocol @@ -257,9 +257,10 @@ async def execute(self, context: TaskStepContext) -> TaskStepContext: f"{directive.service!r} (env={self.env_id}). " f"Advertised: {[e.get('uri') for e in (card.get('capabilities') or {}).get('extensions') or []]}" ) + owner = server.record if server is not None and server.record is not None else deployed result = await protocol_v1.invoke_extension( base_url, card, directive.uri, params=directive.args, - timeout=self.timeout_seconds, headers=deployed.control_headers, + timeout=self.timeout_seconds, headers=owner.control_headers, ) except ApplyServerConfigError: raise diff --git a/src/agent_env/task_step/task_steps/snapshot_env.py b/src/agent_env/task_step/task_steps/snapshot_env.py index abb5573f3..6a8fc314c 100644 --- a/src/agent_env/task_step/task_steps/snapshot_env.py +++ b/src/agent_env/task_step/task_steps/snapshot_env.py @@ -694,8 +694,8 @@ async def export_one(server: BackingServer): try: result = await cls._export_environment_to_file( gateway, environment_name, tmp_path, export_timeout_seconds, - deployed=card_record, data_get_params=(data_get_params or {}).get(environment_name), - server=server, **website, + deployed=server.record or card_record, # a multi env's computer: its own record's token + data_get_params=(data_get_params or {}).get(environment_name), server=server, **website, ) except httpx.HTTPStatusError as e: body_snippet = "" diff --git a/src/agent_env/task_step/task_steps/sync_env_clock.py b/src/agent_env/task_step/task_steps/sync_env_clock.py index 8ae463f56..e2646aa53 100644 --- a/src/agent_env/task_step/task_steps/sync_env_clock.py +++ b/src/agent_env/task_step/task_steps/sync_env_clock.py @@ -137,8 +137,10 @@ async def execute(self, context: TaskStepContext) -> TaskStepContext: synced, skipped = [], [] for server in await self._backing_servers(deployed): service = server.environment_name - outcome = await self._sync_one(deployed, gateway_url_of(deployed), service, env_get_time_url, mcp=server.mcp, - tolerate=self.tolerate_missing_sync_time or not server.mcp, server=server) + # A server on a sandbox of its own, a multi env's computer, takes its own record's control token. + outcome = await self._sync_one(server.record or deployed, gateway_url_of(deployed), service, env_get_time_url, + mcp=server.mcp, tolerate=self.tolerate_missing_sync_time or not server.mcp, + server=server) entry = {"service": service, "environment": service, **({} if server.mcp else {"website": True}), **outcome} (synced if outcome.get("synced") else skipped).append(entry) diff --git a/tst/integration/computer/multi_env_computers_test.py b/tst/integration/computer/multi_env_computers_test.py index 150f2093f..c5576728b 100644 --- a/tst/integration/computer/multi_env_computers_test.py +++ b/tst/integration/computer/multi_env_computers_test.py @@ -21,8 +21,11 @@ from mcp import ClientSession from mcp.client.streamable_http import streamable_http_client +from agent_env.artifact import EnvironmentArtifact, EnvironmentUniverseArtifact, FileArtifact from agent_env.env import Env +from agent_env.env.env import DeployedEnv from agent_env.env.envs.computer.env import COMPUTER_TOOLS, ComputerEnv +from agent_env.env.envs.computer.utils import inside from agent_env.env.envs.mcp_server import MCPServerEnv from agent_env.env.envs.multi_env import MultiEnv from agent_env.providers.env_providers.env_gateway_provider import EnvironmentGatewayProvider @@ -31,7 +34,10 @@ from agent_env.task.teardown import teardown_run from agent_env.task_step.context import TaskStepContext from agent_env.task_step.task_steps.deploy_env import DeployEnvTaskStep -from tst.integration.env.envs.server_env_local_test import _put_items_image +from agent_env.task_step.task_steps.load_artifact import LoadArtifactTaskStep +from agent_env.task_step.task_steps.reset_env import ResetEnvTaskStep +from agent_env.task_step.task_steps.snapshot_env import SnapshotEnvTaskStep +from tst.integration.env.envs.server_env_local_test import _items_artifact, _put_items_image from tst.integration.store.local_parallel_deploy_test import _docker, _seed_bootstrap_envs pytestmark = [pytest.mark.integration, pytest.mark.int_test_slow] @@ -84,6 +90,30 @@ async def _answers(deployed, tools: list[str], *, until: bool = True, tries: int return answered +def _universe(uid: str, files: dict[str, bytes]) -> EnvironmentUniverseArtifact: + """The items server's two items, and the desktop's ``files`` by their paths under its user's home.""" + desktop = EnvironmentArtifact.put(id=f"office-desktop-{uid}", environment_name="desktop", file_artifacts={ + path: FileArtifact.put_bytes(id=f"office-desktop-{uid}-{index}", description="multi env computers e2e", + filename=path.rsplit("/", 1)[-1], content=content, content_type="text/plain") + for index, (path, content) in enumerate(files.items())}) + return EnvironmentUniverseArtifact.put(id=f"office-world-{uid}", environment_artifacts=[_items_artifact(uid), desktop]) + + +def _snapshotted(context: TaskStepContext, step: str) -> dict[str, dict[str, bytes]]: + """Each environment the snapshot ``step`` kept, with its files by their paths.""" + kept = context.metadata["env_snapshotted_universes"][step] + universe = EnvironmentUniverseArtifact.get(kept["id"], version=kept["version"]) + return {environment.environment_name: {path: file.load() for path, file in environment.get_file_artifacts().items()} + for environment in universe.get_environment_artifacts()} + + +async def _items(deployed) -> str: + async with streamable_http_client(deployed.mcp_url) as (read, write, _): + async with ClientSession(read, write) as session: + await session.initialize() + return " ".join(part.text for part in (await session.call_tool("list_items", {})).content if part.type == "text") + + def _containers(sandbox_id: str) -> list[str]: return _docker("ps", "-aq", "--filter", f"name=agent-{sandbox_id}").stdout.split() @@ -111,12 +141,28 @@ async def test_a_computer_in_a_multi_env_is_served_through_its_gateway_under_its listed, shot = await _tools(deployed) async with httpx.AsyncClient(timeout=30) as client: card = (await client.get(f"{deployed.gateway_url}/svc/desktop{WELL_KNOWN_PATH}")).json() + # Load, snapshot and reset reach the computer through the multi env, beside its MCP server. + uid, own = uuid.uuid4().hex[:8], DeployedEnv.from_dict(computer) + await LoadArtifactTaskStep(id="seed", version=None, env_id=office.id, + artifact_id=_universe(uid, {"Documents/note.txt": b"from the universe"}).id + ).execute(context) + note = (await inside.run(own, ["cat", "Documents/note.txt"], timeout_s=30))["stdout"] + listed_items = await _items(deployed) + await SnapshotEnvTaskStep(id="snap", version=None, env_id=office.id, + snapshot_id=f"office-snap-{uid}").execute(context) + snapshot = _snapshotted(context, "snap") + await ResetEnvTaskStep(id="reset", version=None, env_id=office.id, fail_task_on_error=True).execute(context) + after_reset = (await inside.run(own, ["sh", "-c", "test -e Documents/note.txt && echo kept || echo gone"], + timeout_s=30))["stdout"].strip() + reset_answers = await _answers(deployed, ["desktop_computer_screenshot"]) + await deployed.invoke(DISABLE_TOOL_EXTENSION_URI, DISABLE, {"role": DEFAULT_ROLE, "tools": [WILDCARD]}) await deployed.invoke(ENABLE_TOOL_EXTENSION_URI, ENABLE, {"role": DEFAULT_ROLE, "tools": ["desktop_computer_screenshot"]}) narrowed, narrowed_shot = await _tools(deployed) reattached = await Env.from_instance_id(deployed.instance_id) up = _containers(computer["sandbox_id"]) + finally: report = await teardown_run(context) @@ -130,6 +176,9 @@ async def test_a_computer_in_a_multi_env_is_served_through_its_gateway_under_its assert [env._deployed.sandbox_id for env in reattached.computer_envs] == [computer["sandbox_id"]] assert _containers(computer["sandbox_id"]) == [] assert json.dumps(deployed.child_envs) # the record stores as JSON + assert note == "from the universe" and "snap-x" in listed_items + assert {"items", "desktop"} <= set(snapshot) and snapshot["desktop"]["Documents/note.txt"] == b"from the universe" + assert after_reset == "gone" and all(reset_answers.values()), reset_answers @pytest.mark.asyncio diff --git a/tst/unit/bundle/computer_env_folder_test.py b/tst/unit/bundle/computer_env_folder_test.py index c30fc020c..0221673de 100644 --- a/tst/unit/bundle/computer_env_folder_test.py +++ b/tst/unit/bundle/computer_env_folder_test.py @@ -243,3 +243,39 @@ def test_a_multi_env_whose_gateway_cant_tell_its_computers_apart_by_name_is_refu assert problem in refused.value.problems, refused.value assert composed == [] + + +def _office_with_apps(root, computers, extra=None): + """``_office`` with the app folders ``APPS``, mail and notes, which its computers may name.""" + return layout(root, {**{f"envs/{folder}/env.toml": toml for folder, toml in computers.items()}, **APPS, + "envs/office/env.toml": f'type = "multi"\ncomputer_envs = {json.dumps(list(computers))}\n', + **(extra or {})}) + + +def test_a_universe_loaded_into_a_multi_env_seeds_its_computer_and_each_of_the_computers_apps(tmp_path, composed): + def loading(root, *seeded): + return _office_with_apps(root, {"desktop": WITH_APPS}, { + "artifacts/world/artifact.toml": 'type = "environment_universe"\n', + **{f"artifacts/world/{name}/a.json": "{}" for name in ("desktop", "mail", *seeded)}, + "tasks/t.json": json.dumps([{"id": "load", "type": "load_artifact", "env_id": "office", "artifact_id": "world"}])}) + + _plan(loading(tmp_path / "seeds")) + with pytest.raises(BundleError) as refused: + _plan(loading(tmp_path / "typo", "mial")) + + assert refused.value.problems == ( + "tasks/t.json: step 'load': artifacts/world/mial seeds an environment named 'mial', and envs/office has no server " + "by that name ('desktop', 'mail', 'notes'); name it after the server it seeds, or leave it out",) + + +def test_a_multi_env_whose_computers_share_an_apps_name_is_refused_before_any_write(tmp_path, composed): + laptop = WITH_APPS.replace('apps = ["notes", { env = "mail", install = "build" }]', 'apps = ["mail"]') + with pytest.raises(BundleError) as refused: + _plan(_office_with_apps(tmp_path / "desk", {"desktop": WITH_APPS, "laptop": laptop}, { + "tasks/t.json": json.dumps([{"id": "load", "type": "load_artifact", "env_id": "office", "artifact_id": "notes"}]), + "artifacts/notes/notes.txt": "a note\n"})) + + assert [problem for problem in refused.value.problems if "app 'mail'" in problem] == [ + f"envs/office: computer_envs: app 'mail' of computer '{name}' has the name of another of its child envs, and " + "loads and snapshots find an environment by its name" for name in ("desktop", "laptop")] + assert composed == [] diff --git a/tst/unit/env/envs/test_multi_env_computers.py b/tst/unit/env/envs/test_multi_env_computers.py index c78e4f24c..09a948258 100644 --- a/tst/unit/env/envs/test_multi_env_computers.py +++ b/tst/unit/env/envs/test_multi_env_computers.py @@ -23,6 +23,7 @@ from agent_env.env.gateway.constants import WELL_KNOWN_PATH from agent_env.providers.env_providers.env_gateway_provider import EnvironmentGatewayProvider from agent_env.providers.env_providers.env_provider import EnvironmentProvider +from agent_env.providers.env_state import LocalPostgresStateProvider from agent_env.task.teardown import env_sandbox_ids from tst.util.sandbox_providers import mock_provider @@ -40,10 +41,33 @@ class FakeComputer: type = COMPUTER_ENV_TYPE - def __init__(self, name: str, *, fails: Exception | None = None, refusal: str | None = None, log: list | None = None): + def __init__(self, name: str, *, fails: Exception | None = None, refusal: str | None = None, log: list | None = None, + apps: tuple[str, ...] = (), resets: Exception | None = None): self.id, self.version, self.environment_name = f"{name}-computer", 1, name self.fails, self.refusal, self.log = fails, refusal, [] if log is None else log self.deploys, self.refusals, self._deployed, self.closes = [], [], None, 0 + self.apps, self.reset_fails = apps, resets + + def composed_apps(self): + return [SimpleNamespace(environment_name=app) for app in self.apps] + + def holds(self, environment_name): + return environment_name in (self.environment_name, *self.apps) + + async def load_environments(self, environments): + inspect.signature(ComputerEnv.load_environments).bind(self, environments) + self.log.append(("loaded", self.environment_name, [environment.environment_name for environment in environments])) + + async def load_environment_artifact(self, environment_artifact): + inspect.signature(ComputerEnv.load_environment_artifact).bind(self, environment_artifact) + self.log.append(("loaded", self.environment_name, [environment_artifact.environment_name])) + + async def reset(self, deployed): + inspect.signature(ComputerEnv.reset).bind(self, deployed) + await asyncio.sleep(0.01) + self.log.append(("reset", self.environment_name, deployed.sandbox_id)) + if self.reset_fails: + raise self.reset_fails def deploy_refusal(self, **options): inspect.signature(ComputerEnv.deploy_refusal).bind(self, **options) # only what the real one takes @@ -344,3 +368,107 @@ def test_cli_put_names_a_computer_name_the_multi_env_refuses(): patch("agent_env.cli.env.multi.detect_base_metadata", return_value={}): result = CliRunner().invoke(multi, ["put", "--id", "office", "--computer", "desktop-number-one-computer"]) assert result.exit_code == 1 and "is 19 characters, and a tool prefix is at most 16" in result.output + + +# --- load and reset through the multi env --- + +def _artifact(name: str) -> SimpleNamespace: + return SimpleNamespace(environment_name=name) + + +@pytest.mark.parametrize("computers, others, problems", [ + ({"desktop": ["mail", "notes"]}, ["slack", "desktop"], []), + ({"desktop": ["slack"]}, ["slack", "desktop"], [ + "app 'slack' of computer 'desktop' has the name of another of its child envs, and loads and snapshots find an " + "environment by its name"]), + ({"desktop": ["mail"], "laptop": ["mail"]}, ["desktop", "laptop"], [ + "app 'mail' of computer 'desktop' has the name of another of its child envs, and loads and snapshots find an " + "environment by its name", + "app 'mail' of computer 'laptop' has the name of another of its child envs, and loads and snapshots find an " + "environment by its name"]), + ({"desktop": ["laptop"]}, ["desktop", "laptop"], [ + "app 'laptop' of computer 'desktop' has the name of another of its child envs, and loads and snapshots find an " + "environment by its name"]), +], ids=["own", "a-server", "two-computers", "another-computer"]) +def test_a_computers_apps_names_are_no_other_child_envs(computers, others, problems): + assert _multi_computers.app_name_problems(computers, others) == problems + + +def test_a_multi_env_refuses_a_computer_whose_app_another_child_env_names(): + with pytest.raises(ValueError, match="app 'slack' of computer 'desktop' has the name of another of its child envs"): + _multi(FakeComputer("desktop", apps=("slack",)), mcp=["slack"]) + + +@pytest.mark.asyncio +async def test_an_environment_artifact_named_for_a_computer_or_one_of_its_apps_loads_into_it(): + log = [] + env = _multi(FakeComputer("desktop", apps=("notes",), log=log), FakeComputer("laptop", log=log), mcp=["slack"]) + env._gateway_url = GATEWAY + [slack] = env.mcp_server_envs + slack.load_environment_artifact = AsyncMock() + + for name in ("notes", "desktop", "laptop", "slack"): + await env.load_environment_artifact(_artifact(name)) + + assert log == [("loaded", "desktop", ["notes"]), ("loaded", "desktop", ["desktop"]), ("loaded", "laptop", ["laptop"])] + slack.load_environment_artifact.assert_awaited_once() + + +@pytest.mark.asyncio +async def test_a_computer_loads_its_own_environment_before_its_apps(): + computer = SimpleNamespace(computer_name="desktop", _load=AsyncMock()) + await ComputerEnv.load_environments(computer, [_artifact("notes"), _artifact("desktop"), _artifact("mail")]) + assert [environment.environment_name for environment in computer._load.await_args.args[0]] == [ + "desktop", "notes", "mail"] + + +@pytest.mark.asyncio +@pytest.mark.parametrize("restored", [False, True], ids=["re-ingested", "restored"]) +async def test_a_universe_loads_each_computers_environments_after_the_services_even_after_a_restore(restored): + log = [] + env = _multi(FakeComputer("desktop", apps=("notes",), log=log), FakeComputer("laptop", log=log)) + env._instance_id, env._sandbox = "inst", MagicMock(mode="vm", exec_script=AsyncMock(return_value="8\n")) + env._env_provider = EnvironmentGatewayProvider() + env._env_provider._state_provider = LocalPostgresStateProvider() + env._load_from_snapshot = AsyncMock(side_effect=lambda snapshot: log.append(("restored",))) + env.load_environment_artifact = AsyncMock(side_effect=lambda artifact: log.append(("service", artifact.environment_name))) + universe = MagicMock(id="uni", version=1, **{"get_metadata.return_value": {}}) + universe.get_environment_artifacts.return_value = [_artifact(name) for name in ("notes", "a", "desktop", "laptop", "b")] + snapshots = MagicMock(**{"get_clean.return_value": MagicMock() if restored else None}) + with patch("agent_env.env.store.get_env_instance_store", return_value=MagicMock(**{"get_loaded_environments.return_value": []})), \ + patch("agent_env.env.snapshot_store.get_env_snapshot_store", return_value=snapshots), \ + patch("agent_env.env.snapshot_store.compute_env_fingerprint", return_value="fp"), \ + patch("agent_env.env.snapshot_store._check_changelog_empty", AsyncMock(return_value=True)), \ + patch("agent_env.env.store.update_env_instance_environment_universe", MagicMock()): + await env.load_environment_universe_artifact(universe, snapshot_after_load=False) + + services = [("restored",)] if restored else [("service", "a"), ("service", "b")] + assert log[:len(services)] == services + assert sorted(log[len(services):]) == [("loaded", "desktop", ["notes", "desktop"]), ("loaded", "laptop", ["laptop"])] + + +@pytest.mark.asyncio +async def test_reset_resets_each_computer_from_its_own_record_and_a_multi_env_without_one_has_none(gateway, providers): + deployed = await _multi(FakeComputer("desktop"), FakeComputer("laptop")).deploy() + log = [] + stored = DeployedEnv.from_dict(dataclasses.asdict(deployed)) + + await _multi(FakeComputer("desktop", log=log), FakeComputer("laptop", log=log)).reset(stored) # as reset_env gets it + + assert sorted(log) == [("reset", "desktop", "sb-desktop"), ("reset", "laptop", "sb-laptop")] + with pytest.raises(NotImplementedError): + await _multi(mcp=["slack"]).reset(stored) + + +@pytest.mark.asyncio +async def test_a_computer_that_fails_to_reset_fails_the_reset_once_every_computer_has_reset(gateway, providers, caplog): + stored = await _multi(FakeComputer("desktop"), FakeComputer("laptop")).deploy() + log = [] + env = _multi(FakeComputer("desktop", log=log, resets=RuntimeError("no reboot")), + FakeComputer("laptop", log=log, resets=RuntimeError("no reboot either"))) + + with pytest.raises(RuntimeError, match="^no reboot$"): + await env.reset(stored) + + assert sorted(log) == [("reset", "desktop", "sb-desktop"), ("reset", "laptop", "sb-laptop")] + assert "failed to reset computer 'laptop' too: RuntimeError('no reboot either')" in caplog.text diff --git a/tst/unit/env/test_legacy_protocol.py b/tst/unit/env/test_legacy_protocol.py index baae080d0..e3fcae528 100644 --- a/tst/unit/env/test_legacy_protocol.py +++ b/tst/unit/env/test_legacy_protocol.py @@ -293,3 +293,28 @@ async def test_a_stored_cards_website_and_mcp_server_sharing_a_name_are_each_rea assert await legacy_protocol.v1_base_url(deployed, None, "mail", mcp=True) == "http://gw:18765/svc/mcp-mail" assert (await legacy_protocol.child_env_card(deployed, None, "mail", mcp=False))[1] is site assert (await legacy_protocol.child_env_card(deployed, None, "mail", mcp=True))[1] is server + + +@pytest.mark.asyncio +@pytest.mark.parametrize("gateway", ["http://gw", None]) +async def test_backing_servers_list_a_multi_envs_computer_and_its_apps_from_its_own_record(gateway): + """Not at the gateway's /svc//, which carries no token of the computer's and reads as a website's route.""" + import dataclasses + from types import SimpleNamespace + + gateway_card = {"name": "office", "url": RPC_PATH, "children_environments": [ + {"name": "slack", "url": "/svc/mcp-slack/agentenv"}, {"name": "desktop", "url": "/svc/desktop/agentenv"}]} + computer_card = {"name": "desktop", "url": RPC_PATH, "capabilities": {"operations": ["data/get"]}, + "children_environments": [{"name": "notes", "url": "/svc/notes/agentenv"}]} + computer = DeployedSandboxEnv(env_id="desk", env_version=1, sandbox_id="sb-desk", control_token="desk-token", + environment_card_url=f"https://desk.example{WELL_KNOWN_PATH}", environment_card=computer_card) + record = _record(gateway_card) + record.child_envs = {"desktop": dataclasses.asdict(computer)} + env = SimpleNamespace(mcp_server_envs=[SimpleNamespace(environment_name="slack")], website_envs=[]) + + servers = await legacy_protocol.backing_servers(record, gateway, env) + + assert [(s.environment_name, s.address, s.record.control_token if s.record else None) for s in servers] == [ + ("slack", "https://env.example", None), ("desktop", "https://desk.example", "desk-token"), + ("notes", "https://desk.example", "desk-token")] + assert await legacy_protocol.server_v1_base_url(servers[2], gateway) == "https://desk.example/svc/notes" diff --git a/tst/unit/task_step/sync_env_clock_test.py b/tst/unit/task_step/sync_env_clock_test.py index a9a109e2a..e95acf2b3 100644 --- a/tst/unit/task_step/sync_env_clock_test.py +++ b/tst/unit/task_step/sync_env_clock_test.py @@ -439,6 +439,33 @@ async def test_a_website_sharing_an_mcp_servers_name_is_synced_with_the_envs_con assert [s["service"] for s in context.metadata["clock_configurations"][0]["synced"]] == ["email", "email"] +@pytest.mark.asyncio +async def test_a_multi_envs_computer_is_synced_at_its_own_address_with_its_own_control_token(monkeypatch): + """Not through the gateway's /svc/desktop/, which carries the gateway's token, not the computer's.""" + import dataclasses + from unittest.mock import patch + + from agent_env.env.env import DeployedSandboxEnv + from agent_env.env.gateway.constants import WELL_KNOWN_PATH + + sent = _mock_http(monkeypatch, state={"env_get_time_url": CLOCK_URL}) + computer = DeployedSandboxEnv(env_id="desk", env_version=1, sandbox_id="sb-desk", control_token="desk-token", + environment_card_url=f"https://desk.example{WELL_KNOWN_PATH}", + environment_card={"name": "desktop", "url": "/agentenv", + "capabilities": {"extensions": [_CLOCK_EXT]}}) + record = dataclasses.replace(_carded(await _composed_card({"mcp-email": [_CLOCK_EXT], "desktop": [_CLOCK_EXT]})), + control_token="gateway-token", child_envs={"desktop": dataclasses.asdict(computer)}) + env = SimpleNamespace(mcp_server_envs=[SimpleNamespace(environment_name="email")], website_envs=[]) + + with patch("agent_env.env.env.Env.get", return_value=env): + await _step().execute(TaskStepContext(deployed_envs=[record])) + + syncs = {str(r.url): r.headers for r in sent if r.url.path.endswith("/sync_time")} + assert set(syncs) == {f"{_CARD}/svc/mcp-email/agentenv/ext/sync_time", "https://desk.example/agentenv/ext/sync_time"} + assert {k: syncs["https://desk.example/agentenv/ext/sync_time"].get(k) for k in computer.control_headers} == \ + computer.control_headers + + def test_a_padded_zone_is_stored_and_sent_stripped(): s = _zoned(timezone=" America/New_York ") assert s.timezone == "America/New_York" and s.to_dict()["timezone"] == "America/New_York" diff --git a/tst/unit/task_step/test_apply_server_config.py b/tst/unit/task_step/test_apply_server_config.py index 94ed35986..9df2a67ec 100644 --- a/tst/unit/task_step/test_apply_server_config.py +++ b/tst/unit/task_step/test_apply_server_config.py @@ -837,3 +837,40 @@ def _carded_context(card: dict) -> TaskStepContext: ctx.deployed_envs[0].environment_card_url = f"{_CARD}{WELL_KNOWN_PATH}" ctx.deployed_envs[0].environment_card = card return ctx + + +@pytest.mark.asyncio +@pytest.mark.parametrize("service", ["desktop", "*"], ids=["named", "broadcast"]) +async def test_a_multi_envs_computer_is_configured_at_its_own_address_with_its_own_token(service): + """Not through the gateway's /svc/desktop/, which carries the gateway's token, not the computer's.""" + import dataclasses + + from agent_env.env.env import DeployedSandboxEnv + + computer = DeployedSandboxEnv(env_id="desk", env_version=1, sandbox_id="sb-desk", control_token="desk-token", + environment_card_url="https://desk.example/.well-known/agent-env.json", + environment_card={**_card(_ext(_SET_ERRORS_URI, "/agentenv/ext/set_errors")), "name": "desktop"}) + record = DeployedGatewayEnv(env_id="env-x", env_version=1, gateway_url=_GATEWAY, mcp_url="", sandbox_id="sb-env", + control_token="gateway-token", environment_card_url=f"{_GATEWAY}/.well-known/agent-env.json", + environment_card={"name": "office", "url": "/agentenv", "children_environments": [ + {"name": "desktop", "url": "/svc/desktop/agentenv", "capabilities": {"extensions": []}}]}, + child_envs={"desktop": dataclasses.asdict(computer)}) + sent = [] + + class Client: + async def request(self, method, url, *, json=None, timeout=None, headers=None): + sent.append((url, headers)) + return _resp(200, url, {"ok": True}) + + async def __aenter__(self): + return self + + async def __aexit__(self, *a): + return False + + step = _step(directives=[{"service": service, "uri": _SET_ERRORS_URI, "args": {"tool_name": "t", "error_rate": 0.5}}]) + with patch("httpx.AsyncClient", return_value=Client()), \ + patch("agent_env.env.env.Env.get", return_value=SimpleNamespace(mcp_server_envs=[], website_envs=[])): + await step.execute(TaskStepContext(deployed_envs=[record])) + + assert sent == [("https://desk.example/agentenv/ext/set_errors", computer.control_headers)] From 7e890e87f8aab5eab60e181736646d33c2e11fc5 Mon Sep 17 00:00:00 2001 From: Edgar Arakelyan Date: Sun, 8 Nov 2026 10:58:00 -0800 Subject: [PATCH 2/7] fix(multi): a record's computers are served only for its own gateway backing_servers read another gateway's live card but still listed the record's computers, so a snapshot through an override gateway could mix two deployments. A record's child envs now count only when the gateway asked is the record's own. Co-Authored-By: Claude Opus 5.5 --- src/agent_env/env/legacy_protocol.py | 4 +++- tst/unit/env/test_legacy_protocol.py | 19 +++++++++++++++++++ 2 files changed, 22 insertions(+), 1 deletion(-) diff --git a/src/agent_env/env/legacy_protocol.py b/src/agent_env/env/legacy_protocol.py index 0b6d0a154..7130cdeb4 100644 --- a/src/agent_env/env/legacy_protocol.py +++ b/src/agent_env/env/legacy_protocol.py @@ -117,7 +117,9 @@ async def backing_servers(deployed: Optional[DeployedEnv], gateway_url: Optional elif deployed is not None: why = "its record has no card URL" named = definition_servers(env) - own = getattr(deployed, "child_envs", None) or {} + # A record's computers are its own deployment's: none when the gateway asked is another's. + own = ((getattr(deployed, "child_envs", None) or {}) + if deployed is not None and (gateway is None or (gateway_url_of(deployed) or "").rstrip("/") == gateway) else {}) if not isinstance(card, dict): logger.info(f"env {getattr(env, 'id', None)!r}: {why}, so its servers are the ones its definition names, " f"each read live at its gateway path: {[(s.environment_name, s.mcp) for s in named]}") diff --git a/tst/unit/env/test_legacy_protocol.py b/tst/unit/env/test_legacy_protocol.py index e3fcae528..67c2ba8d2 100644 --- a/tst/unit/env/test_legacy_protocol.py +++ b/tst/unit/env/test_legacy_protocol.py @@ -318,3 +318,22 @@ async def test_backing_servers_list_a_multi_envs_computer_and_its_apps_from_its_ ("slack", "https://env.example", None), ("desktop", "https://desk.example", "desk-token"), ("notes", "https://desk.example", "desk-token")] assert await legacy_protocol.server_v1_base_url(servers[2], gateway) == "https://desk.example/svc/notes" + + +@pytest.mark.asyncio +async def test_backing_servers_use_a_records_computers_only_for_its_own_gateway(monkeypatch): + """Another gateway's card is another deployment's, whose computers this record doesn't hold.""" + import dataclasses + from types import SimpleNamespace + + computer = DeployedSandboxEnv(env_id="desk", env_version=1, sandbox_id="sb-desk", control_token="desk-token", + environment_card_url=f"https://desk.example{WELL_KNOWN_PATH}", + environment_card={"name": "desktop", "url": RPC_PATH}) + record = _record({"name": "office", "url": RPC_PATH, "children_environments": [{"name": "desktop", "url": "/svc/desktop/agentenv"}]}) + record.child_envs = {"desktop": dataclasses.asdict(computer)} + other = {"name": "office", "url": RPC_PATH, "children_environments": [{"name": "desktop", "url": "/svc/desktop/agentenv"}]} + monkeypatch.setattr(legacy_protocol.protocol_v1, "get_card", AsyncMock(return_value=other)) + + servers = await legacy_protocol.backing_servers(record, "http://another-gw", SimpleNamespace(mcp_server_envs=[], website_envs=[])) + + assert [(s.environment_name, s.address, s.record) for s in servers] == [("desktop", "http://another-gw", None)] From e47487dcf2f9aca13c7139ed750511cbec9c13df Mon Sep 17 00:00:00 2001 From: Edgar Arakelyan Date: Sun, 8 Nov 2026 17:01:25 -0800 Subject: [PATCH 3/7] feat(multi): reset_env empties a multi env's MCP servers and websites too A multi env's reset now resets every child env at once, each as it resets alone. An MCP server and a website gain a reset of their own: data/reset, or an older server's /api/reset, empties what loads put in, as each load already does before it adds, and its changelog starts afresh. A task loads again after, as after a computer's reboot. One serving no reset (its card leaves data/reset out, as the website browser's does, or an older server answers 404) takes no load either and is left as it is. A child whose reset fails fails the reset, each one named, once the others have reset. The instance's record of which services its loads put in is cleared, so the next load reloads every one rather than resuming. Co-Authored-By: Claude Opus 5.5 --- src/agent_env/env/envs/_deployment.py | 36 ++++- src/agent_env/env/envs/_multi_computers.py | 10 +- src/agent_env/env/envs/mcp_server.py | 9 +- src/agent_env/env/envs/multi_env.py | 53 ++++++- src/agent_env/env/envs/website.py | 9 +- .../task_step/task_steps/reset_env.py | 5 +- .../computer/multi_env_computers_test.py | 12 +- tst/unit/env/envs/test_multi_env_computers.py | 87 ++++++++-- tst/unit/env/envs/test_server_reset.py | 149 ++++++++++++++++++ 9 files changed, 335 insertions(+), 35 deletions(-) create mode 100644 tst/unit/env/envs/test_server_reset.py diff --git a/src/agent_env/env/envs/_deployment.py b/src/agent_env/env/envs/_deployment.py index 755d78261..c640dfcbe 100644 --- a/src/agent_env/env/envs/_deployment.py +++ b/src/agent_env/env/envs/_deployment.py @@ -1,5 +1,6 @@ """The env side of the environment-provider contract: deploying an env through its provider, the options a provider takes, -the checks on a plugin's record, loading into a deployment a plugin's provider made, and closing a deployment.""" +the checks on a plugin's record, loading into a deployment a plugin's provider made, emptying a server's data, and closing +a deployment.""" from __future__ import annotations @@ -10,9 +11,11 @@ from collections.abc import Awaitable, Callable from typing import TYPE_CHECKING, Optional +import httpx from agentenv_protocol import DATA_OBJECTS_EXTENSION_URI, METHOD_ADD, METHOD_RESET, RPC_PATH, FilePart, client as protocol_v1 from agent_env.env import legacy_protocol from agent_env.env.env import DeployedSandboxEnv, gateway_url_of +from agent_env.env.gateway.constants import DATA_PLANE_LOAD_TIMEOUT_S from agent_env.env.store import register_env_instance from agent_env.store.base import ObjectNotFoundError from agent_env.utils.paths import validate_file_name @@ -142,6 +145,37 @@ async def load_by_signed_url(env: MCPServerEnv | WebsiteEnv, environment_artifac await protocol_v1.add_data(base_url, file_parts(environment_artifact, files, urls), timeout=timeout) +async def reset_server_data(env: MCPServerEnv | WebsiteEnv, *, mcp: bool) -> bool: + """Empty what loads put into ``env``, an MCP server or with ``mcp=False`` a website, as each load does before it adds: + through ``data/reset``, or an older server's ``/api/reset``; then, behind a gateway of ours, its changelog started + afresh, as after a load. ``env`` is attached to its deployment, which may be a MultiEnv's. False, with nothing sent, + for one serving no reset, which takes no load either: a card declaring operations without ``data/reset``, a plugin's + card offering it no data plane, or an older server answering 404.""" + name = env.environment_name + if env._deployed is None and env._gateway_url is None: + raise RuntimeError("Environment not deployed - call deploy() first") + builtin = as_builtin(env._env_provider) + base_url = await legacy_protocol.v1_base_url(env._deployed, env._gateway_url, name, mcp=mcp) + if base_url is not None: + child = env._deployed.child_env(name, mcp=mcp) if env._deployed is not None and env._deployed.environment_card else None + if child is not None and child.serves(METHOD_RESET) is False: + return False + await protocol_v1.reset_data(base_url, timeout=DATA_PLANE_LOAD_TIMEOUT_S) + elif builtin is None: + return False + else: + try: + await legacy_protocol.reset_via_rest(legacy_protocol.environment_base_url(env._gateway_url, name, mcp=mcp), + timeout=60) + except httpx.HTTPStatusError as e: + if e.response.status_code != 404: + raise + return False + if builtin is not None: + await builtin.install_changelog_triggers(name) + return True + + def file_parts(environment_artifact: EnvironmentArtifact, files: dict[str, FileArtifact], uris: dict[str, str]) -> list[FilePart]: """The parts ``data/add`` takes ``environment_artifact``'s ``files`` as, each fetched from its uri in ``uris``: one file as the one part it has always been sent as, each of several with its path in the data-objects marker.""" diff --git a/src/agent_env/env/envs/_multi_computers.py b/src/agent_env/env/envs/_multi_computers.py index e1199cbd3..1e97fa943 100644 --- a/src/agent_env/env/envs/_multi_computers.py +++ b/src/agent_env/env/envs/_multi_computers.py @@ -111,12 +111,12 @@ async def load(self, environments: list[EnvironmentArtifact]) -> None: await _all(self._owner, "load into", [env for env, _ in loads], [env.load_environments(held) for env, held in loads]) - async def reset(self, deployed: DeployedEnv) -> None: - """Reset each computer ``deployed``, the multi env's record, holds, from its own record, as it resets alone.""" + def resets(self, deployed: DeployedEnv) -> list[tuple[str, Awaitable[None]]]: + """Each computer ``deployed``, the multi env's record, holds, by name, with its reset from its own record, as it + resets alone; none is awaited yet.""" records = getattr(deployed, "child_envs", None) or {} - envs = [env for env in self.envs if env.environment_name in records] - await _all(self._owner, "reset", envs, - [env.reset(DeployedEnv.from_dict(records[env.environment_name])) for env in envs]) + return [(env.environment_name, env.reset(DeployedEnv.from_dict(records[env.environment_name]))) + for env in self.envs if env.environment_name in records] def deployer(self, child_envs: Optional[dict], *, sandbox_type: str | None, ttl_seconds: int, attribution: Optional[Attribution]) -> Callable[[Optional[str]], Awaitable[list[ExternalChild]]]: diff --git a/src/agent_env/env/envs/mcp_server.py b/src/agent_env/env/envs/mcp_server.py index 2f950f77a..bb959deb3 100644 --- a/src/agent_env/env/envs/mcp_server.py +++ b/src/agent_env/env/envs/mcp_server.py @@ -21,7 +21,8 @@ from agent_env.env import legacy_protocol from agent_env.env.envs._deployment import ( as_builtin, builtin_provider_for, close_deployed, close_replaced, deploy_refusal, deploy_through_provider, host_staging_refusal, - file_parts, legacy_load_file, load_by_signed_url, plugin_provider_like_a_builtin, provider_or_class, staged_paths, + file_parts, legacy_load_file, load_by_signed_url, plugin_provider_like_a_builtin, provider_or_class, reset_server_data, + staged_paths, ) from agent_env.env.gateway import GatewayMode from agent_env.providers.sandbox_providers.sandbox import VmSandbox @@ -136,6 +137,12 @@ async def from_deployed_env(cls, deployed: DeployedEnv) -> MCPServerEnv: env._deployed = deployed return env + async def reset(self, deployed: DeployedEnv) -> None: + """Empty what loads put into the server, attached to ``deployed`` as a load is, so a task loads it again after; + NotImplementedError for one serving no reset, which takes no load either.""" + if not await reset_server_data(await type(self).from_deployed_env(deployed), mcp=True): + raise NotImplementedError(f"MCP server '{self.environment_name}' serves no reset") + async def close(self) -> None: await close_replaced(self) if self._env_provider is not None: diff --git a/src/agent_env/env/envs/multi_env.py b/src/agent_env/env/envs/multi_env.py index 46600c333..2d97d3cb6 100644 --- a/src/agent_env/env/envs/multi_env.py +++ b/src/agent_env/env/envs/multi_env.py @@ -1,6 +1,7 @@ """Multi environment combining multiple MCP servers, websites and computers.""" from __future__ import annotations +import asyncio import logging import os import re @@ -40,8 +41,9 @@ def _snapshot_after_load_default() -> bool: from agent_env.env.gateway import GatewayMode from agent_env.env.envs._deployment import ( as_builtin, builtin_provider_for, close_deployed, close_replaced, deploy_refusal, deploy_through_provider, host_staging_refusal, - plugin_provider_like_a_builtin, provider_or_class, + plugin_provider_like_a_builtin, provider_or_class, reset_server_data, ) +from agent_env.env.store import get_env_instance_store from agent_env.env.envs import _multi_computers from agent_env.env.envs.computer import COMPUTER_ENV_TYPE from agent_env.env.envs.computer.utils import sites @@ -264,6 +266,15 @@ def child_envs_refusal(self, child_envs: Optional[dict], *, sandbox_type: str | @classmethod async def from_deployed_env(cls, deployed: DeployedEnv) -> MultiEnv: + env = await cls._attached(deployed) + if env.computer_envs: + await env._computers.reattach(deployed) + return env + + @classmethod + async def _attached(cls, deployed: DeployedEnv) -> MultiEnv: + """The multi env ``deployed`` records, attached to it as its loads are: its gateway reattached, and its MCP + servers and websites handed the provider and the record; its computers aren't reattached.""" env = Env.get(deployed.env_id, deployed.env_version) if not isinstance(env, MultiEnv): raise TypeError(f"Expected MultiEnv, got {type(env).__name__}") @@ -278,8 +289,6 @@ async def from_deployed_env(cls, deployed: DeployedEnv) -> MultiEnv: _hand_record_to_child_envs(env, deployed) env._instance_id = deployed.instance_id env._mcp_server_name = deployed.mcp_server_name - if env.computer_envs: - await env._computers.reattach(deployed) return env async def load_environment_artifact(self, environment_artifact: EnvironmentArtifact) -> None: @@ -881,11 +890,27 @@ async def validate_universe_compatibility(self, universe_artifact_id: str, unive return context.instance_id async def reset(self, deployed: DeployedEnv) -> None: - """Reset each computer as it resets alone: rebooted, and its ``tools`` given again. Its MCP servers and websites - have no reset alone, so they stay as they are, and a multi env with no computers has none.""" - if not self.computer_envs: - raise NotImplementedError(f"multi env '{self.id}' has no computers to reset") - await self._computers.reset(deployed) + """Reset every child env at once, each as it resets alone: a computer reboots from its own record and gets its + ``tools`` again, and an MCP server or website is emptied of what loads put in, so a task loads again after; one + serving no reset takes no load, and stays as it is. A child that fails to reset fails the reset, each such one + named, once the others have reset. Which services the instance's loads put in is forgotten, so the next load + puts each in again rather than resuming.""" + services = await type(self)._attached(deployed) if self.mcp_server_envs or self.website_envs else self + resets = [*((f"computer {name!r}", call) for name, call in self._computers.resets(deployed)), + *((f"MCP server {env.environment_name!r}", reset_server_data(env, mcp=True)) + for env in services.mcp_server_envs), + *((f"website {env.environment_name!r}", reset_server_data(env, mcp=False)) + for env in services.website_envs)] + results = await asyncio.gather(*(call for _, call in resets), return_exceptions=True) + _forget_loaded_environments(deployed.instance_id) + if interrupted := next((r for r in results if isinstance(r, BaseException) and not isinstance(r, Exception)), None): + raise interrupted + for (child, _), result in zip(resets, results): + if result is False: + logger.info(f"multi env '{self.id}': {child} serves no reset and takes no load, so it stays as it is") + if failed := [(child, result) for (child, _), result in zip(resets, results) if isinstance(result, Exception)]: + raise RuntimeError(f"multi env '{self.id}': " + "; ".join(f"{child} failed to reset: {error!r}" + for child, error in failed)) from failed[0][1] async def close(self) -> None: await self._computers.close() @@ -904,6 +929,18 @@ async def close(self) -> None: self._sandbox = None +def _forget_loaded_environments(instance_id: Optional[str]) -> None: + """Forget which services the instance's loads put in, so its next load puts each in again rather than resuming; + best-effort, since only a resumed load reads it.""" + if not instance_id: + return + try: + get_env_instance_store().clear_loaded_environments(instance_id) + except Exception as e: # noqa: BLE001 + logger.warning(f"Could not forget which services instance {instance_id!r} loaded; a resumed load may skip " + f"one a reset emptied: {e}") + + def _hand_provider_to_child_envs(env: MultiEnv) -> None: """Point each child env at the MultiEnv's deployment: the provider and URL its loads use, and behind our gateway the sandbox they stage into. A plugin's provider leaves them no sandbox, so they load through the record's card.""" diff --git a/src/agent_env/env/envs/website.py b/src/agent_env/env/envs/website.py index 474a2a9a6..62ceb925e 100644 --- a/src/agent_env/env/envs/website.py +++ b/src/agent_env/env/envs/website.py @@ -27,7 +27,8 @@ from agent_env.env import legacy_protocol from agent_env.env.envs._deployment import ( as_builtin, builtin_provider_for, close_deployed, close_replaced, deploy_refusal, deploy_through_provider, host_staging_refusal, - file_parts, legacy_load_file, load_by_signed_url, plugin_provider_like_a_builtin, provider_or_class, staged_paths, + file_parts, legacy_load_file, load_by_signed_url, plugin_provider_like_a_builtin, provider_or_class, reset_server_data, + staged_paths, ) from agent_env.env.gateway import GatewayMode from agent_env.attribution import Attribution @@ -289,6 +290,12 @@ async def _load_environment_artifact_legacy(self, file_artifact) -> None: ) raise + async def reset(self, deployed: DeployedEnv) -> None: + """Empty what loads put into the website, attached to ``deployed`` as a load is, so a task loads it again after; + NotImplementedError for one serving no reset, which takes no load either.""" + if not await reset_server_data(await type(self).from_deployed_env(deployed), mcp=False): + raise NotImplementedError(f"website '{self.environment_name}' serves no reset") + async def close(self) -> None: await close_replaced(self) if self._env_provider is not None: diff --git a/src/agent_env/task_step/task_steps/reset_env.py b/src/agent_env/task_step/task_steps/reset_env.py index 88059fdde..79cff0deb 100644 --- a/src/agent_env/task_step/task_steps/reset_env.py +++ b/src/agent_env/task_step/task_steps/reset_env.py @@ -2,8 +2,9 @@ Env-agnostic: looks up the deployed env in context and calls its ``reset()``. Best-effort by default — a reset failure (including an env that doesn't support -it) is logged and the run continues. Place right before prompt_agent in a -warm-reuse task. +it) is logged and the run continues. A reset empties what loads put in (a +computer reboots, an MCP server or website is emptied), so in a warm-reuse task +place it before the load that seeds the next attempt, then prompt_agent. """ from __future__ import annotations diff --git a/tst/integration/computer/multi_env_computers_test.py b/tst/integration/computer/multi_env_computers_test.py index c5576728b..e349ee2b9 100644 --- a/tst/integration/computer/multi_env_computers_test.py +++ b/tst/integration/computer/multi_env_computers_test.py @@ -143,9 +143,8 @@ async def test_a_computer_in_a_multi_env_is_served_through_its_gateway_under_its card = (await client.get(f"{deployed.gateway_url}/svc/desktop{WELL_KNOWN_PATH}")).json() # Load, snapshot and reset reach the computer through the multi env, beside its MCP server. uid, own = uuid.uuid4().hex[:8], DeployedEnv.from_dict(computer) - await LoadArtifactTaskStep(id="seed", version=None, env_id=office.id, - artifact_id=_universe(uid, {"Documents/note.txt": b"from the universe"}).id - ).execute(context) + world = _universe(uid, {"Documents/note.txt": b"from the universe"}) + await LoadArtifactTaskStep(id="seed", version=None, env_id=office.id, artifact_id=world.id).execute(context) note = (await inside.run(own, ["cat", "Documents/note.txt"], timeout_s=30))["stdout"] listed_items = await _items(deployed) await SnapshotEnvTaskStep(id="snap", version=None, env_id=office.id, @@ -155,6 +154,11 @@ async def test_a_computer_in_a_multi_env_is_served_through_its_gateway_under_its after_reset = (await inside.run(own, ["sh", "-c", "test -e Documents/note.txt && echo kept || echo gone"], timeout_s=30))["stdout"].strip() reset_answers = await _answers(deployed, ["desktop_computer_screenshot"]) + emptied_items = await _items(deployed) + # A reset empties the server too, so the next attempt loads again, every service and the computer. + await LoadArtifactTaskStep(id="reseed", version=None, env_id=office.id, artifact_id=world.id).execute(context) + reloaded = ((await inside.run(own, ["cat", "Documents/note.txt"], timeout_s=30))["stdout"], + await _items(deployed)) await deployed.invoke(DISABLE_TOOL_EXTENSION_URI, DISABLE, {"role": DEFAULT_ROLE, "tools": [WILDCARD]}) await deployed.invoke(ENABLE_TOOL_EXTENSION_URI, ENABLE, {"role": DEFAULT_ROLE, @@ -179,6 +183,8 @@ async def test_a_computer_in_a_multi_env_is_served_through_its_gateway_under_its assert note == "from the universe" and "snap-x" in listed_items assert {"items", "desktop"} <= set(snapshot) and snapshot["desktop"]["Documents/note.txt"] == b"from the universe" assert after_reset == "gone" and all(reset_answers.values()), reset_answers + assert "snap-x" not in emptied_items, emptied_items + assert reloaded[0] == "from the universe" and "snap-x" in reloaded[1], reloaded @pytest.mark.asyncio diff --git a/tst/unit/env/envs/test_multi_env_computers.py b/tst/unit/env/envs/test_multi_env_computers.py index 09a948258..635dfa9ac 100644 --- a/tst/unit/env/envs/test_multi_env_computers.py +++ b/tst/unit/env/envs/test_multi_env_computers.py @@ -447,28 +447,87 @@ async def test_a_universe_loads_each_computers_environments_after_the_services_e assert sorted(log[len(services):]) == [("loaded", "desktop", ["notes", "desktop"]), ("loaded", "laptop", ["laptop"])] +@pytest.fixture +def server_resets(monkeypatch): + """Each MCP server's and website's reset, as (name, mcp) in ``log``, attached to the multi env's record: False, as + for one serving no reset, for a name in ``unserved``, and raising for one in ``failing``; the instance whose loads + are forgotten in ``forgotten``.""" + resets = SimpleNamespace(log=[], unserved=set(), failing={}, forgotten=[], attached=[]) + + async def reset(env, *, mcp): + inspect.signature(_deployment.reset_server_data).bind(env, mcp=mcp) + await asyncio.sleep(0.01) + resets.log.append((env.environment_name, mcp, env._deployed.instance_id)) + if env.environment_name in resets.failing: + raise resets.failing[env.environment_name] + return env.environment_name not in resets.unserved + + async def attached(cls, deployed): + resets.attached.append(deployed.instance_id) + env = _multi(mcp=["slack"], websites=["shop"]) + for child in [*env.mcp_server_envs, *env.website_envs]: + child._deployed = deployed + return env + + monkeypatch.setattr("agent_env.env.envs.multi_env.reset_server_data", reset) + monkeypatch.setattr(MultiEnv, "_attached", classmethod(attached)) + store = MagicMock(clear_loaded_environments=resets.forgotten.append) + monkeypatch.setattr("agent_env.env.envs.multi_env.get_env_instance_store", lambda: store) + return resets + + +async def _stored(*computers) -> DeployedEnv: + """The record of a multi env with ``computers``, as reset_env reads it back.""" + deployed = await _multi(*computers, mcp=["slack"], websites=["shop"]).deploy() + return DeployedEnv.from_dict({**dataclasses.asdict(deployed), "instance_id": "inst-1"}) + + @pytest.mark.asyncio -async def test_reset_resets_each_computer_from_its_own_record_and_a_multi_env_without_one_has_none(gateway, providers): - deployed = await _multi(FakeComputer("desktop"), FakeComputer("laptop")).deploy() - log = [] - stored = DeployedEnv.from_dict(dataclasses.asdict(deployed)) +async def test_reset_resets_every_child_env_at_once_each_as_it_resets_alone_and_forgets_what_loads_put_in( + gateway, providers, server_resets): + stored, log = await _stored(FakeComputer("desktop"), FakeComputer("laptop")), [] - await _multi(FakeComputer("desktop", log=log), FakeComputer("laptop", log=log)).reset(stored) # as reset_env gets it + await _multi(FakeComputer("desktop", log=log), FakeComputer("laptop", log=log), mcp=["slack"], + websites=["shop"]).reset(stored) assert sorted(log) == [("reset", "desktop", "sb-desktop"), ("reset", "laptop", "sb-laptop")] - with pytest.raises(NotImplementedError): - await _multi(mcp=["slack"]).reset(stored) + assert sorted(server_resets.log) == [("shop", False, "inst-1"), ("slack", True, "inst-1")] + assert server_resets.attached == ["inst-1"] and server_resets.forgotten == ["inst-1"] @pytest.mark.asyncio -async def test_a_computer_that_fails_to_reset_fails_the_reset_once_every_computer_has_reset(gateway, providers, caplog): - stored = await _multi(FakeComputer("desktop"), FakeComputer("laptop")).deploy() - log = [] - env = _multi(FakeComputer("desktop", log=log, resets=RuntimeError("no reboot")), - FakeComputer("laptop", log=log, resets=RuntimeError("no reboot either"))) +async def test_a_multi_env_of_computers_alone_resets_them_without_reattaching_its_gateway(gateway, providers, + server_resets): + deployed, log = await _multi(FakeComputer("desktop")).deploy(), [] + + await _multi(FakeComputer("desktop", log=log)).reset(DeployedEnv.from_dict(dataclasses.asdict(deployed))) + + assert log == [("reset", "desktop", "sb-desktop")] and server_resets.attached == server_resets.log == [] + + +@pytest.mark.asyncio +async def test_a_server_serving_no_reset_stays_as_it_is_and_the_rest_reset(gateway, providers, server_resets, caplog): + stored, log = await _stored(FakeComputer("desktop")), [] + server_resets.unserved.add("shop") + + with caplog.at_level("INFO"): + await _multi(FakeComputer("desktop", log=log), mcp=["slack"], websites=["shop"]).reset(stored) + + assert log == [("reset", "desktop", "sb-desktop")] and len(server_resets.log) == 2 + assert "multi env 'office': website 'shop' serves no reset and takes no load, so it stays as it is" in caplog.text + + +@pytest.mark.asyncio +async def test_each_child_that_fails_to_reset_is_named_once_every_child_env_has_reset(gateway, providers, server_resets): + stored, log = await _stored(FakeComputer("desktop"), FakeComputer("laptop")), [] + server_resets.failing["slack"] = RuntimeError("data/reset timed out") + env = _multi(FakeComputer("desktop", log=log, resets=RuntimeError("no reboot")), FakeComputer("laptop", log=log), + mcp=["slack"], websites=["shop"]) - with pytest.raises(RuntimeError, match="^no reboot$"): + with pytest.raises(RuntimeError) as raised: await env.reset(stored) + assert str(raised.value) == ("multi env 'office': computer 'desktop' failed to reset: RuntimeError('no reboot'); " + "MCP server 'slack' failed to reset: RuntimeError('data/reset timed out')") assert sorted(log) == [("reset", "desktop", "sb-desktop"), ("reset", "laptop", "sb-laptop")] - assert "failed to reset computer 'laptop' too: RuntimeError('no reboot either')" in caplog.text + assert len(server_resets.log) == 2 and server_resets.forgotten == ["inst-1"] diff --git a/tst/unit/env/envs/test_server_reset.py b/tst/unit/env/envs/test_server_reset.py new file mode 100644 index 000000000..89f47c480 --- /dev/null +++ b/tst/unit/env/envs/test_server_reset.py @@ -0,0 +1,149 @@ +"""An MCP server's or website's reset empties what loads put in, as each load does before it adds: through data/reset, or +an older server's /api/reset, its changelog started afresh after; one serving no reset takes no load and is left as it +is. Alone, each attaches to its record as a load does.""" + +from __future__ import annotations + +import json +from types import SimpleNamespace +from unittest.mock import AsyncMock, MagicMock, patch + +import httpx +import pytest + +from agent_env.env.env import DeployedEnv +from agent_env.env.envs import _deployment, mcp_server, website +from agent_env.env.envs.mcp_server import MCPServerEnv +from agent_env.env.envs.website import WebsiteEnv +from agent_env.env.gateway.constants import DATA_PLANE_LOAD_TIMEOUT_S +from agent_env.providers.env_providers.env_gateway_provider import EnvironmentGatewayProvider + +GATEWAY = "https://gw.example" + + +@pytest.fixture +def server(monkeypatch): + """Each request a reset sends, in ``requests``, answered ``status``; and the changelog triggers installed after it.""" + seen = SimpleNamespace(requests=[], status=200, triggers=AsyncMock()) + real = httpx.AsyncClient + + def handle(request): + seen.requests.append(request) + return httpx.Response(seen.status, json={"jsonrpc": "2.0", "id": 1, "result": {}}) + + monkeypatch.setattr(httpx, "AsyncClient", lambda *a, **k: real(transport=httpx.MockTransport(handle))) + monkeypatch.setattr(EnvironmentGatewayProvider, "install_changelog_triggers", seen.triggers) + return seen + + +def _record(card: dict | None) -> DeployedEnv: + return DeployedEnv(env_id="mcp-email", env_version=1, env_provider_type="gateway", instance_id="inst-1", + environment_card_url=f"{GATEWAY}/.well-known/agent-env.json", environment_card=card) + + +def _server(card: dict | None, env_provider_type: str = "gateway") -> MCPServerEnv: + """The email server behind a gateway of ours, attached to a record keeping ``card``.""" + env = MCPServerEnv(id="mcp-email", version=1, docker_image_artifact=MagicMock(), environment_name="email", + env_provider_type=env_provider_type) + env._deployed, env._gateway_url = _record(card), GATEWAY + return env + + +def _card(*operations: str) -> dict: + return {"name": "email", "url": "/agentenv", "capabilities": {"operations": list(operations)}} + + +@pytest.mark.asyncio +@pytest.mark.parametrize("card", [_card("data/reset", "data/add", "data/get"), {"name": "email", "url": "/agentenv"}], + ids=["declared", "an-older-card-declaring-none"]) +async def test_a_server_serving_data_reset_is_emptied_through_it_and_its_changelog_starts_afresh(server, card): + assert await _deployment.reset_server_data(_server(card), mcp=True) is True + + [request] = server.requests + assert (str(request.url), json.loads(request.content)["method"]) == (f"{GATEWAY}/agentenv", "data/reset") + assert request.extensions["timeout"]["read"] == DATA_PLANE_LOAD_TIMEOUT_S # a load's budget, not the client's 30 s + server.triggers.assert_awaited_once_with("email") + + +@pytest.mark.asyncio +async def test_a_server_whose_card_declares_no_data_reset_takes_no_load_and_is_left_as_it_is(server): + assert await _deployment.reset_server_data(_server(_card()), mcp=True) is False + assert server.requests == [] and not server.triggers.await_count + + +@pytest.mark.asyncio +@pytest.mark.parametrize("status, reset", [(200, True), (404, False)], ids=["serves-it", "serves-none"]) +async def test_an_older_server_is_emptied_through_its_api_reset_and_one_answering_404_has_none(server, status, reset): + server.status = status + with patch("agent_env.env.legacy_protocol.v1_base_url", AsyncMock(return_value=None)): + assert await _deployment.reset_server_data(_server(None), mcp=True) is reset + + [request] = server.requests + assert (request.method, str(request.url)) == ("POST", f"{GATEWAY}/svc/mcp-email/api/reset") + assert server.triggers.await_count == reset + + +@pytest.mark.asyncio +async def test_an_older_server_failing_its_reset_fails_it(server): + server.status = 500 + with patch("agent_env.env.legacy_protocol.v1_base_url", AsyncMock(return_value=None)), \ + pytest.raises(httpx.HTTPStatusError): + await _deployment.reset_server_data(_server(None), mcp=True) + assert not server.triggers.await_count + + +@pytest.mark.asyncio +async def test_a_server_a_plugin_deployed_with_no_data_plane_is_left_as_it_is(server): + env = _server(None, env_provider_type="gateway") + env._env_provider = MagicMock() # a plugin's provider, no built-in + with patch("agent_env.env.legacy_protocol.v1_base_url", AsyncMock(return_value=None)): + assert await _deployment.reset_server_data(env, mcp=True) is False + assert server.requests == [] + + +@pytest.mark.asyncio +async def test_a_website_is_emptied_at_its_own_path(server): + env = WebsiteEnv(id="shop-site", version=1, server_docker_image_artifact=MagicMock(), environment_name="shop") + env._deployed, env._gateway_url = None, GATEWAY # a name an MCP server shares: the live probe, no record + with patch("agent_env.env.legacy_protocol.v1_base_url", AsyncMock(return_value=f"{GATEWAY}/svc/shop")) as base: + assert await _deployment.reset_server_data(env, mcp=False) is True + + assert base.await_args.kwargs == {"mcp": False} + assert [str(request.url) for request in server.requests] == [f"{GATEWAY}/svc/shop/agentenv"] + server.triggers.assert_awaited_once_with("shop") + + +@pytest.mark.asyncio +async def test_a_server_not_deployed_cannot_reset(server): + env = _server(None) + env._deployed = env._gateway_url = None + with pytest.raises(RuntimeError, match="not deployed"): + await _deployment.reset_server_data(env, mcp=True) + + +@pytest.mark.asyncio +@pytest.mark.parametrize("cls, module, mcp, what", [ + (MCPServerEnv, mcp_server, True, "MCP server 'email'"), + (WebsiteEnv, website, False, "website 'email'"), +], ids=["mcp-server", "website"]) +async def test_alone_each_attaches_to_its_record_as_a_load_does_and_one_serving_no_reset_has_none( + monkeypatch, cls, module, mcp, what): + record, attached, calls, served = _record(None), SimpleNamespace(environment_name="email"), [], [True, False] + + async def attach(_cls, deployed): + calls.append(("attach", deployed)) + return attached + + async def reset(env, *, mcp): + calls.append(("reset", env, mcp)) + return served.pop(0) + + monkeypatch.setattr(cls, "from_deployed_env", classmethod(attach)) + monkeypatch.setattr(module, "reset_server_data", reset) + env = cls("email-env", 1, MagicMock(), environment_name="email") + + await env.reset(record) + with pytest.raises(NotImplementedError, match=f"^{what} serves no reset$"): + await env.reset(record) + + assert calls == [("attach", record), ("reset", attached, mcp)] * 2 From 88f861cdf7e51a20111eec16d0f15cc02f7cb01d Mon Sep 17 00:00:00 2001 From: Edgar Arakelyan Date: Sun, 8 Nov 2026 17:13:04 -0800 Subject: [PATCH 4/7] refactor(multi): one owner per server call, one way to name failed children, one store import - BackingServer.owner(deployed) is the record whose control token a call to the server takes; apply_server_config, snapshot_env and sync_env_clock use it rather than each spelling the choice. - _multi_computers.each awaits a multi env's child envs at once and names each that failed; a load into several computers now does as a reset does, rather than raising the first failure and logging the rest. - multi_env reaches the instance store through one module import, so a test patching agent_env.env.store reaches every path, and a snapshot restore forgets the loaded services through the same helper a reset does. Co-Authored-By: Claude Opus 5.5 --- src/agent_env/env/envs/_multi_computers.py | 28 ++++++++-------- src/agent_env/env/envs/multi_env.py | 33 ++++++------------- src/agent_env/env/legacy_protocol.py | 5 +++ .../task_steps/apply_server_config.py | 2 +- .../task_step/task_steps/snapshot_env.py | 2 +- .../task_step/task_steps/sync_env_clock.py | 3 +- tst/unit/env/envs/test_multi_env_computers.py | 26 ++++++++++++--- 7 files changed, 55 insertions(+), 44 deletions(-) diff --git a/src/agent_env/env/envs/_multi_computers.py b/src/agent_env/env/envs/_multi_computers.py index 1e97fa943..eda519f88 100644 --- a/src/agent_env/env/envs/_multi_computers.py +++ b/src/agent_env/env/envs/_multi_computers.py @@ -8,7 +8,7 @@ import logging from collections import Counter from collections.abc import Awaitable, Callable, Iterable, Mapping -from typing import TYPE_CHECKING, Optional +from typing import TYPE_CHECKING, Any, Optional from agentenv_protocol.computer import tool_prefix_problem @@ -106,10 +106,10 @@ def holding(self, environment_name: str) -> Optional[ComputerEnv]: return next((env for env in self.envs if env.holds(environment_name)), None) async def load(self, environments: list[EnvironmentArtifact]) -> None: - """Load each computer's of ``environments`` into it, in its own order, the computers at once.""" - loads = [(env, held) for env in self.envs if (held := [e for e in environments if env.holds(e.environment_name)])] - await _all(self._owner, "load into", [env for env, _ in loads], - [env.load_environments(held) for env, held in loads]) + """Load each computer's of ``environments`` into it, in its own order, the computers at once (``each``).""" + await each(self._owner, "load", [(f"computer {env.environment_name!r}", env.load_environments(held)) + for env in self.envs + if (held := [e for e in environments if env.holds(e.environment_name)])]) def resets(self, deployed: DeployedEnv) -> list[tuple[str, Awaitable[None]]]: """Each computer ``deployed``, the multi env's record, holds, by name, with its reset from its own record, as it @@ -174,11 +174,13 @@ async def close(self) -> None: raise result -async def _all(owner: str, what: str, envs: list[ComputerEnv], calls: list[Awaitable]) -> None: - """Await ``calls``, one per computer of ``envs``, at once, then raise the first failure, each other one logged.""" - results = await asyncio.gather(*calls, return_exceptions=True) - failed = [(env, result) for env, result in zip(envs, results) if isinstance(result, BaseException)] - for env, error in failed[1:]: - logger.warning(f"multi env '{owner}': failed to {what} computer {env.environment_name!r} too: {error!r}") - if failed: - raise failed[0][1] +async def each(owner: str, what: str, calls: list[tuple[str, Awaitable[Any]]]) -> list[Any]: + """Await ``calls``, each a child env's under its label, at once, and once all have ended, what each returned; or, + when any failed to ``what``, a RuntimeError of the multi env ``owner`` naming each that did.""" + results = await asyncio.gather(*(call for _, call in calls), return_exceptions=True) + if interrupted := next((r for r in results if isinstance(r, BaseException) and not isinstance(r, Exception)), None): + raise interrupted + if failed := [(child, result) for (child, _), result in zip(calls, results) if isinstance(result, Exception)]: + raise RuntimeError(f"multi env '{owner}': " + "; ".join(f"{child} failed to {what}: {error!r}" + for child, error in failed)) from failed[0][1] + return results diff --git a/src/agent_env/env/envs/multi_env.py b/src/agent_env/env/envs/multi_env.py index 2d97d3cb6..cf8f55b39 100644 --- a/src/agent_env/env/envs/multi_env.py +++ b/src/agent_env/env/envs/multi_env.py @@ -1,7 +1,6 @@ """Multi environment combining multiple MCP servers, websites and computers.""" from __future__ import annotations -import asyncio import logging import os import re @@ -43,7 +42,7 @@ def _snapshot_after_load_default() -> bool: as_builtin, builtin_provider_for, close_deployed, close_replaced, deploy_refusal, deploy_through_provider, host_staging_refusal, plugin_provider_like_a_builtin, provider_or_class, reset_server_data, ) -from agent_env.env.store import get_env_instance_store +from agent_env.env import store as env_store from agent_env.env.envs import _multi_computers from agent_env.env.envs.computer import COMPUTER_ENV_TYPE from agent_env.env.envs.computer.utils import sites @@ -370,12 +369,7 @@ async def load_environment_universe_artifact( restored_from_snapshot = True # A restore swaps the whole database at once, so per-service resume state from # any earlier partial re-ingest no longer describes anything real. - if self._instance_id: - try: - from agent_env.env.store import get_env_instance_store - get_env_instance_store().clear_loaded_environments(self._instance_id) - except Exception as e: # noqa: BLE001 - logger.warning("Could not clear resume state after a snapshot restore: %s", e) + _forget_loaded_environments(self._instance_id) else: import asyncio import time @@ -473,8 +467,7 @@ async def _load_one(idx: int, artifact): # Every time, never skipped as a resumed service is: the changelog a resume reads doesn't see a computer's files. await self._computers.load(environment_universe_artifact.get_environment_artifacts()) if self._instance_id: - from agent_env.env.store import update_env_instance_environment_universe - update_env_instance_environment_universe(self._instance_id, environment_universe_artifact.id, environment_universe_artifact.version) + env_store.update_env_instance_environment_universe(self._instance_id, environment_universe_artifact.id, environment_universe_artifact.version) # Bake the snapshot that makes the NEXT load of this (images, universe) pair an # image swap. Deliberately placed here: after the universe stamp, which @@ -538,9 +531,8 @@ async def _resumable_environments(self, environment_universe_artifact, total: in return set() try: from agent_env.env.snapshot_store import _check_changelog_empty - from agent_env.env.store import get_env_instance_store - recorded = set(get_env_instance_store().get_loaded_environments( + recorded = set(env_store.get_env_instance_store().get_loaded_environments( self._instance_id, environment_universe_artifact.id, environment_universe_artifact.version, )) if not recorded: @@ -572,9 +564,7 @@ def _record_loaded_environment(self, environment_universe_artifact, environment_ if not self._instance_id: return try: - from agent_env.env.store import get_env_instance_store - - get_env_instance_store().record_loaded_environment( + env_store.get_env_instance_store().record_loaded_environment( self._instance_id, environment_universe_artifact.id, environment_universe_artifact.version, environment_name, ) @@ -901,16 +891,13 @@ async def reset(self, deployed: DeployedEnv) -> None: for env in services.mcp_server_envs), *((f"website {env.environment_name!r}", reset_server_data(env, mcp=False)) for env in services.website_envs)] - results = await asyncio.gather(*(call for _, call in resets), return_exceptions=True) - _forget_loaded_environments(deployed.instance_id) - if interrupted := next((r for r in results if isinstance(r, BaseException) and not isinstance(r, Exception)), None): - raise interrupted + try: + results = await _multi_computers.each(self.id, "reset", resets) + finally: + _forget_loaded_environments(deployed.instance_id) for (child, _), result in zip(resets, results): if result is False: logger.info(f"multi env '{self.id}': {child} serves no reset and takes no load, so it stays as it is") - if failed := [(child, result) for (child, _), result in zip(resets, results) if isinstance(result, Exception)]: - raise RuntimeError(f"multi env '{self.id}': " + "; ".join(f"{child} failed to reset: {error!r}" - for child, error in failed)) from failed[0][1] async def close(self) -> None: await self._computers.close() @@ -935,7 +922,7 @@ def _forget_loaded_environments(instance_id: Optional[str]) -> None: if not instance_id: return try: - get_env_instance_store().clear_loaded_environments(instance_id) + env_store.get_env_instance_store().clear_loaded_environments(instance_id) except Exception as e: # noqa: BLE001 logger.warning(f"Could not forget which services instance {instance_id!r} loaded; a resumed load may skip " f"one a reset emptied: {e}") diff --git a/src/agent_env/env/legacy_protocol.py b/src/agent_env/env/legacy_protocol.py index 7130cdeb4..240ff3901 100644 --- a/src/agent_env/env/legacy_protocol.py +++ b/src/agent_env/env/legacy_protocol.py @@ -58,6 +58,11 @@ def card(self) -> Optional[dict]: """The server's card as the env's card lists it, or None.""" return self.child.card if self.child is not None else None + def owner(self, deployed: DeployedEnv) -> DeployedEnv: + """The record whose control token a call to the server takes: its own ``record``, a multi env's computer's or + one of its apps', else ``deployed``, the record of the env it was listed for.""" + return self.record or deployed + def definition_servers(env: Any) -> list[BackingServer]: """The servers an env definition names: a MultiEnv's MCP servers then its websites, a WebsiteEnv's website, or diff --git a/src/agent_env/task_step/task_steps/apply_server_config.py b/src/agent_env/task_step/task_steps/apply_server_config.py index 038c9f582..efe0444c9 100644 --- a/src/agent_env/task_step/task_steps/apply_server_config.py +++ b/src/agent_env/task_step/task_steps/apply_server_config.py @@ -257,7 +257,7 @@ async def execute(self, context: TaskStepContext) -> TaskStepContext: f"{directive.service!r} (env={self.env_id}). " f"Advertised: {[e.get('uri') for e in (card.get('capabilities') or {}).get('extensions') or []]}" ) - owner = server.record if server is not None and server.record is not None else deployed + owner = server.owner(deployed) if server is not None else deployed result = await protocol_v1.invoke_extension( base_url, card, directive.uri, params=directive.args, timeout=self.timeout_seconds, headers=owner.control_headers, diff --git a/src/agent_env/task_step/task_steps/snapshot_env.py b/src/agent_env/task_step/task_steps/snapshot_env.py index 6a8fc314c..d42d70943 100644 --- a/src/agent_env/task_step/task_steps/snapshot_env.py +++ b/src/agent_env/task_step/task_steps/snapshot_env.py @@ -694,7 +694,7 @@ async def export_one(server: BackingServer): try: result = await cls._export_environment_to_file( gateway, environment_name, tmp_path, export_timeout_seconds, - deployed=server.record or card_record, # a multi env's computer: its own record's token + deployed=server.owner(card_record), data_get_params=(data_get_params or {}).get(environment_name), server=server, **website, ) except httpx.HTTPStatusError as e: diff --git a/src/agent_env/task_step/task_steps/sync_env_clock.py b/src/agent_env/task_step/task_steps/sync_env_clock.py index e2646aa53..040c958c2 100644 --- a/src/agent_env/task_step/task_steps/sync_env_clock.py +++ b/src/agent_env/task_step/task_steps/sync_env_clock.py @@ -137,8 +137,7 @@ async def execute(self, context: TaskStepContext) -> TaskStepContext: synced, skipped = [], [] for server in await self._backing_servers(deployed): service = server.environment_name - # A server on a sandbox of its own, a multi env's computer, takes its own record's control token. - outcome = await self._sync_one(server.record or deployed, gateway_url_of(deployed), service, env_get_time_url, + outcome = await self._sync_one(server.owner(deployed), gateway_url_of(deployed), service, env_get_time_url, mcp=server.mcp, tolerate=self.tolerate_missing_sync_time or not server.mcp, server=server) entry = {"service": service, "environment": service, **({} if server.mcp else {"website": True}), **outcome} diff --git a/tst/unit/env/envs/test_multi_env_computers.py b/tst/unit/env/envs/test_multi_env_computers.py index 635dfa9ac..c904f7716 100644 --- a/tst/unit/env/envs/test_multi_env_computers.py +++ b/tst/unit/env/envs/test_multi_env_computers.py @@ -21,6 +21,7 @@ from agent_env.env.envs.multi_env import MultiEnv from agent_env.env.gateway import ExternalChild from agent_env.env.gateway.constants import WELL_KNOWN_PATH +from agent_env.env.store import EnvInstanceStore from agent_env.providers.env_providers.env_gateway_provider import EnvironmentGatewayProvider from agent_env.providers.env_providers.env_provider import EnvironmentProvider from agent_env.providers.env_state import LocalPostgresStateProvider @@ -42,11 +43,11 @@ class FakeComputer: type = COMPUTER_ENV_TYPE def __init__(self, name: str, *, fails: Exception | None = None, refusal: str | None = None, log: list | None = None, - apps: tuple[str, ...] = (), resets: Exception | None = None): + apps: tuple[str, ...] = (), resets: Exception | None = None, loads: Exception | None = None): self.id, self.version, self.environment_name = f"{name}-computer", 1, name self.fails, self.refusal, self.log = fails, refusal, [] if log is None else log self.deploys, self.refusals, self._deployed, self.closes = [], [], None, 0 - self.apps, self.reset_fails = apps, resets + self.apps, self.reset_fails, self.load_fails = apps, resets, loads def composed_apps(self): return [SimpleNamespace(environment_name=app) for app in self.apps] @@ -56,7 +57,10 @@ def holds(self, environment_name): async def load_environments(self, environments): inspect.signature(ComputerEnv.load_environments).bind(self, environments) + await asyncio.sleep(0.01) self.log.append(("loaded", self.environment_name, [environment.environment_name for environment in environments])) + if self.load_fails: + raise self.load_fails async def load_environment_artifact(self, environment_artifact): inspect.signature(ComputerEnv.load_environment_artifact).bind(self, environment_artifact) @@ -447,6 +451,20 @@ async def test_a_universe_loads_each_computers_environments_after_the_services_e assert sorted(log[len(services):]) == [("loaded", "desktop", ["notes", "desktop"]), ("loaded", "laptop", ["laptop"])] +@pytest.mark.asyncio +async def test_each_computer_that_fails_to_load_is_named_once_every_computer_has_loaded(): + log = [] + env = _multi(FakeComputer("desktop", log=log, loads=RuntimeError("disk full")), + FakeComputer("laptop", log=log, loads=ValueError("bad path")), FakeComputer("kiosk", log=log)) + + with pytest.raises(RuntimeError) as raised: + await env._computers.load([_artifact(name) for name in ("desktop", "laptop", "kiosk")]) + + assert str(raised.value) == ("multi env 'office': computer 'desktop' failed to load: RuntimeError('disk full'); " + "computer 'laptop' failed to load: ValueError('bad path')") + assert sorted(name for _, name, _ in log) == ["desktop", "kiosk", "laptop"] + + @pytest.fixture def server_resets(monkeypatch): """Each MCP server's and website's reset, as (name, mcp) in ``log``, attached to the multi env's record: False, as @@ -471,8 +489,8 @@ async def attached(cls, deployed): monkeypatch.setattr("agent_env.env.envs.multi_env.reset_server_data", reset) monkeypatch.setattr(MultiEnv, "_attached", classmethod(attached)) - store = MagicMock(clear_loaded_environments=resets.forgotten.append) - monkeypatch.setattr("agent_env.env.envs.multi_env.get_env_instance_store", lambda: store) + monkeypatch.setattr(EnvInstanceStore, "clear_loaded_environments", + lambda store, instance_id: resets.forgotten.append(instance_id)) return resets From 6f1b9d368cca85beed079485c4e5604a73cdc452 Mon Sep 17 00:00:00 2001 From: Edgar Arakelyan Date: Sun, 8 Nov 2026 17:20:33 -0800 Subject: [PATCH 5/7] fix(multi): forget the loaded services before a reset empties any, and an older tool-only server isn't skipped - MultiEnv.reset forgets which services the instance's loads put in before any server is emptied, and empties nothing when it can't: a reset also clears the changelog, so a resumed load would otherwise skip a service it had emptied. - An older MCP server answering 404 at /api/reset that offers a _reset tool resets only to a seed that tool loads, so its reset fails, naming it, rather than being left as a server that takes no load. Co-Authored-By: Claude Opus 5.5 --- src/agent_env/env/envs/_deployment.py | 6 +++++- src/agent_env/env/envs/multi_env.py | 18 +++++++++-------- src/agent_env/env/legacy_protocol.py | 18 +++++++++++++++-- tst/unit/env/envs/test_multi_env_computers.py | 20 +++++++++++++++---- tst/unit/env/envs/test_server_reset.py | 15 +++++++++++++- 5 files changed, 61 insertions(+), 16 deletions(-) diff --git a/src/agent_env/env/envs/_deployment.py b/src/agent_env/env/envs/_deployment.py index c640dfcbe..89b7fec47 100644 --- a/src/agent_env/env/envs/_deployment.py +++ b/src/agent_env/env/envs/_deployment.py @@ -150,7 +150,8 @@ async def reset_server_data(env: MCPServerEnv | WebsiteEnv, *, mcp: bool) -> boo through ``data/reset``, or an older server's ``/api/reset``; then, behind a gateway of ours, its changelog started afresh, as after a load. ``env`` is attached to its deployment, which may be a MultiEnv's. False, with nothing sent, for one serving no reset, which takes no load either: a card declaring operations without ``data/reset``, a plugin's - card offering it no data plane, or an older server answering 404.""" + card offering it no data plane, or an older server answering 404 that offers no ``_reset`` tool. One that does + offers it only to load a seed, which a load does; RuntimeError, since a reset can't empty it.""" name = env.environment_name if env._deployed is None and env._gateway_url is None: raise RuntimeError("Environment not deployed - call deploy() first") @@ -170,6 +171,9 @@ async def reset_server_data(env: MCPServerEnv | WebsiteEnv, *, mcp: bool) -> boo except httpx.HTTPStatusError as e: if e.response.status_code != 404: raise + if mcp and await legacy_protocol.offers_tool(f"{env._gateway_url.rstrip('/')}/mcp", f"{name}_reset"): + raise RuntimeError(f"MCP server '{name}' resets only to a seed loaded through its {name}_reset tool, so " + "a reset can't empty it; load it again instead") from None return False if builtin is not None: await builtin.install_changelog_triggers(name) diff --git a/src/agent_env/env/envs/multi_env.py b/src/agent_env/env/envs/multi_env.py index cf8f55b39..386ab9fc5 100644 --- a/src/agent_env/env/envs/multi_env.py +++ b/src/agent_env/env/envs/multi_env.py @@ -883,18 +883,20 @@ async def reset(self, deployed: DeployedEnv) -> None: """Reset every child env at once, each as it resets alone: a computer reboots from its own record and gets its ``tools`` again, and an MCP server or website is emptied of what loads put in, so a task loads again after; one serving no reset takes no load, and stays as it is. A child that fails to reset fails the reset, each such one - named, once the others have reset. Which services the instance's loads put in is forgotten, so the next load - puts each in again rather than resuming.""" - services = await type(self)._attached(deployed) if self.mcp_server_envs or self.website_envs else self + named, once the others have reset. Before any server is emptied, which services the instance's loads put in is + forgotten, so the next load puts each in again rather than resuming past one; a reset that can't forget it + empties nothing.""" + services = self + if self.mcp_server_envs or self.website_envs: + services = await type(self)._attached(deployed) + if deployed.instance_id: + env_store.get_env_instance_store().clear_loaded_environments(deployed.instance_id) resets = [*((f"computer {name!r}", call) for name, call in self._computers.resets(deployed)), *((f"MCP server {env.environment_name!r}", reset_server_data(env, mcp=True)) for env in services.mcp_server_envs), *((f"website {env.environment_name!r}", reset_server_data(env, mcp=False)) for env in services.website_envs)] - try: - results = await _multi_computers.each(self.id, "reset", resets) - finally: - _forget_loaded_environments(deployed.instance_id) + results = await _multi_computers.each(self.id, "reset", resets) for (child, _), result in zip(resets, results): if result is False: logger.info(f"multi env '{self.id}': {child} serves no reset and takes no load, so it stays as it is") @@ -925,7 +927,7 @@ def _forget_loaded_environments(instance_id: Optional[str]) -> None: env_store.get_env_instance_store().clear_loaded_environments(instance_id) except Exception as e: # noqa: BLE001 logger.warning(f"Could not forget which services instance {instance_id!r} loaded; a resumed load may skip " - f"one a reset emptied: {e}") + f"one: {e}") def _hand_provider_to_child_envs(env: MultiEnv) -> None: diff --git a/src/agent_env/env/legacy_protocol.py b/src/agent_env/env/legacy_protocol.py index 240ff3901..9ba6f702a 100644 --- a/src/agent_env/env/legacy_protocol.py +++ b/src/agent_env/env/legacy_protocol.py @@ -15,6 +15,8 @@ import httpx from agentenv_protocol import METHOD_GET, DataPart, client as protocol_v1 +from mcp import ClientSession +from mcp.client.streamable_http import streamable_http_client if TYPE_CHECKING: from agent_env.env.env import DeployedEnv @@ -260,6 +262,20 @@ async def service_state(deployed: Optional[DeployedEnv], gateway_url: Optional[s return await _export_state_at(base_url, timeout=EXPORT_STATE_TIMEOUT_SECONDS, verify=True) +async def offers_tool(mcp_url: str, name: str) -> bool: + """Whether the MCP endpoint at ``mcp_url`` lists the tool ``name``, on any page of its tools.""" + async with streamable_http_client(mcp_url) as (read_stream, write_stream, _): + async with ClientSession(read_stream, write_stream) as session: + await session.initialize() + cursor = None + while True: + page = await session.list_tools(cursor) + if any(tool.name == name for tool in page.tools): + return True + if not (cursor := page.nextCursor): + return False + + async def reset_via_mcp_tool( mcp_url: str, environment_name: str, @@ -267,8 +283,6 @@ async def reset_via_mcp_tool( max_retries: int = DEFAULT_MCP_MAX_RETRIES, ) -> None: """Call the ``{environment_name}_reset`` MCP tool, retrying on transient failures.""" - from mcp import ClientSession - from mcp.client.streamable_http import streamable_http_client for attempt in range(max_retries): reset_done = False diff --git a/tst/unit/env/envs/test_multi_env_computers.py b/tst/unit/env/envs/test_multi_env_computers.py index c904f7716..7cbc8f9e1 100644 --- a/tst/unit/env/envs/test_multi_env_computers.py +++ b/tst/unit/env/envs/test_multi_env_computers.py @@ -469,7 +469,7 @@ async def test_each_computer_that_fails_to_load_is_named_once_every_computer_has def server_resets(monkeypatch): """Each MCP server's and website's reset, as (name, mcp) in ``log``, attached to the multi env's record: False, as for one serving no reset, for a name in ``unserved``, and raising for one in ``failing``; the instance whose loads - are forgotten in ``forgotten``.""" + are forgotten in ``forgotten``, with how many servers had reset by then.""" resets = SimpleNamespace(log=[], unserved=set(), failing={}, forgotten=[], attached=[]) async def reset(env, *, mcp): @@ -490,7 +490,7 @@ async def attached(cls, deployed): monkeypatch.setattr("agent_env.env.envs.multi_env.reset_server_data", reset) monkeypatch.setattr(MultiEnv, "_attached", classmethod(attached)) monkeypatch.setattr(EnvInstanceStore, "clear_loaded_environments", - lambda store, instance_id: resets.forgotten.append(instance_id)) + lambda store, instance_id: resets.forgotten.append((instance_id, len(resets.log)))) return resets @@ -510,7 +510,7 @@ async def test_reset_resets_every_child_env_at_once_each_as_it_resets_alone_and_ assert sorted(log) == [("reset", "desktop", "sb-desktop"), ("reset", "laptop", "sb-laptop")] assert sorted(server_resets.log) == [("shop", False, "inst-1"), ("slack", True, "inst-1")] - assert server_resets.attached == ["inst-1"] and server_resets.forgotten == ["inst-1"] + assert server_resets.attached == ["inst-1"] and server_resets.forgotten == [("inst-1", 0)] # before any reset @pytest.mark.asyncio @@ -548,4 +548,16 @@ async def test_each_child_that_fails_to_reset_is_named_once_every_child_env_has_ assert str(raised.value) == ("multi env 'office': computer 'desktop' failed to reset: RuntimeError('no reboot'); " "MCP server 'slack' failed to reset: RuntimeError('data/reset timed out')") assert sorted(log) == [("reset", "desktop", "sb-desktop"), ("reset", "laptop", "sb-laptop")] - assert len(server_resets.log) == 2 and server_resets.forgotten == ["inst-1"] + assert len(server_resets.log) == 2 and server_resets.forgotten == [("inst-1", 0)] + + +@pytest.mark.asyncio +async def test_a_reset_that_cannot_forget_what_loads_put_in_empties_nothing(gateway, providers, server_resets, + monkeypatch): + stored, log = await _stored(FakeComputer("desktop")), [] + monkeypatch.setattr(EnvInstanceStore, "clear_loaded_environments", MagicMock(side_effect=OSError("store down"))) + + with pytest.raises(OSError, match="store down"): + await _multi(FakeComputer("desktop", log=log), mcp=["slack"], websites=["shop"]).reset(stored) + + assert log == server_resets.log == [] # a resumed load would skip a service a reset had emptied diff --git a/tst/unit/env/envs/test_server_reset.py b/tst/unit/env/envs/test_server_reset.py index 89f47c480..c74453bf1 100644 --- a/tst/unit/env/envs/test_server_reset.py +++ b/tst/unit/env/envs/test_server_reset.py @@ -75,12 +75,25 @@ async def test_a_server_whose_card_declares_no_data_reset_takes_no_load_and_is_l @pytest.mark.parametrize("status, reset", [(200, True), (404, False)], ids=["serves-it", "serves-none"]) async def test_an_older_server_is_emptied_through_its_api_reset_and_one_answering_404_has_none(server, status, reset): server.status = status - with patch("agent_env.env.legacy_protocol.v1_base_url", AsyncMock(return_value=None)): + with patch("agent_env.env.legacy_protocol.v1_base_url", AsyncMock(return_value=None)), \ + patch("agent_env.env.legacy_protocol.offers_tool", AsyncMock(return_value=False)) as offers: assert await _deployment.reset_server_data(_server(None), mcp=True) is reset [request] = server.requests assert (request.method, str(request.url)) == ("POST", f"{GATEWAY}/svc/mcp-email/api/reset") assert server.triggers.await_count == reset + assert [call.args for call in offers.await_args_list] == ([] if reset else [(f"{GATEWAY}/mcp", "email_reset")]) + + +@pytest.mark.asyncio +async def test_an_older_server_answering_404_that_resets_only_through_its_tool_to_a_seed_cant_be_emptied(server): + server.status = 404 + with patch("agent_env.env.legacy_protocol.v1_base_url", AsyncMock(return_value=None)), \ + patch("agent_env.env.legacy_protocol.offers_tool", AsyncMock(return_value=True)), \ + pytest.raises(RuntimeError, match="^MCP server 'email' resets only to a seed loaded through its email_reset " + "tool, so a reset can't empty it; load it again instead$"): + await _deployment.reset_server_data(_server(None), mcp=True) + assert not server.triggers.await_count @pytest.mark.asyncio From d83d1aaffee0240d99e1b6a99dd6157a2adf62cd Mon Sep 17 00:00:00 2001 From: Edgar Arakelyan Date: Sun, 8 Nov 2026 17:41:10 -0800 Subject: [PATCH 6/7] fix(multi): a universe load reads its environments at most once, and a restore without computers none A universe load read the universe's environments again at its end to load the computers', even into a multi env with none, and on a snapshot restore, which never read them before. A re-ingest now reads them once for the services and the computers alike, a restore reads them only for computers to load, and a multi env without computers loads none: as before computers, a restore no longer fails on an environment it never needed. Co-Authored-By: Claude Opus 5.5 --- src/agent_env/env/envs/multi_env.py | 13 ++++++-- tst/unit/env/envs/test_multi_env_computers.py | 30 +++++++++++++++---- 2 files changed, 35 insertions(+), 8 deletions(-) diff --git a/src/agent_env/env/envs/multi_env.py b/src/agent_env/env/envs/multi_env.py index 386ab9fc5..fe5b4d27c 100644 --- a/src/agent_env/env/envs/multi_env.py +++ b/src/agent_env/env/envs/multi_env.py @@ -360,6 +360,9 @@ async def load_environment_universe_artifact( env_fingerprint=env_fingerprint, ) if can_restore else None restored_from_snapshot = False + # The universe's environments, read at most once, and only for a load that needs them: a restore reads none + # unless the multi env has computers to load. + environments: Optional[list[EnvironmentArtifact]] = None snapshot_baked: bool | None = None snapshot_bake_error: str | None = None @@ -374,7 +377,8 @@ async def load_environment_universe_artifact( import asyncio import time # The services' alone: the computers' load after them, in each computer's own order. - environment_artifacts = [artifact for artifact in environment_universe_artifact.get_environment_artifacts() + environments = environment_universe_artifact.get_environment_artifacts() + environment_artifacts = [artifact for artifact in environments if self._computers.holding(artifact.environment_name) is None] total = len(environment_artifacts) # WARNING, not info: this is the path that can FAIL. Every service is @@ -464,8 +468,11 @@ async def _load_one(idx: int, artifact): for i, name, e in failed ) ) - # Every time, never skipped as a resumed service is: the changelog a resume reads doesn't see a computer's files. - await self._computers.load(environment_universe_artifact.get_environment_artifacts()) + if self.computer_envs: + # Every time, never skipped as a resumed service is: the changelog a resume reads doesn't see a computer's + # files. + await self._computers.load(environments if environments is not None + else environment_universe_artifact.get_environment_artifacts()) if self._instance_id: env_store.update_env_instance_environment_universe(self._instance_id, environment_universe_artifact.id, environment_universe_artifact.version) diff --git a/tst/unit/env/envs/test_multi_env_computers.py b/tst/unit/env/envs/test_multi_env_computers.py index 7cbc8f9e1..50d112519 100644 --- a/tst/unit/env/envs/test_multi_env_computers.py +++ b/tst/unit/env/envs/test_multi_env_computers.py @@ -426,11 +426,9 @@ async def test_a_computer_loads_its_own_environment_before_its_apps(): "desktop", "notes", "mail"] -@pytest.mark.asyncio -@pytest.mark.parametrize("restored", [False, True], ids=["re-ingested", "restored"]) -async def test_a_universe_loads_each_computers_environments_after_the_services_even_after_a_restore(restored): - log = [] - env = _multi(FakeComputer("desktop", apps=("notes",), log=log), FakeComputer("laptop", log=log)) +async def _load_universe(env: MultiEnv, log: list, *, restored: bool) -> MagicMock: + """Load a universe of five environments into ``env``, restored from a clean snapshot or re-ingested, each + service's load or the restore in ``log``; the universe, whose reads of its environments a test counts.""" env._instance_id, env._sandbox = "inst", MagicMock(mode="vm", exec_script=AsyncMock(return_value="8\n")) env._env_provider = EnvironmentGatewayProvider() env._env_provider._state_provider = LocalPostgresStateProvider() @@ -445,10 +443,32 @@ async def test_a_universe_loads_each_computers_environments_after_the_services_e patch("agent_env.env.snapshot_store._check_changelog_empty", AsyncMock(return_value=True)), \ patch("agent_env.env.store.update_env_instance_environment_universe", MagicMock()): await env.load_environment_universe_artifact(universe, snapshot_after_load=False) + return universe + + +@pytest.mark.asyncio +@pytest.mark.parametrize("restored", [False, True], ids=["re-ingested", "restored"]) +async def test_a_universe_loads_each_computers_environments_after_the_services_even_after_a_restore(restored): + log = [] + env = _multi(FakeComputer("desktop", apps=("notes",), log=log), FakeComputer("laptop", log=log)) + + universe = await _load_universe(env, log, restored=restored) services = [("restored",)] if restored else [("service", "a"), ("service", "b")] assert log[:len(services)] == services assert sorted(log[len(services):]) == [("loaded", "desktop", ["notes", "desktop"]), ("loaded", "laptop", ["laptop"])] + assert universe.get_environment_artifacts.call_count == 1 # the services and the computers load the same read + + +@pytest.mark.asyncio +@pytest.mark.parametrize("restored, reads", [(False, 1), (True, 0)], ids=["re-ingested", "restored"]) +async def test_a_multi_env_without_computers_reads_the_universes_environments_only_to_re_ingest_them(restored, reads): + log = [] + + universe = await _load_universe(_multi(mcp=["a", "b"]), log, restored=restored) + + assert log == ([("restored",)] if restored else [("service", name) for name in ("notes", "a", "desktop", "laptop", "b")]) + assert universe.get_environment_artifacts.call_count == reads # a restore needs none of them, as before computers @pytest.mark.asyncio From 877bfb8cc05b2a2c610bba1b8f2227fa9dfa5d56 Mon Sep 17 00:00:00 2001 From: Edgar Arakelyan Date: Sun, 8 Nov 2026 18:03:29 -0800 Subject: [PATCH 7/7] fix(multi): an older server's reset tool resets with no seed; reset_env covered for servers alone and in a multi env - An older MCP server answering 404 at /api/reset that offers its _reset tool is reset through it with no seed, which puts back the data it boots with, as /api/reset with no body does; only a tool that fails fails the reset. reset_via_mcp_tool takes no seed and returns the tool's answer. - Integration: a multi env without computers resets its servers through the reset_env step, the items server through data/reset and the older slack server, which serves no card, through /api/reset; a server deployed alone is emptied too. Co-Authored-By: Claude Opus 5.5 --- src/agent_env/env/envs/_deployment.py | 20 +++++++------ src/agent_env/env/legacy_protocol.py | 13 +++++---- .../env/envs/multi_env_local_test.py | 28 ++++++++++++++++--- .../env/envs/server_env_local_test.py | 4 +++ tst/unit/env/envs/test_server_reset.py | 21 ++++++++++++-- 5 files changed, 65 insertions(+), 21 deletions(-) diff --git a/src/agent_env/env/envs/_deployment.py b/src/agent_env/env/envs/_deployment.py index 89b7fec47..428c88528 100644 --- a/src/agent_env/env/envs/_deployment.py +++ b/src/agent_env/env/envs/_deployment.py @@ -147,11 +147,11 @@ async def load_by_signed_url(env: MCPServerEnv | WebsiteEnv, environment_artifac async def reset_server_data(env: MCPServerEnv | WebsiteEnv, *, mcp: bool) -> bool: """Empty what loads put into ``env``, an MCP server or with ``mcp=False`` a website, as each load does before it adds: - through ``data/reset``, or an older server's ``/api/reset``; then, behind a gateway of ours, its changelog started - afresh, as after a load. ``env`` is attached to its deployment, which may be a MultiEnv's. False, with nothing sent, - for one serving no reset, which takes no load either: a card declaring operations without ``data/reset``, a plugin's - card offering it no data plane, or an older server answering 404 that offers no ``_reset`` tool. One that does - offers it only to load a seed, which a load does; RuntimeError, since a reset can't empty it.""" + through ``data/reset``, or an older server's ``/api/reset``, or else its ``_reset`` tool, which with no seed + puts back the data the server boots with; then, behind a gateway of ours, its changelog started afresh, as after a + load. ``env`` is attached to its deployment, which may be a MultiEnv's. False, with nothing sent, for one serving no + reset, which takes no load either: a card declaring operations without ``data/reset``, a plugin's card offering it + no data plane, or an older server answering 404 that offers no ``_reset`` tool.""" name = env.environment_name if env._deployed is None and env._gateway_url is None: raise RuntimeError("Environment not deployed - call deploy() first") @@ -171,10 +171,12 @@ async def reset_server_data(env: MCPServerEnv | WebsiteEnv, *, mcp: bool) -> boo except httpx.HTTPStatusError as e: if e.response.status_code != 404: raise - if mcp and await legacy_protocol.offers_tool(f"{env._gateway_url.rstrip('/')}/mcp", f"{name}_reset"): - raise RuntimeError(f"MCP server '{name}' resets only to a seed loaded through its {name}_reset tool, so " - "a reset can't empty it; load it again instead") from None - return False + mcp_url = f"{env._gateway_url.rstrip('/')}/mcp" + if not (mcp and await legacy_protocol.offers_tool(mcp_url, f"{name}_reset")): + return False + if (answer := await legacy_protocol.reset_via_mcp_tool(mcp_url, name)).isError: + said = "".join(part.text for part in answer.content if hasattr(part, "text")) + raise RuntimeError(f"MCP server '{name}': its {name}_reset tool failed: {said}") from None if builtin is not None: await builtin.install_changelog_triggers(name) return True diff --git a/src/agent_env/env/legacy_protocol.py b/src/agent_env/env/legacy_protocol.py index 9ba6f702a..c914e51cd 100644 --- a/src/agent_env/env/legacy_protocol.py +++ b/src/agent_env/env/legacy_protocol.py @@ -16,6 +16,7 @@ import httpx from agentenv_protocol import METHOD_GET, DataPart, client as protocol_v1 from mcp import ClientSession +from mcp.types import CallToolResult from mcp.client.streamable_http import streamable_http_client if TYPE_CHECKING: @@ -279,11 +280,12 @@ async def offers_tool(mcp_url: str, name: str) -> bool: async def reset_via_mcp_tool( mcp_url: str, environment_name: str, - mock_data_path: str, + mock_data_path: Optional[str] = None, max_retries: int = DEFAULT_MCP_MAX_RETRIES, -) -> None: - """Call the ``{environment_name}_reset`` MCP tool, retrying on transient failures.""" - +) -> CallToolResult: + """Call the ``{environment_name}_reset`` MCP tool, retrying on transient failures; what it answered. With + ``mock_data_path``, the seed it loads; with none, an older server's tool puts back the data it boots with.""" + arguments = {} if mock_data_path is None else {"mock_data_path": mock_data_path} for attempt in range(max_retries): reset_done = False try: @@ -291,7 +293,7 @@ async def reset_via_mcp_tool( async with ClientSession(read_stream, write_stream) as session: await session.initialize() reset_tool_name = f"{environment_name}_reset" - result = await session.call_tool(reset_tool_name, {"mock_data_path": mock_data_path}) + result = await session.call_tool(reset_tool_name, arguments) result_text = "".join(c.text for c in result.content if hasattr(c, "text")) logger.info(f"load_environment_artifact: {reset_tool_name} returned: {result_text}") reset_done = True @@ -312,6 +314,7 @@ async def reset_via_mcp_tool( raise else: break + return result async def reset( diff --git a/tst/integration/env/envs/multi_env_local_test.py b/tst/integration/env/envs/multi_env_local_test.py index ce5dc5e05..92535eede 100644 --- a/tst/integration/env/envs/multi_env_local_test.py +++ b/tst/integration/env/envs/multi_env_local_test.py @@ -1,14 +1,16 @@ """A MultiEnv on the local backend: two MCP servers behind one gateway and the local Postgres store, on docker compose. -The env deploys, a fresh object restores its record as a later process would, loads a universe into one of its servers, -and close() takes the whole compose stack down. Requires a docker daemon; spins up a throwaway ``registry:2`` and skips -if it can't start. +The env deploys, a fresh object restores its record as a later process would, loads a universe into both its servers, +the reset_env step empties both (the items server through data/reset, the older slack server, which serves no card, +through its /api/reset), and close() takes the whole compose stack down. Requires a docker daemon; spins up a throwaway +``registry:2`` and skips if it can't start. """ import json import uuid from pathlib import Path +import httpx import pytest from agentenv_protocol import client as protocol_v1 @@ -17,6 +19,8 @@ from agent_env.env.env import DeployedGatewayEnv, Env from agent_env.env.envs.mcp_server import MCPServerEnv from agent_env.env.envs.multi_env import MultiEnv +from agent_env.task_step.context import TaskStepContext +from agent_env.task_step.task_steps.reset_env import ResetEnvTaskStep from tst.integration.env.envs.server_env_local_test import _put_items_image from tst.integration.store.local_parallel_deploy_test import _docker, _seed_bootstrap_envs, local_stack as local_stack @@ -50,6 +54,14 @@ async def test_a_multi_env_deploys_restores_loads_and_tears_down_on_local_compos await restored.load_environment_universe_artifact(_items_universe(uid)) base_url = await legacy_protocol.v1_base_url(deployed, deployed.gateway_url, "items") assert (await protocol_v1.get_data(base_url)).model_dump()["parts"][0]["data"] == {"items": ["snap-x", "snap-y"]} + slack_state = f"{legacy_protocol.environment_base_url(deployed.gateway_url, 'slack')}/export-state" + assert len(httpx.get(slack_state, timeout=30).json()["channels"]) == 10 + + # A multi env without computers resets its servers, each as it resets alone, and fails if one doesn't. + await ResetEnvTaskStep(id="reset", version=None, env_id=env.id, fail_task_on_error=True).execute( + TaskStepContext(deployed_envs=[deployed])) + assert (await protocol_v1.get_data(base_url)).model_dump()["parts"][0]["data"] == {"items": []} + assert httpx.get(slack_state, timeout=30).json()["channels"] == [] await restored.close() assert _stack(work_dir) == "" @@ -63,10 +75,18 @@ def _stack(work_dir: Path) -> str: def _items_universe(uid: str) -> EnvironmentUniverseArtifact: + """The items server's two items, and the slack server's workspace of ten channels.""" items = EnvironmentArtifact.put( id=f"multi-items-data-{uid}", environment_name="items", file_artifact=FileArtifact.put_bytes(id=f"multi-items-file-{uid}", description="multi env e2e", filename="items.json", content=json.dumps({"items": ["snap-x", "snap-y"]}).encode(), content_type="application/json"), ) - return EnvironmentUniverseArtifact.put(id=f"multi-universe-{uid}", environment_artifacts=[items]) + slack = EnvironmentArtifact.put( + id=f"multi-slack-data-{uid}", + environment_name="slack", + file_artifact=FileArtifact.put_bytes(id=f"multi-slack-file-{uid}", description="multi env e2e", filename="slack.json", + content=(_TST_DATA / "slack_mcp/generated_data.json").read_bytes(), + content_type="application/json"), + ) + return EnvironmentUniverseArtifact.put(id=f"multi-universe-{uid}", environment_artifacts=[items, slack]) diff --git a/tst/integration/env/envs/server_env_local_test.py b/tst/integration/env/envs/server_env_local_test.py index 1285ea568..04e88dc04 100644 --- a/tst/integration/env/envs/server_env_local_test.py +++ b/tst/integration/env/envs/server_env_local_test.py @@ -38,6 +38,7 @@ from agent_env.task import EpisodeSpec, Task from agent_env.task_step.context import TaskStepContext from agent_env.task.teardown import TORN_DOWN_KEY +from agent_env.task_step.task_steps.reset_env import ResetEnvTaskStep from agent_env.task_step.task_steps.teardown_sandboxes import TeardownSandboxesTaskStep from tst.integration.utils.registry import REGISTRY_IMAGE from tst.util.a2a_test_agent import put_test_agent @@ -125,6 +126,9 @@ async def test_a_server_env_deploys_restores_loads_and_tears_down_on_local_conta await restored.load_environment_artifact(_items_artifact(uid)) base_url = await legacy_protocol.v1_base_url(deployed, None, "items") assert (await protocol_v1.get_data(base_url)).model_dump()["parts"][0]["data"] == {"items": ["snap-x", "snap-y"]} + await ResetEnvTaskStep(id="reset", version=None, env_id=env.id, fail_task_on_error=True).execute( + TaskStepContext(deployed_envs=[deployed])) + assert (await protocol_v1.get_data(base_url)).model_dump()["parts"][0]["data"] == {"items": []} # emptied alone too step = TeardownSandboxesTaskStep(id="teardown", version=None, env_ids=[env.id]) context = await step.execute(TaskStepContext(deployed_envs=[deployed])) diff --git a/tst/unit/env/envs/test_server_reset.py b/tst/unit/env/envs/test_server_reset.py index c74453bf1..a73236dc1 100644 --- a/tst/unit/env/envs/test_server_reset.py +++ b/tst/unit/env/envs/test_server_reset.py @@ -10,6 +10,7 @@ import httpx import pytest +from mcp.types import CallToolResult, TextContent from agent_env.env.env import DeployedEnv from agent_env.env.envs import _deployment, mcp_server, website @@ -86,12 +87,26 @@ async def test_an_older_server_is_emptied_through_its_api_reset_and_one_answerin @pytest.mark.asyncio -async def test_an_older_server_answering_404_that_resets_only_through_its_tool_to_a_seed_cant_be_emptied(server): +async def test_an_older_server_answering_404_resets_through_its_tool_with_no_seed_to_the_data_it_boots_with(server): server.status = 404 + tool = AsyncMock(return_value=CallToolResult(content=[TextContent(type="text", text="Data reset for email.")])) with patch("agent_env.env.legacy_protocol.v1_base_url", AsyncMock(return_value=None)), \ patch("agent_env.env.legacy_protocol.offers_tool", AsyncMock(return_value=True)), \ - pytest.raises(RuntimeError, match="^MCP server 'email' resets only to a seed loaded through its email_reset " - "tool, so a reset can't empty it; load it again instead$"): + patch("agent_env.env.legacy_protocol.reset_via_mcp_tool", tool): + assert await _deployment.reset_server_data(_server(None), mcp=True) is True + + tool.assert_awaited_once_with(f"{GATEWAY}/mcp", "email") # no seed + server.triggers.assert_awaited_once_with("email") + + +@pytest.mark.asyncio +async def test_an_older_server_whose_reset_tool_fails_fails_its_reset_named(server): + server.status = 404 + failed = CallToolResult(content=[TextContent(type="text", text="database is locked")], isError=True) + with patch("agent_env.env.legacy_protocol.v1_base_url", AsyncMock(return_value=None)), \ + patch("agent_env.env.legacy_protocol.offers_tool", AsyncMock(return_value=True)), \ + patch("agent_env.env.legacy_protocol.reset_via_mcp_tool", AsyncMock(return_value=failed)), \ + pytest.raises(RuntimeError, match="^MCP server 'email': its email_reset tool failed: database is locked$"): await _deployment.reset_server_data(_server(None), mcp=True) assert not server.triggers.await_count