agentenv-framework 0.9.1305__tar.gz → 0.9.1306__tar.gz

{agentenv_framework-0.9.1305 → agentenv_framework-0.9.1306}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: agentenv-framework
-Version: 0.9.1305
+Version: 0.9.1306
 Summary: SDK and CLI for building, deploying and running agent environments and the tasks that grade agents in them.
 Project-URL: Homepage, https://www.agentenvframework.com
 Project-URL: Documentation, https://www.agentenvframework.com/docs
@@ -27,9 +27,9 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
 Classifier: Typing :: Typed
-Requires-Python: >=3.11
+Requires-Python: >=3.11.4
 Requires-Dist: a2a-sdk==0.3.26
-Requires-Dist: agentenv-framework-protocol==0.1.320
+Requires-Dist: agentenv-framework-protocol==0.1.321
 Requires-Dist: certifi>=2024.2.2
 Requires-Dist: click>=8.0.0
 Requires-Dist: cryptography>=42
@@ -94,7 +94,7 @@ AgentEnv Framework is a Python SDK and CLI for building, deploying and running a
 
 ## Install
 
-Both packages are on PyPI. You need Python 3.11 or newer and, to run environments locally, a running Docker daemon. With [uv](https://docs.astral.sh/uv/), install the `agent-env` command as a tool:
+Both packages are on PyPI. You need Python 3.11.4 or newer and, to run environments locally, a running Docker daemon. With [uv](https://docs.astral.sh/uv/), install the `agent-env` command as a tool:
 
 ```bash
 uv tool install agentenv-framework

{agentenv_framework-0.9.1305 → agentenv_framework-0.9.1306}/README.md

@@ -11,7 +11,7 @@ AgentEnv Framework is a Python SDK and CLI for building, deploying and running a
 
 ## Install
 
-Both packages are on PyPI. You need Python 3.11 or newer and, to run environments locally, a running Docker daemon. With [uv](https://docs.astral.sh/uv/), install the `agent-env` command as a tool:
+Both packages are on PyPI. You need Python 3.11.4 or newer and, to run environments locally, a running Docker daemon. With [uv](https://docs.astral.sh/uv/), install the `agent-env` command as a tool:
 
 ```bash
 uv tool install agentenv-framework

{agentenv_framework-0.9.1305 → agentenv_framework-0.9.1306}/packages/agentenv-protocol/pyproject.toml

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

{agentenv_framework-0.9.1305 → agentenv_framework-0.9.1306}/pyproject.toml

@@ -4,13 +4,13 @@ build-backend = "hatchling.build"
 
 [project]
 name = "agentenv-framework"
-version = "0.9.1305"
+version = "0.9.1306"
 description = "SDK and CLI for building, deploying and running agent environments and the tasks that grade agents in them."
 readme = "README.md"
 license = "Apache-2.0"
 license-files = ["LICENSE", "NOTICE", "THIRD_PARTY_NOTICES.md"]
 authors = [{ name = "Scale AI" }]
-requires-python = ">=3.11"
+requires-python = ">=3.11.4"
 keywords = ["reinforcement-learning", "rl-environments", "ai-agents", "llm-agents", "agent-evaluation", "mcp", "model-context-protocol", "a2a", "sandbox"]
 classifiers = [
     "Development Status :: 4 - Beta",
@@ -29,7 +29,7 @@ classifiers = [
     "Typing :: Typed",
 ]
 dependencies = [
-    "agentenv-framework-protocol==0.1.320",
+    "agentenv-framework-protocol==0.1.321",
     "certifi>=2024.2.2",  # the public roots the local transfer CA's trust bundle carries
     "click>=8.0.0",
     "cryptography>=42",  # the local transfer CA

{agentenv_framework-0.9.1305 → agentenv_framework-0.9.1306}/src/agent_env/a2a_agent/a2a_agent.py

@@ -26,16 +26,13 @@ from agent_env.a2a_agent.object_transfer import (
     skill_add_call,
 )
 from agent_env.a2a_agent.staging import transfer_store
-from agent_env.providers.sandbox_providers.local_sandbox import (
-    LOCAL_TRUST_ENV,
-    LocalSandbox,
-    LocalSandboxProvider,
-    local_grant_trust,
-    start_trusting,
+from agent_env.providers.sandbox_providers.local_sandbox import LOCAL_TRUST_ENV, local_grant_trust, start_trusting
+from agent_env.providers.sandbox_providers.sandbox_provider import (
+    Accepts,
+    SandboxProvider,
+    all_sandbox_container_env,
+    all_sandbox_url_rewrites,
 )
-from agent_env.providers.sandbox_providers.chained_sandbox_provider import ChainedSandboxProvider
-from agent_env.providers.sandbox_providers.modal_sandbox import ModalSandboxProvider
-from agent_env.providers.sandbox_providers.sandbox_provider import all_sandbox_container_env, all_sandbox_url_rewrites
 from agent_env.attribution import Attribution
 
 if TYPE_CHECKING:
@@ -122,6 +119,11 @@ class A2AAgent:
     SNAPSHOT_METHOD_ENABLE_CHANGELOG: ClassVar[str] = "enable-changelog"
     SNAPSHOT_METHOD_APPLY_CHANGELOG: ClassVar[str] = "apply-changelog"
 
+    @staticmethod
+    def accepts(sandbox_provider: SandboxProvider) -> Accepts:
+        """The images an agent deploys from on ``sandbox_provider``: those its sandboxes run (``create_sandbox``)."""
+        return sandbox_provider.SANDBOX_ACCEPTS
+
     @staticmethod
     def find_extension(card: dict, uri: str) -> dict | None:
         caps = card.get("capabilities") or {}
@@ -428,8 +430,8 @@ class A2AAgent:
             resolved_env["LITELLM_API_KEY"] = config.get_litellm_api_key()
         if "LITELLM_BASE_URL" not in resolved_env and "LITELLM_BASE_URL" not in self.default_env_vars:
             resolved_env["LITELLM_BASE_URL"] = config.get_litellm_base_url()
-        if "LITELLM_BASE_URL" in resolved_env and isinstance(provider or sandbox, (LocalSandboxProvider, LocalSandbox)):
-            resolved_env["LITELLM_BASE_URL"] = LocalSandboxProvider.get_external_url(resolved_env["LITELLM_BASE_URL"])
+        if "LITELLM_BASE_URL" in resolved_env:
+            resolved_env["LITELLM_BASE_URL"] = (provider or sandbox).url_from_sandbox(resolved_env["LITELLM_BASE_URL"])
 
         merged_env = await asyncio.to_thread(self._build_merged_env, resolved_env, a2a_port)
         image_name = self.docker_image_artifact.image_name
@@ -437,14 +439,15 @@ class A2AAgent:
             if provider is None and sandbox.mode != SANDBOX_MODE_VM:
                 raise ValueError(f"Can't deploy agent {self.id!r} on the container sandbox {sandbox.sandbox_id!r}, which "
                                  f"runs its own image, never the agent's: {problem}")
-            links = provider.providers if isinstance(provider, ChainedSandboxProvider) else [provider] if provider else []
-            if by_name := [link for link in links if isinstance(link, (LocalSandboxProvider, ModalSandboxProvider))]:
+            links = provider.links if provider else ()
+            if by_name := [link for link in links if self.accepts(link).problem(self.docker_image_artifact)]:
                 raise ValueError(f"Can't deploy agent {self.id!r} with {type(by_name[0]).__name__}, which runs an "
                                  f"agent's image by name: {problem}")
 
         try:
             if provider is not None:
                 logger.info(f"Provisioning sandbox for A2A agent '{self.id}' via {type(provider).__name__}...")
+                await provider.prepare_image(self.docker_image_artifact, attribution=attribution)
                 self._sandbox = await provider.create_sandbox(
                     image_name=image_name, port=a2a_port, env=merged_env,
                     cpu=cpu, memory=memory, disk_size_gb=disk_size_gb, timeout=ttl_seconds,
@@ -520,7 +523,7 @@ class A2AAgent:
 
     async def _run_container(self, image_name: str, a2a_port: int, merged_env: dict[str, str], enable_docker: bool = False) -> None:
         # On a local VM sandbox the container runs on this host, so it is given the local CA as the provider's are.
-        trust_dir = await asyncio.to_thread(local_grant_trust) if isinstance(self._sandbox, LocalSandbox) else None
+        trust_dir = await asyncio.to_thread(local_grant_trust) if self._sandbox.ON_THIS_MACHINE else None
         agent_env = dict(merged_env) if trust_dir is None else {**LOCAL_TRUST_ENV, **merged_env}
         setup_script = ""
         network_flag = "".join(f"--add-host {entry} \\\n    " for entry in self._sandbox.extra_hosts)

{agentenv_framework-0.9.1305 → agentenv_framework-0.9.1306}/src/agent_env/artifact/artifacts/docker_image.py

@@ -271,7 +271,7 @@ class DockerImageArtifact(Artifact):
     @property
     def context_only(self) -> bool:
         """Whether only the image's build context is stored: no tar.gz, and an image name that names no registry, the
-        tag a VM sandbox gives the image when it builds it."""
+        tag the image's build gives it."""
         return bool(self.build_context_object_url) and not self.tar_gz_object_url and not names_registry(self.image_name)
 
     def load_problem(self) -> str | None:
@@ -284,9 +284,10 @@ class DockerImageArtifact(Artifact):
 
     def by_name_problem(self) -> str | None:
         """Why a sandbox that runs an image by pulling its name can't run this one, or None when it can: a context-only
-        image's name is a tag only a VM sandbox's build gives it, and pulled, it would be looked up on Docker Hub."""
+        image's name is a tag only its build gives it, a VM sandbox's or Modal's, and pulled, it would be looked up on
+        Docker Hub."""
         if self.context_only:
-            return f"{self.id!r} v{self.version} is only a build context, which only a VM sandbox builds"
+            return f"{self.id!r} v{self.version} is only a build context, which has to be built, not pulled"
         return None
 
     @classmethod
@@ -309,7 +310,6 @@ class DockerImageArtifact(Artifact):
         without slashes, or the default branch.
         """
         from agent_env.providers import get_sandbox_provider
-        from agent_env.providers.sandbox_providers.local_sandbox import LocalSandboxProvider
         from agent_env.providers.sandbox_providers.sandbox import upload_vm_file
         from agent_env.config import get_config
 
@@ -344,7 +344,7 @@ class DockerImageArtifact(Artifact):
         repository = image_repository(id)
         image_ref = image_store.image_ref(repository, f"v{version}")
         provider = get_sandbox_provider()
-        if is_loopback_host(registry_host_from_ref(image_ref)) and not isinstance(provider, LocalSandboxProvider):
+        if is_loopback_host(registry_host_from_ref(image_ref)) and not provider.ON_THIS_MACHINE:
             raise ValueError(
                 f"{image_ref} is in a registry on this machine, which a {type(provider).__name__} build VM can't push to; "
                 "build on the local sandbox provider, or configure an image store a remote VM can reach"

{agentenv_framework-0.9.1305 → agentenv_framework-0.9.1306}/src/agent_env/bundle/ledger.py

@@ -42,7 +42,7 @@ LEDGER_COLLECTION = "bundle_ledger"
 SCHEME = 1
 
 _CONTEXT = "build context"
-_FORMS = {None: "an image built on this machine", _CONTEXT: "a build context, which its VMs build"}
+_FORMS = {None: "an image built on this machine", _CONTEXT: "a build context, built where it runs"}
 
 _COLLECTIONS = {"env": ENVS_COLLECTION, "agent": A2A_AGENTS_COLLECTION, "artifact": ARTIFACTS_COLLECTION,
                 "task": TASKS_COLLECTION, "eval": EVALS_COLLECTION}
@@ -53,7 +53,7 @@ _LISTED = 5
 class Digest:
     value: str
     inputs: dict[str, Any]  # type, config, files {key: sha256}, needs and store_refs {"<kind> <id>": version}, and
-    # for an image written as its build context, its form and the platform its VMs build it for
+    # for an image written as its build context, its form and the platform it's built for
 
 
 @dataclass(frozen=True)

{agentenv_framework-0.9.1305 → agentenv_framework-0.9.1306}/src/agent_env/bundle/materialize.py

@@ -4,11 +4,12 @@ Materializing first refuses every write this release has no writer for, so nothi
 that can't be written whole. It needs the CLI's namespace routing, which sends ``@local`` writes to the
 ``@local`` namespace's store. Holding the bundle's lock, it writes the entities in the plan's order, an image
 built from an entry's Dockerfile just before the entry: with ``docker build`` on this machine, or, for one
-whose deploys build it in their VMs, as its build context alone. Then it builds and preflights every task
-before writing any of them, and writes the evals last, since they name the tasks. Each write goes through the ledger, so one whose inputs haven't changed reuses the version the bundle
-last wrote. A reused task keeps whatever its steps took from config when it was first written, such as a
-rubrics verifier's default judge model. A dry run takes the same path, refusals, checks and preflights
-included, without the lock or a single write.
+whose deploys build it where they run, as its build context alone. Then it builds and preflights every task
+before writing any of them, and writes the evals last, since they name the tasks. Each write goes through the
+ledger, so one whose inputs haven't changed reuses the version the bundle last wrote. A reused task keeps
+whatever its steps took from config when it was first written, such as a rubrics verifier's default judge
+model. A dry run takes the same path, refusals, checks and preflights included, without the lock or a single
+write.
 """
 
 from __future__ import annotations
@@ -83,7 +84,7 @@ def materialize(
     one stays: they're in the ledger, so the next run reuses them. ``on_wait`` is called when another run
     holds a lock this one needs, ``on_build`` before an image is built, and ``on_write`` after each write,
     reused or not. An image the bundle builds whose id is in ``contexts`` is written as its build context
-    alone, for the VM sandboxes that deploy it to build (``preflight_run`` decides which).
+    alone, for the providers that deploy it to build (``preflight_run`` decides which).
 
     ``dry_run`` checks and preflights what a run would, and writes nothing: no entity, ledger row or lock.
     Each write gets the version it would reuse or the store's next, which another run can take first. A step
@@ -159,7 +160,7 @@ def _staged(plan: Plan, image: BuiltImage) -> Iterator[Path]:
 
 def _write_build_context(plan: Plan, write: Write) -> int:
     """Write the image an entry's Dockerfile describes as a docker_image artifact holding its build context alone,
-    which each VM sandbox that deploys it builds."""
+    which each provider that deploys it builds."""
     image = write.source
     with _staged(plan, image) as context:
         try:

{agentenv_framework-0.9.1305 → agentenv_framework-0.9.1306}/src/agent_env/bundle/preflight.py

@@ -10,8 +10,9 @@ that names none, deploy the configured default agent, which must be in the store
 checked from its planned env.toml.
 
 An image the bundle builds is written in the form its deploys can run: built on this machine when they deploy on the
-local provider, and as its build context alone when they deploy on providers whose VMs build it. One version is one of
-the two, so a run deploying it both ways is refused, as is one deploying it on a provider that runs an image by name.
+local provider, and as its build context alone when they deploy on providers that build it, in a VM or, as Modal does,
+themselves. One version is one of the two, so a run deploying it both ways is refused, as is one deploying it on a
+provider that runs an image by name.
 
 A gateway deploy on the local provider runs on infra envs the store may not hold yet: the gateway, the service-db its
 local Postgres state runs from, and the website browser it adds for websites. The run builds those once its writes are
@@ -20,8 +21,8 @@ done (``agent_env.env.bootstrap``), so they're named here, and refused here when
 
 from __future__ import annotations
 
-from collections.abc import Callable, Iterable
-from dataclasses import dataclass
+from collections.abc import Callable, Iterable, Mapping
+from dataclasses import dataclass, field
 from urllib.parse import urlparse
 
 from agent_env.a2a_agent import A2AAgent
@@ -50,10 +51,8 @@ from agent_env.providers.env_providers.env_provider import _env_provider_class
 from agent_env.providers.env_providers.env_server_provider import EnvironmentServerProvider
 from agent_env.providers.env_state.env_state_provider import LOCAL_POSTGRES_STATE_TYPE
 from agent_env.providers.env_state.store import get_env_state_instance_store
-from agent_env.providers.sandbox_providers.chained_sandbox_provider import ChainedSandboxProvider
-from agent_env.providers.sandbox_providers.local_sandbox import LocalSandboxProvider
-from agent_env.providers.sandbox_providers.modal_sandbox import ModalSandboxProvider
 from agent_env.providers.sandbox_providers.sandbox_provider import (
+    Accepts,
     SandboxProvider,
     build_sandbox_provider,
     get_agent_sandbox_provider,
@@ -100,8 +99,7 @@ class _Image:
 
     what: str
     local_only: str | None  # why only this machine has it, or None
-    unloadable: str | None = None  # why no sandbox can get it, or None
-    by_name: str | None = None  # why a sandbox that runs it by pulling its name can't, or None
+    refused: Mapping[Accepts, str] = field(default_factory=dict)  # why a provider accepting each form can't run it
     built: str | None = None  # the id of the image when the bundle builds it, whose form the walk decides at the end
 
 
@@ -128,8 +126,8 @@ class _Walk:
         self.agents = {write.id: write.source for write in plan.writes if write.kind is BundleKind.AGENT}
         self.envs = {write.id: write.source for write in plan.writes if write.kind is BundleKind.ENV}
         self.built = {write.id: write.source for write in plan.writes if isinstance(write.source, BuiltImage)}
-        # Each deploy of an image the bundle builds: (where, what, its provider's links, those that run it by name)
-        self.uses: dict[str, list[tuple[str, str, list[SandboxProvider], list[SandboxProvider]]]] = {}
+        # Each deploy of an image the bundle builds: (where, what, its provider's links, the images it accepts on each)
+        self.uses: dict[str, list[tuple[str, str, list[SandboxProvider], Callable[[SandboxProvider], Accepts]]]] = {}
 
     def task(self, task: ResolvedEntry) -> None:
         steps = [build_step(config) for config in task.config]
@@ -189,27 +187,19 @@ class _Walk:
             kinds = set()
         else:  # a plugin's provider, or one deploy_env's own preflight refuses for this env
             return
-        env_id, images = step.env_id, deployment.images
-        if GATEWAY in kinds and (loaders := [link for link in _links(provider)
-                                             if not isinstance(link, ModalSandboxProvider)]):
-            self._loadable(where, loaders, images)  # a gateway VM loads its images; Modal's runs each by name
-        # A lone server runs in a container from its image's name on any provider; a gateway does on Modal.
-        by_name = ([link for link in _links(provider) if isinstance(link, ModalSandboxProvider)] if GATEWAY in kinds
-                   else _links(provider))
-        self._by_name(where, by_name, images)
-        self._use(where, _links(provider), by_name, images)
+        env_id, images, env_provider = step.env_id, deployment.images, deployment.provider
+        self._check(where, provider, env_provider.accepts, images)
         if _local_link(provider):
             self.infra |= kinds
             self.docker_users.append(where)
-        if remote := _remote_links(provider):
-            self._reachable(where, remote, images)
-            # Modal's gateway runs each server in a container of its own, and can't serve websites.
-            containers = [link for link in remote if isinstance(link, ModalSandboxProvider)]
+        if (remote := _remote_links(provider)) and GATEWAY in kinds:
+            for link in remote:
+                if problem := env_provider.sandbox_problem(link, websites=WEBSITE_BROWSER in kinds):
+                    self._problem(where, f"deploys env {env_id!r} on the {_shown(link)} sandbox provider, which "
+                                         f"{problem}; run it on a VM provider, such as --sandbox local")
+                    break
+            containers = [link for link in remote if not env_provider.in_vm(link)]
             vms = [link for link in remote if link not in containers]
-            if WEBSITE_BROWSER in kinds and containers:
-                self._problem(where, f"deploys env {env_id!r}, which has websites, on the {_shown(containers[0])} "
-                                     "sandbox provider, whose gateway runs in containers and can't serve websites; run it "
-                                     "on a VM provider, such as --sandbox local")
             if containers:
                 self.remote_infra.append((where, containers[0], kinds - {WEBSITE_BROWSER}))
             if vms:
@@ -305,22 +295,13 @@ class _Walk:
         if agent_id is None:
             self.default_agent_users.append((where, unnamed))
             agent_id = get_config().get_default_a2a_agent_id()
-        by_name = [link for link in _links(provider) if isinstance(link, (LocalSandboxProvider, ModalSandboxProvider))]
-        loaders = [link for link in _links(provider) if link not in by_name]  # by_name run an agent in a container
-        remote = _remote_links(provider)
-        if (image := self._agent_image(agent_id, version)) is None:
-            return
-        if loaders:
-            self._loadable(where, loaders, [image])
-        self._by_name(where, by_name, [image])
-        self._use(where, _links(provider), by_name, [image])
-        if remote:
-            self._reachable(where, remote, [image])
+        if (image := self._agent_image(agent_id, version)) is not None:
+            self._check(where, provider, A2AAgent.accepts, [image])
 
     def _sandbox(self, where: str, step: DeploySandboxTaskStep) -> None:
         provider = _provider(self.sandbox or step.sandbox_type, get_sandbox_provider)
         if step.sandbox_mode == "vm":
-            if not _creates_vms(provider):
+            if not provider.CREATES_VMS:
                 self._problem(where, f"deploys a VM sandbox, and the {_shown(provider)} sandbox provider can't create a "
                                      "VM; run it on one that can, such as --sandbox local")
             return
@@ -348,22 +329,37 @@ class _Walk:
         except (NotFoundError, ValueError, KeyError, TypeError):
             return None
 
-    def _loadable(self, where: str, loaders: list[SandboxProvider], images: list[_Image]) -> None:
-        """Refuse each of ``images`` a VM on ``loaders`` can't get: it loads an image's tar.gz, or pulls an image with
-        none by name."""
+    def _check(self, where: str, provider: SandboxProvider, accepts: Callable[[SandboxProvider], Accepts],
+               images: list[_Image]) -> None:
+        """Check ``images`` on each provider a deploy may run on, as ``accepts`` says the deploy runs them there, and
+        that one not on this machine reaches each. An image the bundle builds is noted with them, for ``_contexts`` to
+        choose its form."""
+        links = list(provider.links)
+        for form in Accepts:
+            if accepting := [link for link in links if accepts(link) is form]:
+                self._accepted(where, accepting[0], form, images)
+        if remote := _remote_links(provider):
+            self._reachable(where, remote, images)
         for image in images:
-            if image.unloadable:
-                self._problem(where, f"deploys {image.what} on the {_shown(loaders[0])} sandbox provider, which can't "
-                                     f"load it: {image.unloadable}")
+            if image.built is not None:
+                self.uses.setdefault(image.built, []).append((where, image.what, links, accepts))
 
-    def _by_name(self, where: str, links: list[SandboxProvider], images: list[_Image]) -> None:
-        """Refuse each of ``images`` a sandbox on ``links`` can't run: it pulls an image by its name, and a context-only
-        image's name is a tag only a VM sandbox's build gives it."""
+    def _accepted(self, where: str, link: SandboxProvider, form: Accepts, images: list[_Image]) -> None:
+        """Refuse each of ``images`` a deploy can't run on ``link``, which takes images in ``form``: a VM loads an
+        image's tar.gz, or pulls an image with none when its name names a registry, and a provider that runs an image
+        by name can't run one that is only a build context, whose name is a tag only its build gives it."""
         for image in images:
-            if links and image.by_name:
-                self._problem(where, f"deploys {image.what} on the {_shown(links[0])} sandbox provider, which runs it "
-                                     f"by name: {image.by_name}; run it on a provider whose VMs build it, such as "
-                                     "--sandbox modal_vm")
+            if (refusal := image.refused.get(form)) is None:
+                continue
+            if form is Accepts.LOADABLE:
+                self._problem(where, f"deploys {image.what} on the {_shown(link)} sandbox provider, which can't load "
+                                     f"it: {refusal}")
+                continue
+            builds_itself = link.CONTAINER_ACCEPTS is Accepts.NAME_OR_CONTEXT
+            builds = ("whose VMs build it, such as --sandbox modal_vm" if builds_itself
+                      else "that builds it, such as --sandbox modal")
+            self._problem(where, f"deploys {image.what} on the {_shown(link)} sandbox provider, which runs it by name: "
+                                 f"{refusal}; run it on a provider {builds}")
 
     def _reachable(self, where: str, remote: list[SandboxProvider], images: list[_Image]) -> None:
         for image in images:
@@ -384,36 +380,28 @@ class _Walk:
             artifacts = ([env.db_docker_image_artifact, env.db_web_docker_image_artifact,
                           env.db_mcp_docker_image_artifact] if isinstance(env, ServiceDBEnv) else [env.docker_image_artifact])
             images = [_image(f"the {kind} env {env_id!r}'s image {image.id!r}", image) for image in artifacts]
-            if not isinstance(provider, ModalSandboxProvider):  # whose containers run by name, or are swapped out
-                self._loadable(where, [provider], images)
-            else:
-                self._by_name(where, [provider], images)
+            accepts = EnvironmentGatewayProvider.accepts(provider, prepared=kind == GATEWAY)
+            self._accepted(where, provider, accepts, images)
             self._reachable(where, [provider], images)
 
-    def _use(self, where: str, links: list[SandboxProvider], by_name: list[SandboxProvider],
-             images: list[_Image]) -> None:
-        for image in images:
-            if image.built is not None:
-                self.uses.setdefault(image.built, []).append((where, image.what, links, by_name))
-
     def _contexts(self) -> frozenset[str]:
-        """The images the bundle builds that it writes as build contexts: those every deploy runs on providers whose
-        VMs build them. One its deploys run only on the local provider, or that none runs, is built on this machine."""
+        """The images the bundle builds that it writes as build contexts: those every deploy runs on providers that
+        build them. One its deploys run only on the local provider, or that none runs, is built on this machine."""
         contexts = set()
         for image_id, uses in self.uses.items():
             built = self.built[image_id]
             source = f"{relative(self.plan.bundle.bundle.root, built.entry.path)}/{built.dockerfile}"
             local, vms = [], []
-            for where, what, links, by_name in uses:
+            for where, what, links, accepts in uses:
                 for link in links:
-                    if isinstance(link, LocalSandboxProvider):
+                    if link.ON_THIS_MACHINE:
                         local.append((where, what, links, link))
-                    elif link in by_name or not _creates_vms(link):
-                        how = "runs it by name" if link in by_name else "creates no VM to build it in"
-                        self._problem(where, f"deploys {what} on the {_shown(link)} sandbox provider, which {how}, and "
-                                             f"the bundle builds it from {source}, which a sandbox runs only once built "
-                                             "on this machine or in its VM; run it with --sandbox local, or on a "
-                                             "provider whose VMs build it, such as --sandbox modal_vm")
+                    elif accepts(link) is Accepts.NAME:
+                        self._problem(where, f"deploys {what} on the {_shown(link)} sandbox provider, which runs it by "
+                                             f"name, and the bundle builds it from {source}, which a sandbox runs only "
+                                             "once it's built on this machine or by the provider it runs on; run it "
+                                             "with --sandbox local, or on a provider that builds it, such as --sandbox "
+                                             "modal")
                     else:
                         vms.append((where, what, links, link))
             if local and vms:
@@ -421,7 +409,7 @@ class _Walk:
                 on = (f"{_named(links)} sandbox provider" if elsewhere == where else
                       f"{_shown(link)} sandbox provider, and {elsewhere} on the {_shown(vm)} one")
                 self._problem(where, f"deploys {what} on the {on}: the bundle builds it from {source} on this machine "
-                                     "for the local provider, and as a build context for one whose VMs build it, and a "
+                                     "for the local provider, and as a build context for one that builds it, and a "
                                      "run writes it one way; run its deploys on one kind, such as --sandbox local or "
                                      "--sandbox modal_vm")
             elif vms:
@@ -472,25 +460,16 @@ def _provider(spec: str | None, default: Callable[[], SandboxProvider]) -> Sandb
     return build_sandbox_provider(spec) if spec else default()
 
 
-def _links(provider: SandboxProvider) -> list[SandboxProvider]:
-    return list(provider.providers) if isinstance(provider, ChainedSandboxProvider) else [provider]
-
-
 def _local_link(provider: SandboxProvider) -> bool:
-    return any(isinstance(link, LocalSandboxProvider) for link in _links(provider))
+    return any(link.ON_THIS_MACHINE for link in provider.links)
 
 
 def _remote_links(provider: SandboxProvider) -> list[SandboxProvider]:
-    return [link for link in _links(provider) if not isinstance(link, LocalSandboxProvider)]
-
-
-def _creates_vms(provider: SandboxProvider) -> bool:
-    """Whether ``provider`` implements create_vm; a chain doesn't, whatever its providers do."""
-    return type(provider).create_vm is not SandboxProvider.create_vm
+    return [link for link in provider.links if not link.ON_THIS_MACHINE]
 
 
 def _shown(provider: SandboxProvider) -> str:
-    return _named(_links(provider))
+    return _named(list(provider.links))
 
 
 def _named(links: list[SandboxProvider]) -> str:
@@ -508,7 +487,7 @@ def _name(provider: SandboxProvider) -> str:
 
 
 def _image(what: str, image: DockerImageArtifact) -> _Image:
-    return _Image(what, _local_only(image), image.load_problem(), image.by_name_problem())
+    return _Image(what, _local_only(image), {form: problem for form in Accepts if (problem := form.problem(image))})
 
 
 def _local_only(image: DockerImageArtifact | str) -> str | None:

{agentenv_framework-0.9.1305 → agentenv_framework-0.9.1306}/src/agent_env/bundle/run.py

@@ -162,7 +162,7 @@ class DryRun:
         plan, contexts = self.materialization.plan, self.materialization.contexts
         return tuple(
             f"{_label(plan, done.write)} v{done.version}: "
-            + (f"a build context, which each VM deploying it builds for {DEFAULT_BUILD_PLATFORM}"
+            + (f"a build context, which each deploy builds where it runs, for {DEFAULT_BUILD_PLATFORM}"
                if done.write.id in contexts else "built on this machine")
             for done in self.materialization.writes if isinstance(done.write.source, BuiltImage)
         )