agenticdome-python-sdk 1.2.6__tar.gz → 1.2.7__tar.gz

{agenticdome_python_sdk-1.2.6/agenticdome_python_sdk.egg-info → agenticdome_python_sdk-1.2.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agenticdome-python-sdk
-Version: 1.2.6
+Version: 1.2.7
 Summary: Official Python SDK for AgenticDome security guardrails, DLP, tool authorization, and multi-agent delegation enforcement.
 Author: AgenticDome
 License: Proprietary

{agenticdome_python_sdk-1.2.6 → agenticdome_python_sdk-1.2.7/agenticdome_python_sdk.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agenticdome-python-sdk
-Version: 1.2.6
+Version: 1.2.7
 Summary: Official Python SDK for AgenticDome security guardrails, DLP, tool authorization, and multi-agent delegation enforcement.
 Author: AgenticDome
 License: Proprietary

{agenticdome_python_sdk-1.2.6 → agenticdome_python_sdk-1.2.7}/agenticdome_sdk/_framework_firewall.py

@@ -63,6 +63,8 @@ class DecisionTokenRecord:
     source_agent_id: str
     created_at: float
     token_hmac: str = ""
+    tool_version: str = ""
+    tool_digest: str = ""
 
 
 def _stable_json(value: Any) -> str:
@@ -213,6 +215,22 @@ class FrameworkFirewallBase:
         except Exception:
             pass
 
+    def register_tool_provenance(
+        self,
+        tool_name: str,
+        *,
+        tool_version: Optional[str] = None,
+        tool_digest: Optional[str] = None,
+        tool_platform: Optional[str] = None,
+    ) -> None:
+        """Cache precomputed provenance once for this firewall's client."""
+        self.client.register_tool_provenance(
+            tool_name,
+            tool_version=tool_version,
+            tool_digest=tool_digest,
+            tool_platform=tool_platform or self.config.default_tool_platform,
+        )
+
     @staticmethod
     def serialize(value: Any) -> str:
         return value if isinstance(value, str) else _stable_json(value)
@@ -372,6 +390,8 @@ class FrameworkFirewallBase:
         tool_args: Dict[str, Any],
         text: str = "",
         tool_platform: Optional[str] = None,
+        tool_version: Optional[str] = None,
+        tool_digest: Optional[str] = None,
         policy_context: Optional[Dict[str, Any]] = None,
         source_agent_id: Optional[str] = None,
     ) -> Dict[str, Any]:
@@ -392,6 +412,8 @@ class FrameworkFirewallBase:
                 tool_platform=tool_platform or self.config.default_tool_platform,
                 tool_name=tool_name,
                 tool_args=clean_args,
+                tool_version=tool_version,
+                tool_digest=tool_digest,
                 policy_context=self._policy_context(session_id, f"{self.config.platform}_tool_call", policy_context, tool_name=tool_name),
             )
             if self.verdict(response) == "BLOCKED":
@@ -421,6 +443,8 @@ class FrameworkFirewallBase:
         tool_args: Dict[str, Any],
         text: str = "",
         tool_platform: Optional[str] = None,
+        tool_version: Optional[str] = None,
+        tool_digest: Optional[str] = None,
         policy_context: Optional[Dict[str, Any]] = None,
     ) -> Dict[str, Any]:
         clean_args = self.strip_private_args(tool_args)
@@ -435,6 +459,8 @@ class FrameworkFirewallBase:
                 tool_platform=tool_platform or self.config.default_tool_platform,
                 tool_name=tool_name,
                 tool_args=clean_args,
+                tool_version=tool_version,
+                tool_digest=tool_digest,
                 session_id=session_id,
                 direction="outbound",
                 policy_context=self._policy_context(
@@ -456,7 +482,7 @@ class FrameworkFirewallBase:
                     target_agent_id=specialist_agent_id,
                     tool_name=tool_name,
                     tool_args=clean_args,
-                    record=DecisionTokenRecord(token, manager_agent_id, time.time(), self._token_hmac(token)),
+                    record=DecisionTokenRecord(token, manager_agent_id, time.time(), self._token_hmac(token), tool_version or "", tool_digest or ""),
                     ttl_s=self.config.handoff_token_ttl_s,
                 )
             return env
