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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agenticdome-python-sdk
-Version: 1.2.7
+Version: 1.2.8
 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.7 → agenticdome_python_sdk-1.2.8/agenticdome_python_sdk.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agenticdome-python-sdk
-Version: 1.2.7
+Version: 1.2.8
 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.7 → agenticdome_python_sdk-1.2.8}/agenticdome_python_sdk.egg-info/SOURCES.txt

@@ -36,6 +36,7 @@ tests/test_aws_bedrock_integration.py
 tests/test_claude_integration.py
 tests/test_client.py
 tests/test_crewai_integration.py
+tests/test_execution_broker.py
 tests/test_google_adk_integration.py
 tests/test_identity_context.py
 tests/test_langgraph_integration.py

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

@@ -1,4 +1,5 @@
 import base64
+import hashlib
 import os
 import re
 from typing import Optional, Dict, List, Any, Tuple, Union, Mapping
@@ -60,6 +61,7 @@ class AgentGuardClient:
         pool_block: bool = False,
         service_token: Optional[str] = None,
         tool_provenance: Optional[Mapping[str, Mapping[str, str]]] = None,
+        execution_broker_mode: Optional[str] = None,
     ):
         self.api_base = self._require_nonempty("api_base", api_base).rstrip("/")
         self.api_key = self._require_nonempty(
@@ -86,6 +88,14 @@ class AgentGuardClient:
             default=5.0,
         )
         self.user_agent = user_agent
+        broker_mode = str(
+            execution_broker_mode
+            if execution_broker_mode is not None
+            else os.getenv("AGENTICDOME_EXECUTION_BROKER_MODE", "off")
+        ).strip().lower()
+        if broker_mode not in {"off", "observe", "enforce"}:
+            raise ValueError("execution_broker_mode must be off, observe, or enforce")
+        self.execution_broker_mode = broker_mode
         self._tool_provenance: Dict[str, Dict[str, str]] = {}
         for registered_name, provenance in dict(tool_provenance or {}).items():
             self.register_tool_provenance(
@@ -528,12 +538,23 @@ class AgentGuardClient:
         actual_role: Optional[str] = None,
         source_agent_role: Optional[str] = None,
         target_agent_role: Optional[str] = None,
+        actor_chain: Optional[List[Dict[str, Any]]] = None,
+        scopes: Optional[List[str]] = None,
+        permissions: Optional[List[str]] = None,
+        parent_jti: Optional[str] = None,
+        root_jti: Optional[str] = None,
+        policy_id: Optional[str] = None,
+        policy_version: Optional[str] = None,
+        policy_hash: Optional[str] = None,
+        proof_thumbprint: Optional[str] = None,
         redact_pii: Optional[bool] = None,
         redact_secrets: Optional[bool] = None,
         block_on_sensitive_output: Optional[bool] = None,
         trusted_destination_domains: Optional[List[str]] = None,
         allowed_destination_domains: Optional[List[str]] = None,
         attachments: Optional[List[str]] = None,
+        execution_broker: Optional[bool] = None,
+        execution_boundary_id: Optional[str] = None,
         tenant_id: Optional[Union[str, int]] = None,
     ) -> Dict[str, Any]:
         """
@@ -596,6 +617,15 @@ class AgentGuardClient:
             actual_role=actual_role,
             source_agent_role=source_agent_role,
             target_agent_role=target_agent_role,
+            actor_chain=actor_chain,
+            scopes=scopes,
+            permissions=permissions,
+            parent_jti=parent_jti,
+            root_jti=root_jti,
+            policy_id=policy_id,
+            policy_version=policy_version,
+            policy_hash=policy_hash,
+            proof_thumbprint=proof_thumbprint,
             redact_pii=redact_pii,
             redact_secrets=redact_secrets,
             block_on_sensitive_output=block_on_sensitive_output,
@@ -628,6 +658,15 @@ class AgentGuardClient:
                 "actual_role": actual_role,
                 "source_agent_role": source_agent_role,
                 "target_agent_role": target_agent_role,
+                "actor_chain": actor_chain,
+                "scopes": scopes,
+                "permissions": permissions,
+                "parent_jti": parent_jti,
+                "root_jti": root_jti,
+                "policy_id": policy_id,
+                "policy_version": policy_version,
+                "policy_hash": policy_hash,
+                "proof_thumbprint": proof_thumbprint,
                 "redact_pii": redact_pii,
                 "redact_secrets": redact_secrets,
                 "block_on_sensitive_output": block_on_sensitive_output,
@@ -637,12 +676,33 @@ class AgentGuardClient:
             }
         )
 
-        return self._request(
-            "POST",
-            "/tools/guardrail/validate",
-            json_body=payload,
-            tenant_id=tenant_id,
+        broker_enabled = bool(
+            tool_name
+            and (self.execution_broker_mode in {"observe", "enforce"} or execution_broker is True)
         )
+        if broker_enabled:
+            boundary_id = self._normalize_optional_string(execution_boundary_id)
+            if boundary_id is None:
+                material = "|".join([
+                    str(platform or "unknown"),
+                    str(agent_id),
+                    str(tool_name),
+                    str(session_id or "stateless"),
+                ])
+                boundary_id = "sdk:" + hashlib.sha256(material.encode("utf-8")).hexdigest()[:32]
+            payload["boundary_id"] = boundary_id
+
+        path = "/tools/execution/authorize" if broker_enabled else "/tools/guardrail/validate"
+        response = self._request("POST", path, json_body=payload, tenant_id=tenant_id)
+        if broker_enabled:
+            broker = response.get("broker") if isinstance(response.get("broker"), dict) else {}
+            verified = bool(broker.get("verified")) and bool(broker.get("token_consumed"))
+            must_enforce = self.execution_broker_mode == "enforce" or execution_broker is True
+            if must_enforce and not verified:
+                raise AgentGuardError(
+                    "AgenticDome execution broker did not return a verified, atomically consumed decision"
+                )
+        return response
 
     # Backward compatibility alias
     def guardrail_check(
@@ -661,6 +721,13 @@ class AgentGuardClient:
             policy_context=policy_context,
         )
 
+    def get_tool_provenance_status(
+        self,
+        tenant_id: Optional[Union[str, int]] = None,
+    ) -> Dict[str, Any]:
+        """Return the tenant's signed provenance cache readiness and tool count."""
+        return self._request("GET", "/tools/provenance/status", tenant_id=tenant_id)
+
     # ------------------------------------------------------------------
     # Mesh
     # ------------------------------------------------------------------
