attestic 0.1.0__tar.gz

attestic-0.1.0/PKG-INFO

@@ -0,0 +1,70 @@
+Metadata-Version: 2.4
+Name: attestic
+Version: 0.1.0
+Summary: Thin client for the Attestic AI gateway: pre-configured OpenAI/Anthropic clients + offline signed-receipt verification.
+Author: VelarIQ Inc.
+License: MIT
+Project-URL: Homepage, https://attestic.ai
+Project-URL: Documentation, https://attestic.ai/developers
+Keywords: attestic,ai,gateway,provenance,openai,anthropic,llm
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: cryptography>=41
+Provides-Extra: openai
+Requires-Dist: openai>=1.30; extra == "openai"
+Provides-Extra: anthropic
+Requires-Dist: anthropic>=0.40; extra == "anthropic"
+Provides-Extra: all
+Requires-Dist: openai>=1.30; extra == "all"
+Requires-Dist: anthropic>=0.40; extra == "all"
+
+# attestic (Python)
+
+Thin client for the [Attestic](https://attestic.ai) AI gateway.
+
+Attestic is drop-in **OpenAI- and Anthropic-compatible**, so you can also just point
+the OpenAI or Anthropic SDK at `https://api.attestic.ai`. This package adds two
+conveniences: a pre-configured client, and **offline verification of the signed
+provenance receipt** every call produces.
+
+```bash
+pip install attestic[all]      # or attestic[openai] / attestic[anthropic]
+```
+
+```python
+from attestic import Attestic
+
+at = Attestic(api_key="atk_...")   # mint a key at attestic.ai/api-keys
+
+# OpenAI-style
+r = at.openai.chat.completions.create(
+    model="gpt-5.5",
+    messages=[{"role": "user", "content": "Explain provenance in one sentence."}],
+)
+print(r.choices[0].message.content)
+
+# Anthropic / Claude-style (same key, same gateway)
+m = at.anthropic.messages.create(
+    model="claude-fable-5", max_tokens=256,
+    messages=[{"role": "user", "content": "hi"}],
+)
+
+# Verify a call's receipt OFFLINE — no trust in Attestic required
+receipt_id = "..."                 # from the x-attestic-receipt-id response header
+assert at.verify(receipt_id)       # checks Ed25519 signature + Merkle inclusion
+```
+
+Models route by id across OpenAI, Anthropic, Google, and NVIDIA open-weight —
+`gpt-5.5`, `claude-fable-5`, `gemini-3.1-pro-preview`, `meta/llama-3.3-70b-instruct`, …
+
+## Without this SDK
+Nothing special required:
+
+```python
+from openai import OpenAI
+client = OpenAI(base_url="https://api.attestic.ai/v1", api_key="atk_...")
+```
+```python
+from anthropic import Anthropic
+client = Anthropic(base_url="https://api.attestic.ai", api_key="atk_...")
+```

attestic-0.1.0/README.md

@@ -0,0 +1,50 @@
+# attestic (Python)
+
+Thin client for the [Attestic](https://attestic.ai) AI gateway.
+
+Attestic is drop-in **OpenAI- and Anthropic-compatible**, so you can also just point
+the OpenAI or Anthropic SDK at `https://api.attestic.ai`. This package adds two
+conveniences: a pre-configured client, and **offline verification of the signed
+provenance receipt** every call produces.
+
+```bash
+pip install attestic[all]      # or attestic[openai] / attestic[anthropic]
+```
+
+```python
+from attestic import Attestic
+
+at = Attestic(api_key="atk_...")   # mint a key at attestic.ai/api-keys
+
+# OpenAI-style
+r = at.openai.chat.completions.create(
+    model="gpt-5.5",
+    messages=[{"role": "user", "content": "Explain provenance in one sentence."}],
+)
+print(r.choices[0].message.content)
+
+# Anthropic / Claude-style (same key, same gateway)
+m = at.anthropic.messages.create(
+    model="claude-fable-5", max_tokens=256,
+    messages=[{"role": "user", "content": "hi"}],
+)
+
+# Verify a call's receipt OFFLINE — no trust in Attestic required
+receipt_id = "..."                 # from the x-attestic-receipt-id response header
+assert at.verify(receipt_id)       # checks Ed25519 signature + Merkle inclusion
+```
+
+Models route by id across OpenAI, Anthropic, Google, and NVIDIA open-weight —
+`gpt-5.5`, `claude-fable-5`, `gemini-3.1-pro-preview`, `meta/llama-3.3-70b-instruct`, …
+
+## Without this SDK
+Nothing special required:
+
+```python
+from openai import OpenAI
+client = OpenAI(base_url="https://api.attestic.ai/v1", api_key="atk_...")
+```
+```python
+from anthropic import Anthropic
+client = Anthropic(base_url="https://api.attestic.ai", api_key="atk_...")
+```

attestic-0.1.0/attestic/__init__.py

@@ -0,0 +1,127 @@
+"""Attestic — thin client for the Attestic AI gateway.
+
+Attestic is drop-in OpenAI- and Anthropic-compatible, so you don't *need* a custom
+SDK — point the OpenAI or Anthropic SDK at the gateway and go. This package is a
+convenience layer that (a) hands you a pre-configured client and (b) does the thing
+that makes Attestic *Attestic*: verify a call's signed provenance receipt **offline**.
+
+    from attestic import Attestic
+
+    at = Attestic(api_key="atk_...")           # base_url defaults to api.attestic.ai
+    resp = at.openai.chat.completions.create(  # the real OpenAI client, pre-pointed
+        model="gpt-5.5", messages=[{"role": "user", "content": "hi"}],
+    )
+    rid = resp.id  # or read the x-attestic-receipt-id response header
+    assert at.verify(rid)                      # Ed25519 + Merkle, no network trust
+
+    msg = at.anthropic.messages.create(        # the Claude client, also pre-pointed
+        model="claude-fable-5", max_tokens=256,
+        messages=[{"role": "user", "content": "hi"}],
+    )
+"""
+from __future__ import annotations
+
+import hashlib
+import json
+import urllib.request
+from typing import Any, Optional
+
+__version__ = "0.1.0"
+
+DEFAULT_BASE = "https://api.attestic.ai"
+
+
+class Attestic:
+    """A pre-configured handle to the Attestic gateway + offline receipt verification.
+
+    By default (``use_oauth=True``) the long-lived ``atk_`` key is exchanged for a
+    short-lived (1h) access token that does the actual calls, refreshed automatically.
+    The key itself never leaves this object after construction — so a leaked request
+    credential expires within the hour. Set ``use_oauth=False`` to send the key directly."""
+
+    def __init__(self, api_key: str, base_url: str = DEFAULT_BASE, use_oauth: bool = True):
+        self.api_key = api_key
+        self.base_url = base_url.rstrip("/")
+        self._v1 = f"{self.base_url}/v1"
+        self.use_oauth = use_oauth
+        self._token: Optional[str] = None
+        self._token_exp: float = 0.0
+        self._openai = None
+        self._openai_cred: Optional[str] = None
+        self._anthropic = None
+        self._anthropic_cred: Optional[str] = None
+
+    def _credential(self) -> str:
+        """The bearer to call the API with: a fresh short-lived token (OAuth) or the key."""
+        if not self.use_oauth:
+            return self.api_key
+        import time as _time
+        if self._token and _time.time() < self._token_exp - 60:
+            return self._token
+        req = urllib.request.Request(
+            f"{self._v1}/oauth/token",
+            data=json.dumps({"api_key": self.api_key}).encode(),
+            headers={"Content-Type": "application/json"},
+        )
+        d = json.load(urllib.request.urlopen(req, timeout=30))
+        self._token = d["access_token"]
+        self._token_exp = _time.time() + float(d.get("expires_in", 3600))
+        return self._token
+
+    def access_token(self) -> str:
+        """The current short-lived access token (minted/refreshed on demand)."""
+        return self._credential()
+
+    @property
+    def openai(self):
+        """A `openai.OpenAI` client pointed at Attestic (lazy; auto-refreshes the token)."""
+        cred = self._credential()
+        if self._openai is None or self._openai_cred != cred:
+            from openai import OpenAI
+            self._openai = OpenAI(base_url=self._v1, api_key=cred)
+            self._openai_cred = cred
+        return self._openai
+
+    @property
+    def anthropic(self):
+        """An `anthropic.Anthropic` client pointed at Attestic (lazy; auto-refreshes the token)."""
+        cred = self._credential()
+        if self._anthropic is None or self._anthropic_cred != cred:
+            from anthropic import Anthropic
+            self._anthropic = Anthropic(base_url=self.base_url, api_key=cred)
+            self._anthropic_cred = cred
+        return self._anthropic
+
+    # --- receipts -----------------------------------------------------------
+    def fetch_receipt(self, receipt_id: str) -> dict:
+        """Fetch the verifiable receipt bundle for a call (own-tenant only)."""
+        req = urllib.request.Request(
+            f"{self._v1}/receipts/{receipt_id}",
+            headers={"Authorization": f"Bearer {self._credential()}"},
+        )
+        return json.load(urllib.request.urlopen(req, timeout=30))
+
+    def verify(self, receipt_id: str) -> bool:
+        """Fetch a receipt and verify it OFFLINE: the Ed25519 signature over the
+        canonical record AND the Merkle inclusion proof. Returns True iff both hold."""
+        return verify_receipt(self.fetch_receipt(receipt_id))
+
+
+def verify_receipt(bundle: dict) -> bool:
+    """Verify an Attestic receipt bundle with no trust in the gateway:
+      1. Ed25519: `public_key` verifies `signature` over `signed_bytes`.
+      2. Merkle: folding `leaf_hash` up `proof` lands on `merkle.root`.
+    Requires the `cryptography` package for the signature check.
+    Fails closed: any malformed/missing field returns False rather than raising."""
+    try:
+        from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PublicKey
+        pk = Ed25519PublicKey.from_public_bytes(bytes.fromhex(bundle["public_key"]))
+        pk.verify(bytes.fromhex(bundle["signature"]), bytes.fromhex(bundle["signed_bytes"]))
+        m = bundle.get("merkle") or {}
+        h = bytes.fromhex(m["leaf_hash"])
+        for step in m.get("proof", []):
+            sib = bytes.fromhex(step["sibling"])
+            h = hashlib.sha256((sib + h) if step.get("side") == "left" else (h + sib)).digest()
+        return h.hex() == m.get("root")
+    except Exception:
+        return False

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

@@ -0,0 +1,70 @@
+Metadata-Version: 2.4
+Name: attestic
+Version: 0.1.0
+Summary: Thin client for the Attestic AI gateway: pre-configured OpenAI/Anthropic clients + offline signed-receipt verification.
+Author: VelarIQ Inc.
+License: MIT
+Project-URL: Homepage, https://attestic.ai
+Project-URL: Documentation, https://attestic.ai/developers
+Keywords: attestic,ai,gateway,provenance,openai,anthropic,llm
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: cryptography>=41
+Provides-Extra: openai
+Requires-Dist: openai>=1.30; extra == "openai"
+Provides-Extra: anthropic
+Requires-Dist: anthropic>=0.40; extra == "anthropic"
+Provides-Extra: all
+Requires-Dist: openai>=1.30; extra == "all"
+Requires-Dist: anthropic>=0.40; extra == "all"
+
+# attestic (Python)
+
+Thin client for the [Attestic](https://attestic.ai) AI gateway.
+
+Attestic is drop-in **OpenAI- and Anthropic-compatible**, so you can also just point
+the OpenAI or Anthropic SDK at `https://api.attestic.ai`. This package adds two
+conveniences: a pre-configured client, and **offline verification of the signed
+provenance receipt** every call produces.
+
+```bash
+pip install attestic[all]      # or attestic[openai] / attestic[anthropic]
+```
+
+```python
+from attestic import Attestic
+
+at = Attestic(api_key="atk_...")   # mint a key at attestic.ai/api-keys
+
+# OpenAI-style
+r = at.openai.chat.completions.create(
+    model="gpt-5.5",
+    messages=[{"role": "user", "content": "Explain provenance in one sentence."}],
+)
+print(r.choices[0].message.content)
+
+# Anthropic / Claude-style (same key, same gateway)
+m = at.anthropic.messages.create(
+    model="claude-fable-5", max_tokens=256,
+    messages=[{"role": "user", "content": "hi"}],
+)
+
+# Verify a call's receipt OFFLINE — no trust in Attestic required
+receipt_id = "..."                 # from the x-attestic-receipt-id response header
+assert at.verify(receipt_id)       # checks Ed25519 signature + Merkle inclusion
+```
+
+Models route by id across OpenAI, Anthropic, Google, and NVIDIA open-weight —
+`gpt-5.5`, `claude-fable-5`, `gemini-3.1-pro-preview`, `meta/llama-3.3-70b-instruct`, …
+
+## Without this SDK
+Nothing special required:
+
+```python
+from openai import OpenAI
+client = OpenAI(base_url="https://api.attestic.ai/v1", api_key="atk_...")
+```
+```python
+from anthropic import Anthropic
+client = Anthropic(base_url="https://api.attestic.ai", api_key="atk_...")
+```

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

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

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

@@ -0,0 +1 @@
+

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

@@ -0,0 +1,11 @@
+cryptography>=41
+
+[all]
+openai>=1.30
+anthropic>=0.40
+
+[anthropic]
+anthropic>=0.40
+
+[openai]
+openai>=1.30

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

@@ -0,0 +1 @@
+attestic

attestic-0.1.0/pyproject.toml

@@ -0,0 +1,26 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "attestic"
+version = "0.1.0"
+description = "Thin client for the Attestic AI gateway: pre-configured OpenAI/Anthropic clients + offline signed-receipt verification."
+readme = "README.md"
+requires-python = ">=3.9"
+license = { text = "MIT" }
+authors = [{ name = "VelarIQ Inc." }]
+keywords = ["attestic", "ai", "gateway", "provenance", "openai", "anthropic", "llm"]
+dependencies = ["cryptography>=41"]
+
+[project.optional-dependencies]
+openai = ["openai>=1.30"]
+anthropic = ["anthropic>=0.40"]
+all = ["openai>=1.30", "anthropic>=0.40"]
+
+[project.urls]
+Homepage = "https://attestic.ai"
+Documentation = "https://attestic.ai/developers"
+
+[tool.setuptools.packages.find]
+include = ["attestic*"]

attestic-0.1.0/setup.cfg

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