agentseal-gateframe 1.0.0__tar.gz

agentseal_gateframe-1.0.0/PKG-INFO

@@ -0,0 +1,25 @@
+Metadata-Version: 2.4
+Name: agentseal-gateframe
+Version: 1.0.0
+Summary: GateFrame AgentSeal — Cryptographic evidence receipts for AI agent decisions
+Home-page: https://gateframe-api.netlify.app
+Author: Shankar Anand
+Author-email: shankar@gateframe.io
+Requires-Python: >=3.9
+Requires-Dist: requests>=2.28
+Provides-Extra: langchain
+Requires-Dist: langchain-core>=0.1; extra == "langchain"
+Provides-Extra: autogen
+Requires-Dist: autogen-agentchat>=0.4; extra == "autogen"
+Provides-Extra: crewai
+Requires-Dist: crewai>=0.28; extra == "crewai"
+Dynamic: author
+Dynamic: author-email
+Dynamic: description
+Dynamic: home-page
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+Ed25519 + SHA-256 Merkle chain. EU AI Act Art. 12. ECOA Reg B. DIFC Reg 10. Patent Pending USPTO 64/067,547.

agentseal_gateframe-1.0.0/agentseal/__init__.py

@@ -0,0 +1,43 @@
+"""
+AgentSeal by GateFrame
+Cryptographic evidence receipts for regulated AI agents.
+One line of code. Any framework. Any jurisdiction.
+
+"Logs tell you what happened. GateFrame proves what AI did."
+
+Quickstart:
+    from agentseal import GateFrameClient
+
+    client = GateFrameClient(
+        api_key="sk-ant-...",
+        agent_id="loan-underwriter-v3",
+        regulatory_framework="ECOA",
+    )
+    chain = client.start_session(session_id="APP-2026-90412")
+
+    response = client.messages_create(
+        model="claude-opus-4-5",
+        messages=[{"role": "user", "content": "Evaluate this application..."}],
+        max_tokens=1024,
+    )
+
+    evidence = client.get_evidence()
+    verification = client.verify()
+    # {"valid": True, "total_records": 3}
+"""
+
+from .schema import AgentAction
+from .chain import EvidenceChain
+from .wrapper import GateFrameClient
+from .policies import SEED_POLICIES, PolicyEngine, CompliancePolicy
+
+__version__ = "0.1.0"
+__author__ = "Shankar Anand <shankar@gateframe.io>"
+__all__ = [
+    "AgentAction",
+    "EvidenceChain",
+    "GateFrameClient",
+    "SEED_POLICIES",
+    "PolicyEngine",
+    "CompliancePolicy",
+]

agentseal_gateframe-1.0.0/agentseal/chain.py

