agentguard-python-sdk 0.1.0__py3-none-any.whl

agentguard/__init__.py

@@ -0,0 +1,3 @@
+from .client import AgentGuardClient
+
+__all__ = ["AgentGuardClient"]

agentguard/client.py

@@ -0,0 +1,126 @@
+import httpx
+import uuid
+import logging
+from typing import Optional, Dict, Any
+from .consent import generate_consent_proof
+from .types import AgentGuardReceipt, AuditProof
+
+logger = logging.getLogger("agentguard-sdk")
+
+class AgentGuardClient:
+    def __init__(self, wallet_address: str, base_url: str = "https://agentguard-backend.onrender.com"):
+        """
+        Initialize the AgentGuard production client.
+        
+        Args:
+            wallet_address: The user's wallet address (Principal ID).
+            base_url: The URL of the AgentGuard Backend.
+        """
+        self.wallet_address = wallet_address
+        self.base_url = base_url.rstrip("/")
+        self.async_client = httpx.AsyncClient(timeout=30.0)
+
+    async def pay_and_fetch(
+        self, 
+        resource_url: str, 
+        amount_algo: float, 
+        purpose: str
+    ) -> AgentGuardReceipt:
+        """
+        Asynchronously perform an on-chain payment and return a typed receipt.
+        
+        Args:
+            resource_url: The URL/ID of the resource being accessed.
+            amount_algo: The amount to pay in ALGO.
+            purpose: The purpose of the data processing.
+            
+        Returns:
+            AgentGuardReceipt: A structured receipt with transaction details.
+        """
+        # 1. Generate Nonce for replay protection
+        nonce = str(uuid.uuid4())
+        
+        # 2. Generate Consent Proof (SHA256 of metadata)
+        consent_hash, timestamp = generate_consent_proof(
+            principal_id=self.wallet_address,
+            resource_url=resource_url,
+            purpose=purpose,
+            nonce=nonce
+        )
+        
+        # 3. Request Payment via Backend Proxy
+        payload = {
+            "resource_url": resource_url,
+            "amount_algo": amount_algo,
+            "purpose": purpose,
+            "principal_id": self.wallet_address,
+            "consent_hash": consent_hash,
+            "nonce": nonce,
+            "timestamp": timestamp
+        }
+        
+        try:
+            response = await self.async_client.post(f"{self.base_url}/pay", json=payload)
+            response.raise_for_status()
+            res_data = response.json()
+            
+            return AgentGuardReceipt(
+                tx_id=res_data["tx_id"],
+                consent_hash=res_data["consent_hash"],
+                audit_url=res_data["audit_url"],
+                data=res_data.get("data", {})
+            )
+        except httpx.HTTPStatusError as e:
+            logger.error(f"Payment failed: {e.response.text}")
+            raise Exception(f"Payment failed: {e.response.text}")
+        except Exception as e:
+            logger.error(f"Connection failed: {e}")
+            raise Exception(f"Could not connect to AgentGuard Backend: {e}")
+
+    async def verify(self, tx_id: str) -> AuditProof:
+        """
+        Asynchronously verify a transaction against the blockchain audit trail.
+        """
+        try:
+            response = await self.async_client.get(f"{self.base_url}/verify/{tx_id}")
+            response.raise_for_status()
+            res_data = response.json()
+            
+            return AuditProof(
+                verified=res_data["verified"],
+                tx_id=res_data["tx_id"],
+                principal_id=res_data["principal_id"],
+                consent_hash=res_data["consent_hash"],
+                on_chain_hash=res_data["on_chain_hash"],
+                explorer_url=res_data["explorer_url"],
+                message=res_data["message"]
+            )
+        except Exception as e:
+            logger.error(f"Verification failed: {e}")
+            raise Exception(f"Verification failed: {e}")
+
+    async def register_budget(self, limit_algo: float) -> Dict[str, Any]:
+        """
+        Convenience method to register/update the user's budget.
+        """
+        payload = {
+            "wallet_address": self.wallet_address,
+            "budget_algo": limit_algo
+        }
+        try:
+            response = await self.async_client.post(f"{self.base_url}/user/register", json=payload)
+            response.raise_for_status()
+            return response.json()
+        except Exception as e:
+            logger.error(f"Budget registration failed: {e}")
+            raise Exception(f"Budget registration failed: {e}")
+
+    async def close(self):
+        """Close the underlying HTTP client."""
+        await self.async_client.aclose()
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        await self.close()

agentguard/consent.py

