agentenv-framework 0.9.1254__py3-none-any.whl

agent_env/task_step/task_steps/a2a_agent_validator/verify_a2a_agent_config_identity.py

@@ -0,0 +1,69 @@
+"""Verify the A2A agent-config extension actually mutates the served card."""
+from __future__ import annotations
+
+import logging
+import uuid
+from typing import ClassVar, Optional
+
+import httpx
+
+from agent_env.a2a_agent import A2AAgent
+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 VerifyA2AAgentConfigIdentityStep(TaskStep):
+    type: ClassVar[str] = "verify_a2a_agent_config_identity"
+    entity_refs = (EntityRef.agent("a2a_agent_id", version_field="a2a_agent_version"),)
+
+    def __init__(self, id: str, version: Optional[int], a2a_agent_id: str, a2a_agent_version: Optional[int] = 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.a2a_agent_id = a2a_agent_id
+        self.a2a_agent_version = a2a_agent_version
+
+    def to_dict(self) -> dict:
+        return {**super().to_dict(), "a2a_agent_id": self.a2a_agent_id, "a2a_agent_version": self.a2a_agent_version}
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "VerifyA2AAgentConfigIdentityStep":
+        return cls(**cls._base_from_dict(data), a2a_agent_id=data["a2a_agent_id"], a2a_agent_version=data.get("a2a_agent_version"))
+
+    async def execute(self, context: TaskStepContext) -> TaskStepContext:
+        deployed = next((a for a in context.deployed_agents if a.agent_name == TaskStep.DEFAULT_AGENT_NAME), None)
+        if deployed is None:
+            raise RuntimeError("VerifyA2AAgentConfigIdentityStep: no deployed default-agent in context")
+        a2a_url = deployed.a2a_url or deployed.api_url
+        ext = A2AAgent.find_extension(deployed.a2a_card or {}, A2AAgent.EXT_AGENT_CONFIG)
+        supported = ((ext or {}).get("params") or {}).get("methods", {}).get("set", {}).get("request", {}).get("supported", [])
+        supports_identity = "name" in supported and "description" in supported
+
+        identity_round_trip_ok = False
+        if ext is not None and supports_identity:
+            name, desc = f"IdentityName-{uuid.uuid4().hex[:12]}", f"IdentityDesc-{uuid.uuid4().hex[:12]}"
+            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()
+                    card_resp = await client.get(f"{a2a_url}/.well-known/agent.json", timeout=30)
+                    card_resp.raise_for_status()
+                    card = card_resp.json() or {}
+                identity_round_trip_ok = card.get("name") == name and card.get("description") == desc
+            except httpx.HTTPError as e:
+                logger.warning(f"VerifyA2AAgentConfigIdentityStep: round-trip failed: {e}")
+
+        entry = {
+            "supported": ext is not None and supports_identity and identity_round_trip_ok,
+            "extension_advertised": ext is not None,
+            "supports_identity": supports_identity,
+            "identity_round_trip_ok": identity_round_trip_ok,
+        }
+        agent = A2AAgent.get(self.a2a_agent_id, self.a2a_agent_version)
+        validated_ext = agent.metadata.get("validated_a2a_extensions", {})
+        validated_ext[A2AAgent.EXT_AGENT_CONFIG] = entry
+        agent.update_metadata({**agent.metadata, "validated_a2a_extensions": validated_ext})
+        context.metadata.setdefault("verifications", {})["a2a_agent_config_identity"] = entry
+        logger.info(f"agent-config identity validation: {entry}")
+        return context

agent_env/task_step/task_steps/a2a_agent_validator/verify_a2a_agent_mcp.py

@@ -0,0 +1,178 @@
+"""Verify A2A agent can invoke MCP tools by sending a test prompt and reading the env trajectory."""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import time
+import uuid
+from typing import ClassVar, Optional
+
+import httpx
+
+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__)
+
+TEST_PROMPT = (
+    "Use the `search_emails` MCP tool (from the registered MCP server) to search for "
+    "emails containing the word 'invoice'. Do not answer from memory and do not call "
+    "any other tool — actually invoke `search_emails`. Report the tool's raw output."
+)
+
+
+class VerifyA2AAgentMCPStep(TaskStep):
+    type: ClassVar[str] = "verify_a2a_agent_mcp"
+    entity_refs = (EntityRef.agent("a2a_agent_id"),)
+
+    def __init__(
+        self,
+        id: str,
+        version: Optional[int],
+        a2a_agent_id: str,
+        timeout_seconds: int = 300,
+        poll_interval_seconds: int = 10,
+        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.a2a_agent_id = a2a_agent_id
+        self.timeout_seconds = timeout_seconds
+        self.poll_interval_seconds = poll_interval_seconds
+
+    def to_dict(self) -> dict:
+        base = super().to_dict()
+        base["a2a_agent_id"] = self.a2a_agent_id
+        base["timeout_seconds"] = self.timeout_seconds
+        base["poll_interval_seconds"] = self.poll_interval_seconds
+        return base
+
+    @classmethod
+    def from_dict(cls, data: dict) -> VerifyA2AAgentMCPStep:
+        return cls(**cls._base_from_dict(data), a2a_agent_id=data["a2a_agent_id"], timeout_seconds=data.get("timeout_seconds", 300), poll_interval_seconds=data.get("poll_interval_seconds", 10))
+
+    async def execute(self, context: TaskStepContext) -> TaskStepContext:
+        from agent_env.a2a_agent import A2AAgent, protocol
+        from agent_env.env.env import require_gateway_url
+
+        deployed_agent = next((a for a in context.deployed_agents), None)
+        if deployed_agent is None:
+            raise RuntimeError("No deployed agent found in context")
+        deployed_env = next((e for e in context.deployed_envs), None)
+        if deployed_env is None:
+            raise RuntimeError("No deployed env found in context")
+        # It counts tool calls in the gateway's trajectory, so an env without one can't be checked here.
+        require_gateway_url(deployed_env, "verify_a2a_agent_mcp")
+
+        a2a_url = deployed_agent.a2a_url or deployed_agent.api_url
+        message_id = uuid.uuid4().hex
+
+        # Send test prompt via message/send (A2A spec 0.3)
+        logger.info(f"Sending test prompt to agent at {a2a_url}...")
+        async with httpx.AsyncClient() as client:
+            resp = await client.post(f"{a2a_url}/a2a", json={
+                "jsonrpc": "2.0", "id": "1", "method": "message/send",
+                "params": {"message": {
+                    "messageId": message_id,
+                    "role": "user",
+                    "parts": [{"kind": "text", "text": TEST_PROMPT}],
+                }},
+            }, timeout=self.timeout_seconds)
+            resp.raise_for_status()
+            send_body = resp.json()
+            if "error" in send_body:
+                raise RuntimeError(f"A2A message/send failed: {send_body['error']}")
+            send_result = send_body.get("result") or {}
+            task_id = send_result["id"]
+            logger.info(f"message/send returned task_id={task_id}")
+
+        # Poll tasks/get until terminal state
+        logger.info("Polling for task completion...")
+        a2a_result = await self._poll_task(a2a_url, task_id)
+        task_status = a2a_result["status"]["state"]
+
+        # Parse the terminal message through the shared compatibility layer so
+        # both legacy top-level telemetry and typed usage telemetry are handled.
+        status_msg = (a2a_result.get("status") or {}).get("message") or {}
+        terminal = protocol.TerminalResponse.from_message(status_msg)
+        agent_response = terminal.response_text
+        tool_call_count_reported = terminal.tool_call_count is not None
+
+        # Read trajectory from env sandbox
+        tools_invoked = await self._count_tool_calls(deployed_env.sandbox_id)
+        passed = task_status == "completed" and tools_invoked > 0
+        logger.info(f"MCP validation: status={task_status} tools_invoked={tools_invoked} passed={passed}")
+
+        mcp_validation = {
+            "passed": passed,
+            "tools_invoked": tools_invoked,
+            "task_status": task_status,
+            "task_id": task_id,
+            "agent_response": agent_response[:500],
+        }
+        context.metadata.setdefault("verifications", {})["a2a_agent_mcp"] = mcp_validation
+
+        # Build validated mcp-config entry from what we actually tested
+        card = deployed_agent.a2a_card or {}
+        mcp_ext = A2AAgent.find_extension(card, A2AAgent.EXT_MCP_CONFIG)
+        mcp_entry: dict = {"supported": mcp_ext is not None and passed}
+        if mcp_ext:
+            ext_config = mcp_ext.get("config") or mcp_ext.get("params") or {}
+            methods: dict = {}
+            for method_name, method_def in ext_config.get("methods", {}).items():
+                method_entry: dict = {"supported": passed}
+                request = method_def.get("request", {})
+                options = []
+                for key in ("required", "optional", "supported"):
+                    options.extend(request.get(key, []))
+                for one_of in request.get("oneOf", []):
+                    options.extend(one_of.get("required", []))
+                if options:
+                    method_entry["options"] = {name: {"supported": passed} for name in options}
+                methods[method_name] = method_entry
+            mcp_entry["methods"] = methods
+
+        agent = A2AAgent.get(self.a2a_agent_id)
+        validated_ext = agent.metadata.get("validated_a2a_extensions", {})
+        validated_ext[A2AAgent.EXT_MCP_CONFIG] = mcp_entry
+        validated_data_ext = agent.metadata.get("validated_data_extensions", {})
+        validated_data_ext["tool_call_count"] = {"supported": tool_call_count_reported}
+        agent.update_metadata({**agent.metadata, "validated_a2a_extensions": validated_ext, "validated_data_extensions": validated_data_ext})
+
+        return context
+
+    async def _poll_task(self, a2a_url: str, task_id: str) -> dict:
+        deadline = time.monotonic() + self.timeout_seconds
+        while time.monotonic() < deadline:
+            await asyncio.sleep(self.poll_interval_seconds)
+            try:
+                async with httpx.AsyncClient() as client:
+                    resp = await client.post(f"{a2a_url}/a2a", json={
+                        "jsonrpc": "2.0", "id": "poll", "method": "tasks/get",
+                        "params": {"id": task_id},
+                    }, timeout=30)
+                    resp.raise_for_status()
+                    data = resp.json()
+                    if "error" in data:
+                        logger.warning(f"A2A poll error (will retry): {data['error']}")
+                        continue
+                    result = data["result"]
+            except (httpx.ConnectError, httpx.ReadTimeout, httpx.RemoteProtocolError) as e:
+                logger.warning(f"A2A poll failed (will retry): {e}")
+                continue
+            state = result["status"]["state"]
+            if state in ("completed", "failed"):
+                return result
+        raise TimeoutError(f"A2A task {task_id} did not complete within {self.timeout_seconds}s")
+
+    @staticmethod
+    async def _count_tool_calls(sandbox_id: str) -> int:
+        """Read the env gateway trajectory from the gateway container and count tool_call events."""
+        from agent_env.providers import get_env_sandbox_provider
+        from agent_env.providers import EnvironmentGatewayProvider
+        sandbox = await get_env_sandbox_provider().get_sandbox(sandbox_id)
+        events = await EnvironmentGatewayProvider().read_trajectory(sandbox)
+        count = sum(1 for e in events if e.get("event_type") == "tool_call")
+        return count

agent_env/task_step/task_steps/a2a_agent_validator/verify_a2a_core_protocol.py

@@ -0,0 +1,67 @@
+"""Verify core A2A protocol support (message/send + tasks/get)."""
+
+from __future__ import annotations
+
+import logging
+from typing import ClassVar, Optional
+
+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 VerifyCoreA2AProtocolStep(TaskStep):
+    type: ClassVar[str] = "verify_a2a_core_protocol"
+    entity_refs = (EntityRef.agent("a2a_agent_id"),)
+
+    def __init__(
+        self,
+        id: str,
+        version: Optional[int],
+        a2a_agent_id: str,
+        prompt_id: str,
+        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.a2a_agent_id = a2a_agent_id
+        self.prompt_id = prompt_id
+
+    def to_dict(self) -> dict:
+        base = super().to_dict()
+        base["a2a_agent_id"] = self.a2a_agent_id
+        base["prompt_id"] = self.prompt_id
+        return base
+
+    @classmethod
+    def from_dict(cls, data: dict) -> VerifyCoreA2AProtocolStep:
+        return cls(**cls._base_from_dict(data), a2a_agent_id=data["a2a_agent_id"], prompt_id=data["prompt_id"])
+
+    async def execute(self, context: TaskStepContext) -> TaskStepContext:
+        from agent_env.a2a_agent import A2AAgent
+
+        prompt_response = next((pr for pr in context.prompt_responses if pr.prompt_id == self.prompt_id), None)
+
+        # message/send succeeded if we have a prompt response at all
+        message_send_ok = prompt_response is not None
+        # tasks/get succeeded if the response has no error_type
+        tasks_get_ok = message_send_ok and prompt_response.error_type is None
+
+        logger.info(f"Core A2A protocol: message/send={message_send_ok} tasks/get={tasks_get_ok}")
+        if not message_send_ok:
+            logger.error("message/send failed: no prompt response found")
+        elif not tasks_get_ok:
+            logger.warning(f"tasks/get returned error: {prompt_response.error_type}")
+
+        protocol = {
+            "message/send": {"supported": message_send_ok},
+            "tasks/get": {"supported": tasks_get_ok},
+        }
+
+        agent = A2AAgent.get(self.a2a_agent_id)
+        agent.update_metadata({**agent.metadata, "validated_a2a_protocol": protocol})
+
+        context.metadata.setdefault("verifications", {})["a2a_core_protocol"] = protocol
+        return context

agent_env/task_step/task_steps/a2a_agent_validator/verify_a2a_install.py

@@ -0,0 +1,115 @@
+"""Verify A2A agent install/v1 extension end-to-end.
+
+Pure recorder step. The actual install exercise (deploy sandbox -> run bare task
+container -> InstallAgentTaskStep -> PromptAgent -> RubricsVerifier) lives in the
+chained steps before this one in the validator DAG. This step reads the rubric
+verdict + checks the installed agent's card, then records the outcome on
+`agent.metadata["validated_a2a_extensions"]` and `context.metadata["verifications"]`.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import ClassVar, Optional
+
+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 VerifyA2AInstallStep(TaskStep):
+    type: ClassVar[str] = "verify_a2a_install"
+    entity_refs = (EntityRef.agent("a2a_agent_id", version_field="a2a_agent_version"),)
+
+    def __init__(
+        self,
+        id: str,
+        version: Optional[int],
+        a2a_agent_id: str,
+        a2a_agent_version: Optional[int] = None,
+        agent_name: str = "install-test-agent",
+        rubric_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.a2a_agent_id = a2a_agent_id
+        self.a2a_agent_version = a2a_agent_version
+        self.agent_name = agent_name
+        self.rubric_verifier_id = rubric_verifier_id
+
+    def to_dict(self) -> dict:
+        base = super().to_dict()
+        base["a2a_agent_id"] = self.a2a_agent_id
+        base["a2a_agent_version"] = self.a2a_agent_version
+        base["agent_name"] = self.agent_name
+        base["rubric_verifier_id"] = self.rubric_verifier_id
+        return base
+
+    @classmethod
+    def from_dict(cls, data: dict) -> VerifyA2AInstallStep:
+        return cls(
+            **cls._base_from_dict(data),
+            a2a_agent_id=data["a2a_agent_id"],
+            a2a_agent_version=data.get("a2a_agent_version"),
+            agent_name=data.get("agent_name", "install-test-agent"),
+            rubric_verifier_id=data.get("rubric_verifier_id"),
+        )
+
+    async def execute(self, context: TaskStepContext) -> TaskStepContext:
+        from agent_env.a2a_agent import A2AAgent
+
+        deployed = next(
+            (a for a in context.deployed_agents if a.agent_name == self.agent_name),
+            None,
+        )
+        result: dict = {
+            "supported": False,
+            "advertised": False,
+            "installed_successfully": deployed is not None,
+            "responded_to_prompt": False,
+        }
+
+        if deployed is None:
+            # Install never produced a DeployedAgent — upstream chain failed.
+            result["error"] = (
+                "InstallAgentTaskStep did not produce a deployed agent named "
+                f"{self.agent_name!r} (upstream chain failure); check earlier validator step logs"
+            )
+            logger.warning(f"[verify_a2a_install] {result['error']}")
+        else:
+            card = deployed.a2a_card or {}
+            result["advertised"] = A2AAgent.find_extension(card, A2AAgent.EXT_INSTALL) is not None
+
+            if self.rubric_verifier_id:
+                rubric = context.metadata.get("verifications", {}).get(self.rubric_verifier_id, {})
+                rubric_results = rubric.get("results") or []
+                responded = any(
+                    r.get("id") == "responded" and r.get("result") for r in rubric_results
+                )
+                result["responded_to_prompt"] = responded
+                result["rubric_score"] = rubric.get("score")
+                logger.info(
+                    f"[verify_a2a_install] rubric {self.rubric_verifier_id!r}: "
+                    f"responded={responded} score={rubric.get('score')}"
+                )
+
+            result["supported"] = result["installed_successfully"] and result["responded_to_prompt"]
+
+        # Persist on the A2AAgent doc so the hub / next consumers can query it.
+        # Guard the DB write: this step runs with fail_task_on_error=False, so a
+        # raised exception would be swallowed by the task runner and the result
+        # lost. Catch it and always fall through to the in-context write.
+        try:
+            agent = A2AAgent.get(self.a2a_agent_id, self.a2a_agent_version)
+            validated_ext = dict(agent.metadata.get("validated_a2a_extensions", {}))
+            validated_ext[A2AAgent.EXT_INSTALL] = result
+            agent.update_metadata({**agent.metadata, "validated_a2a_extensions": validated_ext})
+        except Exception as e:  # noqa: BLE001
+            logger.warning(f"[verify_a2a_install] failed to persist validated_a2a_extensions: {e}")
+
+        context.metadata.setdefault("verifications", {})["a2a_install"] = result
+        logger.info(f"[verify_a2a_install] result: {result}")
+        return context

agent_env/task_step/task_steps/a2a_agent_validator/verify_a2a_litellm_attribution.py

@@ -0,0 +1,124 @@
+"""Verify A2A agent declares LiteLLM cost-attribution support on its card.
+
+Static check: reads the agent's `/.well-known/agent.json` (already fetched
+at deploy time and stored on `deployed.a2a_card`) and inspects the
+`urn:agentenv:agent-config/v1` extension. An agent "supports LiteLLM
+attribution" when its agent-config extension advertises **both**
+`project_id` and `task_id` in its `params.methods.set.request.supported`
+list.
+
+The check tells consumers (e.g. claude-code's auto-integration flow,
+the hub UI) which agents will honor per-prompt attribution delivered
+through `/ext/agent-config` from `PromptAgentTaskStep`. Agents that
+don't advertise it will have those fields filtered out at the worker
+side with a warning, and spend logs from those agents will not carry
+the `projectId:<id>` / `taskId:<id>` tags.
+
+This is a card-level static check only. It does NOT verify the agent
+actually threads attribution into its outbound LLM calls — that's an
+agent-implementation concern (e.g. an agent bridge's own
+`_apply_litellm_attribution` helper). A future runtime probe could be added
+if a self-reporting endpoint is exposed; for now, the static check
+mirrors what an external integrator can discover via the AgentCard.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import ClassVar, Optional
+
+from agent_env.task_step.context import TaskStepContext
+from agent_env.task_step.task_step import TaskStep, TaskStepDependency
+
+logger = logging.getLogger(__name__)
+
+# Body fields the worker (PromptAgentTaskStep) sends via /ext/agent-config
+# for LiteLLM cost attribution. Both must be in the agent-config extension's
+# `supported` list for the agent to be considered attribution-capable.
+ATTRIBUTION_FIELDS = ("project_id", "task_id")
+
+
+class VerifyA2ALitellmAttributionStep(TaskStep):
+    type: ClassVar[str] = "verify_a2a_litellm_attribution"
+
+    def __init__(
+        self,
+        id: str,
+        version: Optional[int],
+        a2a_agent_id: str,
+        a2a_agent_version: Optional[int] = 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.a2a_agent_id = a2a_agent_id
+        self.a2a_agent_version = a2a_agent_version
+
+    def to_dict(self) -> dict:
+        base = super().to_dict()
+        base["a2a_agent_id"] = self.a2a_agent_id
+        base["a2a_agent_version"] = self.a2a_agent_version
+        return base
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "VerifyA2ALitellmAttributionStep":
+        return cls(
+            **cls._base_from_dict(data),
+            a2a_agent_id=data["a2a_agent_id"],
+            a2a_agent_version=data.get("a2a_agent_version"),
+        )
+
+    async def execute(self, context: TaskStepContext) -> TaskStepContext:
+        from agent_env.a2a_agent import A2AAgent
+
+        deployed = next((a for a in context.deployed_agents), None)
+        if deployed is None:
+            raise RuntimeError("No deployed agent found in context")
+
+        card = deployed.a2a_card or {}
+        agent = A2AAgent.get(self.a2a_agent_id, self.a2a_agent_version)
+
+        ext = A2AAgent.find_extension(card, A2AAgent.EXT_AGENT_CONFIG)
+        supported: list[str] = []
+        if ext:
+            supported = (
+                ((ext.get("params") or {}).get("methods") or {})
+                .get("set", {})
+                .get("request", {})
+                .get("supported")
+                or []
+            )
+
+        advertises = {field: field in supported for field in ATTRIBUTION_FIELDS}
+        missing = [field for field, present in advertises.items() if not present]
+        passed = ext is not None and not missing
+
+        if not ext:
+            logger.warning(
+                "Agent '%s' does not advertise the agent-config extension — "
+                "LiteLLM attribution cannot flow.", self.a2a_agent_id,
+            )
+        elif missing:
+            logger.warning(
+                "Agent '%s' advertises agent-config but is missing attribution "
+                "fields in its `supported` set: %s. Spend logs from this agent "
+                "will not carry projectId/taskId tags. See an A2A agent bridge's "
+                "`_apply_litellm_attribution` helper for a reference implementation.",
+                self.a2a_agent_id, missing,
+            )
+        else:
+            logger.info(
+                "Agent '%s' supports LiteLLM attribution: advertises %s in "
+                "agent-config.supported", self.a2a_agent_id, list(ATTRIBUTION_FIELDS),
+            )
+
+        validated = {
+            "passed": passed,
+            "extension_present": ext is not None,
+            "supported_fields": supported,
+            "advertises": advertises,
+            "missing": missing,
+        }
+        agent.update_metadata({**agent.metadata, "validated_litellm_attribution": validated})
+        context.metadata.setdefault("verifications", {})["a2a_litellm_attribution"] = validated
+        return context