@@ -0,0 +1,194 @@
+"""
+agentseal/chain.py
+EvidenceChain — append-only, hash-linked sequence of AgentActions.
+A single bit-flip anywhere breaks verify_chain().
+This is the artifact regulators verify.
+"""
+
+from dataclasses import asdict
+from datetime import datetime, timezone
+from typing import Optional, List
+import json
+import uuid
+
+from .schema import AgentAction
+
+
+class EvidenceChain:
+    """
+    Append-only, hash-linked chain of AgentActions.
+
+    Each record's prev_hash points to the previous record's record_hash.
+    The chain is tamper-evident: any modification anywhere invalidates
+    all subsequent links and is detected by verify_chain().
+
+    Usage:
+        chain = EvidenceChain(chain_id="APP-2026-90412", agent_id="underwriter-v3")
+        action = chain.record(
+            action_type="CREDIT_DENIAL",
+            action_payload={"dti": 0.48, "utilization": 0.82},
+            outcome={"decision": "denied"},
+            regulatory_context={"framework": "ECOA", "evidence_format": "CFPB_MODEL_C1"}
+        )
+        result = chain.verify_chain()
+        # {"valid": True, "total_records": 1, "broken_at": None}
+    """
+
+    SCHEMA_VERSION = "gateframe-agentseal-v1"
+
+    def __init__(self, chain_id: Optional[str] = None, agent_id: str = ""):
+        self.chain_id: str = chain_id or str(uuid.uuid4())
+        self.agent_id: str = agent_id
+        self.records: List[AgentAction] = []
+        self.created_at: str = datetime.now(timezone.utc).isoformat()
+        self._session_metadata: dict = {}
+
+    # ── Core API ──────────────────────────────────────────────────────────────
+
+    def record(
+        self,
+        action_type: str,
+        action_payload: dict,
+        outcome: dict,
+        regulatory_context: Optional[dict] = None,
+        reasoning: Optional[list] = None,
+        agent_version: str = "",
+        authorized_by: str = "",
+        authorized_at: str = "",
+        operator_id: str = "",
+        operator_name: str = "",
+        institution_id: str = "",
+        institution_name: str = "",
+        delegation_present: bool = False,
+        decision_confidence: float = 0.0,
+        input_hash: Optional[str] = None,
+    ) -> AgentAction:
+        """
+        Append a new evidence record to the chain.
+        Automatically sets prev_hash to link it to the previous record.
+        Calls .seal() to compute and store record_hash before appending.
+        Returns the sealed AgentAction.
+        """
+        prev_hash = self.records[-1].record_hash if self.records else None
+
+        action = AgentAction(
+            agent_id=self.agent_id,
+            agent_version=agent_version,
+            action_type=action_type,
+            action_payload=action_payload,
+            outcome=outcome,
+            decision_confidence=decision_confidence,
+            authorized_by=authorized_by,
+            authorized_at=authorized_at,
+            operator_id=operator_id,
+            operator_name=operator_name,
+            institution_id=institution_id,
+            institution_name=institution_name,
+            delegation_present=delegation_present,
+            regulatory_context=regulatory_context or {
+                "framework": "DORA",
+                "specific_articles": ["Article 8(1)"],
+                "evidence_format": "DORA_ICT",
+                "policy_version": "",
+            },
+            reasoning=reasoning or [],
+            prev_hash=prev_hash,
+            input_hash=input_hash,
+        ).seal()
+
+        self.records.append(action)
+        return action
+
+    def set_metadata(self, **kwargs) -> None:
+        """Attach arbitrary session-level metadata (not part of the hash chain)."""
+        self._session_metadata.update(kwargs)
+
+    # ── Verification ──────────────────────────────────────────────────────────
+
+    def verify_chain(self) -> dict:
+        """
+        Verify the integrity of every record and every link in the chain.
+
+        Returns:
+            {
+                "valid": bool,
+                "total_records": int,
+                "broken_at": int | None,   # index of first broken record
+                "reason": str | None,
+            }
+
+        A regulator calls this. Green means the evidence is admissible.
+        Red means something was modified after signing.
+        """
+        for i, record in enumerate(self.records):
+            # 1. Verify record self-integrity
+            if not record.verify():
+                return {
+                    "valid": False,
+                    "total_records": len(self.records),
+                    "broken_at": i,
+                    "reason": "record_hash_mismatch",
+                    "action_id": record.action_id,
+                }
+            # 2. Verify chain link
+            if i > 0:
+                expected_prev = self.records[i - 1].record_hash
+                if record.prev_hash != expected_prev:
+                    return {
+                        "valid": False,
+                        "total_records": len(self.records),
+                        "broken_at": i,
+                        "reason": "chain_link_broken",
+                        "action_id": record.action_id,
+                    }
+
+        return {
+            "valid": True,
+            "total_records": len(self.records),
+            "broken_at": None,
+            "reason": None,
+        }
+
+    # ── Export ────────────────────────────────────────────────────────────────
+
+    def export_for_regulator(self) -> dict:
+        """
+        Full examiner-ready export.
+        This is what you hand to a regulator, an auditor, or a law firm.
+        """
+        return {
+            "schema_version": self.SCHEMA_VERSION,
+            "chain_id": self.chain_id,
+            "agent_id": self.agent_id,
+            "created_at": self.created_at,
+            "exported_at": datetime.now(timezone.utc).isoformat(),
+            "chain_integrity": self.verify_chain(),
+            "record_count": len(self.records),
+            "regulatory_coverage": self._coverage_summary(),
+            "session_metadata": self._session_metadata,
+            "records": [asdict(r) for r in self.records],
+        }
+
+    def export_json(self, indent: int = 2) -> str:
+        return json.dumps(self.export_for_regulator(), indent=indent, default=str)
+
+    def _coverage_summary(self) -> dict:
+        """Count records grouped by regulatory framework."""
+        frameworks: dict = {}
+        for r in self.records:
+            fw = r.regulatory_context.get("framework", "UNKNOWN")
+            frameworks[fw] = frameworks.get(fw, 0) + 1
+        return frameworks
+
+    # ── Convenience ───────────────────────────────────────────────────────────
+
+    def __len__(self) -> int:
+        return len(self.records)
+
+    def __repr__(self) -> str:
+        integrity = self.verify_chain()
+        return (
+            f"EvidenceChain(chain_id={self.chain_id!r}, "
+            f"records={len(self.records)}, "
+            f"valid={integrity['valid']})"
+        )