auctra 0.2.3__tar.gz

auctra-0.2.3/PKG-INFO

@@ -0,0 +1,86 @@
+Metadata-Version: 2.4
+Name: auctra
+Version: 0.2.3
+Summary: Authority Protocol Python client — issue authority, execute actions, verify evidence
+License: MIT
+Project-URL: Homepage, https://auctra.tech/docs
+Keywords: auctra,ai-agents,authority,delegation
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# auctra (Python SDK)
+
+Stage 0/1 Python client — same Authority Protocol as `@auctra/sdk`.
+
+```bash
+pip install auctra  # when published; local: pip install -e packages/python-sdk
+```
+
+## Quick start (with intent anchor)
+
+High-risk actions require **`create_intent`** first, then pass the returned **`intent`** (id + `anchor_token`) on execute:
+
+```python
+from auctra import Auctra
+
+client = Auctra(api_key="auctra_...", base_url="https://app.auctra.tech")
+
+agent_id = "your-agent-uuid"
+expires_at = "2027-01-01T00:00:00Z"
+
+client.authority.issue(
+    subject=agent_id,
+    capabilities=["send_payment"],
+    expires_at=expires_at,
+    max_amount=500,
+    currency="USD",
+)
+
+created = client.create_intent(
+    title="Pay matched vendor invoices",
+    intent_type="payment",
+    risk_level="high",
+    max_risk_level="critical",
+    allowed_action_types=["send_payment"],
+    expires_at=expires_at,
+)
+intent = created["intent"]
+
+preview = client.action.evaluate(
+    agent_id=agent_id,
+    action_type="send_payment",
+    payload={"amount": 50, "currency": "USD"},
+    intent=intent,
+)
+
+decision = client.action.execute(
+    agent_id=agent_id,
+    action_type="send_payment",
+    payload={"amount": 50, "currency": "USD", "target": "vendor:acme"},
+    intent=intent,
+    action={
+        "target": "vendor:acme",
+        "description": "Net-30 invoice payment",
+        "risk_level": "medium",
+    },
+)
+
+print(decision["decision"])
+client.evidence.verify(payload=decision["evidence_payload"], evidence=decision["evidence"])
+```
+
+### New-client gotcha
+
+Sending only `claimed_intent_id` (without `intent_anchor_token` or the `intent` object) returns **`require_approval`** with a reason about the missing anchor. Pass `intent=` from `create_intent`, or set both `claimed_intent_id` and `intent_anchor_token` explicitly.
+
+See [`docs/integrations/intent-anchors.md`](../../docs/integrations/intent-anchors.md).
+
+## Public surface
+
+```text
+client.create_intent
+client.authority.issue | verify | delegate | revoke
+client.action.evaluate | execute
+client.get_action_request
+client.evidence.verify
+```

auctra-0.2.3/README.md

@@ -0,0 +1,76 @@
+# auctra (Python SDK)
+
+Stage 0/1 Python client — same Authority Protocol as `@auctra/sdk`.
+
+```bash
+pip install auctra  # when published; local: pip install -e packages/python-sdk
+```
+
+## Quick start (with intent anchor)
+
+High-risk actions require **`create_intent`** first, then pass the returned **`intent`** (id + `anchor_token`) on execute:
+
+```python
+from auctra import Auctra
+
+client = Auctra(api_key="auctra_...", base_url="https://app.auctra.tech")
+
+agent_id = "your-agent-uuid"
+expires_at = "2027-01-01T00:00:00Z"
+
+client.authority.issue(
+    subject=agent_id,
+    capabilities=["send_payment"],
+    expires_at=expires_at,
+    max_amount=500,
+    currency="USD",
+)
+
+created = client.create_intent(
+    title="Pay matched vendor invoices",
+    intent_type="payment",
+    risk_level="high",
+    max_risk_level="critical",
+    allowed_action_types=["send_payment"],
+    expires_at=expires_at,
+)
+intent = created["intent"]
+
+preview = client.action.evaluate(
+    agent_id=agent_id,
+    action_type="send_payment",
+    payload={"amount": 50, "currency": "USD"},
+    intent=intent,
+)
+
+decision = client.action.execute(
+    agent_id=agent_id,
+    action_type="send_payment",
+    payload={"amount": 50, "currency": "USD", "target": "vendor:acme"},
+    intent=intent,
+    action={
+        "target": "vendor:acme",
+        "description": "Net-30 invoice payment",
+        "risk_level": "medium",
+    },
+)
+
+print(decision["decision"])
+client.evidence.verify(payload=decision["evidence_payload"], evidence=decision["evidence"])
+```
+
+### New-client gotcha
+
+Sending only `claimed_intent_id` (without `intent_anchor_token` or the `intent` object) returns **`require_approval`** with a reason about the missing anchor. Pass `intent=` from `create_intent`, or set both `claimed_intent_id` and `intent_anchor_token` explicitly.
+
+See [`docs/integrations/intent-anchors.md`](../../docs/integrations/intent-anchors.md).
+
+## Public surface
+
+```text
+client.create_intent
+client.authority.issue | verify | delegate | revoke
+client.action.evaluate | execute
+client.get_action_request
+client.evidence.verify
+```