@@ -475,6 +501,8 @@ class FrameworkFirewallBase:
         tool_args: Dict[str, Any],
         decision_token: Optional[str] = None,
         source_agent_id: Optional[str] = None,
+        tool_version: Optional[str] = None,
+        tool_digest: Optional[str] = None,
     ) -> Dict[str, Any]:
         clean_args = self.strip_private_args(tool_args)
         record = None
@@ -488,6 +516,12 @@ class FrameworkFirewallBase:
             if record:
                 decision_token = record.decision_token
                 source_agent_id = source_agent_id or record.source_agent_id
+                if tool_version and record.tool_version and tool_version != record.tool_version:
+                    raise self.denied_error("AgenticDome delegated tool version differs from the authorized version.")
+                if tool_digest and record.tool_digest and tool_digest != record.tool_digest:
+                    raise self.denied_error("AgenticDome delegated tool digest differs from the authorized digest.")
+                tool_version = tool_version or record.tool_version or None
+                tool_digest = tool_digest or record.tool_digest or None
         if record and self.config.token_hmac_secret:
             expected = self._token_hmac(record.decision_token)
             if not record.token_hmac or not hmac.compare_digest(record.token_hmac, expected):
@@ -500,6 +534,8 @@ class FrameworkFirewallBase:
                 decision_token,
                 tool_name=tool_name,
                 tool_args=clean_args,
+                tool_version=tool_version,
+                tool_digest=tool_digest,
                 agent_id=specialist_agent_id,
                 source_agent_id=source_agent_id,
                 platform=self.config.platform,
@@ -611,4 +647,3 @@ class FrameworkFirewallBase:
         def decorator(fn: Callable[..., Any]) -> Callable[..., Any]:
             return self.wrap_tool_handler(tool_name=tool_name or fn.__name__, handler=fn, **options)
         return decorator
-

{agenticdome_python_sdk-1.2.6 → agenticdome_python_sdk-1.2.7}/agenticdome_sdk/client.py

@@ -1,6 +1,7 @@
 import base64
 import os
-from typing import Optional, Dict, List, Any, Tuple, Union
+import re
+from typing import Optional, Dict, List, Any, Tuple, Union, Mapping
 
 import requests
 from requests.adapters import HTTPAdapter
@@ -58,6 +59,7 @@ class AgentGuardClient:
         pool_maxsize: int = 100,
         pool_block: bool = False,
         service_token: Optional[str] = None,
+        tool_provenance: Optional[Mapping[str, Mapping[str, str]]] = None,
     ):
         self.api_base = self._require_nonempty("api_base", api_base).rstrip("/")
         self.api_key = self._require_nonempty(
@@ -84,6 +86,13 @@ class AgentGuardClient:
             default=5.0,
         )
         self.user_agent = user_agent
