veritera 0.1.0__tar.gz

veritera-0.1.0/PKG-INFO

@@ -0,0 +1,14 @@
+Metadata-Version: 2.4
+Name: veritera
+Version: 0.1.0
+Summary: Veritera Forge SDK — Verify AI agent decisions with cryptographic attestation
+Author-email: Veritera AI <engineering@veritera.ai>
+License: MIT
+Project-URL: Homepage, https://veritera.ai
+Project-URL: Documentation, https://veritera.ai/docs
+Project-URL: Repository, https://github.com/VeriteraAI/veritera-website
+Keywords: veritera,forge,ai,verification,agent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: httpx>=0.25.0
+Requires-Dist: cryptography>=41.0.0

veritera-0.1.0/pyproject.toml

@@ -0,0 +1,22 @@
+[project]
+name = "veritera"
+version = "0.1.0"
+description = "Veritera Forge SDK — Verify AI agent decisions with cryptographic attestation"
+readme = "README.md"
+license = {text = "MIT"}
+requires-python = ">=3.9"
+authors = [{name = "Veritera AI", email = "engineering@veritera.ai"}]
+keywords = ["veritera", "forge", "ai", "verification", "agent"]
+dependencies = [
+    "httpx>=0.25.0",
+    "cryptography>=41.0.0",
+]
+
+[project.urls]
+Homepage = "https://veritera.ai"
+Documentation = "https://veritera.ai/docs"
+Repository = "https://github.com/VeriteraAI/veritera-website"
+
+[build-system]
+requires = ["setuptools>=68.0"]
+build-backend = "setuptools.build_meta"

veritera-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

veritera-0.1.0/veritera/__init__.py

@@ -0,0 +1,6 @@
+"""Veritera Forge SDK — Verify AI agent decisions with cryptographic attestation."""
+
+from .client import Veritera, ForgeError, RateLimitError
+
+__version__ = "0.1.0"
+__all__ = ["Veritera", "ForgeError", "RateLimitError"]

veritera-0.1.0/veritera/client.py