auctra-0.2.3/auctra/__init__.py

@@ -0,0 +1,4 @@
+from .client import Auctra, AuctraApiError, DEFAULT_BASE_URL
+
+__all__ = ["Auctra", "AuctraApiError", "DEFAULT_BASE_URL"]
+__version__ = "0.2.3"

auctra-0.2.3/auctra/client.py

@@ -0,0 +1,273 @@
+from __future__ import annotations
+
+import json
+import urllib.error
+import urllib.request
+from typing import Any
+
+__version__ = "0.2.3"
+
+
+class AuctraApiError(Exception):
+    def __init__(self, status: int, message: str, body: Any | None = None) -> None:
+        super().__init__(message)
+        self.status = status
+        self.body = body
+
+
+def _normalize_guard_blocked(payload: Any, status: int) -> dict[str, Any]:
+    data = payload if isinstance(payload, dict) else {}
+    reason = data.get("reason") or data.get("error") or "Blocked before evaluation"
+    action_request_id = data.get("action_request_id")
+    guard_error = data.get("error")
+    return {
+        "decision": "blocked",
+        "reason": reason,
+        "action_request_id": action_request_id if isinstance(action_request_id, str) else None,
+        "guard": {
+            "httpStatus": status,
+            "error": guard_error if isinstance(guard_error, str) else None,
+        },
+    }
+
+
+class _AuthorityAPI:
+    def __init__(self, client: "Auctra") -> None:
+        self._client = client
+
+    def issue(
+        self,
+        *,
+        subject: str,
+        capabilities: list[str],
+        expires_at: str,
+        max_amount: float | None = None,
+        currency: str | None = None,
+        parent: str | None = None,
+    ) -> dict[str, Any]:
+        body: dict[str, Any] = {
+            "agent_id": subject,
+            "action_types": capabilities,
+            "valid_until": expires_at,
+        }
+        if max_amount is not None:
+            body["max_amount"] = max_amount
+        if currency is not None:
+            body["currency"] = currency
+        if parent is not None:
+            body["parent_authority_id"] = parent
+        return self._client._request("POST", "/v1/authorities", body)
+
+    def delegate(
+        self,
+        *,
+        parent: str,
+        subject: str,
+        capabilities: list[str],
+        expires_at: str,
+        max_amount: float | None = None,
+        currency: str | None = None,
+    ) -> dict[str, Any]:
+        return self.issue(
+            subject=subject,
+            capabilities=capabilities,
+            expires_at=expires_at,
+            max_amount=max_amount,
+            currency=currency,
+            parent=parent,
+        )
+
+    def revoke(self, authority_id: str) -> dict[str, Any]:
+        return self._client._request("POST", f"/v1/authorities/{authority_id}/revoke", {})
+
+    def verify(self, *, payload: dict[str, Any], artifact: dict[str, Any]) -> dict[str, Any]:
+        return self._client._request(
+            "POST",
+            "/v1/authorities/verify",
+            {"payload": payload, "artifact": artifact},
+        )
+
+
+class _ActionAPI:
+    def __init__(self, client: "Auctra") -> None:
+        self._client = client
+
+    def evaluate(
+        self,
+        *,
+        agent_id: str,
+        action_type: str,
+        payload: dict[str, Any] | None = None,
+        claimed_intent_id: str | None = None,
+        intent_anchor_token: str | None = None,
+        intent: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        body: dict[str, Any] = {
+            "agent_id": agent_id,
+            "action_type": action_type,
+            "payload": payload or {},
+            "dry_run": True,
+        }
+        intent_id = claimed_intent_id or (intent or {}).get("id")
+        anchor = intent_anchor_token or (intent or {}).get("anchor_token") or (intent or {}).get(
+            "anchorToken"
+        )
+        if intent_id:
+            body["claimed_intent_id"] = intent_id
+        if anchor:
+            body["intent_anchor_token"] = anchor
+        return self._client._request(
+            "POST",
+            "/v1/actions/evaluate",
+            body,
+            normalize_guard_blocked=True,
+        )
+
+    def execute(
+        self,
+        *,
+        agent_id: str,
+        action_type: str,
+        payload: dict[str, Any] | None = None,
+        claimed_intent_id: str | None = None,
+        intent_anchor_token: str | None = None,
+        intent: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        body: dict[str, Any] = {
+            "agent_id": agent_id,
+            "action_type": action_type,
+            "payload": payload or {},
+            "dry_run": False,
+        }
+        intent_id = claimed_intent_id or (intent or {}).get("id")
+        anchor = intent_anchor_token or (intent or {}).get("anchor_token") or (intent or {}).get(
+            "anchorToken"
+        )
+        if intent_id:
+            body["claimed_intent_id"] = intent_id
+        if anchor:
+            body["intent_anchor_token"] = anchor
+        return self._client._request(
+            "POST",
+            "/v1/actions/execute",
+            body,
+            normalize_guard_blocked=True,
+        )
+
+
+class _EvidenceAPI:
+    def __init__(self, client: "Auctra") -> None:
+        self._client = client
+
+    def verify(self, *, payload: dict[str, Any], evidence: dict[str, Any]) -> dict[str, Any]:
+        return self._client._request(
+            "POST",
+            "/v1/evidence/verify",
+            {"payload": payload, "evidence": evidence},
+        )
+
+
+DEFAULT_BASE_URL = "https://app.auctra.tech"
+
+
+class Auctra:
+    def __init__(
+        self,
+        api_key: str,
+        base_url: str = DEFAULT_BASE_URL,
+        timeout: float = 30.0,
+    ) -> None:
+        self.api_key = api_key
+        self.base_url = base_url.rstrip("/")
+        self.timeout = timeout
+        self.authority = _AuthorityAPI(self)
+        self.action = _ActionAPI(self)
+        self.evidence = _EvidenceAPI(self)
+
+    def _request(
+        self,
+        method: str,
+        path: str,
+        body: dict[str, Any] | None = None,
+        *,
+        normalize_guard_blocked: bool = False,
+    ) -> Any:
+        url = f"{self.base_url}{path}"
+        data = None if body is None else json.dumps(body).encode("utf-8")
+        request = urllib.request.Request(
+            url,
+            data=data,
+            method=method,
+            headers={
+                "Authorization": f"Bearer {self.api_key}",
+                "Content-Type": "application/json",
+                "Accept": "application/json",
+                # Cloudflare bot score can block bare urllib user-agents (Error 1010).
+                "User-Agent": f"auctra-python-sdk/{__version__} (+https://auctra.tech)",
+            },
+        )
+        try:
+            with urllib.request.urlopen(request, timeout=self.timeout) as response:
+                return json.loads(response.read().decode("utf-8"))
+        except urllib.error.HTTPError as error:
+            payload = None
+            try:
+                payload = json.loads(error.read().decode("utf-8"))
+            except Exception:
+                payload = None
+            if (
+                normalize_guard_blocked
+                and error.code in (400, 404)
+                and isinstance(payload, dict)
+                and payload.get("decision") == "blocked"
+            ):
+                return _normalize_guard_blocked(payload, error.code)
+            message = payload.get("error") if isinstance(payload, dict) else str(error)
+            raise AuctraApiError(error.code, message or "Request failed", payload) from error
+
+    def verify_audit_chain(self) -> dict[str, Any]:
+        return self._request("GET", "/v1/audit-events/verify")
+
+    def get_audit_event(self, audit_event_id: str) -> dict[str, Any]:
+        return self._request("GET", f"/v1/audit-events/{audit_event_id}")
+
+    def verify_mandate(self, *, payload: dict[str, Any], evidence: dict[str, Any]) -> dict[str, Any]:
+        return self._request(
+            "POST",
+            "/v1/mandates/verify",
+            {"payload": payload, "evidence": evidence},
+        )
+
+    def list_audit_events(self) -> dict[str, Any]:
+        return self._request("GET", "/v1/audit-events")
+
+    def get_action_request(self, action_request_id: str) -> dict[str, Any]:
+        """Dispute pack: decision, receipt, evidence, audit anchors."""
+        return self._request("GET", f"/v1/action-requests/{action_request_id}")
+
+    def create_intent(
+        self,
+        *,
+        title: str,
+        description: str | None = None,
+        intent_type: str | None = None,
+        risk_level: str = "medium",
+        max_risk_level: str = "high",
+        allowed_action_types: list[str] | None = None,
+        expires_at: str | None = None,
+    ) -> dict[str, Any]:
+        """Declare a human intent. Response includes anchor_token for action.execute."""
+        body: dict[str, Any] = {
+            "title": title,
+            "risk_level": risk_level,
+            "max_risk_level": max_risk_level,
+        }
+        if description is not None:
+            body["description"] = description
+        if intent_type is not None:
+            body["intent_type"] = intent_type
+        if allowed_action_types is not None:
+            body["allowed_action_types"] = allowed_action_types
+        if expires_at is not None:
+            body["expires_at"] = expires_at
+        return self._request("POST", "/v1/intents", body)

auctra-0.2.3/auctra.egg-info/PKG-INFO

@@ -0,0 +1,86 @@
+Metadata-Version: 2.4
+Name: auctra
+Version: 0.2.3
+Summary: Authority Protocol Python client — issue authority, execute actions, verify evidence
+License: MIT
+Project-URL: Homepage, https://auctra.tech/docs
+Keywords: auctra,ai-agents,authority,delegation
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# auctra (Python SDK)
+
+Stage 0/1 Python client — same Authority Protocol as `@auctra/sdk`.
+
+```bash
+pip install auctra  # when published; local: pip install -e packages/python-sdk
+```
+
+## Quick start (with intent anchor)
+
+High-risk actions require **`create_intent`** first, then pass the returned **`intent`** (id + `anchor_token`) on execute:
+
+```python
+from auctra import Auctra
+
+client = Auctra(api_key="auctra_...", base_url="https://app.auctra.tech")
+
+agent_id = "your-agent-uuid"
+expires_at = "2027-01-01T00:00:00Z"
+
+client.authority.issue(
+    subject=agent_id,
+    capabilities=["send_payment"],
+    expires_at=expires_at,
+    max_amount=500,
+    currency="USD",
+)
+
+created = client.create_intent(
+    title="Pay matched vendor invoices",
+    intent_type="payment",
+    risk_level="high",
+    max_risk_level="critical",
+    allowed_action_types=["send_payment"],
+    expires_at=expires_at,
+)
+intent = created["intent"]
+
+preview = client.action.evaluate(
+    agent_id=agent_id,
+    action_type="send_payment",
+    payload={"amount": 50, "currency": "USD"},
+    intent=intent,
+)
+
+decision = client.action.execute(
+    agent_id=agent_id,
+    action_type="send_payment",
+    payload={"amount": 50, "currency": "USD", "target": "vendor:acme"},
+    intent=intent,
+    action={
+        "target": "vendor:acme",
+        "description": "Net-30 invoice payment",
+        "risk_level": "medium",
+    },
+)
+
+print(decision["decision"])
+client.evidence.verify(payload=decision["evidence_payload"], evidence=decision["evidence"])
+```
+
+### New-client gotcha
+
+Sending only `claimed_intent_id` (without `intent_anchor_token` or the `intent` object) returns **`require_approval`** with a reason about the missing anchor. Pass `intent=` from `create_intent`, or set both `claimed_intent_id` and `intent_anchor_token` explicitly.
+
+See [`docs/integrations/intent-anchors.md`](../../docs/integrations/intent-anchors.md).
+
+## Public surface
+
+```text
+client.create_intent
+client.authority.issue | verify | delegate | revoke
+client.action.evaluate | execute
+client.get_action_request
+client.evidence.verify
+```

auctra-0.2.3/auctra.egg-info/SOURCES.txt

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

auctra-0.2.3/auctra.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

auctra-0.2.3/auctra.egg-info/top_level.txt

@@ -0,0 +1 @@
+auctra

auctra-0.2.3/pyproject.toml

@@ -0,0 +1,20 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "auctra"
+version = "0.2.3"
+description = "Authority Protocol Python client — issue authority, execute actions, verify evidence"
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "MIT" }
+keywords = ["auctra", "ai-agents", "authority", "delegation"]
+dependencies = []
+
+[project.urls]
+Homepage = "https://auctra.tech/docs"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["auctra*"]

auctra-0.2.3/setup.cfg

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