+        self._tool_provenance: Dict[str, Dict[str, str]] = {}
+        for registered_name, provenance in dict(tool_provenance or {}).items():
+            self.register_tool_provenance(
+                registered_name,
+                tool_version=(provenance or {}).get("tool_version") or (provenance or {}).get("version"),
+                tool_digest=(provenance or {}).get("tool_digest") or (provenance or {}).get("digest"),
+            )
 
         self.session = requests.Session()
         retry = Retry(
@@ -158,6 +167,55 @@ class AgentGuardClient:
         s = str(value).strip()
         return s or None
 
+    def register_tool_provenance(
+        self,
+        tool_name: str,
+        *,
+        tool_version: Optional[str] = None,
+        tool_digest: Optional[str] = None,
+        tool_platform: Optional[str] = None,
+    ) -> None:
+        """Register precomputed provenance once; request-time lookup is local O(1)."""
+        name = self._require_nonempty("tool_name", tool_name)
+        version = self._normalize_optional_string(tool_version)
+        digest = self._normalize_optional_string(tool_digest)
+        if digest is not None and not re.fullmatch(r"sha256:[0-9a-f]{64}", digest):
+            raise ValueError("'tool_digest' must be sha256 followed by 64 lowercase hexadecimal characters")
+        if version is None and digest is None:
+            raise ValueError("tool_version or tool_digest is required")
+        key = f"{self._normalize_optional_string(tool_platform)}:{name}" if tool_platform else name
+        self._tool_provenance[key] = {"tool_version": version or "", "tool_digest": digest or ""}
+
+    def unregister_tool_provenance(self, tool_name: str, *, tool_platform: Optional[str] = None) -> None:
+        name = self._require_nonempty("tool_name", tool_name)
+        key = f"{self._normalize_optional_string(tool_platform)}:{name}" if tool_platform else name
+        self._tool_provenance.pop(key, None)
+
+    def _resolve_tool_provenance(
+        self,
+        *,
+        tool_name: Optional[str],
+        tool_version: Optional[str],
+        tool_digest: Optional[str],
+        tool_platform: Optional[str] = None,
+        policy_context: Optional[Dict[str, Any]] = None,
+    ) -> Tuple[Optional[str], Optional[str]]:
+        if not tool_name:
+            return tool_version, tool_digest
+        context = policy_context or {}
+        context_provenance = context.get("tool_provenance") if isinstance(context.get("tool_provenance"), dict) else {}
+        key = f"{tool_platform}:{tool_name}" if tool_platform else ""
+        registered = self._tool_provenance.get(key) or self._tool_provenance.get(str(tool_name)) or {}
+        version = self._normalize_optional_string(tool_version) or self._normalize_optional_string(
+            context.get("tool_version") or context_provenance.get("tool_version") or context_provenance.get("version") or registered.get("tool_version")
+        )
+        digest = self._normalize_optional_string(tool_digest) or self._normalize_optional_string(
+            context.get("tool_digest") or context_provenance.get("tool_digest") or context_provenance.get("digest") or registered.get("tool_digest")
+        )
+        if digest is not None and not re.fullmatch(r"sha256:[0-9a-f]{64}", digest):
+            raise ValueError("'tool_digest' must be sha256 followed by 64 lowercase hexadecimal characters")
+        return version, digest
+
     def _positive_float(self, name: str, value: Any, *, default: float) -> float:
         try:
             parsed = float(value)
@@ -257,6 +315,7 @@ class AgentGuardClient:
         token: str,
         tool_name: Optional[str] = None,
         tool_args: Optional[Dict[str, Any]] = None,
+        tool_digest: Optional[str] = None,
     ) -> None:
         """
         Validate decision-token verification inputs.
@@ -268,6 +327,8 @@ class AgentGuardClient:
             raise ValueError("'tool_args' is required when 'tool_name' is provided")
         if tool_args is not None and not tool_name:
             raise ValueError("'tool_name' is required when 'tool_args' is provided")
+        if tool_digest is not None and not re.fullmatch(r"sha256:[0-9a-f]{64}", str(tool_digest)):
+            raise ValueError("'tool_digest' must be sha256 followed by 64 lowercase hexadecimal characters")
 
     def _request(
         self,
@@ -453,6 +514,8 @@ class AgentGuardClient:
         tool_platform: Optional[str] = None,
         tool_name: Optional[str] = None,
         tool_args: Optional[Dict[str, Any]] = None,
+        tool_version: Optional[str] = None,
+        tool_digest: Optional[str] = None,
         policy_context: Optional[Dict[str, Any]] = None,
         reasoning_trace: Optional[str] = None,
         agent_instance_id: Optional[str] = None,
@@ -491,6 +554,13 @@ class AgentGuardClient:
         Delegation rule:
           - source_agent_id requires source_platform
         """
+        tool_version, tool_digest = self._resolve_tool_provenance(
+            tool_name=tool_name,
+            tool_version=tool_version,
+            tool_digest=tool_digest,
+            tool_platform=tool_platform,
+            policy_context=policy_context,
+        )
         normalized_direction = self._validate_guardrail_args(
             text=text,
             agent_id=agent_id,
@@ -502,6 +572,8 @@ class AgentGuardClient:
             source_platform=source_platform,
             user_id=user_id,
         )
