allela 0.1.0__tar.gz

allela-0.1.0/PKG-INFO

@@ -0,0 +1,69 @@
+Metadata-Version: 2.4
+Name: allela
+Version: 0.1.0
+Summary: Operational Flight Recorder for AI — tamper-evident, DigiCert co-signed decision attestation
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: cryptography>=41.0
+Requires-Dist: asn1crypto>=1.5
+Requires-Dist: rfc8785>=0.1.2
+Provides-Extra: api
+Requires-Dist: fastapi[standard]>=0.110; extra == "api"
+
+# Allela SDK
+
+Tamper-evident, DigiCert co-signed attestation for AI decisions.
+
+## Install
+
+From this folder:
+
+    pip install -e .
+
+## Quickstart
+
+```python
+import allela
+
+allela.configure(
+    tenant_id="acme_corp",
+    model_provider="anthropic",
+    model_id="claude-sonnet-4-6",
+    model_version="20250929",
+)
+
+@allela.trace(system_prompt="You are a credit risk assistant.")
+def make_credit_decision(applicant_profile: str) -> str:
+    return call_your_llm(applicant_profile)  # your existing AI call, unchanged
+
+result = make_credit_decision("Applicant: income $60,000, requesting $10,000 loan.")
+# `result` is returned immediately — attestation happens on a background
+# thread and does not add latency to your function call.
+
+# Before your process exits, flush any in-flight attestations:
+allela.shutdown()
+```
+
+## Verifying a decision later
+
+```python
+result = allela.reconcile(
+    event_id="evt_...",
+    raw_input="Applicant: income $60,000, requesting $10,000 loan.",
+    raw_output="APPROVED: Low risk profile.",
+)
+print(result["path"])  # FULL_INTEGRITY_VERIFICATION / DATA_UNAVAILABLE_AT_SOURCE / TAMPER_DETECTED
+```
+
+## What gets stored
+
+Only cryptographic hashes and metadata (model ID/version, timestamps,
+a hash of the system prompt) — never your raw input/output text. See
+the Decision Event Schema (`v1/decision-event.json`) for the exact shape.
+
+## Important: call `allela.shutdown()` before exiting
+
+Because attestation runs on a background worker so it never blocks your
+application, an attestation that's still in flight when your process
+exits abruptly could be lost. Call `allela.shutdown()` (which flushes
+the queue) during your application's graceful shutdown sequence.

allela-0.1.0/README.md

@@ -0,0 +1,57 @@
+# Allela SDK
+
+Tamper-evident, DigiCert co-signed attestation for AI decisions.
+
+## Install
+
+From this folder:
+
+    pip install -e .
+
+## Quickstart
+
+```python
+import allela
+
+allela.configure(
+    tenant_id="acme_corp",
+    model_provider="anthropic",
+    model_id="claude-sonnet-4-6",
+    model_version="20250929",
+)
+
+@allela.trace(system_prompt="You are a credit risk assistant.")
+def make_credit_decision(applicant_profile: str) -> str:
+    return call_your_llm(applicant_profile)  # your existing AI call, unchanged
+
+result = make_credit_decision("Applicant: income $60,000, requesting $10,000 loan.")
+# `result` is returned immediately — attestation happens on a background
+# thread and does not add latency to your function call.
+
+# Before your process exits, flush any in-flight attestations:
+allela.shutdown()
+```
+
+## Verifying a decision later
+
+```python
+result = allela.reconcile(
+    event_id="evt_...",
+    raw_input="Applicant: income $60,000, requesting $10,000 loan.",
+    raw_output="APPROVED: Low risk profile.",
+)
+print(result["path"])  # FULL_INTEGRITY_VERIFICATION / DATA_UNAVAILABLE_AT_SOURCE / TAMPER_DETECTED
+```
+
+## What gets stored
+
+Only cryptographic hashes and metadata (model ID/version, timestamps,
+a hash of the system prompt) — never your raw input/output text. See
+the Decision Event Schema (`v1/decision-event.json`) for the exact shape.
+
+## Important: call `allela.shutdown()` before exiting
+
+Because attestation runs on a background worker so it never blocks your
+application, an attestation that's still in flight when your process
+exits abruptly could be lost. Call `allela.shutdown()` (which flushes
+the queue) during your application's graceful shutdown sequence.

