Metadata-Version: 2.4
Name: agentguard-python-sdk
Version: 0.2.5
Summary: A production-grade middleware for AI agents to perform on-chain payments and verifiable consent.
Author: AgentGuard Team
License-Expression: MIT
Requires-Python: >=3.9
Description-Content-Type: text/markdown
License-File: LICENSE
Requires-Dist: httpx>=0.27.0
Requires-Dist: pydantic>=2.0.0
Requires-Dist: pydantic-settings>=2.0.0
Requires-Dist: pynacl>=1.5.0
Requires-Dist: py-algorand-sdk>=2.0.0
Dynamic: license-file

# 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-python-sdk
```

## Quick Start (3-Line Usage)

```python
import asyncio
from agentguard import AgentGuardClient
from agentguard.types import DelegatedAuthorization, AuthorizationConstraints, NonceContext, AuthorizationMetadata

async def main():
    # 1. Initialize the client
    # NOTE: The backend requires a cryptographic signature on `/pay`.
    # Provide `private_key` as a base64-encoded Algorand private key seed for request signing.
    async with AgentGuardClient(
        wallet_address="YOUR_WALLET_ADDRESS",
        private_key="YOUR_PRIVATE_KEY_B64",
        backend_url="https://agentguard-backend-9s8j.onrender.com"
    ) as client:
        
        # 1.5 Authorize a capability (LogicSig)
        auth = DelegatedAuthorization(
            authorization_id="YOUR_AUTHORIZATION_ID",
            principal_id="YOUR_WALLET_ADDRESS",
            logic_sig_b64="YOUR_SIGNED_LOGICSIG_BASE64",
            constraints=AuthorizationConstraints(
                max_amount_microalgos=1000000,
                expires_at_unix=1900000000,
                max_txns_per_window=10,
                window_seconds=3600
            ),
            nonce_context=NonceContext(lease_strategy="deterministic", scope="session"),
            metadata=AuthorizationMetadata(created_at=1716000000, sdk_version="0.2.2", delegation_type="LogicSig")
        )
        await client.authorize(auth)
        
        # 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",
            authorization_id="YOUR_AUTHORIZATION_ID"
        )
        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.