+        if tool_digest is not None and not re.fullmatch(r"sha256:[0-9a-f]{64}", str(tool_digest)):
+            raise ValueError("'tool_digest' must be sha256 followed by 64 lowercase hexadecimal characters")
 
         merged_policy_context = self._merge_policy_context(
             policy_context,
@@ -511,6 +583,8 @@ class AgentGuardClient:
             tool_platform=tool_platform,
             tool_name=tool_name,
             tool_args=tool_args,
+            tool_version=tool_version,
+            tool_digest=tool_digest,
             reasoning_trace=reasoning_trace,
             agent_instance_id=agent_instance_id,
             user_id=user_id,
@@ -540,6 +614,8 @@ class AgentGuardClient:
                 "tool_platform": tool_platform,
                 "tool_name": tool_name,
                 "tool_args": tool_args,
+                "tool_version": tool_version,
+                "tool_digest": tool_digest,
                 "policy_context": merged_policy_context,
                 "reasoning_trace": reasoning_trace,
                 "agent_instance_id": agent_instance_id,
@@ -780,6 +856,8 @@ class AgentGuardClient:
         source_platform: str,
         tool_name: str,
         tool_args: Dict[str, Any],
+        tool_version: Optional[str] = None,
+        tool_digest: Optional[str] = None,
         tool_platform: Optional[str] = None,
         policy_context: Optional[Dict[str, Any]] = None,
         session_id: Optional[str] = None,
@@ -830,6 +908,15 @@ class AgentGuardClient:
         self._require_nonempty("source_agent_id", source_agent_id)
         self._require_nonempty("source_platform", source_platform)
         self._require_nonempty("tool_name", tool_name)
+        tool_version, tool_digest = self._resolve_tool_provenance(
+            tool_name=tool_name,
+            tool_version=tool_version,
+            tool_digest=tool_digest,
+            tool_platform=tool_platform,
+            policy_context=policy_context,
+        )
+        if tool_digest is not None and not re.fullmatch(r"sha256:[0-9a-f]{64}", str(tool_digest)):
+            raise ValueError("'tool_digest' must be sha256 followed by 64 lowercase hexadecimal characters")
 
         normalized_direction = self._validate_guardrail_args(
             text=text,
@@ -851,6 +938,8 @@ class AgentGuardClient:
             source_agent_id=source_agent_id,
             tool_name=tool_name,
             tool_args=tool_args,
+            tool_version=tool_version,
+            tool_digest=tool_digest,
             request_purpose=request_purpose,
             purpose=purpose,
             intent=intent,
@@ -887,6 +976,8 @@ class AgentGuardClient:
                 "tool_platform": tool_platform,
                 "tool_name": tool_name,
                 "tool_args": tool_args,
+                "tool_version": tool_version,
+                "tool_digest": tool_digest,
                 "policy_context": merged_policy_context,
                 "source_agent_id": source_agent_id,
                 "request_purpose": request_purpose,
@@ -937,6 +1028,8 @@ class AgentGuardClient:
         *,
         tool_name: Optional[str] = None,
         tool_args: Optional[Dict[str, Any]] = None,
+        tool_version: Optional[str] = None,
+        tool_digest: Optional[str] = None,
         agent_id: Optional[str] = None,
         source_agent_id: Optional[str] = None,
         platform: Optional[str] = None,
@@ -958,10 +1051,17 @@ class AgentGuardClient:
           - platform
           - source_agent_id (for delegated sensitive flows)
         """
+        tool_version, tool_digest = self._resolve_tool_provenance(
+            tool_name=tool_name,
+            tool_version=tool_version,
+            tool_digest=tool_digest,
+            tool_platform=platform,
+        )
         self._validate_decision_verify_args(
             token=token,
             tool_name=tool_name,
             tool_args=tool_args,
+            tool_digest=tool_digest,
         )
 
         payload = self._drop_none(
@@ -969,6 +1069,8 @@ class AgentGuardClient:
                 "token": token,
                 "tool_name": tool_name,
                 "tool_args": tool_args,
+                "tool_version": tool_version,
+                "tool_digest": tool_digest,
                 "agent_id": agent_id,
                 "source_agent_id": source_agent_id,
                 "platform": platform,
@@ -989,6 +1091,8 @@ class AgentGuardClient:
         *,
         tool_name: Optional[str] = None,
         tool_args: Optional[Dict[str, Any]] = None,
+        tool_version: Optional[str] = None,
+        tool_digest: Optional[str] = None,
         agent_id: Optional[str] = None,
         source_agent_id: Optional[str] = None,
         platform: Optional[str] = None,
@@ -1011,10 +1115,17 @@ class AgentGuardClient:
           - platform
           - source_agent_id (for delegated sensitive flows)
         """
+        tool_version, tool_digest = self._resolve_tool_provenance(
+            tool_name=tool_name,
+            tool_version=tool_version,
+            tool_digest=tool_digest,
+            tool_platform=platform,
+        )
         self._validate_decision_verify_args(
             token=token,
             tool_name=tool_name,
             tool_args=tool_args,
+            tool_digest=tool_digest,
         )
 
         arguments = self._drop_none(
@@ -1022,6 +1133,8 @@ class AgentGuardClient:
                 "token": token,
                 "tool_name": tool_name,
                 "tool_args": tool_args,
+                "tool_version": tool_version,
+                "tool_digest": tool_digest,
                 "agent_id": agent_id,
                 "source_agent_id": source_agent_id,
                 "platform": platform,
@@ -1111,6 +1224,8 @@ class AgentGuardClient:
         tool_platform: Optional[str] = None,
         tool_name: Optional[str] = None,
         tool_args: Optional[Dict[str, Any]] = None,
+        tool_version: Optional[str] = None,
+        tool_digest: Optional[str] = None,
         policy_context: Optional[Dict[str, Any]] = None,
         direction: str = "outbound",
         source_agent_id: Optional[str] = None,
@@ -1149,6 +1264,13 @@ class AgentGuardClient:
         Delegation rule:
           - source_agent_id requires source_platform
         """
+        tool_version, tool_digest = self._resolve_tool_provenance(
+            tool_name=tool_name,
+            tool_version=tool_version,
+            tool_digest=tool_digest,
+            tool_platform=tool_platform,
+            policy_context=policy_context,
+        )
         normalized_direction = self._validate_guardrail_args(
             text=text,
             agent_id=agent_id,
@@ -1170,6 +1292,8 @@ class AgentGuardClient:
             user_id=user_id,
             tool_name=tool_name,
             tool_args=tool_args,
+            tool_version=tool_version,
+            tool_digest=tool_digest,
             reasoning_trace=reasoning_trace,
             request_purpose=request_purpose,
             purpose=purpose,
@@ -1195,6 +1319,8 @@ class AgentGuardClient:
                 "tool_platform": tool_platform,
                 "tool_name": tool_name,
                 "tool_args": tool_args,
+                "tool_version": tool_version,
+                "tool_digest": tool_digest,
                 "policy_context": merged_policy_context,
                 "source_agent_id": source_agent_id,
                 "user_id": user_id,

{agenticdome_python_sdk-1.2.6 → agenticdome_python_sdk-1.2.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "agenticdome-python-sdk"
-version = "1.2.6"
+version = "1.2.7"
 description = "Official Python SDK for AgenticDome security guardrails, DLP, tool authorization, and multi-agent delegation enforcement."
 readme = "README.md"
 requires-python = ">=3.9"

{agenticdome_python_sdk-1.2.6 → agenticdome_python_sdk-1.2.7}/tests/test_autogen_integration.py

@@ -20,6 +20,10 @@ class FakeClient:
         self.mesh_calls = []
         self.incidents = []
         self.revocations = []
+        self.provenance = {}
+
+    def register_tool_provenance(self, tool_name, **kwargs):
+        self.provenance[tool_name] = kwargs
 
     def guardrail_validate(self, **kwargs):
         self.guardrail_calls.append(kwargs)
@@ -69,6 +73,24 @@ def test_autogen_requires_agenticdome_runtime_configuration():
         AgenticDomeAutoGenFirewall(FirewallConfig(api_base="", api_key="", tenant_id=""))
 
 
+def test_autogen_forwards_explicit_tool_provenance_and_supports_cached_registration():
+    fw, client = firewall()
+    digest = "sha256:" + "c" * 64
+    fw.register_tool_provenance("crm.lookup", tool_version="3.0.0", tool_digest=digest)
+    fw.authorize_tool_call(
+        session_id="tool-provenance",
+        agent_id="planner",
+        tool_name="crm.lookup",
+        tool_args={"customer_id": "42"},
+        tool_version="3.0.0",
+        tool_digest=digest,
+    )
+
+    assert client.provenance["crm.lookup"]["tool_digest"] == digest
+    assert client.guardrail_calls[-1]["tool_version"] == "3.0.0"
+    assert client.guardrail_calls[-1]["tool_digest"] == digest
+
+
 def test_conversation_window_sends_family_two_metrics_and_redacts_output():
     fw, client = firewall()
 

{agenticdome_python_sdk-1.2.6 → agenticdome_python_sdk-1.2.7}/tests/test_client.py

@@ -90,6 +90,65 @@ def test_guardrail_validate_success(mock_request, client):
     assert payload["platform"] == "microsoft"
 
 
+@patch("agenticdome_sdk.client.requests.Session.request")
+def test_registered_tool_provenance_is_forwarded_without_runtime_hashing(mock_request, client):
+    digest = "sha256:" + "a" * 64
+    mock_request.return_value = make_response(200, {"verdict": "ALLOWED"})
+    client.register_tool_provenance("crm.lookup", tool_version="4.2.1", tool_digest=digest, tool_platform="mcp")
+
+    client.guardrail_validate(
+        text="lookup customer",
+        agent_id="support-agent",
+        direction="outbound",
+        platform="langgraph",
+        tool_platform="mcp",
+        tool_name="crm.lookup",
+        tool_args={"customer_id": "42"},
+    )
+
+    payload = mock_request.call_args.kwargs["json"]
+    assert payload["tool_version"] == "4.2.1"
+    assert payload["tool_digest"] == digest
+    assert payload["policy_context"]["tool_digest"] == digest
+
+
+@patch("agenticdome_sdk.client.requests.Session.request")
+def test_registered_provenance_is_bound_to_authorize_and_verify(mock_request, client):
+    digest = "sha256:" + "b" * 64
+    mock_request.return_value = make_response(200, {"jsonrpc": "2.0", "id": "1", "result": {"verdict": "ALLOWED", "valid": True}})
+    client.register_tool_provenance("payments.refund", tool_version="2.0.0", tool_digest=digest)
+
+    client.a2a_authorize_tool(
+        text="delegate refund",
+        agent_id="billing-agent",
+        platform="autogen",
+        source_agent_id="manager-agent",
+        source_platform="autogen",
+        tool_name="payments.refund",
+        tool_args={"amount": 25},
+    )
+    authorize = mock_request.call_args.kwargs["json"]["params"]["arguments"]
+    assert authorize["tool_version"] == "2.0.0"
+    assert authorize["tool_digest"] == digest
+
+    client.a2a_verify_decision_token_rpc(
+        "decision-token",
+        tool_name="payments.refund",
+        tool_args={"amount": 25},
+        agent_id="billing-agent",
+        source_agent_id="manager-agent",
+        platform="autogen",
+    )
+    verify = mock_request.call_args.kwargs["json"]["params"]["arguments"]
+    assert verify["tool_version"] == "2.0.0"
+    assert verify["tool_digest"] == digest
+
+
+def test_invalid_registered_tool_digest_fails_before_network(client):
+    with pytest.raises(ValueError, match="tool_digest"):
+        client.register_tool_provenance("unsafe.tool", tool_digest="sha256:not-a-real-digest")
+
+
 @patch("agenticdome_sdk.client.requests.Session.request")
 def test_guardrail_validate_blocks_invalid_tool_pairing(mock_request, client):
     with pytest.raises(ValueError, match="'tool_args' is required"):
@@ -297,6 +356,26 @@ def test_mcp_guardrail_validate(mock_request, client):
     assert arguments["tool_name"] == "mcp.execute_remote_patch"
 
 
+@patch("agenticdome_sdk.client.requests.Session.request")
+def test_mcp_guardrail_uses_registered_tool_provenance(mock_request, client):
+    digest = "sha256:" + "d" * 64
+    mock_request.return_value = make_response(200, {"jsonrpc": "2.0", "id": "1", "result": {"verdict": "ALLOWED"}})
+    client.register_tool_provenance("mcp.customer.lookup", tool_version="1.8.0", tool_digest=digest, tool_platform="mcp")
+
+    client.mcp_guardrail_validate(
+        text="lookup customer",
+        agent_id="mcp-agent",
+        platform="mcp",
+        tool_platform="mcp",
+        tool_name="mcp.customer.lookup",
+        tool_args={"customer_id": "42"},
+    )
+
+    arguments = mock_request.call_args.kwargs["json"]["params"]["arguments"]
+    assert arguments["tool_version"] == "1.8.0"
+    assert arguments["tool_digest"] == digest
+
+
 @patch("agenticdome_sdk.client.requests.Session.request")
 def test_mesh_validate(mock_request, client):
     mock_request.return_value = make_response(