aira-sdk 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Aira (Softure UG)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,198 @@
+# Aira TypeScript SDK
+
+**Legal infrastructure for AI agents.** Cryptographic proof for every action your AI agent takes.
+
+Aira provides the accountability layer that autonomous AI agents need to operate in regulated environments. Every action is notarized with Ed25519 signatures and RFC 3161 timestamps — producing court-admissible proof that an action happened, who authorized it, and what decision was made.
+
+**What you get:**
+- **Notarize actions** — cryptographic receipts for every agent decision, email, transaction
+- **Register agents** — verifiable identity with versioned configs and public profiles
+- **Multi-model consensus** — run the same decision through multiple AI models, flag disagreements
+- **Evidence packages** — sealed, tamper-proof bundles for legal discovery and audit
+- **Agent lifecycle** — wills, succession plans, death certificates, compliance snapshots
+- **Liability commitments** — record accountability commitments with cryptographic proof
+- **Human authorization** — require human co-signatures on high-stakes actions
+- **Public verification** — anyone can verify a receipt without an account
+
+Built for EU AI Act, SR 11-7, and GDPR compliance. Self-hostable. Open-source SDK.
+
+[![npm version](https://img.shields.io/npm/v/aira-sdk.svg)](https://www.npmjs.com/package/aira-sdk)
+[![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](https://opensource.org/licenses/MIT)
+
+```bash
+npm install aira-sdk
+```
+
+## Quick Start
+
+```typescript
+import { Aira } from "aira-sdk";
+
+const aira = new Aira({ apiKey: "aira_live_xxx" });
+
+// Notarize an agent action
+const receipt = await aira.notarize({
+  actionType: "email_sent",
+  details: "Sent onboarding email to customer@example.com",
+  agentId: "support-agent",
+  modelId: "claude-sonnet-4-6",
+});
+
+console.log(receipt.signature);  // ed25519:base64url...
+console.log(receipt.action_id);  // uuid
+```
+
+## Agent Registry
+
+```typescript
+const agent = await aira.registerAgent({
+  agentSlug: "lending-agent",
+  displayName: "Loan Decision Engine",
+  capabilities: ["credit_scoring", "risk_assessment"],
+  public: true,
+});
+
+await aira.publishVersion("lending-agent", {
+  version: "1.0.0",
+  modelId: "claude-sonnet-4-6",
+  changelog: "Initial release",
+});
+
+const agents = await aira.listAgents();
+console.log(agents.total);  // 5
+```
+
+## Action Notarization
+
+```typescript
+// Notarize with chain of custody
+const decision = await aira.notarize({
+  actionType: "loan_approved",
+  details: "Approved loan #4521 for €25,000",
+  agentId: "lending-agent",
+  modelId: "claude-sonnet-4-6",
+  idempotencyKey: "loan-4521",
+});
+
+// Chain a follow-up action
+const email = await aira.notarize({
+  actionType: "email_sent",
+  details: "Sent approval notification",
+  agentId: "lending-agent",
+  parentActionId: decision.action_id,
+});
+
+// Get chain of custody
+const chain = await aira.getActionChain(decision.action_id);
+
+// Human co-signature
+await aira.authorizeAction(decision.action_id);
+
+// Legal hold
+await aira.setLegalHold(decision.action_id);
+```
+
+## Multi-Model Consensus
+
+```typescript
+const result = await aira.runCase(
+  "Should we approve loan #4521?",
+  ["claude-sonnet-4-6", "gpt-4o", "gemini-2.0-flash"],
+);
+
+console.log(result.consensus.decision);     // "APPROVE"
+console.log(result.consensus.confidence);   // 0.92
+```
+
+## Evidence Packages
+
+```typescript
+const pkg = await aira.createEvidencePackage({
+  title: "Q1 2026 Lending Audit",
+  actionIds: [decision.action_id, email.action_id],
+  description: "All lending decisions for regulatory review",
+});
+
+console.log(pkg.package_hash);  // sha256:...
+console.log(pkg.signature);    // ed25519:...
+```
+
+## Agent Will & Estate
+
+```typescript
+await aira.setAgentWill("lending-agent", {
+  successorSlug: "lending-agent-v2",
+  successionPolicy: "transfer_to_successor",
+  dataRetentionDays: 2555,
+  notifyEmails: ["compliance@acme.com"],
+});
+
+await aira.createComplianceSnapshot({
+  framework: "eu-ai-act",
+  agentSlug: "lending-agent",
+  findings: { art_12_logging: "pass", art_14_oversight: "pass" },
+});
+```
+
+## Escrow (Liability Commitments)
+
+Escrow accounts are **accountability ledgers** — they record liability commitments with cryptographic proof. No real funds are custodied by Aira.
+
+```typescript
+const account = await aira.createEscrowAccount({ purpose: "Loan liability" });
+await aira.escrowDeposit(account.id, 15000, "Liability commitment for loan #4521");
+await aira.escrowRelease(account.id, 15000, "Loan disbursed successfully");
+```
+
+## Chat
+
+```typescript
+const response = await aira.ask("How many loan decisions were notarized this week?");
+console.log(response.content);
+```
+
+## Public Verification
+
+```typescript
+// No auth needed — anyone can verify
+const result = await aira.verifyAction("action-uuid");
+console.log(result.valid);    // true
+console.log(result.message);  // "Action receipt exists..."
+```
+
+## Error Handling
+
+```typescript
+import { Aira, AiraError } from "aira-sdk";
+
+try {
+  await aira.notarize({ actionType: "test", details: "test" });
+} catch (e) {
+  if (e instanceof AiraError) {
+    console.log(e.status);   // 429
+    console.log(e.code);     // "PLAN_LIMIT_EXCEEDED"
+    console.log(e.message);  // "Monthly operation limit reached"
+  }
+}
+```
+
+## Configuration
+
+```typescript
+const aira = new Aira({
+  apiKey: "aira_live_xxx",
+  baseUrl: "https://your-self-hosted.com",  // Self-hosted
+  timeout: 60_000,                           // Request timeout in ms
+});
+```
+
+## License
+
+MIT
+
+## Links
+
+- [Documentation](https://docs.airaproof.com)
+- [API Reference](https://docs.airaproof.com/docs/api-reference)
+- [Python SDK](https://pypi.org/project/aira-sdk/)
+- [Dashboard](https://app.airaproof.com)

package/dist/client.d.ts

@@ -0,0 +1,129 @@
+import { ActionReceipt, ActionDetail, AgentDetail, AgentVersion, EvidencePackage, ComplianceSnapshot, EscrowAccount, EscrowTransaction, VerifyResult, PaginatedList } from "./types";
+export interface AiraOptions {
+    apiKey: string;
+    baseUrl?: string;
+    timeout?: number;
+}
+export declare class Aira {
+    private baseUrl;
+    private apiKey;
+    private timeout;
+    constructor(options: AiraOptions);
+    private request;
+    private get;
+    private post;
+    private put;
+    private del;
+    private paginated;
+    notarize(params: {
+        actionType: string;
+        details: string;
+        agentId?: string;
+        agentVersion?: string;
+        modelId?: string;
+        modelVersion?: string;
+        instructionHash?: string;
+        parentActionId?: string;
+        storeDetails?: boolean;
+        idempotencyKey?: string;
+    }): Promise<ActionReceipt>;
+    getAction(actionId: string): Promise<ActionDetail>;
+    listActions(params?: {
+        page?: number;
+        perPage?: number;
+        actionType?: string;
+        agentId?: string;
+        status?: string;
+    }): Promise<PaginatedList<ActionDetail>>;
+    authorizeAction(actionId: string): Promise<Record<string, unknown>>;
+    setLegalHold(actionId: string): Promise<Record<string, unknown>>;
+    releaseLegalHold(actionId: string): Promise<Record<string, unknown>>;
+    getActionChain(actionId: string): Promise<Record<string, unknown>[]>;
+    verifyAction(actionId: string): Promise<VerifyResult>;
+    registerAgent(params: {
+        agentSlug: string;
+        displayName: string;
+        description?: string;
+        capabilities?: string[];
+        public?: boolean;
+    }): Promise<AgentDetail>;
+    getAgent(slug: string): Promise<AgentDetail>;
+    listAgents(params?: {
+        page?: number;
+        status?: string;
+    }): Promise<PaginatedList<AgentDetail>>;
+    updateAgent(slug: string, fields: Partial<{
+        displayName: string;
+        description: string;
+        capabilities: string[];
+        public: boolean;
+    }>): Promise<AgentDetail>;
+    publishVersion(slug: string, params: {
+        version: string;
+        changelog?: string;
+        modelId?: string;
+        instructionHash?: string;
+        configHash?: string;
+    }): Promise<AgentVersion>;
+    listVersions(slug: string): Promise<AgentVersion[]>;
+    decommissionAgent(slug: string): Promise<AgentDetail>;
+    transferAgent(slug: string, toOrgId: string, reason?: string): Promise<Record<string, unknown>>;
+    getAgentActions(slug: string, page?: number): Promise<PaginatedList>;
+    runCase(details: string, models: string[], options?: Record<string, unknown>): Promise<Record<string, unknown>>;
+    getCase(caseId: string): Promise<Record<string, unknown>>;
+    listCases(page?: number): Promise<PaginatedList>;
+    getReceipt(receiptId: string): Promise<Record<string, unknown>>;
+    exportReceipt(receiptId: string, format?: "json" | "pdf"): Promise<Record<string, unknown>>;
+    createEvidencePackage(params: {
+        title: string;
+        actionIds: string[];
+        description?: string;
+        agentSlugs?: string[];
+    }): Promise<EvidencePackage>;
+    listEvidencePackages(page?: number): Promise<PaginatedList<EvidencePackage>>;
+    getEvidencePackage(packageId: string): Promise<EvidencePackage>;
+    timeTravel(params: {
+        pointInTime: string;
+        agentSlug?: string;
+        actionType?: string;
+    }): Promise<Record<string, unknown>>;
+    liabilityChain(actionId: string, maxDepth?: number): Promise<Record<string, unknown>[]>;
+    setAgentWill(slug: string, params: {
+        successorSlug?: string;
+        successionPolicy?: string;
+        dataRetentionDays?: number;
+        notifyEmails?: string[];
+        instructions?: string;
+    }): Promise<Record<string, unknown>>;
+    getAgentWill(slug: string): Promise<Record<string, unknown>>;
+    issueDeathCertificate(slug: string, reason?: string): Promise<Record<string, unknown>>;
+    getDeathCertificate(slug: string): Promise<Record<string, unknown>>;
+    createComplianceSnapshot(params: {
+        framework: string;
+        agentSlug?: string;
+        findings?: Record<string, string>;
+    }): Promise<ComplianceSnapshot>;
+    listComplianceSnapshots(params?: {
+        page?: number;
+        framework?: string;
+    }): Promise<PaginatedList<ComplianceSnapshot>>;
+    createEscrowAccount(params?: {
+        purpose?: string;
+        currency?: string;
+        agentId?: string;
+        counterpartyOrgId?: string;
+    }): Promise<EscrowAccount>;
+    listEscrowAccounts(page?: number): Promise<PaginatedList<EscrowAccount>>;
+    getEscrowAccount(accountId: string): Promise<EscrowAccount>;
+    escrowDeposit(accountId: string, amount: number, description?: string, referenceActionId?: string): Promise<EscrowTransaction>;
+    escrowRelease(accountId: string, amount: number, description?: string, referenceActionId?: string): Promise<EscrowTransaction>;
+    escrowDispute(accountId: string, amount: number, description: string, referenceActionId?: string): Promise<EscrowTransaction>;
+    ask(message: string, params?: {
+        history?: Record<string, unknown>[];
+        model?: string;
+    }): Promise<{
+        content: string;
+        tools_used: string[];
+        model_id?: string;
+    }>;
+}

package/dist/client.js

@@ -0,0 +1,254 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Aira = void 0;
+const types_1 = require("./types");
+const DEFAULT_BASE_URL = "https://api.airaproof.com";
+const DEFAULT_TIMEOUT = 30_000;
+const MAX_DETAILS_LENGTH = 50_000;
+function buildBody(obj) {
+    return Object.fromEntries(Object.entries(obj).filter(([, v]) => v !== undefined && v !== null));
+}
+function sanitizeDetails(text) {
+    return text.length > MAX_DETAILS_LENGTH ? text.slice(0, MAX_DETAILS_LENGTH) + "...[truncated]" : text;
+}
+class Aira {
+    baseUrl;
+    apiKey;
+    timeout;
+    constructor(options) {
+        if (!options.apiKey)
+            throw new Error("apiKey is required");
+        if (!options.apiKey.startsWith("aira_live_") && !options.apiKey.startsWith("aira_test_")) {
+            console.warn("API key does not start with 'aira_live_' or 'aira_test_' — is this correct?");
+        }
+        this.apiKey = options.apiKey;
+        this.baseUrl = (options.baseUrl ?? DEFAULT_BASE_URL).replace(/\/$/, "") + "/api/v1";
+        this.timeout = options.timeout ?? DEFAULT_TIMEOUT;
+    }
+    async request(method, path, body, auth = true) {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), this.timeout);
+        const headers = { "Content-Type": "application/json" };
+        if (auth)
+            headers["Authorization"] = `Bearer ${this.apiKey}`;
+        try {
+            const res = await fetch(`${this.baseUrl}${path}`, {
+                method,
+                headers,
+                body: body ? JSON.stringify(body) : undefined,
+                signal: controller.signal,
+            });
+            if (res.status === 204)
+                return {};
+            const data = (await res.json().catch(() => ({ error: res.statusText, code: "UNKNOWN" })));
+            if (!res.ok) {
+                throw new types_1.AiraError(res.status, data.code ?? "UNKNOWN", data.error ?? res.statusText);
+            }
+            return data;
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    get(path, params, auth = true) {
+        const qs = params ? "?" + new URLSearchParams(Object.entries(params).filter(([, v]) => v != null).map(([k, v]) => [k, String(v)])).toString() : "";
+        return this.request("GET", path + qs, undefined, auth);
+    }
+    post(path, body) {
+        return this.request("POST", path, body);
+    }
+    put(path, body) {
+        return this.request("PUT", path, body);
+    }
+    del(path) {
+        return this.request("DELETE", path);
+    }
+    paginated(data) {
+        const p = data.pagination;
+        return { data: data.data, total: p.total, page: p.page, per_page: p.per_page, has_more: p.has_more };
+    }
+    // ==================== Actions ====================
+    async notarize(params) {
+        const body = buildBody({
+            action_type: params.actionType,
+            details: sanitizeDetails(params.details),
+            agent_id: params.agentId,
+            agent_version: params.agentVersion,
+            model_id: params.modelId,
+            model_version: params.modelVersion,
+            instruction_hash: params.instructionHash,
+            parent_action_id: params.parentActionId,
+            store_details: params.storeDetails || undefined,
+            idempotency_key: params.idempotencyKey,
+        });
+        return this.post("/actions", body);
+    }
+    async getAction(actionId) {
+        return this.get(`/actions/${actionId}`);
+    }
+    async listActions(params) {
+        const data = await this.get("/actions", buildBody({
+            page: params?.page, per_page: params?.perPage, action_type: params?.actionType, agent_id: params?.agentId, status: params?.status,
+        }));
+        return this.paginated(data);
+    }
+    async authorizeAction(actionId) {
+        return this.post(`/actions/${actionId}/authorize`, {});
+    }
+    async setLegalHold(actionId) {
+        return this.post(`/actions/${actionId}/hold`, {});
+    }
+    async releaseLegalHold(actionId) {
+        return this.del(`/actions/${actionId}/hold`);
+    }
+    async getActionChain(actionId) {
+        const data = await this.get(`/actions/${actionId}/chain`);
+        return data.chain ?? [];
+    }
+    async verifyAction(actionId) {
+        return this.get(`/verify/action/${actionId}`, undefined, false);
+    }
+    // ==================== Agents ====================
+    async registerAgent(params) {
+        return this.post("/agents", buildBody({
+            agent_slug: params.agentSlug, display_name: params.displayName,
+            description: params.description, capabilities: params.capabilities, public: params.public,
+        }));
+    }
+    async getAgent(slug) {
+        return this.get(`/agents/${slug}`);
+    }
+    async listAgents(params) {
+        const data = await this.get("/agents", buildBody({ page: params?.page, status: params?.status }));
+        return this.paginated(data);
+    }
+    async updateAgent(slug, fields) {
+        return this.put(`/agents/${slug}`, buildBody({
+            display_name: fields.displayName, description: fields.description,
+            capabilities: fields.capabilities, public: fields.public,
+        }));
+    }
+    async publishVersion(slug, params) {
+        return this.post(`/agents/${slug}/versions`, buildBody({
+            version: params.version, changelog: params.changelog, model_id: params.modelId,
+            instruction_hash: params.instructionHash, config_hash: params.configHash,
+        }));
+    }
+    async listVersions(slug) {
+        return this.get(`/agents/${slug}/versions`);
+    }
+    async decommissionAgent(slug) {
+        return this.post(`/agents/${slug}/decommission`, {});
+    }
+    async transferAgent(slug, toOrgId, reason) {
+        return this.post(`/agents/${slug}/transfer`, buildBody({ to_org_id: toOrgId, reason }));
+    }
+    async getAgentActions(slug, page = 1) {
+        const data = await this.get(`/agents/${slug}/actions`, { page });
+        return this.paginated(data);
+    }
+    // ==================== Cases ====================
+    async runCase(details, models, options) {
+        const body = { details, models };
+        if (options)
+            body.options = options;
+        return this.post("/cases", body);
+    }
+    async getCase(caseId) {
+        return this.get(`/cases/${caseId}`);
+    }
+    async listCases(page = 1) {
+        const data = await this.get("/cases", { page });
+        return this.paginated(data);
+    }
+    // ==================== Receipts ====================
+    async getReceipt(receiptId) {
+        return this.get(`/receipts/${receiptId}`);
+    }
+    async exportReceipt(receiptId, format = "json") {
+        return this.get(`/receipts/${receiptId}/export`, { format });
+    }
+    // ==================== Evidence ====================
+    async createEvidencePackage(params) {
+        return this.post("/evidence/packages", buildBody({
+            title: params.title, action_ids: params.actionIds, description: params.description, agent_slugs: params.agentSlugs,
+        }));
+    }
+    async listEvidencePackages(page = 1) {
+        const data = await this.get("/evidence/packages", { page });
+        return this.paginated(data);
+    }
+    async getEvidencePackage(packageId) {
+        return this.get(`/evidence/packages/${packageId}`);
+    }
+    async timeTravel(params) {
+        return this.post("/evidence/time-travel", buildBody({
+            point_in_time: params.pointInTime, agent_slug: params.agentSlug, action_type: params.actionType,
+        }));
+    }
+    async liabilityChain(actionId, maxDepth = 10) {
+        const data = await this.get(`/evidence/liability-chain/${actionId}`, { max_depth: maxDepth });
+        return data.chain ?? [];
+    }
+    // ==================== Estate ====================
+    async setAgentWill(slug, params) {
+        return this.put(`/estate/agents/${slug}/will`, buildBody({
+            successor_slug: params.successorSlug, succession_policy: params.successionPolicy ?? "transfer_to_successor",
+            data_retention_days: params.dataRetentionDays, notify_emails: params.notifyEmails, instructions: params.instructions,
+        }));
+    }
+    async getAgentWill(slug) {
+        return this.get(`/estate/agents/${slug}/will`);
+    }
+    async issueDeathCertificate(slug, reason = "Decommissioned by organization") {
+        return this.post(`/estate/agents/${slug}/death-certificate`, { reason });
+    }
+    async getDeathCertificate(slug) {
+        return this.get(`/estate/agents/${slug}/death-certificate`);
+    }
+    async createComplianceSnapshot(params) {
+        return this.post("/estate/compliance", buildBody({
+            framework: params.framework, agent_slug: params.agentSlug, findings: params.findings,
+        }));
+    }
+    async listComplianceSnapshots(params) {
+        const data = await this.get("/estate/compliance", buildBody({
+            page: params?.page, framework: params?.framework,
+        }));
+        return this.paginated(data);
+    }
+    // ==================== Escrow ====================
+    async createEscrowAccount(params) {
+        return this.post("/escrow/accounts", buildBody({
+            purpose: params?.purpose, currency: params?.currency ?? "EUR",
+            agent_id: params?.agentId, counterparty_org_id: params?.counterpartyOrgId,
+        }));
+    }
+    async listEscrowAccounts(page = 1) {
+        const data = await this.get("/escrow/accounts", { page });
+        return this.paginated(data);
+    }
+    async getEscrowAccount(accountId) {
+        return this.get(`/escrow/accounts/${accountId}`);
+    }
+    async escrowDeposit(accountId, amount, description, referenceActionId) {
+        return this.post(`/escrow/accounts/${accountId}/deposit`, buildBody({
+            amount, description, reference_action_id: referenceActionId,
+        }));
+    }
+    async escrowRelease(accountId, amount, description, referenceActionId) {
+        return this.post(`/escrow/accounts/${accountId}/release`, buildBody({
+            amount, description, reference_action_id: referenceActionId,
+        }));
+    }
+    async escrowDispute(accountId, amount, description, referenceActionId) {
+        return this.post(`/escrow/accounts/${accountId}/dispute`, buildBody({
+            amount, description, reference_action_id: referenceActionId,
+        }));
+    }
+    // ==================== Chat ====================
+    async ask(message, params) {
+        return this.post("/chat", buildBody({ message, history: params?.history, model: params?.model }));
+    }
+}
+exports.Aira = Aira;

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { Aira } from "./client";
+export type { AiraOptions } from "./client";
+export { AiraError, type ActionReceipt, type ActionDetail, type AgentDetail, type AgentVersion, type EvidencePackage, type ComplianceSnapshot, type EscrowAccount, type EscrowTransaction, type VerifyResult, type PaginatedList, } from "./types";

package/dist/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AiraError = exports.Aira = void 0;
+var client_1 = require("./client");
+Object.defineProperty(exports, "Aira", { enumerable: true, get: function () { return client_1.Aira; } });
+var types_1 = require("./types");
+Object.defineProperty(exports, "AiraError", { enumerable: true, get: function () { return types_1.AiraError; } });

package/dist/types.d.ts

@@ -0,0 +1,123 @@
+/** Cryptographic receipt from notarizing an action. */
+export interface ActionReceipt {
+    action_id: string;
+    payload_hash: string;
+    signature: string;
+    receipt_id: string;
+    action_type: string;
+    agent_id: string | null;
+    created_at: string;
+}
+/** Full action details including receipt and authorizations. */
+export interface ActionDetail {
+    action_id: string;
+    action_type: string;
+    action_details_hash: string;
+    agent_id: string | null;
+    model_id: string | null;
+    instruction_hash: string | null;
+    parent_action_id: string | null;
+    status: string;
+    legal_hold: boolean;
+    created_at: string;
+    receipt: {
+        receipt_id: string;
+        payload_hash: string;
+        signature: string;
+        public_key_id: string;
+        timestamp_token: string | null;
+        receipt_version: string;
+        verify_url: string;
+    } | null;
+    authorizations: {
+        id: string;
+        authorizer_email: string;
+        authorized_at: string | null;
+    }[];
+    request_id: string;
+}
+/** Registered agent identity. */
+export interface AgentDetail {
+    id: string;
+    agent_slug: string;
+    display_name: string;
+    description: string | null;
+    capabilities: string[] | null;
+    status: string;
+    public: boolean;
+    registered_at: string;
+    metadata: Record<string, unknown> | null;
+    versions: AgentVersion[];
+    request_id: string;
+}
+/** Agent version info. */
+export interface AgentVersion {
+    id: string;
+    version: string;
+    model_id: string | null;
+    instruction_hash: string | null;
+    config_hash: string | null;
+    changelog: string | null;
+    status: string;
+    published_at: string | null;
+}
+/** Sealed evidence package. */
+export interface EvidencePackage {
+    id: string;
+    title: string;
+    description: string | null;
+    package_hash: string;
+    signature: string;
+    action_count: number;
+    created_at: string;
+}
+/** Compliance snapshot. */
+export interface ComplianceSnapshot {
+    id: string;
+    framework: string;
+    agent_slug: string | null;
+    findings: Record<string, string>;
+    status: string;
+    created_at: string;
+}
+/** Escrow account. */
+export interface EscrowAccount {
+    id: string;
+    status: string;
+    currency: string;
+    balance: string;
+    purpose: string | null;
+    created_at: string;
+}
+/** Escrow transaction (deposit, release, dispute). */
+export interface EscrowTransaction {
+    id: string;
+    transaction_type: string;
+    amount: string;
+    description: string | null;
+    transaction_hash: string;
+    signature: string;
+    created_at: string;
+}
+/** Public verification result. */
+export interface VerifyResult {
+    valid: boolean;
+    receipt_id: string | null;
+    verified_at: string;
+    public_key_id: string;
+    message: string;
+}
+/** Paginated list response. */
+export interface PaginatedList<T = Record<string, unknown>> {
+    data: T[];
+    total: number;
+    page: number;
+    per_page: number;
+    has_more: boolean;
+}
+/** Aira API error. */
+export declare class AiraError extends Error {
+    status: number;
+    code: string;
+    constructor(status: number, code: string, message: string);
+}

package/dist/types.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AiraError = void 0;
+/** Aira API error. */
+class AiraError extends Error {
+    status;
+    code;
+    constructor(status, code, message) {
+        super(`[${code}] ${message}`);
+        this.name = "AiraError";
+        this.status = status;
+        this.code = code;
+    }
+}
+exports.AiraError = AiraError;

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "aira-sdk",
+  "version": "0.1.0",
+  "description": "TypeScript SDK for Aira — legal infrastructure for AI agents",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "license": "MIT",
+  "author": "Aira <sdk@airaproof.com>",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/aira-proof/typescript-sdk"
+  },
+  "homepage": "https://airaproof.com",
+  "keywords": [
+    "aira",
+    "ai",
+    "agents",
+    "notarization",
+    "compliance",
+    "eu-ai-act",
+    "cryptographic-receipts"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest run",
+    "lint": "tsc --noEmit"
+  },
+  "devDependencies": {
+    "@types/node": "^25.5.0",
+    "typescript": "^5.4.0",
+    "vitest": "^2.0.0"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}