agentenv-framework 0.9.1254__py3-none-any.whl

agent_env/task_step/task_steps/sync_env_clock.py

@@ -0,0 +1,132 @@
+"""Arm a deployed env gateway's virtual clock, then sync its backing servers to it.
+
+Arms the clock (set_time) and reads the gateway's server-reachable env_get_time_url (state), both as the
+stored env card declares clock/v1, then invokes sync_time on each backing server whose child env card
+advertises it. Non-advertisers are skipped when tolerate_missing_sync_time (default True). Place right
+before prompt_agent so the virtual timeline starts at agent-start.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import ClassVar, Optional
+
+import httpx
+from agentenv_protocol import client as protocol_v1
+
+from agent_env.env.gateway.constants import EXT_CLOCK_URI
+from agent_env.task_step.context import TaskStepContext
+from agent_env.entity_refs import EntityRef
+from agent_env.task_step.task_step import TaskStep, TaskStepDependency
+
+logger = logging.getLogger(__name__)
+
+
+class SyncEnvClockTaskStep(TaskStep):
+    type: ClassVar[str] = "sync_env_clock"
+    entity_refs = (EntityRef.env("env_id"),)
+
+    def __init__(
+        self,
+        id: str,
+        version: Optional[int],
+        env_id: str,
+        virtual_time: str,
+        virtual_seconds_per_real_second: float = 1.0,
+        tolerate_missing_sync_time: bool = True,
+        depends_on: Optional[list[TaskStepDependency]] = None,
+        fail_task_on_error: bool = True,
+        timeout_seconds: int = 30,
+    ):
+        """virtual_seconds_per_real_second = clock speed (1.0 real time, 0 frozen, 86400 cap =
+        1 real s -> 1 virtual day). For ~V virtual seconds over an ~R-real-second task, pass V/R."""
+        super().__init__(id, version, depends_on=depends_on, fail_task_on_error=fail_task_on_error)
+        if not isinstance(virtual_time, str):
+            raise ValueError("virtual_time must be an RFC3339 string")
+        self.env_id = env_id
+        self.virtual_time = virtual_time
+        self.virtual_seconds_per_real_second = virtual_seconds_per_real_second
+        self.tolerate_missing_sync_time = tolerate_missing_sync_time
+        self.timeout_seconds = timeout_seconds
+
+    def to_dict(self) -> dict:
+        base = super().to_dict()
+        base["env_id"] = self.env_id
+        base["virtual_time"] = self.virtual_time
+        base["virtual_seconds_per_real_second"] = self.virtual_seconds_per_real_second
+        base["tolerate_missing_sync_time"] = self.tolerate_missing_sync_time
+        base["timeout_seconds"] = self.timeout_seconds
+        return base
+
+    @classmethod
+    def from_dict(cls, data: dict) -> SyncEnvClockTaskStep:
+        return cls(
+            **cls._base_from_dict(data),
+            env_id=data["env_id"],
+            virtual_time=data["virtual_time"],
+            virtual_seconds_per_real_second=data.get("virtual_seconds_per_real_second", 1.0),
+            tolerate_missing_sync_time=data.get("tolerate_missing_sync_time", True),
+            timeout_seconds=data.get("timeout_seconds", 30),
+        )
+
+    def _service_names(self, deployed) -> list[str]:
+        """Backing MCP server names for the env (mirrors apply_server_config's enumeration)."""
+        from agent_env.env.env import Env
+        env = Env.get(deployed.env_id, deployed.env_version)
+        names = [e.environment_name for e in (getattr(env, "mcp_server_envs", None) or [])]
+        if not names and getattr(env, "environment_name", None):
+            names = [env.environment_name]
+        return names
+
+    async def execute(self, context: TaskStepContext) -> TaskStepContext:
+        from agent_env.env.env import gateway_url_of
+
+        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")
+        try:
+            await deployed.invoke(EXT_CLOCK_URI, "set_time",
+                                  {"virtual_time": self.virtual_time, "virtual_seconds_per_real_second": self.virtual_seconds_per_real_second},
+                                  timeout=self.timeout_seconds)
+        except httpx.HTTPStatusError as e:
+            raise RuntimeError(f"clock arm failed (HTTP {e.response.status_code}): {e.response.text}") from e
+        state = await deployed.invoke(EXT_CLOCK_URI, "state", timeout=self.timeout_seconds)
+        env_get_time_url = state.get("env_get_time_url")
+
+        synced, skipped = [], []
+        for service in self._service_names(deployed):
+            outcome = await self._sync_one(deployed, gateway_url_of(deployed), service, env_get_time_url)
+            (synced if outcome.get("synced") else skipped).append({"service": service, "environment": service, **outcome})
+
+        context.metadata.setdefault("clock_configurations", []).append({
+            "step_id": self.id, "env_id": self.env_id,
+            "virtual_time": self.virtual_time, "virtual_seconds_per_real_second": self.virtual_seconds_per_real_second,
+            "env_get_time_url": env_get_time_url, "synced": synced, "skipped": skipped,
+        })
+        logger.info(f"sync_env_clock env={self.env_id}: armed rate={self.virtual_seconds_per_real_second}; "
+                    f"synced={[s['service'] for s in synced]} skipped={[s['service'] for s in skipped]}")
+        if not synced:
+            logger.warning(f"sync_env_clock env={self.env_id}: clock armed but NO server synced "
+                           f"({[(s['service'], s.get('reason')) for s in skipped]}) — every tool still answers wall time")
+        return context
+
+    async def _sync_one(self, deployed, gateway_url: str, service: str, env_get_time_url: Optional[str]) -> dict:
+        """Invoke sync_time on one server if its card advertises clock/v1; skip (or raise) per the flag."""
+        from agent_env.env import legacy_protocol
+
+        base_url, card = await legacy_protocol.child_env_card(deployed, gateway_url, service, timeout=self.timeout_seconds)
+        if card is None:
+            if self.tolerate_missing_sync_time:
+                return {"synced": False, "reason": "no_env_card"}
+            raise RuntimeError(f"{service} has no env card: it serves none, its card isn't named {service!r}, or the deploy couldn't read it")
+        if protocol_v1.find_extension(card, EXT_CLOCK_URI) is None:
+            if self.tolerate_missing_sync_time:
+                logger.info(f"sync_env_clock: {service} does not advertise {EXT_CLOCK_URI}; skipping")
+                return {"synced": False, "reason": "not_advertised"}
+            raise RuntimeError(f"{service} does not advertise {EXT_CLOCK_URI}")
+        if not env_get_time_url:
+            raise RuntimeError(f"gateway did not expose env_get_time_url; cannot sync {service}")
+        result = await protocol_v1.invoke_extension(base_url, card, EXT_CLOCK_URI,
+                                                    params={"env_get_time_url": env_get_time_url},
+                                                    timeout=self.timeout_seconds)
+        return {"synced": True, "result": result}

agent_env/task_step/task_steps/teardown_sandboxes.py

@@ -0,0 +1,170 @@
+"""Terminate the sandboxes behind named agents, envs and bare sandboxes, mid-run.
+
+A long pipeline keeps every sandbox it deployed until the run ends or its TTL expires. Place this
+step after the last step that uses a target (via ``depends_on``) to stop paying for it early.
+Strictly best-effort: a sandbox that is already gone or fails to terminate is logged and the run
+continues. The step never raises on a terminate, so a retry never re-runs it over partly torn-down
+state, and ``fail_task_on_error`` must stay false. The ids it terminated are appended to ``metadata["torn_down_sandbox_ids"]``; the
+``deployed_*`` records stay, since context list fields persist additions only.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+from typing import Optional
+
+from agent_env.entity_refs import EntityRef
+from agent_env.env.env import DeployedSandboxEnv
+from agent_env.providers.sandbox_providers.sandbox_provider import (
+    SandboxProvider,
+    build_sandbox_provider,
+    get_agent_sandbox_provider,
+    get_env_sandbox_provider,
+    get_sandbox_provider,
+)
+from agent_env.task_step.context import TaskStepContext
+from agent_env.task_step.task_step import TaskStep, TaskStepDependency
+
+logger = logging.getLogger(__name__)
+
+TORN_DOWN_KEY = "torn_down_sandbox_ids"
+
+
+class TeardownSandboxesTaskStep(TaskStep):
+    """Terminate every sandbox behind the named deployed agents, envs and bare sandboxes."""
+
+    type = "teardown_sandboxes"
+    entity_refs = (EntityRef.env("env_ids[]"),)
+
+    def __init__(
+        self,
+        id: str,
+        version: Optional[int],
+        agent_names: Optional[list[str]] = None,
+        env_ids: Optional[list[str]] = None,
+        sandbox_names: Optional[list[str]] = None,
+        depends_on: Optional[list[TaskStepDependency]] = None,
+        fail_task_on_error: bool = False,
+    ):
+        if fail_task_on_error:
+            raise ValueError(
+                "teardown_sandboxes is best-effort (a failed terminate is logged, never raised); "
+                "fail_task_on_error must be false"
+            )
+        super().__init__(id, version, depends_on=depends_on, fail_task_on_error=fail_task_on_error)
+        self.agent_names = list(agent_names or [])
+        self.env_ids = list(env_ids or [])
+        self.sandbox_names = list(sandbox_names or [])
+        if not (self.agent_names or self.env_ids or self.sandbox_names):
+            raise ValueError("teardown_sandboxes needs at least one of agent_names, env_ids, sandbox_names")
+
+    def to_dict(self) -> dict:
+        base = super().to_dict()
+        base["agent_names"] = self.agent_names
+        base["env_ids"] = self.env_ids
+        base["sandbox_names"] = self.sandbox_names
+        return base
+
+    @classmethod
+    def from_dict(cls, data: dict) -> TeardownSandboxesTaskStep:
+        base = cls._base_from_dict(data)
+        # Stay best-effort when unset: _base_from_dict would otherwise default it to True.
+        base["fail_task_on_error"] = data.get("fail_task_on_error", False)
+        return cls(
+            **base,
+            agent_names=data.get("agent_names"),
+            env_ids=data.get("env_ids"),
+            sandbox_names=data.get("sandbox_names"),
+        )
+
+    async def execute(self, context: TaskStepContext) -> TaskStepContext:
+        targets, missing = self._resolve(context)
+        if missing:
+            logger.warning(f"teardown_sandboxes: not deployed in this run, skipping: {', '.join(missing)}")
+        already = set(context.metadata.get(TORN_DOWN_KEY) or [])
+        pending = {sid: (stype, default) for sid, (stype, default) in targets.items() if sid not in already}
+        results = await asyncio.gather(
+            *(_terminate(sid, stype, default) for sid, (stype, default) in pending.items()),
+            return_exceptions=True,
+        )
+        terminated, failed = [], []
+        for sandbox_id, result in zip(pending, results):
+            if isinstance(result, BaseException):
+                failed.append(sandbox_id)
+                logger.warning(f"teardown_sandboxes: terminate {sandbox_id} failed: {result!r}"[:300])
+            else:
+                terminated.append(sandbox_id)
+        if terminated:
+            context.metadata[TORN_DOWN_KEY] = [*context.metadata.get(TORN_DOWN_KEY, []), *terminated]
+        logger.info(
+            f"teardown_sandboxes: terminated={len(terminated)} failed={len(failed)} "
+            f"already_torn_down={len(targets) - len(pending)} missing={len(missing)}"
+        )
+        return context
+
+    def _resolve(
+        self, context: TaskStepContext
+    ) -> tuple[dict[str, tuple[Optional[str], str]], list[str]]:
+        """``{sandbox_id: (sandbox_type, default_slot)}`` for every target, plus unmatched names."""
+        targets: dict[str, tuple[Optional[str], str]] = {}
+        missing: list[str] = []
+        for name in self.agent_names:
+            agents = [a for a in context.deployed_agents if a.agent_name == name]
+            if not agents:
+                missing.append(f"agent {name!r}")
+            for agent in agents:
+                if agent.sandbox_id:
+                    targets[agent.sandbox_id] = (agent.sandbox_type, "agent")
+        for name in self.sandbox_names:
+            sandboxes = [s for s in context.deployed_sandboxes if s.sandbox_name == name]
+            if not sandboxes:
+                missing.append(f"sandbox {name!r}")
+            for sandbox in sandboxes:
+                targets[sandbox.sandbox_id] = (sandbox.sandbox_type, "sandbox")
+        for env_id in self.env_ids:
+            envs = [e for e in context.deployed_envs if e.env_id == env_id]
+            if not envs:
+                missing.append(f"env {env_id!r}")
+            for env in envs:
+                targets.update({sid: (stype, "env") for sid, stype in _env_sandbox_ids(env)})
+        return targets, missing
+
+
+def _env_sandbox_ids(env) -> list[tuple[str, Optional[str]]]:
+    """Every (sandbox_id, sandbox_type) of a deployed env: its primary sandbox plus ``sandbox_ids``.
+
+    ``sandbox_ids`` values are an id or a ``{service: id}`` dict and inherit the env's type, unless
+    the key itself names a registered backend (a sandbox on another backend than the gateway's).
+    """
+    if not isinstance(env, DeployedSandboxEnv):  # an env outside our sandboxes owns its own lifetime
+        return []
+    ids = [(env.sandbox_id, env.sandbox_type)] if env.sandbox_id else []
+    for key, value in (env.sandbox_ids or {}).items():
+        entry_type = key if _is_backend(key) else env.sandbox_type
+        values = [value] if isinstance(value, str) else [v for v in value.values() if isinstance(v, str)]
+        ids.extend((v, entry_type) for v in values)
+    return ids
+
+
+def _is_backend(name: str) -> bool:
+    try:
+        build_sandbox_provider(name)
+    except Exception:
+        return False
+    return True
+
+
+_DEFAULT_PROVIDERS = {
+    "agent": get_agent_sandbox_provider,
+    "env": get_env_sandbox_provider,
+    "sandbox": get_sandbox_provider,
+}
+
+
+async def _terminate(sandbox_id: str, sandbox_type: Optional[str], default_slot: str) -> None:
+    provider: SandboxProvider = (
+        build_sandbox_provider(sandbox_type) if sandbox_type else _DEFAULT_PROVIDERS[default_slot]()
+    )
+    sandbox = await provider.get_sandbox(sandbox_id)
+    await sandbox.terminate()

agent_env/task_step/task_steps/verifiers/__init__.py

@@ -0,0 +1,23 @@
+"""Verifier task steps: the steps that score a run and record a row under
+``context.metadata["verifications"]``, plus the helpers only they use (score
+aggregation, judge output formats, trajectory compaction and frame selection for
+the LLM judge)."""
+
+from agent_env.task_step.task_steps.verifiers.scoring import ScoreAggregator, aggregate_score
+from agent_env.task_step.task_steps.verifiers.env_outcome_verifier import EnvOutcomeVerifierTaskStep
+from agent_env.task_step.task_steps.verifiers.rubrics_verifier import RubricsVerifierTaskStep
+from agent_env.task_step.task_steps.verifiers.agent_prompt_response_verifier import AgentPromptResponseVerifierTaskStep
+from agent_env.task_step.task_steps.verifiers.run_container_unit_tests_verifier import RunContainerUnitTestsVerifierTaskStep
+from agent_env.task_step.task_steps.verifiers.verify_sandbox import VerifySandboxTaskStep
+from agent_env.task_step.task_steps.verifiers.aggregate_verifiers import AggregateVerifiersTaskStep
+
+__all__ = [
+    "AgentPromptResponseVerifierTaskStep",
+    "AggregateVerifiersTaskStep",
+    "EnvOutcomeVerifierTaskStep",
+    "RubricsVerifierTaskStep",
+    "RunContainerUnitTestsVerifierTaskStep",
+    "ScoreAggregator",
+    "VerifySandboxTaskStep",
+    "aggregate_score",
+]

agent_env/task_step/task_steps/verifiers/agent_prompt_response_verifier.py

@@ -0,0 +1,166 @@
+"""Verify response-side rubric criteria against an agent's prompt response text.
+
+Deterministic checks that operate on the agent's final text response — no
+sandbox connection, no LLM judge:
+  - response_contains          — every needle in `needles` appears in the response
+  - response_regex_present     — `pattern` (regex) matches the response (re.search)
+
+Strict: unknown criterion types and criteria missing their required field
+(empty `needles` for response_contains, empty `pattern` for
+response_regex_present) raise ValueError. A verifier that can't actually
+verify anything is a misconfiguration, not a runtime decision.
+
+Result rows merge `{**criterion, **outcome}` and aggregated score is written
+to `context.metadata["verifications"][verifier_id]`, matching the shape used
+by `VerifySandboxTaskStep` and `RubricsVerifierTaskStep`.
+"""
+from __future__ import annotations
+
+import logging
+import re
+import uuid
+from typing import ClassVar, Optional
+
+from agent_env.task_step.context import TaskStepContext
+from agent_env.task_step.task_step import TaskStep, TaskStepDependency
+from agent_env.task_step.task_steps.verifiers.scoring import ScoreAggregator, aggregate_score
+
+logger = logging.getLogger(__name__)
+
+_HANDLED_TYPES = {
+    "response_contains",
+    "response_regex_present",
+}
+
+
+class AgentPromptResponseVerifierTaskStep(TaskStep):
+    type: ClassVar[str] = "agent_prompt_response_verifier"
+    entity_refs = ()
+
+    def __init__(
+        self,
+        id: str,
+        version: Optional[int],
+        prompt_id: str,
+        criteria: Optional[list[dict]] = None,
+        score_aggregator: Optional[ScoreAggregator] = None,
+        verifier_id: Optional[str] = None,
+        depends_on: Optional[list[TaskStepDependency]] = None,
+        fail_task_on_error: bool = True,
+    ):
+        super().__init__(id, version, depends_on=depends_on, fail_task_on_error=fail_task_on_error)
+        self.prompt_id = prompt_id
+        self.criteria = list(criteria or [])
+        if isinstance(score_aggregator, str):
+            score_aggregator = ScoreAggregator(score_aggregator)
+        self.score_aggregator = score_aggregator or ScoreAggregator.ALL_PASS
+        self.verifier_id = verifier_id or uuid.uuid4().hex
+
+    def to_dict(self) -> dict:
+        base = super().to_dict()
+        base["prompt_id"] = self.prompt_id
+        base["criteria"] = self.criteria
+        base["score_aggregator"] = self.score_aggregator.value
+        base["verifier_id"] = self.verifier_id
+        return base
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "AgentPromptResponseVerifierTaskStep":
+        raw_agg = data.get("score_aggregator")
+        return cls(
+            **cls._base_from_dict(data),
+            prompt_id=data["prompt_id"],
+            criteria=data.get("criteria"),
+            score_aggregator=ScoreAggregator(raw_agg) if raw_agg else None,
+            verifier_id=data.get("verifier_id"),
+        )
+
+    async def execute(self, context: TaskStepContext) -> TaskStepContext:
+        prompt_response = next(
+            (pr for pr in context.prompt_responses if pr.prompt_id == self.prompt_id),
+            None,
+        )
+        if prompt_response is None:
+            raise RuntimeError(f"PromptResponse with prompt_id='{self.prompt_id}' not found in context")
+
+        if prompt_response.error_type:
+            logger.warning(
+                f"Skipping verification '{self.verifier_id}': prompt had error_type={prompt_response.error_type}"
+            )
+            context.metadata.setdefault("verifications", {})[self.verifier_id] = {
+                "results": [{
+                    "id": "prompt_error",
+                    "score": 0,
+                    "result": False,
+                    "message": f"Skipped: prompt had error_type={prompt_response.error_type}",
+                }],
+                "score": 0,
+            }
+            return context
+
+        response = prompt_response.response or ""
+
+        results: list[dict] = []
+        for idx, criterion in enumerate(self.criteria):
+            rtype = criterion.get("type")
+            if rtype not in _HANDLED_TYPES:
+                raise ValueError(
+                    f"criterion #{idx} has unknown type {rtype!r}; "
+                    f"handled types: {sorted(_HANDLED_TYPES)}"
+                )
+            outcome = self._eval_criterion(idx, response, criterion)
+            results.append({
+                **criterion,
+                "criterion_index": idx,
+                "score": float(outcome["score"]),
+                "result": bool(outcome["passed"]),
+                "justification": outcome["justification"],
+            })
+
+        score = aggregate_score(results, self.score_aggregator)
+
+        context.metadata.setdefault("verifications", {})[self.verifier_id] = {
+            "results": results,
+            "score": score,
+        }
+        logger.info(
+            f"Verification '{self.verifier_id}': "
+            f"{len(results)} criteria evaluated, score={score}"
+        )
+        return context
+
+    def _eval_criterion(self, idx: int, response: str, criterion: dict) -> dict:
+        rtype = criterion["type"]
+        if rtype == "response_contains":
+            needles = criterion.get("needles") or []
+            if not needles:
+                raise ValueError(
+                    f"criterion #{idx} (response_contains) requires non-empty `needles`"
+                )
+            missing = [n for n in needles if n not in response]
+            passed = not missing
+            return {
+                "score": 1.0 if passed else 0.0,
+                "passed": passed,
+                "justification": "all needles present" if passed else f"missing: {missing}",
+            }
+        if rtype == "response_regex_present":
+            pattern = criterion.get("pattern")
+            if not pattern:
+                raise ValueError(
+                    f"criterion #{idx} (response_regex_present) requires non-empty `pattern`"
+                )
+            flags_raw = criterion.get("flags")
+            if flags_raw is None:
+                flags = re.DOTALL
+            else:
+                flags = 0
+                for name in flags_raw:
+                    flags |= getattr(re, name)
+            passed = bool(re.search(pattern, response, flags))
+            return {
+                "score": 1.0 if passed else 0.0,
+                "passed": passed,
+                "justification": "pattern matched" if passed else f"no match for pattern {pattern!r}",
+            }
+        raise RuntimeError(f"unhandled criterion type {rtype}")

agent_env/task_step/task_steps/verifiers/aggregate_verifiers.py

@@ -0,0 +1,90 @@
+"""Aggregate result rows across multiple upstream verifier steps into one unified score.
+
+Reads `context.metadata["verifications"][<vid>]["results"]` for each id in
+`verifier_ids`, concatenates the rows, drops skipped ones, and runs
+`aggregate_score` once on the union — same math as the upstream steps, but
+applied across their combined criterion set.
+
+Use this to match Harbor's unified-aggregation behavior when filesystem
+criteria (verify_sandbox) and response criteria (rubrics_verifier) live in
+separate steps.
+"""
+from __future__ import annotations
+
+import logging
+import uuid
+from typing import ClassVar, Optional
+
+from agent_env.task_step.context import TaskStepContext
+from agent_env.task_step.task_step import TaskStep, TaskStepDependency
+from agent_env.task_step.task_steps.verifiers.scoring import ScoreAggregator, aggregate_score
+
+logger = logging.getLogger(__name__)
+
+
+class AggregateVerifiersTaskStep(TaskStep):
+    type: ClassVar[str] = "aggregate_verifiers"
+    entity_refs = ()
+
+    def __init__(
+        self,
+        id: str,
+        version: Optional[int],
+        verifier_ids: Optional[list[str]] = None,
+        score_aggregator: Optional[ScoreAggregator] = None,
+        verifier_id: Optional[str] = None,
+        depends_on: Optional[list[TaskStepDependency]] = None,
+        fail_task_on_error: bool = True,
+    ):
+        super().__init__(id, version, depends_on=depends_on, fail_task_on_error=fail_task_on_error)
+        self.verifier_ids = list(verifier_ids or [])
+        if isinstance(score_aggregator, str):
+            score_aggregator = ScoreAggregator(score_aggregator)
+        self.score_aggregator = score_aggregator or ScoreAggregator.WEIGHTED_AVERAGE
+        self.verifier_id = verifier_id or uuid.uuid4().hex
+
+    def to_dict(self) -> dict:
+        base = super().to_dict()
+        base["verifier_ids"] = self.verifier_ids
+        base["score_aggregator"] = self.score_aggregator.value
+        base["verifier_id"] = self.verifier_id
+        return base
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "AggregateVerifiersTaskStep":
+        raw_agg = data.get("score_aggregator")
+        return cls(
+            **cls._base_from_dict(data),
+            verifier_ids=data.get("verifier_ids"),
+            score_aggregator=ScoreAggregator(raw_agg) if raw_agg else None,
+            verifier_id=data.get("verifier_id"),
+        )
+
+    async def execute(self, context: TaskStepContext) -> TaskStepContext:
+        all_verifications = context.metadata.get("verifications", {})
+        missing = [vid for vid in self.verifier_ids if vid not in all_verifications]
+        if missing:
+            raise RuntimeError(
+                f"AggregateVerifiers: verifier_id(s) not found in "
+                f"context.metadata.verifications: {missing}. "
+                f"Available: {list(all_verifications.keys())}"
+            )
+
+        merged_results: list[dict] = []
+        for vid in self.verifier_ids:
+            merged_results.extend(all_verifications[vid].get("results", []))
+
+        non_skipped = [r for r in merged_results if not r.get("skipped")]
+        score = aggregate_score(non_skipped, self.score_aggregator)
+
+        if "verifications" not in context.metadata:
+            context.metadata["verifications"] = {}
+        context.metadata["verifications"][self.verifier_id] = {
+            "score": score,
+            "source_verifier_ids": list(self.verifier_ids),
+        }
+        logger.info(
+            f"AggregateVerifiers '{self.verifier_id}': merged {len(self.verifier_ids)} verifier(s), "
+            f"{len(non_skipped)}/{len(merged_results)} criteria evaluated, score={score}"
+        )
+        return context