@@ -0,0 +1,286 @@
+"""
+Veritera Forge SDK — Python Client
+Enterprise-grade AI agent decision verification.
+
+Usage:
+    from veritera import Veritera
+
+    forge = Veritera(api_key="vt_live_...")
+    result = await forge.verify_decision(
+        agent_id="agent-1",
+        action="payment.create",
+        params={"amount": 100, "currency": "USD"},
+        policy="finance-controls",
+    )
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import time
+from dataclasses import dataclass, field
+from typing import Any, Optional
+
+import httpx
+from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PublicKey
+from cryptography.hazmat.primitives.serialization import load_der_public_key
+import base64
+
+
+class ForgeError(Exception):
+    """Structured error from the Forge API."""
+
+    def __init__(self, message: str, code: str = "unknown", status: int = 0, details: Any = None):
+        super().__init__(message)
+        self.code = code
+        self.status = status
+        self.details = details
+
+
+class RateLimitError(ForgeError):
+    """Rate limit exceeded."""
+
+    def __init__(self, message: str, retry_after_ms: int = 60000):
+        super().__init__(message, code="rate_limited", status=429)
+        self.retry_after_ms = retry_after_ms
+
+
+@dataclass
+class ConstraintResult:
+    type: str
+    result: str  # "pass" | "fail" | "skip"
+    detail: Optional[str] = None
+
+
+@dataclass
+class VerifyResponse:
+    verified: bool
+    verdict: str
+    proof_id: str
+    agent_id: str
+    action: str
+    policy: Optional[str]
+    reason: Optional[str]
+    mode: str
+    proof_status: str
+    evaluated_constraints: list[ConstraintResult]
+    verification: dict[str, Any]
+    audit_id: str
+    latency_ms: float
+    timestamp: str
+
+
+@dataclass
+class LocalVerifyResult:
+    valid: bool
+    key_version: Optional[int]
+    payload_hash: str
+    algorithm: str = "Ed25519"
+
+
+class Veritera:
+    """Veritera Forge SDK Client."""
+
+    def __init__(
+        self,
+        api_key: str,
+        base_url: str = "https://api.veritera.ai",
+        timeout: float = 10.0,
+        max_retries: int = 2,
+        debug: bool = False,
+    ):
+        if not api_key:
+            raise ValueError("Forge SDK: api_key is required")
+        self._api_key = api_key
+        self._base_url = base_url.rstrip("/")
+        self._timeout = timeout
+        self._max_retries = max_retries
+        self._debug = debug
+        import os
+        _env = os.environ.get("PYTHON_ENV", os.environ.get("ENV", "production"))
+        self._client = httpx.AsyncClient(
+            base_url=self._base_url,
+            timeout=self._timeout,
+            headers={
+                "Authorization": f"Bearer {self._api_key}",
+                "Content-Type": "application/json",
+                "User-Agent": "veritera-python/0.1.0",
+                "X-Forge-SDK-Version": "0.1.0",
+                "X-Forge-Environment": _env,
+            },
+        )
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, *args):
+        await self.close()
+
+    async def close(self):
+        await self._client.aclose()
+
+    async def _request(self, method: str, path: str, body: Optional[dict] = None) -> dict:
+        """HTTP request with retry and backoff."""
+        last_error: Optional[Exception] = None
+
+        for attempt in range(self._max_retries + 1):
+            if attempt > 0:
+                delay = min(1.0 * (2 ** (attempt - 1)), 10.0)
+                if self._debug:
+                    print(f"[Forge SDK] Retry {attempt}/{self._max_retries} after {delay:.1f}s")
+                await _async_sleep(delay)
+
+            try:
+                response = await self._client.request(
+                    method, path,
+                    json=body if body else None,
+                )
+
+                if response.status_code == 429:
+                    retry_after = int(response.headers.get("Retry-After", "60")) * 1000
+                    raise RateLimitError("Rate limit exceeded", retry_after)
+
+                if 400 <= response.status_code < 500:
+                    data = response.json() if response.content else {}
+                    raise ForgeError(
+                        data.get("message", f"Request failed: {response.status_code}"),
+                        code=data.get("error", "client_error"),
+                        status=response.status_code,
+                        details=data,
+                    )
+
+                if response.status_code >= 500:
+                    last_error = ForgeError(f"Server error: {response.status_code}", status=response.status_code)
+                    continue
+
+                return response.json()
+
+            except (httpx.TimeoutException, httpx.ConnectError) as e:
+                last_error = ForgeError(str(e), code="network_error", status=0)
+                continue
+
+        raise last_error or ForgeError("Request failed after retries")
+
+    # ── Core: Verify a Decision ──
+
+    async def verify_decision(
+        self,
+        agent_id: str,
+        action: str,
+        params: Optional[dict[str, Any]] = None,
+        policy: Optional[str] = None,
+        allowed_actions: Optional[list[str]] = None,
+        delegation_id: Optional[str] = None,
+        require_zk_proof: bool = False,
+    ) -> VerifyResponse:
+        """Verify an AI agent decision against policy constraints."""
+        body: dict[str, Any] = {"agent_id": agent_id, "action": action}
+        if params:
+            body["params"] = params
+        if policy:
+            body["policy"] = policy
+        if allowed_actions:
+            body["allowed_actions"] = allowed_actions
+        if delegation_id:
+            body["delegation_id"] = delegation_id
+        if require_zk_proof:
+            body["require_zk_proof"] = True
+
+        raw = await self._request("POST", "/v1/verify", body)
+        return self._map_verify_response(raw)
+
+    # ── Proof Retrieval ──
+
+    async def get_proof(self, proof_id: str) -> dict:
+        """Retrieve a verification proof by ID."""
+        return await self._request("GET", f"/v1/proofs/{proof_id}")
+
+    # ── Local Proof Verification ──
+
+    def verify_proof_locally(
+        self,
+        attestation: str,
+        attestation_payload: dict[str, Any],
+        public_key: str,
+        key_version: Optional[int] = None,
+    ) -> LocalVerifyResult:
+        """Verify a DPE attestation locally without any backend call."""
+        payload_bytes = json.dumps(attestation_payload).encode("utf-8")
+        payload_hash = hashlib.sha256(payload_bytes).hexdigest()
+
+        try:
+            sig_bytes = base64.b64decode(attestation)
+            pub_key_der = base64.b64decode(public_key)
+            pub_key = load_der_public_key(pub_key_der)
+
+            if not isinstance(pub_key, Ed25519PublicKey):
+                return LocalVerifyResult(valid=False, key_version=key_version, payload_hash=payload_hash)
+
+            pub_key.verify(sig_bytes, payload_bytes)
+            return LocalVerifyResult(valid=True, key_version=key_version, payload_hash=payload_hash)
+
+        except Exception:
+            return LocalVerifyResult(valid=False, key_version=key_version, payload_hash=payload_hash)
+
+    # ── Delegation ──
+
+    async def create_delegation(
+        self,
+        agent_id: str,
+        allowed_actions: list[str],
+        constraints: Optional[dict] = None,
+        expires_in: Optional[str] = None,
+    ) -> dict:
+        """Create a scoped delegation for an agent."""
+        body: dict[str, Any] = {"agent_id": agent_id, "allowed_actions": allowed_actions}
+        if constraints:
+            body["constraints"] = constraints
+        if expires_in:
+            body["expires_in"] = expires_in
+        return await self._request("POST", "/v1/delegate", body)
+
+    # ── Usage ──
+
+    async def get_usage(self, period: Optional[str] = None) -> dict:
+        """Get usage statistics for the current billing period."""
+        path = f"/v1/usage?period={period}" if period else "/v1/usage"
+        return await self._request("GET", path)
+
+    # ── Health ──
+
+    async def health(self) -> dict:
+        """Check Forge API health."""
+        return await self._request("GET", "/v1/health")
+
+    # ── Response Mapping ──
+
+    def _map_verify_response(self, raw: dict) -> VerifyResponse:
+        verification = raw.get("verification", {})
+        constraints = raw.get("evaluated_constraints", [])
+
+        return VerifyResponse(
+            verified=bool(raw.get("verified")),
+            verdict=raw.get("verdict", "approved" if raw.get("verified") else "denied"),
+            proof_id=str(raw.get("proof_id", "")),
+            agent_id=str(raw.get("agent_id", "")),
+            action=str(raw.get("action", "")),
+            policy=raw.get("policy"),
+            reason=raw.get("reason"),
+            mode=raw.get("mode", "dpe"),
+            proof_status=raw.get("proof_status", "not_requested"),
+            evaluated_constraints=[
+                ConstraintResult(type=c.get("type", ""), result=c.get("result", "skip"), detail=c.get("detail"))
+                for c in constraints
+            ],
+            verification=verification,
+            audit_id=str(raw.get("audit_id", "")),
+            latency_ms=float(raw.get("latency_ms", 0)),
+            timestamp=str(raw.get("timestamp", "")),
+        )
+
+
+async def _async_sleep(seconds: float):
+    """Async sleep helper."""
+    import asyncio
+    await asyncio.sleep(seconds)

veritera-0.1.0/veritera.egg-info/PKG-INFO

@@ -0,0 +1,14 @@
+Metadata-Version: 2.4
+Name: veritera
+Version: 0.1.0
+Summary: Veritera Forge SDK — Verify AI agent decisions with cryptographic attestation
+Author-email: Veritera AI <engineering@veritera.ai>
+License: MIT
+Project-URL: Homepage, https://veritera.ai
+Project-URL: Documentation, https://veritera.ai/docs
+Project-URL: Repository, https://github.com/VeriteraAI/veritera-website
+Keywords: veritera,forge,ai,verification,agent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: httpx>=0.25.0
+Requires-Dist: cryptography>=41.0.0

veritera-0.1.0/veritera.egg-info/SOURCES.txt

@@ -0,0 +1,8 @@
+pyproject.toml
+veritera/__init__.py
+veritera/client.py
+veritera.egg-info/PKG-INFO
+veritera.egg-info/SOURCES.txt
+veritera.egg-info/dependency_links.txt
+veritera.egg-info/requires.txt
+veritera.egg-info/top_level.txt

veritera-0.1.0/veritera.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

veritera-0.1.0/veritera.egg-info/requires.txt

@@ -0,0 +1,2 @@
+httpx>=0.25.0
+cryptography>=41.0.0

veritera-0.1.0/veritera.egg-info/top_level.txt

@@ -0,0 +1 @@
+veritera