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 d579968d7..28753073f 100644 --- a/src/agent_env/task_step/task_steps/deploy_env.py +++ b/src/agent_env/task_step/task_steps/deploy_env.py @@ -77,6 +77,16 @@ def run_state(self, user_overrides: Mapping[str, Any]) -> tuple[str | None, str return (user_overrides.get("env_state_type") or self.env_state_type, user_overrides.get("env_state_instance_id") or self.env_state_instance_id) + def run_env_version(self, context: TaskStepContext) -> Optional[int]: + """The env version a run deploys: this step's ``env_version`` step override, over the stored one.""" + overrides = self.step_param_overrides(context) + if "env_version" not in overrides: + return self.env_version + version = overrides["env_version"] + if not isinstance(version, int) or isinstance(version, bool): + raise ValueError(f"deploy_env '{self.id}': step override env_version must be an integer, got {version!r}") + return version + def to_dict(self) -> dict: base = super().to_dict() base["env_id"] = self.env_id @@ -157,7 +167,8 @@ async def execute(self, context: TaskStepContext) -> TaskStepContext: if existing is not None: raise RuntimeError(f"Env '{self.env_id}' is already deployed") - env = Env.get(self.env_id, self.env_version) + env_version = self.run_env_version(context) + env = Env.get(self.env_id, env_version) user_overrides = context.metadata.get("user_overrides", {}) resolved_sandbox_type = user_overrides.get("env_sandbox") or self.sandbox_type resolved_env_state_type, resolved_env_state_instance_id = self.run_state(user_overrides) @@ -165,7 +176,7 @@ async def execute(self, context: TaskStepContext) -> TaskStepContext: resolved_ttl = _ttl_override if _ttl_override is not None else self.ttl_seconds attribution = deploy_attribution(self, context) logger.info( - f"Deploying env '{self.env_id}' (ttl={resolved_ttl}s, " + f"Deploying env '{self.env_id}' (version={env_version}, ttl={resolved_ttl}s, " f"disk_size_gb={self.disk_size_gb}, gateway_mode={self.gateway_mode}, " f"cpu={self.cpu}, memory_mb={self.memory_mb}, " f"sandbox_type={resolved_sandbox_type}, env_state_type={resolved_env_state_type}, " diff --git a/src/agent_env/task_step/task_steps/modify_env_tool_access.py b/src/agent_env/task_step/task_steps/modify_env_tool_access.py index 589da671a..cc468dbc9 100644 --- a/src/agent_env/task_step/task_steps/modify_env_tool_access.py +++ b/src/agent_env/task_step/task_steps/modify_env_tool_access.py @@ -34,7 +34,7 @@ def __init__( raise ValueError(f"action must be {TOOL_DISABLE_ACTION!r} or {TOOL_ENABLE_ACTION!r}, got {action!r}") if not isinstance(role, str) or not role: raise ValueError("role must be a non-empty string") - if not isinstance(tools, list) or not all(isinstance(t, str) for t in tools): + if not _is_tool_list(tools): raise ValueError("tools must be a list of strings") self.env_id = env_id self.action = action @@ -59,22 +59,36 @@ def from_dict(cls, data: dict) -> ModifyEnvToolAccessStep: tools=data["tools"], ) + def run_tools(self, context: TaskStepContext) -> list[str]: + """The tools a run changes: this step's ``tools`` step override, which replaces the stored list.""" + overrides = self.step_param_overrides(context) + if "tools" not in overrides: + return self.tools + if not _is_tool_list(tools := overrides["tools"]): + raise ValueError(f"modify_env_tool_access '{self.id}': step override tools must be a list of strings, got {tools!r}") + return tools + async def execute(self, context: TaskStepContext) -> TaskStepContext: deployed = next((d for d in context.deployed_envs if d.env_id == self.env_id), None) if deployed is None: raise RuntimeError(f"Env '{self.env_id}' not found in context.deployed_envs") - body = await deployed.invoke(_TOOL_ACCESS_URIS[self.action], self.action, {"role": self.role, "tools": self.tools}) - logger.info(f"{self.action} role={self.role!r} tools={self.tools} on env={self.env_id}: {body}") + tools = self.run_tools(context) + body = await deployed.invoke(_TOOL_ACCESS_URIS[self.action], self.action, {"role": self.role, "tools": tools}) + logger.info(f"{self.action} role={self.role!r} tools={tools} on env={self.env_id}: {body}") context.metadata.setdefault("tool_access_changes", []).append({ "step_id": self.id, "env_id": self.env_id, "action": self.action, "role": self.role, - "tools_requested": self.tools, + "tools_requested": tools, "role_state_after": {"disabled": body.get("disabled", []), "allowed": body.get("allowed", [])}, }) return context +def _is_tool_list(tools) -> bool: + return isinstance(tools, list) and all(isinstance(t, str) for t in tools) + + # The gateway extension each action is advertised under on the env card. _TOOL_ACCESS_URIS = {TOOL_DISABLE_ACTION: EXT_DISABLE_TOOL_URI, TOOL_ENABLE_ACTION: EXT_ENABLE_TOOL_URI} diff --git a/tst/unit/task_step/deploy_env_test.py b/tst/unit/task_step/deploy_env_test.py index f3b916f22..41da53274 100644 --- a/tst/unit/task_step/deploy_env_test.py +++ b/tst/unit/task_step/deploy_env_test.py @@ -555,3 +555,34 @@ async def test_execute_refuses_child_envs_for_an_env_whose_deploy_takes_none(): with patch("agent_env.env.env.Env") as Env, pytest.raises(ValueError, match="have no child envs"): Env.get.return_value = env await step.execute(TaskStepContext()) + + +def _step_overrides(step_id: str, params: dict) -> dict: + return {"user_overrides": {"step_params": {step_id: params}}} + + +@pytest.mark.asyncio +@pytest.mark.parametrize("metadata, expected", [ + ({}, 2), + (_step_overrides("t-1.deploy_env", {"env_version": 5}), 5), + (_step_overrides("another-step", {"env_version": 5}), 2), +]) +async def test_execute_deploys_the_env_version_a_step_override_names(metadata, expected): + step = DeployEnvTaskStep(id="t-1.deploy_env", version=None, env_id="art-1", env_version=2) + + with patch("agent_env.env.env.Env") as Env: + Env.get.return_value = _fake_env(_deployed_env(None)) + await step.execute(TaskStepContext(metadata=metadata)) + + Env.get.assert_called_once_with("art-1", expected) + assert step.env_version == 2 + + +@pytest.mark.asyncio +@pytest.mark.parametrize("bad", ["5", 5.0, True, None]) +async def test_execute_rejects_an_env_version_override_that_is_not_an_integer(bad): + step = DeployEnvTaskStep(id="t-1.deploy_env", version=None, env_id="art-1", env_version=2) + + with patch("agent_env.env.env.Env") as Env, pytest.raises(ValueError, match="env_version must be an integer"): + await step.execute(TaskStepContext(metadata=_step_overrides("t-1.deploy_env", {"env_version": bad}))) + Env.get.assert_not_called() diff --git a/tst/unit/task_step/test_modify_env_tool_access.py b/tst/unit/task_step/test_modify_env_tool_access.py index 450ef5a66..8462a5216 100644 --- a/tst/unit/task_step/test_modify_env_tool_access.py +++ b/tst/unit/task_step/test_modify_env_tool_access.py @@ -51,6 +51,37 @@ async def test_a_gateway_error_raises(monkeypatch): await _step("disable").execute(TaskStepContext(deployed_envs=[_record()], metadata={})) +@pytest.mark.asyncio +@pytest.mark.parametrize("step_params, expected", [ + ({}, ["slack_send"]), + ({"tools-1": {"tools": ["mail_send", "mail_delete"]}}, ["mail_send", "mail_delete"]), + ({"tools-1": {"tools": []}}, []), + ({"other-step": {"tools": ["mail_send"]}}, ["slack_send"]), +]) +async def test_a_tools_step_override_replaces_the_stored_tools(monkeypatch, step_params, expected): + sent = _mock_gateway(monkeypatch, {"ok": True, "disabled": expected, "allowed": []}) + ctx = TaskStepContext(deployed_envs=[_record()], metadata={"user_overrides": {"step_params": step_params}}) + step = _step("disable") + + out = await step.execute(ctx) + + [request] = sent + assert json.loads(request.content) == {"role": "default", "tools": expected} + assert out.metadata["tool_access_changes"][0]["tools_requested"] == expected + assert step.tools == ["slack_send"] + + +@pytest.mark.asyncio +@pytest.mark.parametrize("bad", ["mail_send", ["mail_send", 3], None, {"mail_send": True}]) +async def test_a_tools_override_that_is_not_a_list_of_strings_raises_before_any_request(monkeypatch, bad): + sent = _mock_gateway(monkeypatch, {}) + ctx = TaskStepContext(deployed_envs=[_record()], metadata={"user_overrides": {"step_params": {"tools-1": {"tools": bad}}}}) + + with pytest.raises(ValueError, match="step override tools must be a list of strings"): + await _step("disable").execute(ctx) + assert sent == [] + + def _step(action: str) -> ModifyEnvToolAccessStep: return ModifyEnvToolAccessStep(id="tools-1", version=None, env_id="env-x", action=action, role="default", tools=["slack_send"])