diff --git a/packages/agentenv-protocol/src/agentenv_protocol/__init__.py b/packages/agentenv-protocol/src/agentenv_protocol/__init__.py index 43dd1659c..6ec86820f 100644 --- a/packages/agentenv-protocol/src/agentenv_protocol/__init__.py +++ b/packages/agentenv-protocol/src/agentenv_protocol/__init__.py @@ -55,6 +55,7 @@ ) from .types import ( CONTROL_TOKEN_ENV, + CONTROL_TOKEN_HEADER, DATA_OBJECTS_EXTENSION_URI, INTAKE_EXTENSION_URI, MCP_PATH, @@ -165,6 +166,7 @@ "PROTOCOL_VERSION", "RPC_PATH", "CONTROL_TOKEN_ENV", + "CONTROL_TOKEN_HEADER", "WELL_KNOWN_PATH", "METHOD_RESET", "METHOD_ADD", diff --git a/packages/agentenv-protocol/src/agentenv_protocol/client.py b/packages/agentenv-protocol/src/agentenv_protocol/client.py index a895c8fed..0d76ad4aa 100644 --- a/packages/agentenv-protocol/src/agentenv_protocol/client.py +++ b/packages/agentenv-protocol/src/agentenv_protocol/client.py @@ -13,7 +13,7 @@ from .manifest import INTERFACE_MANIFEST_PATH from .transfers import WriteNamespaceGrant -from .types import INTAKE_EXTENSION_URI, MCP_PATH, MCP_TRANSPORT, METHOD_ADD, METHOD_GET, METHOD_RESET, RPC_PATH, WELL_KNOWN_PATH, AddDataResponse, GetDataResponse, Part, ResetDataResponse +from .types import CONTROL_TOKEN_HEADER, INTAKE_EXTENSION_URI, MCP_PATH, MCP_TRANSPORT, METHOD_ADD, METHOD_GET, METHOD_RESET, RPC_PATH, WELL_KNOWN_PATH, AddDataResponse, GetDataResponse, Part, ResetDataResponse logger = logging.getLogger(__name__) @@ -49,6 +49,11 @@ def control_headers(token: str | None) -> dict[str, str]: return {"Authorization": f"Bearer {token}"} if token else {} +def control_token_headers(token: str | None) -> dict[str, str]: + """The header that carries an agent's control token to its extension routes; none without one.""" + return {CONTROL_TOKEN_HEADER: token} if token else {} + + @contextlib.contextmanager def authorized(grants: dict[str | None, dict[str, str]]) -> Iterator[None]: """Within it, a call to an address under one of ``grants``, an env's address and the headers that carry its diff --git a/packages/agentenv-protocol/src/agentenv_protocol/types.py b/packages/agentenv-protocol/src/agentenv_protocol/types.py index 8e4ce6cbf..dff8e0f45 100644 --- a/packages/agentenv-protocol/src/agentenv_protocol/types.py +++ b/packages/agentenv-protocol/src/agentenv_protocol/types.py @@ -19,6 +19,8 @@ def error_body(code: str, message: str, **fields: Any) -> dict: #: The variable that hands an env the token its framework-only routes take as their bearer, everything it serves but #: its MCP endpoint and its card; agent-env sets it when it deploys the env, and without it those routes are open. CONTROL_TOKEN_ENV = "AGENTENV_CONTROL_TOKEN" +#: The header a control token travels in where it must not collide with a front door's own ``Authorization``. +CONTROL_TOKEN_HEADER = "AgentEnv-Control-Token" # A card declares its MCP endpoint as an `additionalInterfaces` entry with this transport; a card # without one is reached at MCP_PATH by convention. diff --git a/packages/agentenv-protocol/tests/test_control_token.py b/packages/agentenv-protocol/tests/test_control_token.py index a083ea4e1..88f42ffbd 100644 --- a/packages/agentenv-protocol/tests/test_control_token.py +++ b/packages/agentenv-protocol/tests/test_control_token.py @@ -124,6 +124,11 @@ def test_a_call_sends_its_own_headers_or_else_the_ones_its_grant_gives_an_addres assert client.control_headers(None) == {} and client.control_headers("") == {} +def test_an_agents_token_travels_in_its_own_header_not_authorization(): + assert client.control_token_headers("s3cret") == {"AgentEnv-Control-Token": "s3cret"} + assert client.control_token_headers(None) == {} and client.control_token_headers("") == {} + + @pytest.mark.asyncio async def test_invoke_extension_and_the_data_plane_send_the_token(monkeypatch): seen = [] diff --git a/src/agent_env/a2a_agent/a2a_agent.py b/src/agent_env/a2a_agent/a2a_agent.py index 24c643be7..79e4bb0dd 100644 --- a/src/agent_env/a2a_agent/a2a_agent.py +++ b/src/agent_env/a2a_agent/a2a_agent.py @@ -10,6 +10,7 @@ from dataclasses import dataclass from typing import TYPE_CHECKING, Any, Callable, ClassVar, Optional +from agentenv_protocol import client as protocol_v1 from agentenv_protocol.a2a_agent import STANDARD_EXTENSIONS from agent_env.config import get_config @@ -41,6 +42,7 @@ all_sandbox_url_rewrites, ) from agent_env.attribution import Attribution +from agent_env.env.envs.computer.utils.boot import control_token as new_control_token if TYPE_CHECKING: from agent_env.a2a_agent.store import A2AAgentQuery, A2AAgentStore @@ -101,6 +103,8 @@ class DeployedA2AAgent: created_at_utc: str | None = None expires_at_utc: str | None = None network_policy: dict | None = None + # The token the agent's extension routes take: agent-env holds it and gives no other agent. + control_token: str | None = None @classmethod def from_dict(cls, data: dict) -> "DeployedA2AAgent": @@ -115,8 +119,13 @@ def from_dict(cls, data: dict) -> "DeployedA2AAgent": created_at_utc=data.get("created_at_utc"), expires_at_utc=data.get("expires_at_utc"), network_policy=data.get("network_policy"), + control_token=data.get("control_token"), ) + @property + def control_headers(self) -> dict[str, str]: + return protocol_v1.control_token_headers(self.control_token) + @dataclass(frozen=True) class NegotiatedAgentConfig: @@ -261,6 +270,7 @@ async def register_skill( operation=f"skill add ({name})", timeout=TRANSFER_TIMEOUT_SECONDS, store=store, + headers=deployed.control_headers, ) @staticmethod @@ -590,6 +600,7 @@ async def deploy( a2a_url=a2a_url, sandbox_id=self._sandbox.sandbox_id, agent_card=agent_card, sandbox_type=self._sandbox.type, network_policy=self._sandbox.network_policy.to_dict() if self._sandbox.network_policy else None, + control_token=new_control_token(), ) from agent_env.a2a_agent.store import get_a2a_agent_instance_store deployed = get_a2a_agent_instance_store().create_instance(deployed, ttl_seconds) diff --git a/src/agent_env/a2a_agent/object_transfer.py b/src/agent_env/a2a_agent/object_transfer.py index 8fff9e46e..336b25790 100644 --- a/src/agent_env/a2a_agent/object_transfer.py +++ b/src/agent_env/a2a_agent/object_transfer.py @@ -175,6 +175,7 @@ async def invoke_transfer( timeout: float, response_model: type[_Response] | None = None, store: ObjectStore | None = None, + headers: Mapping[str, str] | None = None, ) -> Any: """Send ``call`` and return the agent's answer, validated against ``response_model`` when the call carried grants. An error never quotes the answer to such a call, which may echo a @@ -186,7 +187,7 @@ async def invoke_transfer( await staged.push() async with httpx.AsyncClient() as client: send = client.post if verb == "POST" else client.put - resp = await send(url, json=call.payload, timeout=timeout) + resp = await send(url, json=call.payload, headers=headers, timeout=timeout) try: raise_for_extension_status(resp, operation=operation, include_body=call.mode == "legacy") except httpx.HTTPStatusError as exc: @@ -651,6 +652,7 @@ async def fetch_trajectory( upload: TrajectoryUpload | None = None, timeout: float | None = None, store: ObjectStore | None = None, + headers: Mapping[str, str] | None = None, ) -> FetchedTrajectory: """POST one trajectory ``get``. With ``upload`` the agent uploads the trajectory through its grant, issued by ``store``, and the answer is checked. The default wait covers that upload.""" @@ -669,6 +671,7 @@ async def fetch_trajectory( timeout=timeout, response_model=TrajectoryObjectsResponse, store=store, + headers=headers, ) if upload is not None: return FetchedTrajectory(object_url=upload.object_url) diff --git a/src/agent_env/a2a_agent/protocol.py b/src/agent_env/a2a_agent/protocol.py index dd18784c3..04ae02cfc 100644 --- a/src/agent_env/a2a_agent/protocol.py +++ b/src/agent_env/a2a_agent/protocol.py @@ -66,7 +66,8 @@ def raise_for_extension_status( raise httpx.HTTPStatusError(message, request=exc.request, response=response) from exc -async def post_agent_config(url: str, payload: dict, timeout_seconds: int = 60) -> None: +async def post_agent_config(url: str, payload: dict, timeout_seconds: int = 60, *, + headers: Mapping[str, str] | None = None) -> None: """POST to an agent's /ext/agent-config endpoint with retry on transient 404/connect errors. `url` should be the full endpoint URL (a2a_url + endpoint path from the agent card). @@ -77,7 +78,7 @@ async def post_agent_config(url: str, payload: dict, timeout_seconds: int = 60) for attempt in range(1, max_attempts + 1): try: async with httpx.AsyncClient() as client: - resp = await client.post(url, json=payload, timeout=timeout_seconds) + resp = await client.post(url, json=payload, headers=headers, timeout=timeout_seconds) if resp.status_code == 404: raise httpx.HTTPStatusError( f"agent-config endpoint not available (404) at {url} after {max_attempts} " diff --git a/src/agent_env/a2a_agent/trajectory_follower.py b/src/agent_env/a2a_agent/trajectory_follower.py index 01ffbdf02..5162727ee 100644 --- a/src/agent_env/a2a_agent/trajectory_follower.py +++ b/src/agent_env/a2a_agent/trajectory_follower.py @@ -4,7 +4,7 @@ import asyncio import contextlib import logging -from collections.abc import Awaitable, Callable +from collections.abc import Awaitable, Callable, Mapping from contextlib import nullcontext from dataclasses import dataclass from typing import Any @@ -67,6 +67,7 @@ async def follow_trajectory( poll_interval_seconds: float, stop: asyncio.Event, client: httpx.AsyncClient | None = None, + headers: Mapping[str, str] | None = None, ) -> None: """Read task ``task_id``'s trajectory from its first event, handing ``sink`` each page that has events and the last one, until the task has ended and every event is read. @@ -80,7 +81,8 @@ async def follow_trajectory( while True: try: response = await http.post( - endpoint, json={"task_id": task_id, "after": after}, timeout=_READ_TIMEOUT_SECONDS + endpoint, json={"task_id": task_id, "after": after}, headers=headers, + timeout=_READ_TIMEOUT_SECONDS, ) if response.status_code == 404: logger.warning("Agent no longer knows task %s; stopped following its trajectory", task_id) diff --git a/src/agent_env/a2a_agent/validator.py b/src/agent_env/a2a_agent/validator.py index 094f1dee6..049514612 100644 --- a/src/agent_env/a2a_agent/validator.py +++ b/src/agent_env/a2a_agent/validator.py @@ -708,6 +708,7 @@ def record(*, supported, advertised, save_ok, apply_ok, roundtrip_ok, note=""): timeout=TRANSFER_TIMEOUT_SECONDS, response_model=ObjectChangelogApplyResponse, store=store, + headers=apply_agent.control_headers, ) check_changelog_applied(answer, call, agent_name=apply_agent_name) except Exception as e: # noqa: BLE001 diff --git a/src/agent_env/task/episode/proxy.py b/src/agent_env/task/episode/proxy.py index 315362218..2039e9860 100644 --- a/src/agent_env/task/episode/proxy.py +++ b/src/agent_env/task/episode/proxy.py @@ -6,6 +6,7 @@ import asyncio import secrets import threading +from collections.abc import Mapping from typing import Any, TypeVar import httpx @@ -48,14 +49,14 @@ class ProxyClient: the proxy, over a connection a tunnel dropped say, is tried again, except ``record``'s, which isn't idempotent. Answers are read as proxy/v1's models, ignoring fields a newer proxy adds: an agent's protocol isn't pinned.""" - def __init__(self, a2a_url: str, card: dict[str, Any]): + def __init__(self, a2a_url: str, card: dict[str, Any], *, headers: Mapping[str, str] | None = None): proxy = A2AAgent.find_extension(card, PROXY_V1.uri) if proxy is None: raise RuntimeError(f"the agent at {a2a_url} isn't a proxy: its card has no {PROXY_V1.uri}") self._endpoints = {operation: a2a_url + A2AAgent.operation(proxy, operation)[1] for operation in PROXY_V1.operations} self._token = secrets.token_urlsafe(24) - self._client = httpx.AsyncClient(timeout=_CALL_TIMEOUT) + self._client = httpx.AsyncClient(timeout=_CALL_TIMEOUT, headers=headers) async def claim(self) -> None: await self._call("claim") diff --git a/src/agent_env/task/episode/run.py b/src/agent_env/task/episode/run.py index 2b082cd69..0de563ffb 100644 --- a/src/agent_env/task/episode/run.py +++ b/src/agent_env/task/episode/run.py @@ -303,7 +303,7 @@ async def _serve_in_process(self, agent: str, role: str | None, mcp_urls: dict[s async def _attach(self, agent: str, deployed: DeployedAgent) -> None: """Claim ``agent``'s proxy and hand out the turns it opens.""" - proxy = ProxyClient(deployed.a2a_url, deployed.a2a_card or {}) + proxy = ProxyClient(deployed.a2a_url, deployed.a2a_card or {}, headers=deployed.control_headers) self._proxies.append(proxy) await proxy.claim() self._drains.append(asyncio.create_task(self._drain(agent, proxy))) diff --git a/src/agent_env/task/episode/steps.py b/src/agent_env/task/episode/steps.py index 9bcc85816..027c8c75c 100644 --- a/src/agent_env/task/episode/steps.py +++ b/src/agent_env/task/episode/steps.py @@ -53,7 +53,8 @@ async def execute(self, context: TaskStepContext) -> TaskStepContext: context.deployed_agents.append(deployed) if system_prompt := getattr(self.step, "system_prompt", None): config = A2AAgent.negotiate_agent_config(deployed.a2a_card, {"system_prompt": system_prompt}) - await protocol.post_agent_config(deployed.a2a_url + config.endpoint, config.fields) + await protocol.post_agent_config(deployed.a2a_url + config.endpoint, config.fields, + headers=deployed.control_headers) return context await asyncio.to_thread(write_installed, PROXY_AGENT_ID) override = {"a2a_agent_id": PROXY_AGENT_ID} if self.step.type == "deploy_agent" else {PROXY_PARAM: PROXY_AGENT_ID} diff --git a/src/agent_env/task_step/context.py b/src/agent_env/task_step/context.py index 3343042d5..32e7ac7a9 100644 --- a/src/agent_env/task_step/context.py +++ b/src/agent_env/task_step/context.py @@ -9,6 +9,8 @@ from dataclasses import dataclass, field from typing import Any +from agentenv_protocol import client as protocol_v1 + from agent_env.config.loader import ENV_REF_PREFIX, SECRET_REF_PREFIX from agent_env.env.env import DeployedEnv from agent_env.providers.sandbox_providers.local_docker.provider import LocalSandbox, host_url_for @@ -128,6 +130,8 @@ class DeployedAgent: installed_container: str | None = None # The envs deploy_agent registered with it, by id. env_ids: list[str] = field(default_factory=list) + # The token its extension routes take, from the deploy that started it; None for an agent agent-env didn't start. + control_token: str | None = None @classmethod def from_dict(cls, data: dict) -> DeployedAgent: @@ -144,8 +148,13 @@ def from_dict(cls, data: dict) -> DeployedAgent: on_host=bool(data.get("on_host", False)), installed_container=data.get("installed_container"), env_ids=list(data.get("env_ids") or []), + control_token=data.get("control_token"), ) + @property + def control_headers(self) -> dict[str, str]: + return protocol_v1.control_token_headers(self.control_token) + def url_for(self, sandbox_type: str | None, *, on_host: bool = False) -> str: """This agent's A2A URL as an agent on ``sandbox_type`` reaches it, in a container there or, ``on_host``, on the sandbox's host. A local sandbox's host is this machine, which reaches the URL as it is. An agent outside diff --git a/src/agent_env/task_step/snapshot_utils/agent_state_capture.py b/src/agent_env/task_step/snapshot_utils/agent_state_capture.py index 3630b9454..2694d8488 100644 --- a/src/agent_env/task_step/snapshot_utils/agent_state_capture.py +++ b/src/agent_env/task_step/snapshot_utils/agent_state_capture.py @@ -11,6 +11,7 @@ import logging import uuid from dataclasses import dataclass +from collections.abc import Mapping from typing import Any, Optional import httpx @@ -64,6 +65,7 @@ async def capture_workspace( artifact_id: str, timeout_seconds: float, sandbox_type: str | None, + headers: Mapping[str, str], ) -> WorkspaceCapture: """Capture the agent's workspace below a fresh prefix and wrap it as a universe. @@ -103,6 +105,7 @@ async def capture_workspace( timeout=timeout_seconds, response_model=ObjectSnapshotSaveResponse, store=store, + headers=headers, ) # The agent's answer is only a claim: a snapshot missing either object cannot be restored. @@ -149,6 +152,7 @@ async def read_partial_trajectory( timeout_seconds: float, trajectory_output_prefix: str, sandbox_type: str | None, + headers: Mapping[str, str], ) -> TrajectoryCapture: """Read the trajectory-so-far for an in-progress run. @@ -191,7 +195,8 @@ async def read_partial_trajectory( return TrajectoryCapture(reason="trajectory_grant_unavailable") try: fetched = await fetch_trajectory( - a2a_url + get_path, {"context_id": context_id}, upload=upload, timeout=timeout_seconds, store=store + a2a_url + get_path, {"context_id": context_id}, upload=upload, timeout=timeout_seconds, store=store, + headers=headers, ) except httpx.HTTPStatusError as exc: if exc.response.status_code == 404: diff --git a/src/agent_env/task_step/snapshot_utils/live_trajectory.py b/src/agent_env/task_step/snapshot_utils/live_trajectory.py index fe32b2e66..f14ccb723 100644 --- a/src/agent_env/task_step/snapshot_utils/live_trajectory.py +++ b/src/agent_env/task_step/snapshot_utils/live_trajectory.py @@ -15,7 +15,7 @@ import asyncio import json import logging -from collections.abc import AsyncIterator, Awaitable +from collections.abc import AsyncIterator, Awaitable, Mapping from contextlib import asynccontextmanager from agentenv_protocol.a2a_agent import TrajectoryState @@ -88,8 +88,10 @@ def __init__( turn_id: str, poll_interval_seconds: float, previous_turn_id: str | None, + headers: Mapping[str, str], ) -> None: self._endpoint = endpoint + self._headers = headers self._store = store self._prefix_key = prefix_key self._turn_id = turn_id @@ -112,7 +114,8 @@ def follow(self, task_id: str) -> None: self.followers.append( asyncio.create_task( follow_trajectory( - self._endpoint, task_id, sink, poll_interval_seconds=self._poll_interval_seconds, stop=self.stop + self._endpoint, task_id, sink, poll_interval_seconds=self._poll_interval_seconds, stop=self.stop, + headers=self._headers, ) ) ) @@ -130,6 +133,7 @@ async def following_live_trajectory( turn_id: str, *, poll_interval_seconds: float, + headers: Mapping[str, str], previous_turn_id: str | None = None, ) -> AsyncIterator[LiveTurn]: """Yield the turn whose task is followed once its message is sent; then ``previous_turn_id``'s @@ -140,7 +144,7 @@ async def following_live_trajectory( end the follower did not read is marked ended in the state the body reported, else ``canceled`` for a cancelled step or ``failed``, so readers do not wait on it. A follower's own failure is logged and never fails the turn.""" - turn = LiveTurn(endpoint, store, prefix_key, turn_id, poll_interval_seconds, previous_turn_id) + turn = LiveTurn(endpoint, store, prefix_key, turn_id, poll_interval_seconds, previous_turn_id, headers) stopped_as = TrajectoryState.FAILED try: @@ -179,8 +183,10 @@ class LiveTurns: """A step's turns, followed one after another: a turn sent after another is named in that one's ``next.json``, and ``end`` marks the last turn sent as the step's last.""" - def __init__(self, endpoint: str, store: ObjectStore, prefix_key: str, *, poll_interval_seconds: float) -> None: + def __init__(self, endpoint: str, store: ObjectStore, prefix_key: str, *, poll_interval_seconds: float, + headers: Mapping[str, str]) -> None: self._endpoint = endpoint + self._headers = headers self._store = store self._prefix_key = prefix_key self._poll_interval_seconds = poll_interval_seconds @@ -195,6 +201,7 @@ async def following(self, turn_id: str) -> AsyncIterator[LiveTurn]: self._prefix_key, turn_id, poll_interval_seconds=self._poll_interval_seconds, + headers=self._headers, previous_turn_id=self._last_sent, ) as turn: try: diff --git a/src/agent_env/task_step/snapshot_utils/snapshot_series.py b/src/agent_env/task_step/snapshot_utils/snapshot_series.py index f0b8817ea..049533361 100644 --- a/src/agent_env/task_step/snapshot_utils/snapshot_series.py +++ b/src/agent_env/task_step/snapshot_utils/snapshot_series.py @@ -428,6 +428,7 @@ def remaining() -> float: artifact_id=self.workspace_artifact_id, timeout_seconds=remaining(), sandbox_type=agent.sandbox_type, + headers=agent.control_headers, ) row["id"] = workspace.universe_id row["version"] = workspace.universe_version @@ -445,6 +446,7 @@ def remaining() -> float: timeout_seconds=remaining(), trajectory_output_prefix=self.trajectory_output_prefix, sandbox_type=agent.sandbox_type, + headers=agent.control_headers, ) if traj.reason and is_final: recorded = self._recorded_trajectory_uri(context) diff --git a/src/agent_env/task_step/task_steps/a2a_agent_validator/verify_a2a_agent_config_identity.py b/src/agent_env/task_step/task_steps/a2a_agent_validator/verify_a2a_agent_config_identity.py index 5ecd0429d..5dfe1e3db 100644 --- a/src/agent_env/task_step/task_steps/a2a_agent_validator/verify_a2a_agent_config_identity.py +++ b/src/agent_env/task_step/task_steps/a2a_agent_validator/verify_a2a_agent_config_identity.py @@ -46,7 +46,8 @@ async def execute(self, context: TaskStepContext) -> TaskStepContext: endpoint = a2a_url + (ext.get("params") or {}).get("endpoint", "/ext/agent-config") try: async with httpx.AsyncClient() as client: - (await client.post(endpoint, json={"name": name, "description": desc}, timeout=30)).raise_for_status() + (await client.post(endpoint, json={"name": name, "description": desc}, + headers=deployed.control_headers, timeout=30)).raise_for_status() card_resp = await client.get(f"{a2a_url}/.well-known/agent.json", timeout=30) card_resp.raise_for_status() card = card_resp.json() or {} diff --git a/src/agent_env/task_step/task_steps/a2a_agent_validator/verify_a2a_builtin_tools.py b/src/agent_env/task_step/task_steps/a2a_agent_validator/verify_a2a_builtin_tools.py index b3aa1d457..83ec7e65e 100644 --- a/src/agent_env/task_step/task_steps/a2a_agent_validator/verify_a2a_builtin_tools.py +++ b/src/agent_env/task_step/task_steps/a2a_agent_validator/verify_a2a_builtin_tools.py @@ -78,7 +78,7 @@ async def execute(self, context: TaskStepContext) -> TaskStepContext: builtin_tools={"disable": "*"}).execute(context) limited = next(a for a in context.deployed_agents if a.agent_name == AGENT_NAME) url = (limited.a2a_url or limited.api_url) + params.get("endpoint", "/ext/agent-config") - async with httpx.AsyncClient(timeout=30.0) as client: + async with httpx.AsyncClient(timeout=30.0, headers=limited.control_headers) as client: refused = (await client.post(url, json={"builtin_tools": {"only": [NO_SUCH_TOOL]}})).status_code config = (((await client.get(url)).json() or {}).get("config") or {}) if "get" in methods else None await PromptAgentTaskStep(id=prompt_id, version=None, prompt=PROMPT, prompt_id=prompt_id, diff --git a/src/agent_env/task_step/task_steps/a2a_agent_validator/verify_a2a_peer_agents.py b/src/agent_env/task_step/task_steps/a2a_agent_validator/verify_a2a_peer_agents.py index bba35f04b..a981879db 100644 --- a/src/agent_env/task_step/task_steps/a2a_agent_validator/verify_a2a_peer_agents.py +++ b/src/agent_env/task_step/task_steps/a2a_agent_validator/verify_a2a_peer_agents.py @@ -2,6 +2,7 @@ from __future__ import annotations import logging +from collections.abc import Mapping from typing import ClassVar, Optional import httpx @@ -49,8 +50,8 @@ async def execute(self, context: TaskStepContext) -> TaskStepContext: extension = A2AAgent.find_extension(deployed.a2a_card or {}, A2AAgent.EXT_PEER_AGENTS) extension_advertised = extension is not None endpoint = (extension.get("params") or {}).get("endpoint", "/ext/peer-agents") if extension else "/ext/peer-agents" - post_ok, list_ok = await self._check_round_trip(a2a_url, endpoint) - sidecar_registered = await self._check_sidecar_registered(a2a_url) + post_ok, list_ok = await self._check_round_trip(a2a_url, endpoint, deployed.control_headers) + sidecar_registered = await self._check_sidecar_registered(a2a_url, deployed.control_headers) peer_call_ok, response_excerpt = self._check_peer_call(context) peer_entry = { @@ -72,10 +73,10 @@ async def execute(self, context: TaskStepContext) -> TaskStepContext: return context @staticmethod - async def _check_round_trip(a2a_url: str, endpoint: str) -> tuple[bool, bool]: + async def _check_round_trip(a2a_url: str, endpoint: str, headers: Mapping[str, str]) -> tuple[bool, bool]: probe = {"peers": [{"name": "probe", "url": "http://example.invalid"}]} post_ok = list_ok = False - async with httpx.AsyncClient() as client: + async with httpx.AsyncClient(headers=headers) as client: try: post_resp = await client.post(f"{a2a_url}{endpoint}", json=probe, timeout=30) post_ok = post_resp.status_code < 400 @@ -86,8 +87,8 @@ async def _check_round_trip(a2a_url: str, endpoint: str) -> tuple[bool, bool]: return post_ok, list_ok @staticmethod - async def _check_sidecar_registered(a2a_url: str) -> bool: - async with httpx.AsyncClient() as client: + async def _check_sidecar_registered(a2a_url: str, headers: Mapping[str, str]) -> bool: + async with httpx.AsyncClient(headers=headers) as client: resp = await client.get(f"{a2a_url}/ext/mcp-config", timeout=30) if resp.status_code >= 400: return False diff --git a/src/agent_env/task_step/task_steps/a2a_agent_validator/verify_a2a_role.py b/src/agent_env/task_step/task_steps/a2a_agent_validator/verify_a2a_role.py index 4096ac42d..97d6ccc93 100644 --- a/src/agent_env/task_step/task_steps/a2a_agent_validator/verify_a2a_role.py +++ b/src/agent_env/task_step/task_steps/a2a_agent_validator/verify_a2a_role.py @@ -101,7 +101,7 @@ async def execute(self, context: TaskStepContext) -> TaskStepContext: logger.info("Round-tripping role=%r through %s", test_role, url) try: - async with httpx.AsyncClient(timeout=10.0) as client: + async with httpx.AsyncClient(timeout=10.0, headers=deployed.control_headers) as client: post_resp = await client.post(url, json={"role": test_role}) post_resp.raise_for_status() get_resp = await client.get(url) diff --git a/src/agent_env/task_step/task_steps/a2a_agent_validator/verify_a2a_skill_config.py b/src/agent_env/task_step/task_steps/a2a_agent_validator/verify_a2a_skill_config.py index 4b800fdd0..13545f77b 100644 --- a/src/agent_env/task_step/task_steps/a2a_agent_validator/verify_a2a_skill_config.py +++ b/src/agent_env/task_step/task_steps/a2a_agent_validator/verify_a2a_skill_config.py @@ -117,6 +117,7 @@ async def probe_bundle(name: str, description: str, object_url: str | None) -> b operation="skill add (bundle)", timeout=TRANSFER_TIMEOUT_SECONDS, store=store, + headers=deployed_agent.control_headers, ) result = parse_response(SkillAddResponse, answer, operation="skill add (bundle)") if result.name != name: @@ -143,7 +144,8 @@ async def probe_bundle(name: str, description: str, object_url: str | None) -> b list_ok = False try: async with httpx.AsyncClient() as client: - resp = await client.get(a2a_url + A2AAgent.operation(skill_ext, "list")[1], timeout=30) + resp = await client.get(a2a_url + A2AAgent.operation(skill_ext, "list")[1], + headers=deployed_agent.control_headers, timeout=30) resp.raise_for_status() data = resp.json() skills = data.get("skills", {}) diff --git a/src/agent_env/task_step/task_steps/a2a_agent_validator/verify_a2a_system_prompt.py b/src/agent_env/task_step/task_steps/a2a_agent_validator/verify_a2a_system_prompt.py index 70daf95b8..4a3e221b0 100644 --- a/src/agent_env/task_step/task_steps/a2a_agent_validator/verify_a2a_system_prompt.py +++ b/src/agent_env/task_step/task_steps/a2a_agent_validator/verify_a2a_system_prompt.py @@ -118,7 +118,8 @@ async def execute(self, context: TaskStepContext) -> TaskStepContext: try: async with httpx.AsyncClient(timeout=30.0) as client: - resp = await client.post(config_endpoint, json={"system_prompt": sentinel_prompt}) + resp = await client.post(config_endpoint, json={"system_prompt": sentinel_prompt}, + headers=deployed.control_headers) resp.raise_for_status() except Exception as e: self._record(context, { diff --git a/src/agent_env/task_step/task_steps/a2a_agent_validator/verify_a2a_trajectory.py b/src/agent_env/task_step/task_steps/a2a_agent_validator/verify_a2a_trajectory.py index d1f0dea80..271a8ca46 100644 --- a/src/agent_env/task_step/task_steps/a2a_agent_validator/verify_a2a_trajectory.py +++ b/src/agent_env/task_step/task_steps/a2a_agent_validator/verify_a2a_trajectory.py @@ -76,7 +76,7 @@ async def execute(self, context: TaskStepContext) -> TaskStepContext: # Test inline trajectory retrieval inline_ok = False try: - fetched = await fetch_trajectory(endpoint, {"task_id": task_id}) + fetched = await fetch_trajectory(endpoint, {"task_id": task_id}, headers=deployed_agent.control_headers) if fetched.inline: inline_ok = True logger.info(f"Inline trajectory: OK ({len(fetched.inline)} events)") @@ -100,7 +100,8 @@ async def execute(self, context: TaskStepContext) -> TaskStepContext: upload = await asyncio.to_thread( TrajectoryUpload.to, granting, trajectory_object_url(prefix, name=task_id, store=granting) ) - await fetch_trajectory(endpoint, {"task_id": task_id}, upload=upload, store=granting) + await fetch_trajectory(endpoint, {"task_id": task_id}, upload=upload, store=granting, + headers=deployed_agent.control_headers) objects_ok = True logger.info("Object trajectory: OK") except Exception as e: diff --git a/src/agent_env/task_step/task_steps/agent/deploy_user_sim_agent.py b/src/agent_env/task_step/task_steps/agent/deploy_user_sim_agent.py index 34a81e810..dd31e1f2a 100644 --- a/src/agent_env/task_step/task_steps/agent/deploy_user_sim_agent.py +++ b/src/agent_env/task_step/task_steps/agent/deploy_user_sim_agent.py @@ -325,7 +325,8 @@ async def _set_user(self, context: TaskStepContext, agent, setup: dict) -> TaskS if negotiated is None or "model" not in negotiated.fields: raise RuntimeError(f"{self.type} '{self.id}': agent '{self.agent_name}' takes no model through " f"{A2AAgent.EXT_AGENT_CONFIG}, so it would play the user on a model of its own") - await protocol.post_agent_config((agent.a2a_url or agent.api_url) + negotiated.endpoint, negotiated.fields) + await protocol.post_agent_config((agent.a2a_url or agent.api_url) + negotiated.endpoint, negotiated.fields, + headers=agent.control_headers) context.record_model("user simulator", self.id, model) prompt = setup["system_prompt"] persona = self.persona diff --git a/src/agent_env/task_step/task_steps/agent/rate_user_satisfaction.py b/src/agent_env/task_step/task_steps/agent/rate_user_satisfaction.py index 12ba5baa9..899d05fd9 100644 --- a/src/agent_env/task_step/task_steps/agent/rate_user_satisfaction.py +++ b/src/agent_env/task_step/task_steps/agent/rate_user_satisfaction.py @@ -271,7 +271,7 @@ async def _trajectory(self, agent: DeployedAgent, session: _Session, task_id: st # prompt_agent's fetch uses nothing of its step, so the run's own code stores it. return await asyncio.wait_for(PromptAgentTaskStep._fetch_trajectory( None, agent.a2a_url or agent.api_url, ext, task_id, session.trajectory_prefix, message_id, - card=card, sandbox_type=agent.sandbox_type), + card=card, sandbox_type=agent.sandbox_type, headers=agent.control_headers), max(0.0, min(TRAJECTORY_FETCH_SECONDS, deadline - time.monotonic()))) except Exception as e: logger.warning(f"user sim trajectory fetch failed (continuing): {e}") diff --git a/src/agent_env/task_step/task_steps/always_on.py b/src/agent_env/task_step/task_steps/always_on.py index a02fd21a6..1063c8779 100644 --- a/src/agent_env/task_step/task_steps/always_on.py +++ b/src/agent_env/task_step/task_steps/always_on.py @@ -591,7 +591,8 @@ async def _configure_agents(self) -> None: desired["model_params"] = model_params negotiated = A2AAgent.negotiate_agent_config(card, desired) if negotiated: - await protocol.post_agent_config(self.target_url + negotiated.endpoint, negotiated.fields) + await protocol.post_agent_config(self.target_url + negotiated.endpoint, negotiated.fields, + headers=self.agent.control_headers) ctx.record_model("solver", step.id, negotiated.fields.get("model") if negotiated else None) self.rules_in_system_prompt = bool(desired.get("system_prompt") and negotiated and "system_prompt" in negotiated.fields) @@ -610,7 +611,8 @@ async def _configure_agents(self) -> None: user_config = {k: v for k, v in user_config.items() if v is not None} negotiated = A2AAgent.negotiate_agent_config(self.user_agent.a2a_card or {}, user_config) if negotiated: - await protocol.post_agent_config(self.user_url + negotiated.endpoint, negotiated.fields) + await protocol.post_agent_config(self.user_url + negotiated.endpoint, negotiated.fields, + headers=self.user_agent.control_headers) accepted = sorted(negotiated.fields) if negotiated else [] ctx.record_model("user simulator", step.id, negotiated.fields.get("model") if negotiated else None) self.user_setup = {"model": self.user_model, "model_from": self.user_model_from, @@ -1281,7 +1283,8 @@ def record() -> None: try: traj = await asyncio.wait_for( step._fetch_trajectory(self.target_url, traj_ext, task_id, step._trajectory_prefix(), msg_id, - card=card, sandbox_type=self.agent.sandbox_type), TRAJECTORY_FETCH_SECONDS) + card=card, sandbox_type=self.agent.sandbox_type, + headers=self.agent.control_headers), TRAJECTORY_FETCH_SECONDS) except Exception as e: logger.warning(f"wake {self.wakes}: trajectory fetch failed (continuing): {e}") self.per_turn_trajectory_urls.append(traj) @@ -1360,7 +1363,8 @@ def record() -> None: try: traj = await asyncio.wait_for( step._fetch_trajectory(self.target_url, traj_ext, task_id, step._trajectory_prefix(), msg_id, - card=card, sandbox_type=self.agent.sandbox_type), TRAJECTORY_FETCH_SECONDS) + card=card, sandbox_type=self.agent.sandbox_type, + headers=self.agent.control_headers), TRAJECTORY_FETCH_SECONDS) except Exception as e: logger.warning(f"nudge after wake {self.wakes}: trajectory fetch failed (continuing): {e}") self.per_turn_trajectory_urls.append(traj) @@ -1575,7 +1579,8 @@ async def _ask_user_sim(self, text: str, deadline: float) -> dict: traj = await asyncio.wait_for( self.step._fetch_trajectory(self.user_url, traj_ext, user_task_id, self.step._trajectory_prefix() + "user_sim/", msg_id, - card=card, sandbox_type=self.user_agent.sandbox_type), + card=card, sandbox_type=self.user_agent.sandbox_type, + headers=self.user_agent.control_headers), max(0.0, min(TRAJECTORY_FETCH_SECONDS, deadline - time.monotonic()))) except Exception as e: logger.warning(f"user sim trajectory fetch failed (continuing): {e}") diff --git a/src/agent_env/task_step/task_steps/browser/connect_cdp.py b/src/agent_env/task_step/task_steps/browser/connect_cdp.py index 597b5d916..608e30b3f 100644 --- a/src/agent_env/task_step/task_steps/browser/connect_cdp.py +++ b/src/agent_env/task_step/task_steps/browser/connect_cdp.py @@ -102,7 +102,7 @@ async def execute(self, context: TaskStepContext) -> TaskStepContext: async with httpx.AsyncClient(timeout=ADD_TIMEOUT_S) as client: added = await client.post(agent.a2a_url + cdp_config["params"]["endpoint"], json={ "name": self.name, "http_url": http_url, "ws_url": ws_url, - "metadata": {"browser": browser or deployed.environment_card.get("name")}}) + "metadata": {"browser": browser or deployed.environment_card.get("name")}}, headers=agent.control_headers) added.raise_for_status() role = agent.role or DEFAULT_ROLE hidden = None if self.keep_tools else WILDCARD diff --git a/src/agent_env/task_step/task_steps/deploy_agent.py b/src/agent_env/task_step/task_steps/deploy_agent.py index fb24dc111..638cffba8 100644 --- a/src/agent_env/task_step/task_steps/deploy_agent.py +++ b/src/agent_env/task_step/task_steps/deploy_agent.py @@ -3,7 +3,7 @@ import asyncio import logging -from collections.abc import Iterable +from collections.abc import Iterable, Mapping from typing import ClassVar, Optional import httpx @@ -484,7 +484,7 @@ async def _execute(self, context: TaskStepContext, deployed_agents: list) -> Tas async with httpx.AsyncClient() as client: for env_id, body in registrations: logger.info(f"Registering MCP for env {env_id} via {body['url']}") - resp = await client.post(endpoint, json=body, timeout=180) + resp = await client.post(endpoint, json=body, headers=deployed.control_headers, timeout=180) if resp.status_code >= 400: logger.error(f"Failed to register MCP {env_id}: {resp.status_code} {resp.text}") resp.raise_for_status() @@ -510,11 +510,13 @@ async def _execute(self, context: TaskStepContext, deployed_agents: list) -> Tas " — skipping") else: endpoint = a2a_url + (config_ext.get("params") or {}).get("endpoint", "/ext/agent-config") - await protocol.post_agent_config(endpoint, {"system_prompt": system_prompt}) + await protocol.post_agent_config(endpoint, {"system_prompt": system_prompt}, + headers=deployed.control_headers) logger.info(f"Set system_prompt on agent '{self.agent_name}'") if identity is not None: - await protocol.post_agent_config(a2a_url + identity.endpoint, identity.fields) + await protocol.post_agent_config(a2a_url + identity.endpoint, identity.fields, + headers=deployed.control_headers) card.update(identity.fields) logger.info(f"Stamped card identity on '{self.agent_name}': {sorted(identity.fields)}") @@ -524,14 +526,17 @@ async def _execute(self, context: TaskStepContext, deployed_agents: list) -> Tas logger.info(f"Set context.default_agent_model to '{default_model}'") if self.agent_snapshot_files_artifact_id: - await self._load_snapshot(a2a_url, card, a2a_agent_id, context, sandbox_type=deployed.sandbox_type) + await self._load_snapshot(a2a_url, card, a2a_agent_id, context, sandbox_type=deployed.sandbox_type, + headers=deployed.control_headers) if self.agent_changelog_object_url: - await self._apply_agent_changelog(a2a_url, card, context, sandbox_type=deployed.sandbox_type) + await self._apply_agent_changelog(a2a_url, card, context, sandbox_type=deployed.sandbox_type, + headers=deployed.control_headers) if self.enable_agent_changelog: await self._configure_agent_changelog( - a2a_url, card, context, expires_in=resolved_ttl, sandbox_type=deployed.sandbox_type + a2a_url, card, context, expires_in=resolved_ttl, sandbox_type=deployed.sandbox_type, + headers=deployed.control_headers, ) context.deployed_agents.append(DeployedAgent( @@ -545,6 +550,7 @@ async def _execute(self, context: TaskStepContext, deployed_agents: list) -> Tas role=self.role, network_policy=deployed.network_policy, env_ids=list(self.env_ids), + control_token=deployed.control_token, )) return context @@ -576,6 +582,7 @@ async def _configure_agent_changelog( *, expires_in: int, sandbox_type: str | None, + headers: Mapping[str, str], ) -> None: """Enable whole-writable-layer changelog capture via the snapshot enable-changelog method; records the derived prefix in context.metadata['agent_changelog'].""" from agent_env.a2a_agent import A2AAgent @@ -609,6 +616,7 @@ async def _configure_agent_changelog( timeout=REPLY_TIMEOUT_SECONDS, response_model=NamespaceChangelogEnableResponse, store=store, + headers=headers, ) entry = { "agent_name": self.agent_name, @@ -624,7 +632,8 @@ async def _configure_agent_changelog( logger.info(f"agent-changelog capture enabled on '{self.agent_name}': {namespace_url}") async def _apply_agent_changelog( - self, a2a_url: str, card: dict, context: TaskStepContext, *, sandbox_type: str | None + self, a2a_url: str, card: dict, context: TaskStepContext, *, sandbox_type: str | None, + headers: Mapping[str, str], ) -> None: """Rewind this fresh agent to a point in a source changelog (fs + conversation) via the snapshot apply-changelog method and resume.""" from agent_env.a2a_agent import A2AAgent @@ -657,6 +666,7 @@ async def _apply_agent_changelog( timeout=TRANSFER_TIMEOUT_SECONDS, response_model=ObjectChangelogApplyResponse, store=store, + headers=headers, ) check_changelog_applied(answer, call, agent_name=self.agent_name) context_id = answer.context_id @@ -680,6 +690,7 @@ async def _load_snapshot( context: TaskStepContext, *, sandbox_type: str | None, + headers: Mapping[str, str], ) -> None: """Restore a snapshot into the freshly-deployed agent via /ext/snapshot.""" from agent_env.a2a_agent import A2AAgent @@ -720,6 +731,7 @@ async def _load_snapshot( timeout=TRANSFER_TIMEOUT_SECONDS, response_model=ObjectSnapshotLoadResponse, store=store, + headers=headers, ) loaded_context_id = answer.context_id logger.info( diff --git a/src/agent_env/task_step/task_steps/deploy_env.py b/src/agent_env/task_step/task_steps/deploy_env.py index 96a669f65..9517bff49 100644 --- a/src/agent_env/task_step/task_steps/deploy_env.py +++ b/src/agent_env/task_step/task_steps/deploy_env.py @@ -239,6 +239,7 @@ async def execute(self, context: TaskStepContext) -> TaskStepContext: a2a_url=agent_info.get("a2a_url"), a2a_card=agent_info.get("a2a_card"), instance_id=agent_info.get("instance_id") or deployed_env.instance_id, + control_token=agent_info.get("control_token"), )) return context diff --git a/src/agent_env/task_step/task_steps/install_agent.py b/src/agent_env/task_step/task_steps/install_agent.py index edebd8b2b..c72b74d03 100644 --- a/src/agent_env/task_step/task_steps/install_agent.py +++ b/src/agent_env/task_step/task_steps/install_agent.py @@ -25,6 +25,7 @@ from agent_env.artifact.artifacts.docker_image import DockerImageArtifact from agent_env.config import get_config from agent_env.entity.scopes import FieldScope +from agent_env.env.envs.computer.utils.boot import control_token as new_control_token from agent_env.providers.sandbox_providers.local_docker.provider import ( LOCAL_TRUST_DIR, LOCAL_TRUST_ENV, @@ -361,7 +362,7 @@ async def execute(self, context: TaskStepContext) -> TaskStepContext: agent_card = await self._wait_for_agent_card(a2a_url) logger.info(f"Agent '{self.agent_name}' reachable at {a2a_url} (card name={agent_card.get('name')})") - deployed = self._register_instance(agent, a2a_url, ds, agent_card) + deployed = self._register_instance(agent, a2a_url, ds, agent_card, new_control_token()) context.deployed_agents.append(DeployedAgent( agent_name=self.agent_name, @@ -373,6 +374,7 @@ async def execute(self, context: TaskStepContext) -> TaskStepContext: instance_id=deployed.instance_id, on_host=host_mode, installed_container=container, + control_token=deployed.control_token, )) default_model = agent.metadata.get("default_model") or get_config().get_model_for_role("agent") @@ -420,7 +422,7 @@ async def _host_place_of(self, sandbox, agent: A2AAgent) -> HostPlace: ) return HostPlace(workdir.format(agent_name=self.agent_name), user.format(agent_name=self.agent_name)) - def _register_instance(self, agent, a2a_url: str, ds, agent_card: dict): + def _register_instance(self, agent, a2a_url: str, ds, agent_card: dict, control_token: str): """Register the installed agent in the instance store, same as A2AAgent.deploy(), so store-resolving consumers (AddSkillsTaskStep, the a2a-agent CLIs) can find it.""" from agent_env.a2a_agent.a2a_agent import DeployedA2AAgent @@ -434,6 +436,7 @@ def _register_instance(self, agent, a2a_url: str, ds, agent_card: dict): sandbox_id=ds.sandbox_id, agent_card=agent_card, sandbox_type=ds.sandbox_type, + control_token=control_token, ), ttl_seconds=self._instance_ttl_seconds(ds), ) diff --git a/src/agent_env/task_step/task_steps/peer_agents.py b/src/agent_env/task_step/task_steps/peer_agents.py index 268d32c54..44247645c 100644 --- a/src/agent_env/task_step/task_steps/peer_agents.py +++ b/src/agent_env/task_step/task_steps/peer_agents.py @@ -81,7 +81,8 @@ async def _post(self, deployed_by_name: dict[str, DeployedAgent], peering: Agent endpoint = (ext.get("params") or {}).get("endpoint", "/ext/peer-agents") peers = [self._record(deployed_by_name[n], src) for n in peering.peer_agent_names] async with httpx.AsyncClient() as client: - resp = await client.post(a2a_url + endpoint, json={"peers": peers}, timeout=_POST_TIMEOUT_SECONDS) + resp = await client.post(a2a_url + endpoint, json={"peers": peers}, headers=src.control_headers, + timeout=_POST_TIMEOUT_SECONDS) if resp.status_code >= 400: raise RuntimeError(f"PeerAgentsTaskStep: POST {a2a_url + endpoint} failed for '{peering.source_agent_name}': {resp.status_code} {resp.text}") logger.info("PeerAgentsTaskStep: peered '%s' with %s", peering.source_agent_name, peering.peer_agent_names) diff --git a/src/agent_env/task_step/task_steps/prompt_agent.py b/src/agent_env/task_step/task_steps/prompt_agent.py index e94f6e1b3..218e5e282 100644 --- a/src/agent_env/task_step/task_steps/prompt_agent.py +++ b/src/agent_env/task_step/task_steps/prompt_agent.py @@ -10,6 +10,7 @@ import uuid from contextlib import nullcontext from datetime import datetime, timezone +from collections.abc import Mapping from typing import Any, ClassVar, Optional import httpx from a2a.types import TaskState @@ -554,7 +555,8 @@ async def _converse( desired_config["model_params"] = model_params negotiated = A2AAgent.negotiate_agent_config(card, desired_config) if negotiated: - await protocol.post_agent_config(target_url + negotiated.endpoint, negotiated.fields) + await protocol.post_agent_config(target_url + negotiated.endpoint, negotiated.fields, + headers=agent.control_headers) # A model the agent's card doesn't accept is never sent, and the agent runs its own. context.record_model("solver", self.id, negotiated.fields.get("model") if negotiated else None) @@ -567,7 +569,8 @@ async def _converse( user_config = {k: v for k, v in {"output_format": user_output_format, "model": user_model}.items() if v is not None} negotiated = A2AAgent.negotiate_agent_config(user_sim.a2a_card or {}, user_config) if negotiated: - await protocol.post_agent_config(user_url + negotiated.endpoint, negotiated.fields) + await protocol.post_agent_config(user_url + negotiated.endpoint, negotiated.fields, + headers=user_sim.control_headers) logger.info(f"Configured user-sim '{self.user_agent_name}' with structured output_format for done-signal") context.record_model("user simulator", self.id, negotiated.fields.get("model") if negotiated else None) @@ -625,7 +628,8 @@ async def _converse( traj_ext_cached = A2AAgent.find_extension(card, A2AAgent.EXT_TRAJECTORY) live = self._live_trajectory_target(context, card, target_url, trajectory_output_prefix) live_turns = ( - LiveTurns(*live, poll_interval_seconds=self.poll_interval_seconds) if live is not None else None + LiveTurns(*live, poll_interval_seconds=self.poll_interval_seconds, headers=agent.control_headers) + if live is not None else None ) final_state: str = TaskState.completed.value trajectory_url: Optional[str] = None @@ -701,6 +705,7 @@ def record_turn() -> None: turn_traj_uri = await self._fetch_trajectory( target_url, traj_ext_cached, sent_task_id, trajectory_output_prefix, target_a2a_task_id, card=card, sandbox_type=agent.sandbox_type, + headers=agent.control_headers, ) except Exception as e: logger.warning(f"Turn {turn+1} trajectory fetch failed (continuing): {e}") @@ -773,7 +778,7 @@ def record_turn() -> None: if trig_ext and triggers_registered: # best-effort firing-log readback (provenance only; never fails the run) try: async with httpx.AsyncClient() as client: - r = await client.get(state_url, timeout=15) + r = await client.get(state_url, headers=user_sim.control_headers, timeout=15) r.raise_for_status() context.metadata.setdefault("agent_trigger_state", {})[self.id] = r.json().get("firing_log", []) except Exception as e: @@ -887,7 +892,7 @@ def _live_trajectory_target( async def _fetch_trajectory( self, a2a_url: str, traj_ext: dict, a2a_server_task_id: str, trajectory_output_prefix: str, - target_a2a_task_id: str, *, sandbox_type: str | None, card: dict | None = None, + target_a2a_task_id: str, *, sandbox_type: str | None, headers: Mapping[str, str], card: dict | None = None, ) -> str | None: get_method, get_path = A2AAgent.operation(traj_ext, "get") store = transfer_store(get_config().get_object_store(), a2a_url, card, sandbox_type=sandbox_type) @@ -905,7 +910,8 @@ async def _fetch_trajectory( TrajectoryUpload.to, store, trajectory_object_url(trajectory_output_prefix, name=target_a2a_task_id, store=store), ) - fetched = await fetch_trajectory(a2a_url + get_path, {"task_id": a2a_server_task_id}, upload=upload, store=store) + fetched = await fetch_trajectory(a2a_url + get_path, {"task_id": a2a_server_task_id}, upload=upload, store=store, + headers=headers) return await asyncio.to_thread(store_trajectory, fetched, trajectory_output_prefix, name=target_a2a_task_id) async def _env_clock(self, envs: list) -> dict: @@ -940,12 +946,12 @@ async def _read_env_triggers(self, context: TaskStepContext) -> dict: return env_triggers async def _decide(self, decide_url: str, turn: int, solver_message: str, context_id: str, env_triggers: dict, - **quiet: bool) -> dict: + *, headers: Mapping[str, str], **quiet: bool) -> dict: """Call the usersim's /decide for the triggers that should fire this turn.""" payload = {"turn": turn, "solver_message": solver_message, "context_id": context_id, "env_triggers": env_triggers, **quiet} async with httpx.AsyncClient() as client: - resp = await client.post(decide_url, json=payload, timeout=self.user_agent_timeout_seconds) + resp = await client.post(decide_url, json=payload, headers=headers, timeout=self.user_agent_timeout_seconds) if resp.status_code >= 400: raise RuntimeError(f"agent-trigger /decide failed (HTTP {resp.status_code}): {resp.text}") return resp.json() @@ -1130,7 +1136,7 @@ async def ask(self, number: int, solver_message: str, agent_parts: list[dict]) - env_triggers = await self._step._read_env_triggers(self._context) self._record("env_trigger_snapshots", {"turn": number, "envs": env_triggers}) resp = await self._step._decide(self._decide_url, number, solver_message, self._conversation_id, - env_triggers) + env_triggers, headers=self._user_sim.control_headers) self._record("agent_trigger_firings", {"turn": number, "fired": resp.get("fired", [])}) logger.info(f"Turn {number} agent-trigger decide: fired={resp.get('fired', [])} done={resp.get('done')}") answer = _trigger_answer(resp) @@ -1176,7 +1182,8 @@ async def _user_sim_trajectory(self, task_id: str, message_id: str) -> Optional[ try: return await asyncio.wait_for( step._fetch_trajectory(self._url, ext, task_id, step._trajectory_prefix() + "user_sim/", message_id, - card=card, sandbox_type=self._user_sim.sandbox_type), + card=card, sandbox_type=self._user_sim.sandbox_type, + headers=self._user_sim.control_headers), _USER_SIM_TRAJECTORY_FETCH_SECONDS) except Exception as e: logger.warning(f"user sim trajectory fetch failed (continuing): {e}") @@ -1192,7 +1199,7 @@ async def triggers(self, number: int, solver_message: str) -> Optional[dict]: "agentenv-framework-protocol whose triggers/v1 decide takes record_unfired") env_triggers = await self._step._read_env_triggers(self._context) resp = await self._step._decide(self._decide_url, number, solver_message, self._conversation_id, env_triggers, - record_unfired=False) + headers=self._user_sim.control_headers, record_unfired=False) logger.info(f"Turn {number} agent-trigger decide: fired={resp.get('fired', [])} done={resp.get('done')}") answer = _trigger_answer(resp) if answer is not None: diff --git a/src/agent_env/task_step/task_steps/register_agent_triggers.py b/src/agent_env/task_step/task_steps/register_agent_triggers.py index 05171c26f..fa5dea5db 100644 --- a/src/agent_env/task_step/task_steps/register_agent_triggers.py +++ b/src/agent_env/task_step/task_steps/register_agent_triggers.py @@ -100,7 +100,7 @@ async def execute(self, context: TaskStepContext) -> TaskStepContext: body: dict = {"triggers": self.triggers} url = f"{agent.a2a_url or agent.api_url}{endpoint}" async with httpx.AsyncClient() as client: - resp = await client.post(url, json=body, timeout=30) + resp = await client.post(url, json=body, headers=agent.control_headers, timeout=30) if resp.status_code >= 400: raise RuntimeError(f"agent trigger registration failed (HTTP {resp.status_code}): {resp.text}") result = resp.json() diff --git a/src/agent_env/task_step/task_steps/snapshot_agent_state.py b/src/agent_env/task_step/task_steps/snapshot_agent_state.py index b491029d6..a9b75c8a8 100644 --- a/src/agent_env/task_step/task_steps/snapshot_agent_state.py +++ b/src/agent_env/task_step/task_steps/snapshot_agent_state.py @@ -154,6 +154,7 @@ async def execute(self, context: TaskStepContext) -> TaskStepContext: artifact_id=self._resolve_artifact_id(context), timeout_seconds=self.timeout_seconds, sandbox_type=deployed.sandbox_type, + headers=deployed.control_headers, ) snapshots = context.metadata.setdefault("agent_snapshots", []) diff --git a/src/agent_env/task_step/task_steps/verifiers/rubrics_verifier.py b/src/agent_env/task_step/task_steps/verifiers/rubrics_verifier.py index 71f7bf944..1e70514ad 100644 --- a/src/agent_env/task_step/task_steps/verifiers/rubrics_verifier.py +++ b/src/agent_env/task_step/task_steps/verifiers/rubrics_verifier.py @@ -7,7 +7,7 @@ import logging import re import uuid -from collections.abc import Sequence +from collections.abc import Mapping, Sequence from dataclasses import dataclass, field, replace from typing import Any, ClassVar, Optional @@ -1414,6 +1414,7 @@ async def _configure_judge_a2a( judge_effort: Optional[str], judge_max_thinking_tokens: Optional[int], context: TaskStepContext, + headers: Mapping[str, str], ) -> None: from agent_env.a2a_agent import A2AAgent from agent_env.a2a_agent import protocol @@ -1440,7 +1441,7 @@ async def _configure_judge_a2a( self.verifier_id, unsupported) if config_payload: endpoint = (config_ext.get("params") or {}).get("endpoint", "/ext/agent-config") - await protocol.post_agent_config(judge_a2a_url + endpoint, config_payload) + await protocol.post_agent_config(judge_a2a_url + endpoint, config_payload, headers=headers) logger.info(f"Set judge agent config: {list(config_payload.keys())}") # What the judge agent took; one that doesn't accept a model grades on its own. context.record_model("judge", self.id, config_payload.get("model")) @@ -1514,6 +1515,7 @@ async def _invoke_judge_a2a( judge_agent_card=judge_agent_card, a2a_server_task_id=task_id, sandbox_type=getattr(judge_agent, "sandbox_type", None), + headers=judge_agent.control_headers, ) return {"response": tr.response_text, "trajectory_object_url": judge_trajectory_url} @@ -1522,7 +1524,8 @@ async def _judge_timed_out(self, why: str, judge_a2a_url: str, judge_agent_card: """The error for a judge call that ran out of time, carrying the judge's trajectory so far.""" url = await self._fetch_judge_trajectory(judge_a2a_url=judge_a2a_url, judge_agent_card=judge_agent_card, a2a_server_task_id=task_id, - sandbox_type=getattr(judge_agent, "sandbox_type", None)) + sandbox_type=getattr(judge_agent, "sandbox_type", None), + headers=judge_agent.control_headers) logger.warning("Verifier '%s': judge task %s ran out of its %ss (%s); its trajectory so far: %s", self.verifier_id, task_id, self.judge_timeout_seconds, why, url) return JudgeTimeoutError(f"Judge A2A task {task_id} ran out of its {self.judge_timeout_seconds}s: {why} " @@ -1550,6 +1553,7 @@ async def _fetch_judge_trajectory( judge_agent_card: dict, a2a_server_task_id: str, sandbox_type: Optional[str], + headers: Mapping[str, str], ) -> Optional[str]: """Best-effort capture of the judge's own reasoning trajectory, via the same EXT_TRAJECTORY extension `prompt_agent` uses, keyed by the A2A task id. Retries @@ -1595,7 +1599,8 @@ async def _fetch_judge_trajectory( for attempt in range(1, self.DEFAULT_MAX_RETRIES + 1): try: fetched = await fetch_trajectory( - judge_a2a_url + get_path, {"task_id": a2a_server_task_id}, upload=upload, store=store + judge_a2a_url + get_path, {"task_id": a2a_server_task_id}, upload=upload, store=store, + headers=headers, ) return await asyncio.to_thread(store_trajectory, fetched, prefix) except Exception as exc: @@ -1647,6 +1652,7 @@ async def _run_judge_with_output_retries( judge_effort=judge_effort, judge_max_thinking_tokens=judge_max_thinking_tokens, context=context, + headers=judge_agent.control_headers, ) for attempt in range(1, self.DEFAULT_MAX_RETRIES + 1): diff --git a/tst/unit/a2a_agent/add_skill_test.py b/tst/unit/a2a_agent/add_skill_test.py index 30c3ac0bf..60fd53169 100644 --- a/tst/unit/a2a_agent/add_skill_test.py +++ b/tst/unit/a2a_agent/add_skill_test.py @@ -98,7 +98,7 @@ def agent(monkeypatch: pytest.MonkeyPatch) -> _Agent: monkeypatch.setattr(Skill, "validate", lambda self: None) agent = _Agent() - async def post(self, url, *, json, timeout): + async def post(self, url, *, json, timeout, headers=None): agent.requests.append({"url": url, "json": json, "timeout": timeout}) body = ( {"status": "added", "name": json["name"], "source": "s3"} @@ -381,7 +381,7 @@ async def test_an_s3_url_skill_s_skill_md_is_read_off_the_event_loop( get = store.get monkeypatch.setattr(store, "get", lambda url: (on_loop.append(on_event_loop()), get(url))[1]) - async def post(self, url, *, json, timeout): + async def post(self, url, *, json, timeout, headers=None): return httpx.Response(200, json={"status": "added", "name": json["name"]}, request=httpx.Request("POST", url)) monkeypatch.setattr(httpx.AsyncClient, "post", post) diff --git a/tst/unit/a2a_agent/deploy_cleanup_test.py b/tst/unit/a2a_agent/deploy_cleanup_test.py index 282cfe781..131e6ed91 100644 --- a/tst/unit/a2a_agent/deploy_cleanup_test.py +++ b/tst/unit/a2a_agent/deploy_cleanup_test.py @@ -1,11 +1,12 @@ """``A2AAgent.deploy`` closes the sandbox it created when the deploy fails or is cancelled, so an agent that never -made it into a run's context doesn't outlive it.""" +made it into a run's context doesn't outlive it. One that succeeds is recorded with a control token of its own.""" import asyncio import pytest from agent_env.a2a_agent.a2a_agent import DEFAULT_A2A_PORT, A2AAgent +from agent_env.a2a_agent.store import get_a2a_agent_instance_store from agent_env.artifact.artifacts.docker_image import DockerImageArtifact from agent_env.providers.sandbox_providers import sandbox_provider from agent_env.providers.sandbox_providers.sandbox_provider import SANDBOX_MODE_CONTAINER, SandboxProvider @@ -47,3 +48,25 @@ async def wait_for_card(self, url): await deploying assert sandbox.terminated + + +@pytest.mark.asyncio +async def test_each_deploy_is_recorded_with_a_control_token_of_its_own(monkeypatch, local_stores): + class _Provider(SandboxProvider): + async def create_sandbox(self, **_): + return _Sandbox() + + async def card(self, url): + return {"name": "solver"} + + monkeypatch.setattr(sandbox_provider, "build_sandbox_provider", lambda name: _Provider()) + monkeypatch.setattr(A2AAgent, "_wait_for_agent_card", card) + agent = A2AAgent(id="solver", version=1, docker_image_artifact=DockerImageArtifact(id="img", description="d", image_name="img")) + env_vars = {"LITELLM_API_KEY": "k", "LITELLM_BASE_URL": "http://llm"} + + first = await agent.deploy(sandbox_type="fake", env_vars=env_vars) + second = await agent.deploy(sandbox_type="fake", env_vars=env_vars) + + assert first.control_token and second.control_token and first.control_token != second.control_token + assert first.control_headers == {"AgentEnv-Control-Token": first.control_token} + assert get_a2a_agent_instance_store().get(first.instance_id).control_token == first.control_token diff --git a/tst/unit/a2a_agent/store_test.py b/tst/unit/a2a_agent/store_test.py index 1839aeed3..ad5f6dbee 100644 --- a/tst/unit/a2a_agent/store_test.py +++ b/tst/unit/a2a_agent/store_test.py @@ -20,6 +20,7 @@ def test_deployed_a2a_agent_roundtrip_preserves_all_fields(): instance_id=None, created_at_utc=None, expires_at_utc=None, + control_token="tok", ) persisted = store.create_instance(original, ttl_seconds=60) rehydrated = store.get(persisted.instance_id) diff --git a/tst/unit/a2a_agent/test_trajectory_follower.py b/tst/unit/a2a_agent/test_trajectory_follower.py index 8aac86070..dfebf921e 100644 --- a/tst/unit/a2a_agent/test_trajectory_follower.py +++ b/tst/unit/a2a_agent/test_trajectory_follower.py @@ -41,16 +41,18 @@ class _Agent: def __init__(self, *answers: httpx.Response) -> None: self.answers = list(answers) self.afters: list[int] = [] + self.tokens: list[str | None] = [] def client(self) -> httpx.AsyncClient: return httpx.AsyncClient(transport=httpx.MockTransport(self._answer)) def _answer(self, request: httpx.Request) -> httpx.Response: self.afters.append(json.loads(request.content)["after"]) + self.tokens.append(request.headers.get("agentenv-control-token")) return self.answers.pop(0) -async def _follow(agent: _Agent) -> list[TrajectoryBatch]: +async def _follow(agent: _Agent, headers: dict[str, str] | None = None) -> list[TrajectoryBatch]: batches: list[TrajectoryBatch] = [] async def sink(batch: TrajectoryBatch) -> None: @@ -58,7 +60,7 @@ async def sink(batch: TrajectoryBatch) -> None: async with agent.client() as client: await follow_trajectory( - _ENDPOINT, "task-1", sink, poll_interval_seconds=0, stop=asyncio.Event(), client=client + _ENDPOINT, "task-1", sink, poll_interval_seconds=0, stop=asyncio.Event(), client=client, headers=headers ) return batches @@ -102,6 +104,18 @@ async def test_pages_are_followed_until_the_task_ends_and_every_event_is_read(): assert batches[-1].state is TrajectoryState.COMPLETED +@pytest.mark.asyncio +async def test_every_read_carries_the_headers_it_was_given(): + agent = _Agent( + httpx.Response(200, json=_page(0, [{"i": 0}], "running")), + httpx.Response(200, json=_page(1, [], "completed")), + ) + + await _follow(agent, headers={"AgentEnv-Control-Token": "tok"}) + + assert agent.tokens == ["tok", "tok"] + + @pytest.mark.asyncio async def test_an_ended_task_with_nothing_new_still_gets_a_last_batch(): agent = _Agent(httpx.Response(200, json=_page(0, [], "failed"))) @@ -271,7 +285,7 @@ async def test_a_failed_turn_stops_its_follower_without_draining_and_marks_it_en with pytest.raises(type(error)): async with following_live_trajectory( - _ENDPOINT, store, "prefix/", "turn", poll_interval_seconds=0 + _ENDPOINT, store, "prefix/", "turn", poll_interval_seconds=0, headers={} ) as turn: turn.follow("task-1") await asyncio.sleep(0.05) @@ -298,7 +312,7 @@ def put_then_linger(key, body, *, content_type): with pytest.raises(asyncio.CancelledError): async with following_live_trajectory( - _ENDPOINT, store, "prefix/", "turn", poll_interval_seconds=0 + _ENDPOINT, store, "prefix/", "turn", poll_interval_seconds=0, headers={} ) as turn: turn.follow("task-1") async with asyncio.timeout(5): @@ -316,7 +330,7 @@ async def test_a_turn_the_follower_saw_end_keeps_its_state(monkeypatch, tmp_path with pytest.raises(RuntimeError): async with following_live_trajectory( - _ENDPOINT, store, "prefix/", "turn", poll_interval_seconds=0 + _ENDPOINT, store, "prefix/", "turn", poll_interval_seconds=0, headers={} ) as turn: turn.follow("task-1") async with asyncio.timeout(5): @@ -349,7 +363,7 @@ async def test_a_turn_the_follower_stopped_before_its_end_is_marked_ended_in_the _agent_answering(monkeypatch, _page(0, [{"i": 0}, {"i": 1}], "running"), stops_with) store = LocalFilesystemObjectStore(str(tmp_path)) - async with following_live_trajectory(_ENDPOINT, store, "prefix/", "turn", poll_interval_seconds=0) as turn: + async with following_live_trajectory(_ENDPOINT, store, "prefix/", "turn", poll_interval_seconds=0, headers={}) as turn: turn.follow("task-1") await _until_stored(store, "prefix/turn/live/00000000-00000002.jsonl") turn.ended("completed") @@ -363,7 +377,7 @@ async def test_a_reported_task_state_ends_the_turn_as_its_trajectory_state(monke _agent_answering(monkeypatch, httpx.Response(404, json={"detail": "Unknown task"})) store = LocalFilesystemObjectStore(str(tmp_path)) - async with following_live_trajectory(_ENDPOINT, store, "prefix/", "turn", poll_interval_seconds=0) as turn: + async with following_live_trajectory(_ENDPOINT, store, "prefix/", "turn", poll_interval_seconds=0, headers={}) as turn: turn.follow("task-1") turn.ended(task_state) @@ -378,7 +392,7 @@ def _next(store: LocalFilesystemObjectStore, turn: str) -> dict: async def test_each_turn_names_the_next_and_the_last_is_marked_last(monkeypatch, tmp_path): _agent_answering(monkeypatch, _page(0, [{"i": 0}], "completed")) store = LocalFilesystemObjectStore(str(tmp_path)) - turns = LiveTurns(_ENDPOINT, store, "prefix/", poll_interval_seconds=0) + turns = LiveTurns(_ENDPOINT, store, "prefix/", poll_interval_seconds=0, headers={}) for turn_id in ("turn-1", "turn-2"): async with turns.following(turn_id) as turn: @@ -396,7 +410,7 @@ async def test_each_turn_names_the_next_and_the_last_is_marked_last(monkeypatch, async def test_a_turn_never_sent_is_not_linked_and_the_last_sent_is_marked_last(monkeypatch, tmp_path): _agent_answering(monkeypatch, _page(0, [{"i": 0}], "completed")) store = LocalFilesystemObjectStore(str(tmp_path)) - turns = LiveTurns(_ENDPOINT, store, "prefix/", poll_interval_seconds=0) + turns = LiveTurns(_ENDPOINT, store, "prefix/", poll_interval_seconds=0, headers={}) async with turns.following("turn-1") as turn: turn.follow("task-1") turn.ended("completed") @@ -414,6 +428,6 @@ async def test_a_turn_never_sent_is_not_linked_and_the_last_sent_is_marked_last( async def test_a_step_that_sent_no_turn_marks_none(tmp_path): store = LocalFilesystemObjectStore(str(tmp_path)) - await LiveTurns(_ENDPOINT, store, "prefix/", poll_interval_seconds=0).end() + await LiveTurns(_ENDPOINT, store, "prefix/", poll_interval_seconds=0, headers={}).end() assert store.list("prefix/") == [] diff --git a/tst/unit/a2a_agent/test_validator_changelog_objects.py b/tst/unit/a2a_agent/test_validator_changelog_objects.py index e348e61a8..de044ce31 100644 --- a/tst/unit/a2a_agent/test_validator_changelog_objects.py +++ b/tst/unit/a2a_agent/test_validator_changelog_objects.py @@ -79,6 +79,7 @@ def _context(capture: dict, *apply_variants: list[str]) -> TaskStepContext: }, sandbox_type="local", sandbox_id="sandbox-1", + control_headers={}, ) context = TaskStepContext() context.deployed_agents = [apply_agent] diff --git a/tst/unit/a2a_agent/test_validator_skill_variants.py b/tst/unit/a2a_agent/test_validator_skill_variants.py index a61c35979..f2339db6b 100644 --- a/tst/unit/a2a_agent/test_validator_skill_variants.py +++ b/tst/unit/a2a_agent/test_validator_skill_variants.py @@ -35,14 +35,14 @@ async def __aenter__(self): async def __aexit__(self, *args): return None - async def get(self, url, *, timeout): + async def get(self, url, *, timeout, headers=None): return httpx.Response( 200, json={"skills": {"validator-test": {"description": "test"}}}, request=httpx.Request("GET", url), ) - async def post(self, url, *, json, timeout): + async def post(self, url, *, json, timeout, headers=None): variant = "bundle" if "skill_bundle" in json else "other" self.posts.append({"variant": variant, "json": json}) status_code = 422 if variant in self.rejected_variants else 200 diff --git a/tst/unit/a2a_agent/validator_trajectory_dag_test.py b/tst/unit/a2a_agent/validator_trajectory_dag_test.py index 26dd0ea47..957ad5653 100644 --- a/tst/unit/a2a_agent/validator_trajectory_dag_test.py +++ b/tst/unit/a2a_agent/validator_trajectory_dag_test.py @@ -92,7 +92,7 @@ async def __aenter__(self) -> "_StubAsyncClient": async def __aexit__(self, *_exc_info) -> None: return None - async def post(self, _url: str, json: dict, timeout: int) -> _StubResponse: # noqa: A002 + async def post(self, _url: str, json: dict, timeout: int, headers=None) -> _StubResponse: # noqa: A002 type(self).posts.append(json) if "objects" in json: return _StubResponse( diff --git a/tst/unit/task/episode/proxy_test.py b/tst/unit/task/episode/proxy_test.py index baf850d26..784e0e1b3 100644 --- a/tst/unit/task/episode/proxy_test.py +++ b/tst/unit/task/episode/proxy_test.py @@ -62,6 +62,25 @@ async def test_a_recorded_model_call_is_never_sent_twice(monkeypatch): assert sent == ["/ext/proxy/record"] +@pytest.mark.asyncio +async def test_every_call_carries_the_headers_the_client_was_made_with(monkeypatch): + seen: list[str | None] = [] + real_client = httpx.AsyncClient + + def handle(request: httpx.Request) -> httpx.Response: + seen.append(request.headers.get("agentenv-control-token")) + return httpx.Response(200, json={"tools": []}) + + monkeypatch.setattr(client_module.httpx, "AsyncClient", + lambda **kw: real_client(transport=httpx.MockTransport(handle), **kw)) + client = ProxyClient("http://proxy", CARD, headers={"AgentEnv-Control-Token": "tok"}) + + await client.claim() + await client.tools("task-1") + + assert seen == ["tok", "tok"] + + @pytest.mark.asyncio async def test_fields_a_newer_proxy_adds_are_ignored(): turn = {"task_id": "task-1", "context_id": "c", "parts": [{"kind": "text", "text": "Add one.", "lang": "en"}], diff --git a/tst/unit/task_step/always_on_harness.py b/tst/unit/task_step/always_on_harness.py index 3da8eab02..15c0d30f3 100644 --- a/tst/unit/task_step/always_on_harness.py +++ b/tst/unit/task_step/always_on_harness.py @@ -86,7 +86,7 @@ def __init__(self, monkeypatch, tmp_path, *, agent: Optional[Turn] = None, answe monkeypatch.setattr(ao, "send_and_wait", self._send_and_wait) monkeypatch.setattr(ao._Run, "_load_plugin", self._load_plugin) if takes_config: - async def post(url, fields): + async def post(url, fields, headers=None): self.configs.append((url, fields)) monkeypatch.setattr(ao.protocol, "post_agent_config", post) diff --git a/tst/unit/task_step/capture_stubs.py b/tst/unit/task_step/capture_stubs.py index 7fb44c6e8..c1bc73954 100644 --- a/tst/unit/task_step/capture_stubs.py +++ b/tst/unit/task_step/capture_stubs.py @@ -197,6 +197,7 @@ def __init__(self, name="solver", a2a_url="https://agent", card=None): self.sandbox_id = "sb-agent" self.sandbox_type = None self.role = None + self.control_headers = {} def context(*, agent: Optional[_StubAgent] = None, env_id: Optional[str] = None) -> TaskStepContext: diff --git a/tst/unit/task_step/deploy_agent_cleanup_test.py b/tst/unit/task_step/deploy_agent_cleanup_test.py index d887d21e6..66b9eb1e5 100644 --- a/tst/unit/task_step/deploy_agent_cleanup_test.py +++ b/tst/unit/task_step/deploy_agent_cleanup_test.py @@ -19,7 +19,7 @@ def __init__(self) -> None: async def deploy(self, **_): return SimpleNamespace( a2a_url="https://agent.example.test", agent_card={}, sandbox_id="sb-1", sandbox_type="fake", - instance_id="i-1", network_policy=None, + instance_id="i-1", network_policy=None, control_token=None, control_headers={}, ) async def close(self) -> None: diff --git a/tst/unit/task_step/install_agent_test.py b/tst/unit/task_step/install_agent_test.py index 22f55a2fa..0eef2a44c 100644 --- a/tst/unit/task_step/install_agent_test.py +++ b/tst/unit/task_step/install_agent_test.py @@ -176,7 +176,7 @@ async def test_install_logs_show_the_command_template_not_the_model_key_or_heade "install_commands_host": ["start --key {litellm_api_key} --headers {litellm_extra_headers}"], "required_params_host": ["litellm_api_key", "litellm_extra_headers"], "a2a_port": 8000}})) monkeypatch.setattr(step, "_wait_for_agent_card", _resolved({})) - monkeypatch.setattr(step, "_register_instance", lambda *args: SimpleNamespace(instance_id="solver-1")) + monkeypatch.setattr(step, "_register_instance", lambda *args: SimpleNamespace(instance_id="solver-1", control_token=None)) context = TaskStepContext(deployed_sandboxes=[DeployedSandbox( sandbox_name="vm", sandbox_id="sb-1", sandbox_mode="vm", sandbox_type="local", tunnel_urls={"8000": "http://127.0.0.1:8000"})]) @@ -205,7 +205,7 @@ async def test_a_per_run_key_given_by_reference_is_resolved_through_the_secret_s "install_commands_host": ["start --key {litellm_api_key}"], "required_params_host": ["litellm_api_key"], "a2a_port": 8000}})) monkeypatch.setattr(step, "_wait_for_agent_card", _resolved({})) - monkeypatch.setattr(step, "_register_instance", lambda *args: SimpleNamespace(instance_id="solver-1")) + monkeypatch.setattr(step, "_register_instance", lambda *args: SimpleNamespace(instance_id="solver-1", control_token=None)) context = TaskStepContext( deployed_sandboxes=[DeployedSandbox( sandbox_name="vm", sandbox_id="sb-1", sandbox_mode="vm", sandbox_type="local", @@ -341,7 +341,7 @@ def _installing_in_place(monkeypatch, *, codex=CODEX_INSTALL, sandbox=None, cont monkeypatch.setattr(step, "_extract_install_extension", lambda sandbox, image: _resolved(cards[image.image_name])()) monkeypatch.setattr(step, "_wait_for_agent_card", _resolved({})) - monkeypatch.setattr(step, "_register_instance", lambda *args: SimpleNamespace(instance_id="solver-1")) + monkeypatch.setattr(step, "_register_instance", lambda *args: SimpleNamespace(instance_id="solver-1", control_token=None)) context = TaskStepContext( deployed_sandboxes=[DeployedSandbox( sandbox_name="vm", sandbox_id="sb-1", sandbox_mode="vm", sandbox_type="modal_vm", diff --git a/tst/unit/task_step/local_step_containers_test.py b/tst/unit/task_step/local_step_containers_test.py index 9150c3c10..27ad0d73e 100644 --- a/tst/unit/task_step/local_step_containers_test.py +++ b/tst/unit/task_step/local_step_containers_test.py @@ -200,7 +200,7 @@ async def test_an_installed_agent_uses_the_sandboxs_container_and_published_port ["container", "a2a_port"] if container_name else ["a2a_port"]} monkeypatch.setattr(InstallAgentTaskStep, "_extract_install_extension", AsyncMock(return_value={"params": params})) monkeypatch.setattr(InstallAgentTaskStep, "_wait_for_agent_card", AsyncMock(return_value={})) - monkeypatch.setattr(InstallAgentTaskStep, "_register_instance", lambda *a: types.SimpleNamespace(instance_id="i")) + monkeypatch.setattr(InstallAgentTaskStep, "_register_instance", lambda *a: types.SimpleNamespace(instance_id="i", control_token=None)) await InstallAgentTaskStep(id="install", version=None, sandbox_name="h", container_name=container_name, a2a_agent_id="agent").execute(context) diff --git a/tst/unit/task_step/test_agent_state_capture.py b/tst/unit/task_step/test_agent_state_capture.py index 88e717b77..5269e467e 100644 --- a/tst/unit/task_step/test_agent_state_capture.py +++ b/tst/unit/task_step/test_agent_state_capture.py @@ -50,7 +50,7 @@ async def _capture(**overrides): sandbox_type="local", ) kwargs.update(overrides) - return await mod.capture_workspace(**kwargs) + return await mod.capture_workspace(**kwargs, headers={}) def _granted(rec) -> dict[str, str]: @@ -214,7 +214,7 @@ async def _read(card, **overrides): trajectory_output_prefix=PARTIAL_PREFIX, sandbox_type="local", ) kwargs.update(overrides) - return await mod.read_partial_trajectory(**kwargs) + return await mod.read_partial_trajectory(**kwargs, headers={}) @pytest.mark.asyncio diff --git a/tst/unit/task_step/test_always_on_user_model.py b/tst/unit/task_step/test_always_on_user_model.py index 9147aa3b5..3c00a4113 100644 --- a/tst/unit/task_step/test_always_on_user_model.py +++ b/tst/unit/task_step/test_always_on_user_model.py @@ -27,7 +27,7 @@ async def test_the_run_s_user_model_sets_the_user_sim_agent_s_model(monkeypatch, tmp_path, overrides, model, source): posted: list[tuple[str, dict]] = [] - async def post(url, fields): + async def post(url, fields, headers=None): posted.append((url, fields)) monkeypatch.setattr(ao.protocol, "post_agent_config", post) diff --git a/tst/unit/task_step/test_deploy_agent_changelog_objects.py b/tst/unit/task_step/test_deploy_agent_changelog_objects.py index 8c1ce3f41..1e534dac5 100644 --- a/tst/unit/task_step/test_deploy_agent_changelog_objects.py +++ b/tst/unit/task_step/test_deploy_agent_changelog_objects.py @@ -116,7 +116,7 @@ async def test_enable_prefers_a_bounded_namespace_grant(monkeypatch, store): context = _run_context() await _step(enable_agent_changelog=True)._configure_agent_changelog( - "https://agent", _card(), context, expires_in=28_800, sandbox_type="local" + "https://agent", _card(), context, expires_in=28_800, sandbox_type="local", headers={} ) sent = requests[0] @@ -147,7 +147,7 @@ async def test_the_changelog_namespace_is_under_the_fixture_prefix(monkeypatch, context = _run_context() await _step(enable_agent_changelog=True)._configure_agent_changelog( - "https://agent", _card(), context, expires_in=600, sandbox_type="local" + "https://agent", _card(), context, expires_in=600, sandbox_type="local", headers={} ) assert requests[0]["json"]["write_namespace"]["root_path"] == f"fx/{NAMESPACE_KEY}" @@ -174,7 +174,7 @@ def unavailable(*args, **kwargs): _card(enable_legacy=enable_legacy), _run_context(), expires_in=28_800, - sandbox_type="local", + sandbox_type="local", headers={}, ) assert not requests @@ -188,7 +188,7 @@ async def test_enable_on_a_store_without_grants_is_refused(monkeypatch, store, e with pytest.raises(RuntimeError, match="does not issue transfer grants"): await _step(enable_agent_changelog=True)._configure_agent_changelog( - "https://agent", _card(enable_legacy=enable_legacy), _run_context(), expires_in=7_200, sandbox_type="local" + "https://agent", _card(enable_legacy=enable_legacy), _run_context(), expires_in=7_200, sandbox_type="local", headers={} ) assert not requests @@ -201,7 +201,7 @@ async def test_enable_is_refused_for_an_agent_without_the_object_form(monkeypatc with pytest.raises(RuntimeError, match="does not advertise the object form"): await _step(enable_agent_changelog=True)._configure_agent_changelog( - "https://agent", _card(enable_objects=False), _run_context(), expires_in=7_200, sandbox_type="local" + "https://agent", _card(enable_objects=False), _run_context(), expires_in=7_200, sandbox_type="local", headers={} ) assert not requests @@ -224,7 +224,7 @@ async def test_apply_lists_validates_and_sends_ordered_read_grants(monkeypatch, context = TaskStepContext() event_loop_thread = threading.get_ident() - await step._apply_agent_changelog("https://agent", _card(), context, sandbox_type="local") + await step._apply_agent_changelog("https://agent", _card(), context, sandbox_type="local", headers={}) sent = requests[0]["json"] assert [item["sequence"] for item in sent["increments"]] == [0, 1] @@ -247,7 +247,7 @@ async def test_apply_uses_absolute_tool_call_positions_for_the_cutoff(monkeypatc agent_changelog_toolcall_position_exclusive=7, ) - await step._apply_agent_changelog("https://agent", _card(), TaskStepContext(), sandbox_type="local") + await step._apply_agent_changelog("https://agent", _card(), TaskStepContext(), sandbox_type="local", headers={}) assert [item["sequence"] for item in requests[0]["json"]["increments"]] == [2, 4] assert _granted_names(store) == ["000002.tar", "000004.tar"] @@ -262,7 +262,7 @@ async def test_apply_allows_a_cutoff_beyond_the_last_tool_call(monkeypatch, stor agent_changelog_toolcall_position_exclusive=99, ) - await step._apply_agent_changelog("https://agent", _card(), TaskStepContext(), sandbox_type="local") + await step._apply_agent_changelog("https://agent", _card(), TaskStepContext(), sandbox_type="local", headers={}) assert [item["sequence"] for item in requests[0]["json"]["increments"]] == [2, 4] @@ -274,7 +274,7 @@ async def test_apply_rejects_duplicate_tool_call_positions(monkeypatch, store): with pytest.raises(ValueError, match="strictly increasing"): await _step(agent_changelog_object_url=namespace)._apply_agent_changelog( - "https://agent", _card(), TaskStepContext(), sandbox_type="local" + "https://agent", _card(), TaskStepContext(), sandbox_type="local", headers={} ) assert not requests @@ -286,7 +286,7 @@ async def test_apply_rejects_unsequenced_objects_in_a_portable_namespace(monkeyp with pytest.raises(ValueError, match="zero-padded sequence names"): await _step(agent_changelog_object_url=namespace)._apply_agent_changelog( - "https://agent", _card(), TaskStepContext(), sandbox_type="local" + "https://agent", _card(), TaskStepContext(), sandbox_type="local", headers={} ) assert not requests assert store.granted == [] @@ -309,7 +309,7 @@ async def test_apply_sends_the_empty_baseline_when_no_increment_is_selected( agent_changelog_toolcall_position_exclusive=cutoff, ) - await step._apply_agent_changelog("https://agent", _card(), context, sandbox_type="local") + await step._apply_agent_changelog("https://agent", _card(), context, sandbox_type="local", headers={}) assert requests[0]["json"]["increments"] == [] assert store.granted == [] @@ -368,7 +368,7 @@ async def test_a_source_is_not_sent_to_an_agent_without_the_object_apply_form(mo with pytest.raises(RuntimeError, match="does not advertise the object form"): await _step(agent_changelog_object_url=namespace)._apply_agent_changelog( - "https://agent", _card(apply_objects=False), TaskStepContext(), sandbox_type="local" + "https://agent", _card(apply_objects=False), TaskStepContext(), sandbox_type="local", headers={} ) assert not requests diff --git a/tst/unit/task_step/test_deploy_agent_role_delivery.py b/tst/unit/task_step/test_deploy_agent_role_delivery.py index e642fd0de..3e605df0f 100644 --- a/tst/unit/task_step/test_deploy_agent_role_delivery.py +++ b/tst/unit/task_step/test_deploy_agent_role_delivery.py @@ -12,7 +12,7 @@ import pytest from agentenv_protocol.a2a_agent import AgentConfig, BuiltinTools -from agent_env.a2a_agent.a2a_agent import A2AAgent +from agent_env.a2a_agent.a2a_agent import A2AAgent, DeployedA2AAgent from agent_env.env.env import DeployedGatewayEnv from agent_env.env.gateway import AGENT_ENV_ROLE_HEADER from agent_env.task_step.context import TaskStepContext @@ -57,6 +57,16 @@ class _ToolConfig(AgentConfig): TOOLS_CONFIG["params"]["methods"]["set"]["request"]["schema"] = _ToolConfig.model_json_schema() +@pytest.mark.asyncio +async def test_every_request_to_the_agent_carries_its_control_token_and_the_record_keeps_it(wiring): + context = await wiring.deploy(_card(HEADERS_MCP, ROLE_CONFIG), role="executor") + + assert {r.url.path for r in wiring.requests} == {"/ext/mcp-config", "/ext/agent-config"} + assert {r.headers.get("agentenv-control-token") for r in wiring.requests} == {"tok"} + assert not any("authorization" in r.headers for r in wiring.requests) + assert context.deployed_agents[0].control_token == "tok" + + @pytest.mark.asyncio async def test_a_card_with_both_paths_gets_the_role_on_both_and_the_agent_records_its_envs(wiring, caplog): with caplog.at_level(logging.WARNING, logger=_LOGGER): @@ -245,9 +255,10 @@ def _handle(self, request: httpx.Request) -> httpx.Response: return httpx.Response(200, json={"ok": True}) async def deploy(self, card: dict, *, role: str | None, env_ids=("crm",), **step_kwargs) -> TaskStepContext: - self.agent.deploy = AsyncMock( - return_value=MagicMock(a2a_url="https://agent.example", agent_card=card, sandbox_type=None) - ) + self.agent.deploy = AsyncMock(return_value=DeployedA2AAgent( + agent_id="solver", agent_version=1, a2a_url="https://agent.example", sandbox_id="sb", agent_card=card, + control_token="tok", + )) step = DeployAgentTaskStep( id="ag", version=None, env_ids=list(env_ids), agent_name="solver", role=role, **step_kwargs ) diff --git a/tst/unit/task_step/test_deploy_agent_snapshot_objects.py b/tst/unit/task_step/test_deploy_agent_snapshot_objects.py index 494b3aaf1..14f912d8c 100644 --- a/tst/unit/task_step/test_deploy_agent_snapshot_objects.py +++ b/tst/unit/task_step/test_deploy_agent_snapshot_objects.py @@ -107,7 +107,7 @@ async def test_load_prefers_objects_for_a_portable_snapshot(monkeypatch, store): ) context = TaskStepContext() - await _step()._load_snapshot("https://agent", _card(), "agent-1", context, sandbox_type="local") + await _step()._load_snapshot("https://agent", _card(), "agent-1", context, sandbox_type="local", headers={}) sent = requests[0] assert sent["url"] == "https://agent/custom/snapshot" @@ -136,7 +136,7 @@ def recording(url): monkeypatch.setattr(store, "get_object_metadata_at", recording) - await _step()._load_snapshot("https://agent", _card(), "agent-1", TaskStepContext(), sandbox_type="local") + await _step()._load_snapshot("https://agent", _card(), "agent-1", TaskStepContext(), sandbox_type="local", headers={}) assert loop_threads == [False, False] @@ -155,7 +155,7 @@ async def test_a_legacy_snapshot_cannot_be_restored(monkeypatch, store, card, fi requests = _install(monkeypatch, _Universe(store, files), {"context_id": "wrong"}) with pytest.raises(RuntimeError, match="is not a portable snapshot, so it cannot be restored"): - await _step()._load_snapshot("https://agent", card, "agent-1", TaskStepContext(), sandbox_type="local") + await _step()._load_snapshot("https://agent", card, "agent-1", TaskStepContext(), sandbox_type="local", headers={}) assert not store.granted assert not requests @@ -167,7 +167,7 @@ async def test_load_validates_the_object_response(monkeypatch, store): with pytest.raises(RuntimeError, match="invalid object response"): await _step()._load_snapshot( - "https://agent", _card(), "agent-1", TaskStepContext(), sandbox_type="local" + "https://agent", _card(), "agent-1", TaskStepContext(), sandbox_type="local", headers={} ) @@ -180,7 +180,7 @@ async def test_load_ignores_response_fields_it_does_not_know(monkeypatch, store) ) context = TaskStepContext() - await _step()._load_snapshot("https://agent", _card(), "agent-1", context, sandbox_type="local") + await _step()._load_snapshot("https://agent", _card(), "agent-1", context, sandbox_type="local", headers={}) assert context.metadata["agent_loaded_snapshots"][0]["context_id"] == ( "restored-context" @@ -203,7 +203,7 @@ async def test_a_portable_snapshot_loads_through_objects_or_not_at_all( requests = _install(monkeypatch, _Universe(store, PORTABLE[:1]), {"context_id": "wrong"}) with pytest.raises(RuntimeError, match=refusal): - await _step()._load_snapshot("https://agent", card, "agent-1", TaskStepContext(), sandbox_type="local") + await _step()._load_snapshot("https://agent", card, "agent-1", TaskStepContext(), sandbox_type="local", headers={}) assert not store.granted assert not requests diff --git a/tst/unit/task_step/test_deploy_user_sim_agent.py b/tst/unit/task_step/test_deploy_user_sim_agent.py index e0755fd3f..ce8ef2917 100644 --- a/tst/unit/task_step/test_deploy_user_sim_agent.py +++ b/tst/unit/task_step/test_deploy_user_sim_agent.py @@ -55,9 +55,10 @@ def __init__(self, monkeypatch, card: dict = TAKES_ALL): self.posts: list[tuple[str, dict]] = [] self.agent = MagicMock(metadata={}) self.agent.close = AsyncMock() - self.agent.deploy = AsyncMock(return_value=MagicMock(a2a_url=AGENT_URL, agent_card=card, sandbox_type=None)) + self.agent.deploy = AsyncMock(return_value=MagicMock(a2a_url=AGENT_URL, agent_card=card, sandbox_type=None, + control_token=None, control_headers={})) - async def post(url, fields): + async def post(url, fields, headers=None): self.posts.append((url, fields)) monkeypatch.setattr(protocol, "post_agent_config", post) @@ -350,7 +351,7 @@ async def test_a_card_that_won_t_take_the_model_fails_the_step(monkeypatch): async def test_a_failed_model_post_closes_the_agent_and_leaves_no_record(monkeypatch): deploy = _Deploy(monkeypatch) - async def refuse(url, fields): + async def refuse(url, fields, headers=None): if "model" in fields: raise RuntimeError("agent-config refused") @@ -393,7 +394,7 @@ def agent(n, texts, rig): user_texts=['{"outcome": "reply", "message": "blue!", "used": "W1"}']) await rig.arm() ctx = await _rig_context(monkeypatch, rig) - async def post(url, fields): + async def post(url, fields, headers=None): ctx_posts.append((url, fields)) monkeypatch.setattr(ao.protocol, "post_agent_config", post) diff --git a/tst/unit/task_step/test_install_agent_registers_instance.py b/tst/unit/task_step/test_install_agent_registers_instance.py index 2a4cb3901..391c90b1a 100644 --- a/tst/unit/task_step/test_install_agent_registers_instance.py +++ b/tst/unit/task_step/test_install_agent_registers_instance.py @@ -47,7 +47,7 @@ def test_installed_agent_is_registered_in_the_instance_store(): "agent_env.a2a_agent.store.get_a2a_agent_instance_store", return_value=store, ): - deployed = _step()._register_instance(agent, "https://a2a.example", _sandbox_record(), card) + deployed = _step()._register_instance(agent, "https://a2a.example", _sandbox_record(), card, control_token="t") assert deployed.instance_id == "claude-code-cli-abcd1234" (created, _ttl), = store.created @@ -57,6 +57,7 @@ def test_installed_agent_is_registered_in_the_instance_store(): assert created.sandbox_id == "sb-1" assert created.sandbox_type == "modal_vm" assert created.agent_card == card + assert created.control_token == "t" def test_instance_ttl_mirrors_the_sandbox_expiry(): diff --git a/tst/unit/task_step/test_prompt_agent.py b/tst/unit/task_step/test_prompt_agent.py index 7eb108e67..457848273 100644 --- a/tst/unit/task_step/test_prompt_agent.py +++ b/tst/unit/task_step/test_prompt_agent.py @@ -141,7 +141,7 @@ def put(key, *args, **kwargs): # unbound call: the inline branch never touches `self`, so we skip AWS-touching construction. uri = asyncio.run(PromptAgentTaskStep._fetch_trajectory( object(), "http://a", {"params": {"endpoint": "/t"}}, "SERVER-ID", "s3://b/traj/", - "CLIENT-ID", sandbox_type="local")) + "CLIENT-ID", sandbox_type="local", headers={})) assert uri == "s3://b/traj/trajectory-CLIENT-ID.json" assert puts_on_loop == [False] @@ -151,7 +151,7 @@ def test_fetch_trajectory_prefers_advertised_object_mode(monkeypatch): grants_on_loop = [] client = MagicMock() - async def post(url, *, json, timeout): + async def post(url, *, json, timeout, headers=None): sent.update(url=url, json=json, timeout=timeout) return SimpleNamespace( raise_for_status=lambda: None, @@ -216,7 +216,7 @@ def issue_write_grant(self, object_url, *, media_type, max_bytes, expires_in=Non "SERVER-ID", "s3://b/traj/", "CLIENT-ID", - sandbox_type="local", + sandbox_type="local", headers={}, ) ) diff --git a/tst/unit/task_step/test_prompt_agent_built_in_user_sim.py b/tst/unit/task_step/test_prompt_agent_built_in_user_sim.py index 3bdae6d29..5eb2490d3 100644 --- a/tst/unit/task_step/test_prompt_agent_built_in_user_sim.py +++ b/tst/unit/task_step/test_prompt_agent_built_in_user_sim.py @@ -236,7 +236,7 @@ async def test_each_user_sim_turn_records_its_trajectory_as_always_on_does(monke {"uri": A2AAgent.EXT_TRAJECTORY, "params": {}}]}} fetched = [] - async def fetch(self, url, ext, task_id, prefix, name, *, sandbox_type, card=None): + async def fetch(self, url, ext, task_id, prefix, name, *, sandbox_type, headers, card=None): fetched.append((url, task_id, prefix, sandbox_type)) return f"{prefix}{name}.json" diff --git a/tst/unit/task_step/test_prompt_agent_builtin_tools.py b/tst/unit/task_step/test_prompt_agent_builtin_tools.py index 4066f94a3..cadbfe19f 100644 --- a/tst/unit/task_step/test_prompt_agent_builtin_tools.py +++ b/tst/unit/task_step/test_prompt_agent_builtin_tools.py @@ -26,7 +26,7 @@ def posted(monkeypatch): monkeypatch.setattr(pa_mod.conversation_store, fn, lambda *a, **kw: None) configs = [] - async def post_agent_config(url, fields): + async def post_agent_config(url, fields, headers=None): configs.append(fields) async def send(url, parts, message_id, context_id, timeout): @@ -65,3 +65,19 @@ async def test_an_agent_deployed_without_a_selection_is_sent_none(posted): await PromptAgentTaskStep(id="one", version=None, prompt="one", agent_name="solver").execute(_context()) assert all("builtin_tools" not in fields for fields in posted) + + +@pytest.mark.asyncio +async def test_each_turns_config_carries_the_agents_control_token(posted, monkeypatch): + sent = [] + + async def post_agent_config(url, fields, headers=None): + sent.append(headers) + + monkeypatch.setattr(pa_mod.protocol, "post_agent_config", post_agent_config) + context = _context(builtin_tools={"disable": "*"}) + context.deployed_agents[0].control_token = "tok" + + await PromptAgentTaskStep(id="one", version=None, prompt="one", agent_name="solver").execute(context) + + assert sent == [{"AgentEnv-Control-Token": "tok"}] diff --git a/tst/unit/task_step/test_prompt_agent_conversation_tool_calls.py b/tst/unit/task_step/test_prompt_agent_conversation_tool_calls.py index 8d1f3af68..2e42a5fb5 100644 --- a/tst/unit/task_step/test_prompt_agent_conversation_tool_calls.py +++ b/tst/unit/task_step/test_prompt_agent_conversation_tool_calls.py @@ -25,7 +25,7 @@ def _wire(monkeypatch, solver_tool_calls: list): monkeypatch.setattr(pa_mod.conversation_store, fn, lambda *a, **kw: None) solver_turns = iter(solver_tool_calls) - async def post_agent_config(url, fields): + async def post_agent_config(url, fields, headers=None): return None async def send(url, parts, message_id, context_id, timeout): diff --git a/tst/unit/task_step/test_prompt_agent_triggers.py b/tst/unit/task_step/test_prompt_agent_triggers.py index 5f26930a6..0d33d5b9a 100644 --- a/tst/unit/task_step/test_prompt_agent_triggers.py +++ b/tst/unit/task_step/test_prompt_agent_triggers.py @@ -137,14 +137,14 @@ async def fake_get(self, url, timeout, params=None, headers=None): async def test_decide_request_body_and_parse(): captured = {} - async def fake_post(self, url, json, timeout): + async def fake_post(self, url, json, timeout, headers=None): captured["url"] = url captured["json"] = json return _resp(200, {"parts": [{"kind": "text", "text": "[Julia]: re-sweep"}], "done": False, "fired": ["re-sweep"]}, "POST") with patch.object(httpx.AsyncClient, "post", fake_post): out = await _step()._decide("http://sk/ext/triggers/decide", 3, "solver said X", - "conv-1", {"env-a": {"v6-rate": "fired"}}) + "conv-1", {"env-a": {"v6-rate": "fired"}}, headers={}) assert captured["url"] == "http://sk/ext/triggers/decide" assert captured["json"] == {"turn": 3, "solver_message": "solver said X", @@ -154,12 +154,12 @@ async def fake_post(self, url, json, timeout): @pytest.mark.asyncio async def test_decide_4xx_raises(): - async def fake_post(self, url, json, timeout): + async def fake_post(self, url, json, timeout, headers=None): return _resp(400, {"error": "bad turn"}, "POST") with patch.object(httpx.AsyncClient, "post", fake_post): with pytest.raises(RuntimeError, match="agent-trigger /decide failed"): - await _step()._decide("http://sk/ext/triggers/decide", 1, "", "c", {}) + await _step()._decide("http://sk/ext/triggers/decide", 1, "", "c", {}, headers={}) # ---- _persist_env_trigger_state --------------------------------------------- diff --git a/tst/unit/task_step/test_recorded_models.py b/tst/unit/task_step/test_recorded_models.py index 93f23f004..673c4cbe6 100644 --- a/tst/unit/task_step/test_recorded_models.py +++ b/tst/unit/task_step/test_recorded_models.py @@ -30,7 +30,7 @@ def posted(monkeypatch): monkeypatch.setattr(pa_mod.conversation_store, fn, lambda *a, **kw: None) configs = {} - async def post_agent_config(url, fields): + async def post_agent_config(url, fields, headers=None): configs[url] = fields async def send(url, parts, message_id, context_id, timeout): @@ -89,13 +89,13 @@ def _judge() -> RubricsVerifierTaskStep: (_card("output_format"), None), ({}, None)], ids=["takes a model", "takes no model", "takes no config"]) async def test_an_agent_judge_records_the_model_it_took(monkeypatch, card, recorded): - async def post_agent_config(url, fields): + async def post_agent_config(url, fields, headers=None): pass monkeypatch.setattr(protocol, "post_agent_config", post_agent_config) context = TaskStepContext(metadata={"task_id": "t"}) await _judge()._configure_judge_a2a(judge_a2a_url="http://judge", judge_agent_card=card, model="flag-judge", - judge_effort=None, judge_max_thinking_tokens=None, context=context) + judge_effort=None, judge_max_thinking_tokens=None, context=context, headers={}) assert context.metadata["models"] == {"judge": {"judge": recorded}} diff --git a/tst/unit/task_step/test_register_agent_triggers.py b/tst/unit/task_step/test_register_agent_triggers.py index 2e4e510f9..612ecf933 100644 --- a/tst/unit/task_step/test_register_agent_triggers.py +++ b/tst/unit/task_step/test_register_agent_triggers.py @@ -74,7 +74,7 @@ def test_bad_triggers_rejected_at_construction(): async def test_registers_and_audits_with_card_endpoint(): captured = {} - async def fake_post(self, url, json, timeout): + async def fake_post(self, url, json, timeout, headers=None): captured["url"] = url captured["body"] = json return _resp(200, url, {"ok": True, "added": ["open", "re-sweep"], "all": ["open", "re-sweep"]}) @@ -95,7 +95,7 @@ async def fake_post(self, url, json, timeout): async def test_custom_endpoint_from_card_is_honored(): captured = {} - async def fake_post(self, url, json, timeout): + async def fake_post(self, url, json, timeout, headers=None): captured["url"] = url return _resp(200, url, {"ok": True, "added": []}) @@ -137,7 +137,7 @@ async def test_env_trigger_id_not_registered_raises(): @pytest.mark.asyncio async def test_agent_4xx_raises(): - async def fake_post(self, url, json, timeout): + async def fake_post(self, url, json, timeout, headers=None): return _resp(400, url, {"ok": False, "error": "trigger 'open': bad when"}) ctx = _context() diff --git a/tst/unit/task_step/verifiers/test_rubrics_verifier_judge_batches.py b/tst/unit/task_step/verifiers/test_rubrics_verifier_judge_batches.py index 379b99409..cd72b45eb 100644 --- a/tst/unit/task_step/verifiers/test_rubrics_verifier_judge_batches.py +++ b/tst/unit/task_step/verifiers/test_rubrics_verifier_judge_batches.py @@ -262,7 +262,7 @@ async def fake_cancel(url, task_id): monkeypatch.setattr(protocol, "cancel_a2a_task", fake_cancel) call = asyncio.create_task(v._invoke_judge_a2a( eval_prompt="grade", judge_a2a_url="http://judge", judge_agent_card={}, - judge_agent=SimpleNamespace(sandbox_id="sb-1"))) + judge_agent=SimpleNamespace(sandbox_id="sb-1", control_headers={}))) await polling.wait() call.cancel() with pytest.raises(asyncio.CancelledError): diff --git a/tst/unit/task_step/verifiers/test_rubrics_verifier_judge_retry.py b/tst/unit/task_step/verifiers/test_rubrics_verifier_judge_retry.py index 2f89bea21..72ee82da8 100644 --- a/tst/unit/task_step/verifiers/test_rubrics_verifier_judge_retry.py +++ b/tst/unit/task_step/verifiers/test_rubrics_verifier_judge_retry.py @@ -122,7 +122,7 @@ async def fake_invoke(*, eval_prompt: str, judge_a2a_url: str, judge_agent_card: model="claude-sonnet-4-6", judge_a2a_url="http://judge.example/a2a", judge_agent_card={}, - judge_agent=SimpleNamespace(sandbox_id="sb-test", sandbox_type=None), + judge_agent=SimpleNamespace(sandbox_id="sb-test", sandbox_type=None, control_headers={}), judge_effort=None, judge_max_thinking_tokens=None, use_agent_judge=True, diff --git a/tst/unit/task_step/verifiers/test_rubrics_verifier_judge_timeout_retry.py b/tst/unit/task_step/verifiers/test_rubrics_verifier_judge_timeout_retry.py index 90eac5518..e7bbb2be3 100644 --- a/tst/unit/task_step/verifiers/test_rubrics_verifier_judge_timeout_retry.py +++ b/tst/unit/task_step/verifiers/test_rubrics_verifier_judge_timeout_retry.py @@ -55,7 +55,7 @@ async def fetch(*, a2a_server_task_id, **kwargs): async def _grade(verifier): return await verifier._run_judge_with_output_retries( eval_prompt="grade it", criteria=CRITERIA, context=TaskStepContext(), model="m", - judge_a2a_url="http://judge.test", judge_agent_card={}, judge_agent=SimpleNamespace(sandbox_id=None), + judge_a2a_url="http://judge.test", judge_agent_card={}, judge_agent=SimpleNamespace(sandbox_id=None, control_headers={}), judge_effort=None, judge_max_thinking_tokens=None, use_agent_judge=True) @@ -115,7 +115,7 @@ async def test_a_judge_task_that_fails_before_the_deadline_is_not_retried_whatev async def test_with_retries_the_judge_is_allowed_a_margin_past_the_poll_s_deadline(monkeypatch, retries, sent): posted: list[dict] = [] - async def post(url, payload): + async def post(url, payload, headers=None): posted.append(payload) monkeypatch.setattr(protocol, "post_agent_config", post) @@ -123,7 +123,7 @@ async def post(url, payload): "endpoint": "/ext/agent-config", "methods": {"set": {"request": {"supported": ["model", "timeout_seconds"]}}}}}]}} await _verifier(judge_timeout_retries=retries)._configure_judge_a2a( judge_a2a_url="http://judge.test", judge_agent_card=card, model="m", judge_effort=None, - judge_max_thinking_tokens=None, context=TaskStepContext()) + judge_max_thinking_tokens=None, context=TaskStepContext(), headers={}) assert posted == [{"model": "m", "timeout_seconds": sent}] @@ -143,7 +143,7 @@ def test_judge_timeout_retries_and_max_turns_round_trip_and_are_left_out_unset() async def test_judge_agent_config_extras_go_to_a_judge_that_takes_them(monkeypatch, caplog): posted: list[dict] = [] - async def post(url, payload): + async def post(url, payload, headers=None): posted.append(payload) monkeypatch.setattr(protocol, "post_agent_config", post) @@ -157,7 +157,7 @@ def judge_agent_config(self, judge_agent_card: dict) -> dict: "model", "builtin_tools", "max_turns"]}}}}}]}} verifier = Extra(id="verify", version=1, criteria=CRITERIA, prompt_id="p", verifier_id="vt", judge_max_turns=300) await verifier._configure_judge_a2a(judge_a2a_url="http://judge.test", judge_agent_card=card, model="m", - judge_effort=None, judge_max_thinking_tokens=None, context=TaskStepContext()) + judge_effort=None, judge_max_thinking_tokens=None, context=TaskStepContext(), headers={}) assert posted == [{"model": "m", "max_turns": 300, "builtin_tools": {"disable": ["Agent"]}}] assert "doesn't take ['effort_level']" in caplog.text @@ -165,5 +165,5 @@ def judge_agent_config(self, judge_agent_card: dict) -> dict: posted.clear() plain = RubricsVerifierTaskStep(id="verify", version=1, criteria=CRITERIA, prompt_id="p", verifier_id="vt") await plain._configure_judge_a2a(judge_a2a_url="http://judge.test", judge_agent_card=card, model="m", - judge_effort=None, judge_max_thinking_tokens=None, context=TaskStepContext()) + judge_effort=None, judge_max_thinking_tokens=None, context=TaskStepContext(), headers={}) assert posted == [{"model": "m"}] diff --git a/tst/unit/task_step/verifiers/test_rubrics_verifier_judge_trajectory.py b/tst/unit/task_step/verifiers/test_rubrics_verifier_judge_trajectory.py index 73f6e81ac..90ba61bfb 100644 --- a/tst/unit/task_step/verifiers/test_rubrics_verifier_judge_trajectory.py +++ b/tst/unit/task_step/verifiers/test_rubrics_verifier_judge_trajectory.py @@ -1,6 +1,7 @@ """Unit tests for RubricsVerifierTaskStep._fetch_judge_trajectory.""" from datetime import UTC, datetime, timedelta +from types import SimpleNamespace import httpx import pytest @@ -111,7 +112,7 @@ async def boom(self, method, url, **kwargs): uri = await verifier._fetch_judge_trajectory( judge_a2a_url="http://judge.example", judge_agent_card={}, a2a_server_task_id="t1", - sandbox_type="local", + sandbox_type="local", headers={}, ) assert uri is None @@ -128,7 +129,7 @@ async def boom(self, method, url, **kwargs): card = {"capabilities": {"extensions": [{"uri": A2AAgent.EXT_TRAJECTORY, "params": {}}]}} uri = await verifier._fetch_judge_trajectory( judge_a2a_url="http://judge.example", judge_agent_card=card, a2a_server_task_id="t1", - sandbox_type="local", + sandbox_type="local", headers={}, ) assert uri is None @@ -160,7 +161,7 @@ def fake_upload(trajectory, prefix, *, name=None): judge_a2a_url="http://judge.example", judge_agent_card=_card_with_trajectory_ext(), a2a_server_task_id="t1", - sandbox_type="local", + sandbox_type="local", headers={}, ) assert uri == "s3://bucket/judge_trajectories/verifier_id=verifier-test/trajectory-t1.json" @@ -195,7 +196,7 @@ def list_at(self, prefix): judge_a2a_url="http://judge.example", judge_agent_card=_card_with_trajectory_ext(), a2a_server_task_id="t1", - sandbox_type="local", + sandbox_type="local", headers={}, ) assert uri is None @@ -226,7 +227,7 @@ async def fake_request(self, method, url, **kwargs): judge_a2a_url="http://judge.example", judge_agent_card=_card_with_object_trajectory_ext(), a2a_server_task_id="t1", - sandbox_type="local", + sandbox_type="local", headers={}, ) assert store.write_grants == [(uri, "application/json", DEFAULT_TRAJECTORY_MAX_BYTES)] @@ -247,7 +248,7 @@ async def fake_request(self, method, url, **kwargs): judge_a2a_url="http://judge.example", judge_agent_card=_card_with_object_trajectory_ext(), a2a_server_task_id="t1", - sandbox_type="local", + sandbox_type="local", headers={}, ) assert uri.startswith("s3://bucket/fx/judge_trajectories/verifier_id=verifier-test/trajectory-") @@ -275,7 +276,7 @@ async def fake_request(self, method, url, **kwargs): uris = [ await verifier._fetch_judge_trajectory( judge_a2a_url="http://judge.example", judge_agent_card=card, a2a_server_task_id="t1", - sandbox_type="local", + sandbox_type="local", headers={}, ) for _ in range(2) ] @@ -304,7 +305,7 @@ async def fake_request(self, method, url, **kwargs): judge_a2a_url="http://judge.example", judge_agent_card=_card_with_object_trajectory_ext(), a2a_server_task_id="t1", - sandbox_type="local", + sandbox_type="local", headers={}, ) assert sent == [{"task_id": "t1"}] @@ -328,7 +329,7 @@ async def boom(self, method, url, **kwargs): judge_a2a_url="http://judge.example", judge_agent_card=_card_with_object_trajectory_ext(), a2a_server_task_id="t1", - sandbox_type="local", + sandbox_type="local", headers={}, ) assert uri is None @@ -351,7 +352,7 @@ async def boom(self, method, url, **kwargs): judge_a2a_url="http://judge.example", judge_agent_card=_card_with_trajectory_ext(), a2a_server_task_id="t1", - sandbox_type="local", + sandbox_type="local", headers={}, ) assert uri is None assert attempts == RubricsVerifierTaskStep.DEFAULT_MAX_RETRIES @@ -382,7 +383,7 @@ async def flaky(self, method, url, **kwargs): judge_a2a_url="http://judge.example", judge_agent_card=_card_with_trajectory_ext(), a2a_server_task_id="t1", - sandbox_type="local", + sandbox_type="local", headers={}, ) assert uri == "s3://bucket/trajectory.json" assert attempts == 2 @@ -404,11 +405,12 @@ async def fake_poll(*args, **kwargs): monkeypatch.setattr(protocol, "poll_a2a_task", fake_poll) async def fake_fetch( - self, *, judge_a2a_url, judge_agent_card, a2a_server_task_id, sandbox_type + self, *, judge_a2a_url, judge_agent_card, a2a_server_task_id, sandbox_type, headers ): assert judge_a2a_url == "http://judge.example" assert a2a_server_task_id == "task-1" assert sandbox_type is None + assert headers == {"AgentEnv-Control-Token": "tok"} return "s3://bucket/judge_trajectories/verifier_id=verifier-test/trajectory-task-1.json" monkeypatch.setattr(RubricsVerifierTaskStep, "_fetch_judge_trajectory", fake_fetch) @@ -417,7 +419,7 @@ async def fake_fetch( eval_prompt="evaluate", judge_a2a_url="http://judge.example", judge_agent_card=_card_with_trajectory_ext(), - judge_agent=None, + judge_agent=SimpleNamespace(sandbox_id=None, sandbox_type=None, control_headers={"AgentEnv-Control-Token": "tok"}), ) assert result == {