@@ -0,0 +1,58 @@
+import time
+import json
+import hashlib
+import logging
+from typing import Dict, Any
+
+# Configure logging
+logger = logging.getLogger("agentguard-sdk")
+
+def generate_consent(principal_id: str, purpose: str, item: str, nonce: str, data_fiduciary: str = "AgentGuard Platform") -> Dict[str, Any]:
+    """
+    Creates a user consent object dictionary containing DPDP compliant fields.
+    """
+    timestamp = int(time.time())
+    
+    consent_obj = {
+        "principal_id": principal_id,
+        "data_fiduciary": data_fiduciary,
+        "purpose": purpose,
+        "item": item,
+        "timestamp": timestamp,
+        "nonce": nonce
+    }
+    
+    logger.info(f"Generated DPDP consent for principal={principal_id} at {timestamp}")
+    return consent_obj
+
+def hash_consent(consent: Dict[str, Any]) -> str:
+    """
+    Converts a consent dictionary into a sorted JSON string
+    and generates a SHA256 hash of it for on-chain logging.
+    
+    Args:
+        consent: The consent dictionary.
+        
+    Returns:
+        str: SHA256 hash string.
+    """
+    # Convert consent dict to JSON string with sorted keys to ensure determinism
+    consent_json = json.dumps(consent, sort_keys=True)
+    
+    # Generate SHA256 hash
+    consent_hash = hashlib.sha256(consent_json.encode("utf-8")).hexdigest()
+    
+    logger.info(f"Consent hash generated: {consent_hash}")
+    return consent_hash
+
+def generate_consent_proof(principal_id: str, resource_url: str, purpose: str, nonce: str) -> tuple[str, int]:
+    """
+    High-level helper to generate a consent hash and return the timestamp used.
+    """
+    consent = generate_consent(
+        principal_id=principal_id,
+        purpose=purpose,
+        item=resource_url,
+        nonce=nonce
+    )
+    return hash_consent(consent), consent["timestamp"]

agentguard/types.py

@@ -0,0 +1,25 @@
+from dataclasses import dataclass, field
+from typing import Dict, Any
+
+@dataclass
+class AgentGuardReceipt:
+    """
+    Structured response for a successful AgentGuard payment.
+    """
+    tx_id: str
+    consent_hash: str
+    audit_url: str
+    data: Dict[str, Any] = field(default_factory=dict)
+
+@dataclass
+class AuditProof:
+    """
+    Structured response for a DPDP compliance audit.
+    """
+    verified: bool
+    tx_id: str
+    principal_id: str
+    consent_hash: str
+    on_chain_hash: str
+    explorer_url: str
+    message: str

agentguard_python_sdk-0.1.0.dist-info/METADATA

@@ -0,0 +1,65 @@
+Metadata-Version: 2.4
+Name: agentguard-python-sdk
+Version: 0.1.0
+Summary: A production-grade middleware for AI agents to perform on-chain payments and verifiable consent.
+Author: AgentGuard Team
+License: MIT
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: pydantic>=2.0.0
+
+# AgentGuard SDK
+
+AgentGuard is a production-grade middleware that enables AI agents to perform on-chain payments and generate verifiable consent proofs in compliance with DPDP (Digital Personal Data Protection) standards.
+
+By isolating private keys in a hardened **MCP Server (Vault)** and using the **AgentGuard Backend (Dispatcher)** as a secure proxy, the SDK allows developers to add monetization and compliance to their agents with zero blockchain complexity.
+
+## Installation
+
+```bash
+pip install agentguard
+```
+
+## Quick Start (3-Line Usage)
+
+```python
+import asyncio
+from agentguard import AgentGuardClient
+
+async def main():
+    # 1. Initialize the client
+    async with AgentGuardClient(wallet_address="YOUR_WALLET_ADDRESS") as client:
+        
+        # 2. Perform a secure payment (includes automatic DPDP consent hashing)
+        receipt = await client.pay_and_fetch(
+            resource_url="https://api.stock.com/reliance",
+            amount_algo=0.05,
+            purpose="Financial Analysis"
+        )
+        print(f"Payment Successful! TX ID: {receipt.tx_id}")
+
+        # 3. Verify compliance audit trail
+        proof = await client.verify(receipt.tx_id)
+        print(f"On-Chain Verified: {proof.verified}")
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+## Architecture
+
+1.  **SDK**: Generates UUID nonces and SHA256 consent hashes.
+2.  **Backend**: Proxies requests to the internal vault and maintains audit records.
+3.  **MCP Server (Vault)**: A hardened, isolated environment that signs transactions using Algorand.
+4.  **Algorand Blockchain**: Provides the irrefutable proof-of-consent and payment settlement.
+
+## Features
+
+- **Async First**: Built on `httpx` for high-performance agentic loops.
+- **Zero-Trust**: Private keys never leave the vault.
+- **DPDP Compliant**: Automatic cryptographic logging of purpose-bound consent.
+- **Simple Audit**: Direct links to blockchain explorers for every transaction.
+
+---
+© 2026 AgentGuard Team. Built for the Algorand Ecosystem.

agentguard_python_sdk-0.1.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+agentguard/__init__.py,sha256=P8UrlV5qCw8DCFwGmAunbItyBncuDH7UK7HzsqYMxBk,69
+agentguard/client.py,sha256=8rvSOzfrtjKNy5PibBbikX9Sm-_-OnW4OXxrFWUGRUM,4550
+agentguard/consent.py,sha256=RDefJwimc9MM14fbRrM9740yMHate7IIyJElkDoPPHE,1846
+agentguard/types.py,sha256=lJCLHl-DYYV6wDETIhj7NbE548YviUXgMp6svH5nM60,534
+agentguard_python_sdk-0.1.0.dist-info/METADATA,sha256=I67rw1MY1cM2EjF3eO48ij2lu6GVmmi8y2TEkXov2j4,2410
+agentguard_python_sdk-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+agentguard_python_sdk-0.1.0.dist-info/top_level.txt,sha256=rEW5sAnjxXRs63ja2psmsMRMJJfi_3EAxf7crl1nHyw,11
+agentguard_python_sdk-0.1.0.dist-info/RECORD,,

agentguard_python_sdk-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

agentguard_python_sdk-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+agentguard