allela-0.1.0/allela/__init__.py

@@ -0,0 +1,36 @@
+"""
+Allela SDK — Public API
+=========================
+    import allela
+
+    allela.configure(
+        tenant_id="acme_corp",
+        model_provider="anthropic",
+        model_id="claude-sonnet-4-6",
+        model_version="20250929",
+    )
+
+    @allela.trace
+    def make_credit_decision(applicant_profile: str) -> str:
+        return call_your_llm(applicant_profile)
+
+    result = make_credit_decision("Applicant: ...")
+    # The function returns immediately — attestation happens on a
+    # background worker thread and does not add latency to your call.
+
+    # Later, to verify:
+    result = allela.reconcile(event_id, raw_input="...", raw_output="...")
+"""
+
+from .core import (
+    configure,
+    trace,
+    attest,
+    reconcile,
+    get_event,
+    list_events,
+    shutdown,
+)
+
+__all__ = ["configure", "trace", "attest", "reconcile", "get_event", "list_events", "shutdown"]
+__version__ = "0.1.0"

allela-0.1.0/allela/core.py

@@ -0,0 +1,496 @@
+"""
+Allela SDK Core
+=================
+Self-contained implementation (no dependency on loose script files) of:
+  - Ed25519 signing / SHA-256 hashing
+  - DigiCert RFC 3161 co-signing
+  - Decision Event Schema (v1) with JCS canonicalization
+  - Append-only SQLite ledger
+  - Reconciliation Protocol (3 paths)
+  - The @allela.trace decorator, backed by a background async worker so
+    attestation NEVER blocks the decorated function's return.
+
+This consolidates the logic already tested in allela.py and
+decision_event.py into a single, pip-installable package.
+"""
+
+import base64
+import functools
+import hashlib
+import json
+import logging
+import os
+import queue
+import secrets
+import sqlite3
+import threading
+import time
+import urllib.request
+import uuid
+from datetime import datetime, timezone
+
+from cryptography.exceptions import InvalidSignature
+from cryptography.hazmat.primitives import serialization
+from cryptography.hazmat.primitives.asymmetric.ed25519 import (
+    Ed25519PrivateKey,
+    Ed25519PublicKey,
+)
+
+try:
+    from asn1crypto import algos, tsp
+except ImportError:
+    algos = None
+    tsp = None
+
+try:
+    import rfc8785
+    _HAVE_RFC8785 = True
+except ImportError:
+    _HAVE_RFC8785 = False
+
+logger = logging.getLogger("allela")
+
+# --------------------------------------------------------------------------
+# Configuration (set once via allela.configure(...))
+# --------------------------------------------------------------------------
+_CONFIG = {
+    "tenant_id": None,
+    "model_provider": None,
+    "model_id": None,
+    "model_version": None,
+    "environment": "production",
+    "db_path": "allela_ledger.db",
+    "private_key_path": "allela_private.key",
+    "public_key_path": "allela_public.key",
+    "tsa_url": "http://timestamp.digicert.com",
+    "intent_timeout_seconds": 30,
+}
+
+
+def configure(
+    tenant_id: str,
+    model_provider: str,
+    model_id: str,
+    model_version: str,
+    environment: str = "production",
+    db_path: str = "allela_ledger.db",
+    private_key_path: str = "allela_private.key",
+    public_key_path: str = "allela_public.key",
+) -> None:
+    """Must be called once before using @allela.trace or allela.attest()."""
+    _CONFIG.update({
+        "tenant_id": tenant_id,
+        "model_provider": model_provider,
+        "model_id": model_id,
+        "model_version": model_version,
+        "environment": environment,
+        "db_path": db_path,
+        "private_key_path": private_key_path,
+        "public_key_path": public_key_path,
+    })
+    _init_db()
+
+
+def _require_configured():
+    if _CONFIG["tenant_id"] is None:
+        raise RuntimeError(
+            "allela.configure(...) must be called before use. "
+            "See the module docstring for an example."
+        )
+
+
+# --------------------------------------------------------------------------
+# Crypto primitives
+# --------------------------------------------------------------------------
+def sha256_hex(text: str) -> str:
+    return hashlib.sha256(text.encode("utf-8")).hexdigest()
+
+
+def _load_or_generate_keypair():
+    priv_path = _CONFIG["private_key_path"]
+    pub_path = _CONFIG["public_key_path"]
+    if os.path.exists(priv_path):
+        with open(priv_path, "rb") as f:
+            private_key = serialization.load_pem_private_key(f.read(), password=None)
+    else:
+        private_key = Ed25519PrivateKey.generate()
+        pem = private_key.private_bytes(
+            encoding=serialization.Encoding.PEM,
+            format=serialization.PrivateFormat.PKCS8,
+            encryption_algorithm=serialization.NoEncryption(),
+        )
+        with open(priv_path, "wb") as f:
+            f.write(pem)
+        try:
+            os.chmod(priv_path, 0o600)
+        except OSError:
+            pass
+    public_key = private_key.public_key()
+    with open(pub_path, "wb") as f:
+        f.write(public_key.public_bytes(
+            encoding=serialization.Encoding.PEM,
+            format=serialization.PublicFormat.SubjectPublicKeyInfo,
+        ))
+    return private_key, public_key
+
+
+def _load_public_key():
+    with open(_CONFIG["public_key_path"], "rb") as f:
+        return serialization.load_pem_public_key(f.read())
+
+
+def canonicalize(obj: dict) -> bytes:
+    if _HAVE_RFC8785:
+        return rfc8785.dumps(obj)
+    return json.dumps(obj, sort_keys=True, separators=(",", ":"), ensure_ascii=False).encode("utf-8")
+
+
+def _get_rfc3161_timestamp(digest_hex: str) -> str:
+    if tsp is None or algos is None:
+        raise RuntimeError("asn1crypto is not installed. Run: pip install asn1crypto")
+    digest = bytes.fromhex(digest_hex)
+    nonce = int.from_bytes(secrets.token_bytes(16), "big")
+    req = tsp.TimeStampReq({
+        "version": 1,
+        "message_imprint": tsp.MessageImprint({
+            "hash_algorithm": algos.DigestAlgorithm({"algorithm": "sha256"}),
+            "hashed_message": digest,
+        }),
+        "nonce": nonce,
+        "cert_req": True,
+    })
+    req_der = req.dump()
+    http_req = urllib.request.Request(
+        _CONFIG["tsa_url"], data=req_der,
+        headers={"Content-Type": "application/timestamp-query", "Content-Length": str(len(req_der))},
+        method="POST",
+    )
+    with urllib.request.urlopen(http_req, timeout=20) as resp:
+        resp_der = resp.read()
+    tsr = tsp.TimeStampResp.load(resp_der)
+    status_str = tsr["status"]["status"].native
+    if status_str not in ("granted", "grantedWithMods", "granted_with_mods"):
+        raise RuntimeError(f"TSA refused the request: {status_str}")
+    return base64.b64encode(resp_der).decode("ascii")
+
+
+def _verify_rfc3161_token(token_b64: str, expected_digest_hex: str) -> bool:
+    if tsp is None:
+        return False
+    resp_der = base64.b64decode(token_b64)
+    tsr = tsp.TimeStampResp.load(resp_der)
+    if tsr["status"]["status"].native not in ("granted", "grantedWithMods", "granted_with_mods"):
+        return False
+    content_info = tsr["time_stamp_token"]
+    if content_info is None:
+        return False
+    signed_data = content_info["content"]
+    econtent = signed_data["encap_content_info"]["content"]
+    tst_info = econtent if isinstance(econtent, tsp.TSTInfo) else tsp.TSTInfo.load(bytes(econtent))
+    imprint = tst_info["message_imprint"]["hashed_message"].native
+    return imprint == bytes.fromhex(expected_digest_hex)
+
+
+# --------------------------------------------------------------------------
+# Storage
+# --------------------------------------------------------------------------
+def _get_conn() -> sqlite3.Connection:
+    conn = sqlite3.connect(_CONFIG["db_path"])
+    conn.row_factory = sqlite3.Row
+    return conn
+
+
+def _init_db() -> None:
+    conn = _get_conn()
+    conn.executescript(
+        """
+        CREATE TABLE IF NOT EXISTS decision_events (
+            id                  INTEGER PRIMARY KEY AUTOINCREMENT,
+            event_id            TEXT UNIQUE NOT NULL,
+            tenant_id           TEXT NOT NULL,
+            timestamp_utc       TEXT NOT NULL,
+            canonical_json      TEXT NOT NULL,
+            root_hash           TEXT NOT NULL,
+            signature_hex       TEXT NOT NULL,
+            digicert_token_b64  TEXT,
+            status              TEXT NOT NULL,
+            recorded_at         TEXT NOT NULL DEFAULT (datetime('now'))
+        );
+        CREATE TRIGGER IF NOT EXISTS decision_events_no_update
+        BEFORE UPDATE ON decision_events
+        BEGIN SELECT RAISE(ABORT, 'append-only: UPDATE blocked'); END;
+        CREATE TRIGGER IF NOT EXISTS decision_events_no_delete
+        BEFORE DELETE ON decision_events
+        BEGIN SELECT RAISE(ABORT, 'append-only: DELETE blocked'); END;
+
+        CREATE TABLE IF NOT EXISTS intent_gaps (
+            id          INTEGER PRIMARY KEY AUTOINCREMENT,
+            intent_id   TEXT NOT NULL,
+            flagged_at  TEXT NOT NULL,
+            reason      TEXT
+        );
+        """
+    )
+    conn.commit()
+    conn.close()
+
+
+# --------------------------------------------------------------------------
+# Decision Event Schema + attestation
+# --------------------------------------------------------------------------
+def _build_event(input_text: str, output_text: str, system_prompt: str = "",
+                  execution_params: dict = None) -> dict:
+    return {
+        "$schema": "https://allela.ai/schemas/v1/decision-event.json",
+        "event_id": f"evt_{uuid.uuid4().hex}",
+        "tenant_id": _CONFIG["tenant_id"],
+        "timestamp_utc": datetime.now(timezone.utc).isoformat(),
+        "system_metadata": {
+            "environment": _CONFIG["environment"],
+            "model_provider": _CONFIG["model_provider"],
+            "model_id": _CONFIG["model_id"],
+            "model_version": _CONFIG["model_version"],
+            "system_prompt_hash": sha256_hex(system_prompt) if system_prompt else "",
+            "execution_params": execution_params or {},
+        },
+        "payload_hashes": {
+            "input_hash": sha256_hex(input_text),
+            "output_hash": sha256_hex(output_text),
+        },
+    }
+
+
+def _attest_event(event: dict) -> str:
+    canonical_bytes = canonicalize(event)
+    root_hash = hashlib.sha256(canonical_bytes).hexdigest()
+    private_key, _ = _load_or_generate_keypair()
+    signature_hex = private_key.sign(canonical_bytes).hex()
+
+    status = "success"
+    try:
+        digicert_token_b64 = _get_rfc3161_timestamp(root_hash)
+    except Exception as e:
+        logger.warning("DigiCert timestamping failed (%s); recording as signed_no_tsa", e)
+        digicert_token_b64 = None
+        status = "signed_no_tsa"
+
+    conn = _get_conn()
+    conn.execute(
+        """INSERT INTO decision_events
+           (event_id, tenant_id, timestamp_utc, canonical_json, root_hash,
+            signature_hex, digicert_token_b64, status)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?)""",
+        (event["event_id"], event["tenant_id"], event["timestamp_utc"],
+         canonical_bytes.decode("utf-8"), root_hash, signature_hex,
+         digicert_token_b64, status),
+    )
+    conn.commit()
+    conn.close()
+    logger.info("Attested %s (status=%s)", event["event_id"], status)
+    return event["event_id"]
+
+
+def attest(input_text: str, output_text: str, system_prompt: str = "",
+           execution_params: dict = None, blocking: bool = True) -> str:
+    """Directly attest an input/output pair. If blocking=False, this is
+    queued to the background worker and returns immediately (event_id is
+    still generated and returned synchronously; the DigiCert timestamp
+    and DB write happen asynchronously)."""
+    _require_configured()
+    event = _build_event(input_text, output_text, system_prompt, execution_params)
+    if blocking:
+        return _attest_event(event)
+    _WORKER.submit(event)
+    return event["event_id"]
+
+
+# --------------------------------------------------------------------------
+# Background async worker (so @trace never blocks the caller)
+# --------------------------------------------------------------------------
+class _AsyncWorker:
+    """Runs attestation (hashing already done, but signing + DigiCert +
+    DB write) on a background daemon thread, off the critical path of
+    whatever function is being traced."""
+
+    def __init__(self):
+        self._queue: "queue.Queue[dict]" = queue.Queue()
+        self._thread = threading.Thread(target=self._run, daemon=True)
+        self._started = False
+
+    def _ensure_started(self):
+        if not self._started:
+            self._thread.start()
+            self._started = True
+
+    def submit(self, event: dict) -> None:
+        self._ensure_started()
+        self._queue.put(event)
+
+    def _run(self):
+        while True:
+            event = self._queue.get()
+            if event is None:  # shutdown sentinel
+                break
+            try:
+                _attest_event(event)
+            except Exception:
+                logger.exception("Background attestation failed for %s", event.get("event_id"))
+            finally:
+                self._queue.task_done()
+
+    def flush(self, timeout: float = 30.0):
+        """Blocks until all queued attestations have been processed.
+        Useful in tests/demos and before process exit."""
+        start = time.monotonic()
+        self._queue.join()
+
+
+_WORKER = _AsyncWorker()
+
+
+def shutdown(flush: bool = True, timeout: float = 30.0) -> None:
+    """Call before your process exits if you want to guarantee every
+    background-queued attestation has actually been written and
+    timestamped. Not calling this risks losing in-flight attestations
+    if the process exits abruptly — this is the SDK's own version of
+    the Intent Gap Detector's concern, applied to itself."""
+    if flush:
+        _WORKER.flush(timeout=timeout)
+
+
+# --------------------------------------------------------------------------
+# The @allela.trace decorator
+# --------------------------------------------------------------------------
+def trace(system_prompt: str = "", execution_params: dict = None):
+    """Decorator that attests a function's (input, output) pair on every
+    call, asynchronously, without adding latency to the call itself.
+
+    Usage:
+        @allela.trace()
+        def make_decision(prompt: str) -> str:
+            return call_llm(prompt)
+
+        # or with a fixed system prompt recorded on every call:
+        @allela.trace(system_prompt="You are a credit risk assistant.")
+        def make_decision(prompt: str) -> str:
+            return call_llm(prompt)
+
+    The function's positional/keyword arguments are captured (as a JSON
+    string) as the input; its return value (str) is captured as the
+    output. If your function's inputs/outputs aren't naturally strings,
+    wrap them with str()/json.dumps() before this decorator, or use
+    allela.attest() directly for full control."""
+
+    def decorator(func):
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            _require_configured()
+            result = func(*args, **kwargs)
+            try:
+                input_repr = json.dumps({"args": [str(a) for a in args], "kwargs": kwargs}, sort_keys=True)
+            except TypeError:
+                input_repr = str(args) + str(kwargs)
+            output_repr = result if isinstance(result, str) else json.dumps(result, default=str)
+
+            event = _build_event(input_repr, output_repr, system_prompt, execution_params)
+            _WORKER.submit(event)  # never blocks the caller
+            return result
+        return wrapper
+
+    # allow @allela.trace (no parens) as well as @allela.trace(...)
+    if callable(system_prompt):
+        func = system_prompt
+        return trace()(func)
+    return decorator
+
+
+# --------------------------------------------------------------------------
+# Reconciliation Protocol
+# --------------------------------------------------------------------------
+def reconcile(event_id: str, raw_input: str = None, raw_output: str = None) -> dict:
+    conn = _get_conn()
+    cur = conn.execute("SELECT * FROM decision_events WHERE event_id = ?", (event_id,))
+    row = cur.fetchone()
+    if row is None:
+        conn.close()
+        return {"path": "NOT_FOUND", "event_id": event_id}
+    record = dict(row)
+    stored_event = json.loads(record["canonical_json"])
+
+    public_key = _load_public_key()
+    canonical_bytes = canonicalize(stored_event)
+    recomputed_root = hashlib.sha256(canonical_bytes).hexdigest()
+    try:
+        public_key.verify(bytes.fromhex(record["signature_hex"]), canonical_bytes)
+        sig_valid = True
+    except (InvalidSignature, ValueError):
+        sig_valid = False
+    root_matches = recomputed_root == record["root_hash"]
+
+    tsa_present = record["digicert_token_b64"] is not None
+    tsa_verified = tsa_present and _verify_rfc3161_token(record["digicert_token_b64"], record["root_hash"])
+
+    base = {
+        "event_id": event_id,
+        "tenant_id": record["tenant_id"],
+        "timestamp_utc": record["timestamp_utc"],
+        "model_id": stored_event["system_metadata"]["model_id"],
+        "model_version": stored_event["system_metadata"]["model_version"],
+        "ledger_signature_valid": sig_valid,
+        "ledger_root_hash_valid": root_matches,
+        "digicert_timestamp_verified": tsa_verified,
+    }
+    conn.close()
+
+    if raw_input is None and raw_output is None:
+        base.update({
+            "path": "DATA_UNAVAILABLE_AT_SOURCE",
+            "explanation": (
+                "No raw input/output was supplied. Allela confirms a decision "
+                "event existed at this timestamp, under this model and version — "
+                "but cannot confirm payload content without the caller's own data."
+            ),
+        })
+        return base
+
+    input_matches = sha256_hex(raw_input or "") == stored_event["payload_hashes"]["input_hash"]
+    output_matches = sha256_hex(raw_output or "") == stored_event["payload_hashes"]["output_hash"]
+
+    if input_matches and output_matches:
+        base.update({"path": "FULL_INTEGRITY_VERIFICATION",
+                     "explanation": "Supplied data matches the stored record exactly. Unaltered."})
+    else:
+        mismatched = [f for f, ok in (("input", input_matches), ("output", output_matches)) if not ok]
+        base.update({"path": "TAMPER_DETECTED", "mismatched_fields": mismatched,
+                     "explanation": f"Mismatch detected in: {', '.join(mismatched)}. Record was modified after timestamping."})
+    return base
+
+
+def get_event(event_id: str) -> dict:
+    conn = _get_conn()
+    cur = conn.execute("SELECT * FROM decision_events WHERE event_id = ?", (event_id,))
+    row = cur.fetchone()
+    conn.close()
+    if row is None:
+        return None
+    record = dict(row)
+    return {
+        "event_id": record["event_id"],
+        "tenant_id": record["tenant_id"],
+        "timestamp_utc": record["timestamp_utc"],
+        "root_hash": record["root_hash"],
+        "status": record["status"],
+        "digicert_timestamp_present": record["digicert_token_b64"] is not None,
+    }
+
+
+def list_events(tenant_id: str, limit: int = 20, offset: int = 0) -> list:
+    conn = _get_conn()
+    cur = conn.execute(
+        "SELECT event_id, timestamp_utc, status FROM decision_events "
+        "WHERE tenant_id = ? ORDER BY id DESC LIMIT ? OFFSET ?",
+        (tenant_id, limit, offset),
+    )
+    rows = [dict(r) for r in cur.fetchall()]
+    conn.close()
+    return rows

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