@@ -1340,6 +1407,41 @@ class AgentGuardClient:
             }
         )
 
+        # In broker mode the official MCP adapter uses the same one-request
+        # execution boundary as REST. This preserves immediate decision
+        # consumption without adding a second network round trip.
+        if tool_name and self.execution_broker_mode in {"observe", "enforce"}:
+            return self.guardrail_validate(
+                text=text,
+                agent_id=agent_id,
+                platform=platform,
+                source_platform=source_platform,
+                tool_platform=tool_platform,
+                tool_name=tool_name,
+                tool_args=tool_args,
+                tool_version=tool_version,
+                tool_digest=tool_digest,
+                policy_context=policy_context,
+                direction=direction,
+                source_agent_id=source_agent_id,
+                user_id=user_id,
+                reasoning_trace=reasoning_trace,
+                request_purpose=request_purpose,
+                purpose=purpose,
+                intent=intent,
+                claimed_role=claimed_role,
+                actual_role=actual_role,
+                source_agent_role=source_agent_role,
+                target_agent_role=target_agent_role,
+                redact_pii=redact_pii,
+                redact_secrets=redact_secrets,
+                block_on_sensitive_output=block_on_sensitive_output,
+                trusted_destination_domains=trusted_destination_domains,
+                allowed_destination_domains=allowed_destination_domains,
+                execution_broker=True,
+                tenant_id=tenant_id,
+            )
+
         return self.mcp_tool_call(
             "guardrail.validate",
             arguments,

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "agenticdome-python-sdk"
-version = "1.2.7"
+version = "1.2.8"
 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.8/tests/test_execution_broker.py

@@ -0,0 +1,75 @@
+from agenticdome_sdk.client import AgentGuardClient, AgentGuardError
+
+
+def _client(mode="enforce"):
+    return AgentGuardClient(
+        "https://sidecar.example",
+        api_key="test-key",
+        tenant_id="tenant-1",
+        execution_broker_mode=mode,
+        max_retries=0,
+    )
+
+
+def test_tool_authorization_uses_one_request_broker_and_requires_receipt(monkeypatch):
+    client = _client()
+    observed = {}
+
+    def request(method, path, **kwargs):
+        observed.update({"method": method, "path": path, **kwargs})
+        return {"verdict": "ALLOWED", "broker": {"verified": True, "token_consumed": True}}
+
+    monkeypatch.setattr(client, "_request", request)
+    response = client.guardrail_validate(
+        text="lookup customer",
+        agent_id="support-agent",
+        platform="custom_python",
+        source_agent_id="support-manager",
+        source_platform="microsoft",
+        tool_name="crm.lookup",
+        tool_args={"id": "123"},
+        actor_chain=[
+            {"id": "support-manager", "framework": "microsoft"},
+            {"id": "support-agent", "framework": "custom_python"},
+        ],
+        scopes=["crm.customer.read"],
+        permissions=["case.status.read"],
+        parent_jti="parent-decision",
+        root_jti="root-decision",
+        policy_id="support-policy",
+        policy_version="3",
+        policy_hash="sha256:" + "a" * 64,
+        proof_thumbprint="proof-thumbprint",
+    )
+
+    assert response["verdict"] == "ALLOWED"
+    assert observed["path"] == "/tools/execution/authorize"
+    assert observed["json_body"]["boundary_id"].startswith("sdk:")
+    assert observed["json_body"]["actor_chain"][1]["id"] == "support-agent"
+    assert observed["json_body"]["scopes"] == ["crm.customer.read"]
+    assert observed["json_body"]["permissions"] == ["case.status.read"]
+    assert observed["json_body"]["parent_jti"] == "parent-decision"
+    assert observed["json_body"]["root_jti"] == "root-decision"
+    assert observed["json_body"]["policy_id"] == "support-policy"
+    assert observed["json_body"]["policy_version"] == "3"
+    assert observed["json_body"]["policy_hash"] == "sha256:" + "a" * 64
+    assert observed["json_body"]["proof_thumbprint"] == "proof-thumbprint"
+    assert observed["json_body"]["policy_context"]["actor_chain"][0]["id"] == "support-manager"
+
+
+def test_enforced_broker_fails_closed_without_consumed_receipt(monkeypatch):
+    client = _client()
+    monkeypatch.setattr(client, "_request", lambda *args, **kwargs: {"verdict": "ALLOWED"})
+
+    try:
+        client.guardrail_validate(
+            text="lookup customer",
+            agent_id="support-agent",
+            platform="custom_python",
+            tool_name="crm.lookup",
+            tool_args={"id": "123"},
+        )
+    except AgentGuardError as exc:
+        assert "atomically consumed" in str(exc)
+    else:
+        raise AssertionError("missing broker receipt did not fail closed")