@@ -0,0 +1,69 @@
+Metadata-Version: 2.4
+Name: allela
+Version: 0.1.0
+Summary: Operational Flight Recorder for AI — tamper-evident, DigiCert co-signed decision attestation
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: cryptography>=41.0
+Requires-Dist: asn1crypto>=1.5
+Requires-Dist: rfc8785>=0.1.2
+Provides-Extra: api
+Requires-Dist: fastapi[standard]>=0.110; extra == "api"
+
+# Allela SDK
+
+Tamper-evident, DigiCert co-signed attestation for AI decisions.
+
+## Install
+
+From this folder:
+
+    pip install -e .
+
+## Quickstart
+
+```python
+import allela
+
+allela.configure(
+    tenant_id="acme_corp",
+    model_provider="anthropic",
+    model_id="claude-sonnet-4-6",
+    model_version="20250929",
+)
+
+@allela.trace(system_prompt="You are a credit risk assistant.")
+def make_credit_decision(applicant_profile: str) -> str:
+    return call_your_llm(applicant_profile)  # your existing AI call, unchanged
+
+result = make_credit_decision("Applicant: income $60,000, requesting $10,000 loan.")
+# `result` is returned immediately — attestation happens on a background
+# thread and does not add latency to your function call.
+
+# Before your process exits, flush any in-flight attestations:
+allela.shutdown()
+```
+
+## Verifying a decision later
+
+```python
+result = allela.reconcile(
+    event_id="evt_...",
+    raw_input="Applicant: income $60,000, requesting $10,000 loan.",
+    raw_output="APPROVED: Low risk profile.",
+)
+print(result["path"])  # FULL_INTEGRITY_VERIFICATION / DATA_UNAVAILABLE_AT_SOURCE / TAMPER_DETECTED
+```
+
+## What gets stored
+
+Only cryptographic hashes and metadata (model ID/version, timestamps,
+a hash of the system prompt) — never your raw input/output text. See
+the Decision Event Schema (`v1/decision-event.json`) for the exact shape.
+
+## Important: call `allela.shutdown()` before exiting
+
+Because attestation runs on a background worker so it never blocks your
+application, an attestation that's still in flight when your process
+exits abruptly could be lost. Call `allela.shutdown()` (which flushes
+the queue) during your application's graceful shutdown sequence.

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

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

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

@@ -0,0 +1 @@
+

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

@@ -0,0 +1,6 @@
+cryptography>=41.0
+asn1crypto>=1.5
+rfc8785>=0.1.2
+
+[api]
+fastapi[standard]>=0.110

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

@@ -0,0 +1 @@
+allela

allela-0.1.0/pyproject.toml

@@ -0,0 +1,21 @@
+[build-system]
+requires = ["setuptools>=68.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "allela"
+version = "0.1.0"
+description = "Operational Flight Recorder for AI — tamper-evident, DigiCert co-signed decision attestation"
+readme = "README.md"
+requires-python = ">=3.9"
+dependencies = [
+    "cryptography>=41.0",
+    "asn1crypto>=1.5",
+    "rfc8785>=0.1.2",
+]
+
+[project.optional-dependencies]
+api = ["fastapi[standard]>=0.110"]
+
+[tool.setuptools.packages.find]
+include = ["allela*"]

allela-0.1.0/setup.cfg

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