aira-sdk 0.1.3 → 0.2.2

package/dist/extras/langchain.js

@@ -0,0 +1,82 @@
+"use strict";
+/**
+ * LangChain.js integration — auto-notarize tool and chain completions.
+ *
+ * Requires: @langchain/core (peer dependency)
+ *
+ * Usage:
+ *   import { AiraCallbackHandler } from "aira-sdk/extras/langchain";
+ *   const handler = new AiraCallbackHandler(aira, "my-agent");
+ *   const chain = someChain.withConfig({ callbacks: [handler] });
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AiraCallbackHandler = void 0;
+const MAX_DETAILS = 5000;
+class AiraCallbackHandler {
+    client;
+    agentId;
+    modelId;
+    actionTypes;
+    constructor(client, agentId, options) {
+        this.client = client;
+        this.agentId = agentId;
+        this.modelId = options?.modelId;
+        this.actionTypes = {
+            tool_end: "tool_call",
+            chain_end: "chain_completed",
+            llm_end: "llm_completion",
+            ...(options?.actionTypes ?? {}),
+        };
+    }
+    notarize(actionType, details) {
+        try {
+            const params = {
+                actionType,
+                details: details.slice(0, MAX_DETAILS),
+                agentId: this.agentId,
+            };
+            if (this.modelId)
+                params.modelId = this.modelId;
+            this.client.notarize(params).catch((e) => {
+                console.warn("Aira notarize failed (non-blocking):", e);
+            });
+        }
+        catch (e) {
+            console.warn("Aira notarize failed (non-blocking):", e);
+        }
+    }
+    /** Called when a tool finishes. */
+    handleToolEnd(output, name = "unknown") {
+        this.notarize(this.actionTypes.tool_end, `Tool '${name}' completed. Output length: ${String(output).length} chars`);
+    }
+    /** Called when a chain finishes. */
+    handleChainEnd(outputs) {
+        const keys = typeof outputs === "object" && outputs ? Object.keys(outputs) : [];
+        this.notarize(this.actionTypes.chain_end, `Chain completed. Output keys: [${keys.join(", ")}]`);
+    }
+    /** Called when an LLM finishes. */
+    handleLLMEnd(generationCount) {
+        this.notarize(this.actionTypes.llm_end, `LLM completed. Generations: ${generationCount}`);
+    }
+    /**
+     * Returns a LangChain-compatible callbacks object.
+     * Use with: chain.invoke(input, { callbacks: [handler.asCallbacks()] })
+     */
+    asCallbacks() {
+        return {
+            handleToolEnd: (output, ...args) => {
+                const runId = args[1];
+                const name = args[2]?.name ?? "unknown";
+                this.handleToolEnd(String(output), name);
+            },
+            handleChainEnd: (outputs) => {
+                this.handleChainEnd((outputs ?? {}));
+            },
+            handleLLMEnd: (response) => {
+                const resp = response;
+                this.handleLLMEnd(resp?.generations?.length ?? 0);
+            },
+        };
+    }
+}
+exports.AiraCallbackHandler = AiraCallbackHandler;

package/dist/extras/mcp.d.ts

@@ -0,0 +1,49 @@
+/**
+ * MCP server exposing Aira actions as tools for AI agents.
+ *
+ * Requires: @modelcontextprotocol/sdk (peer dependency)
+ *
+ * Usage:
+ *   import { createServer } from "aira-sdk/extras/mcp";
+ *   const server = createServer({ apiKey: "aira_live_xxx" });
+ */
+import type { Aira } from "../client";
+/** Tool definition for MCP list_tools response. */
+export interface MCPTool {
+    name: string;
+    description: string;
+    inputSchema: Record<string, unknown>;
+}
+/** Text content for MCP call_tool response. */
+export interface MCPTextContent {
+    type: "text";
+    text: string;
+}
+/** MCP tool definitions exposed by the Aira server. */
+export declare function getTools(): MCPTool[];
+/** Handle an MCP tool call and return text content. */
+export declare function handleToolCall(client: Aira, name: string, args: Record<string, unknown>): Promise<MCPTextContent[]>;
+/**
+ * Create an MCP-compatible server handler object.
+ *
+ * This returns plain objects; wire it into @modelcontextprotocol/sdk's Server:
+ *
+ *   import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+ *   import { createServer } from "aira-sdk/extras/mcp";
+ *   const { listTools, callTool } = createServer(airaClient);
+ *   server.setRequestHandler(ListToolsRequestSchema, listTools);
+ *   server.setRequestHandler(CallToolRequestSchema, callTool);
+ */
+export declare function createServer(client: Aira): {
+    listTools: () => Promise<{
+        tools: MCPTool[];
+    }>;
+    callTool: (request: {
+        params: {
+            name: string;
+            arguments?: Record<string, unknown>;
+        };
+    }) => Promise<{
+        content: MCPTextContent[];
+    }>;
+};

package/dist/extras/mcp.js

@@ -0,0 +1,101 @@
+"use strict";
+/**
+ * MCP server exposing Aira actions as tools for AI agents.
+ *
+ * Requires: @modelcontextprotocol/sdk (peer dependency)
+ *
+ * Usage:
+ *   import { createServer } from "aira-sdk/extras/mcp";
+ *   const server = createServer({ apiKey: "aira_live_xxx" });
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTools = getTools;
+exports.handleToolCall = handleToolCall;
+exports.createServer = createServer;
+/** MCP tool definitions exposed by the Aira server. */
+function getTools() {
+    return [
+        {
+            name: "notarize_action",
+            description: "Notarize an AI agent action with a cryptographic receipt",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    action_type: { type: "string", description: "e.g. email_sent, loan_approved, claim_processed" },
+                    details: { type: "string", description: "What happened" },
+                    agent_id: { type: "string", description: "Agent slug" },
+                    model_id: { type: "string", description: "Model used (optional)" },
+                },
+                required: ["action_type", "details"],
+            },
+        },
+        {
+            name: "verify_action",
+            description: "Verify a notarized action's cryptographic receipt",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    action_id: { type: "string", description: "Action UUID" },
+                },
+                required: ["action_id"],
+            },
+        },
+        {
+            name: "get_receipt",
+            description: "Get the cryptographic receipt for a notarized action",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    receipt_id: { type: "string", description: "Receipt UUID" },
+                },
+                required: ["receipt_id"],
+            },
+        },
+    ];
+}
+/** Handle an MCP tool call and return text content. */
+async function handleToolCall(client, name, args) {
+    try {
+        if (name === "notarize_action") {
+            const result = await client.notarize({
+                actionType: args.action_type,
+                details: args.details,
+                agentId: args.agent_id,
+                modelId: args.model_id,
+            });
+            return [{ type: "text", text: JSON.stringify(result) }];
+        }
+        if (name === "verify_action") {
+            const result = await client.verifyAction(args.action_id);
+            return [{ type: "text", text: JSON.stringify(result) }];
+        }
+        if (name === "get_receipt") {
+            const result = await client.getReceipt(args.receipt_id);
+            return [{ type: "text", text: JSON.stringify(result) }];
+        }
+        return [{ type: "text", text: JSON.stringify({ error: `Unknown tool: ${name}` }) }];
+    }
+    catch (e) {
+        return [{ type: "text", text: JSON.stringify({ error: String(e) }) }];
+    }
+}
+/**
+ * Create an MCP-compatible server handler object.
+ *
+ * This returns plain objects; wire it into @modelcontextprotocol/sdk's Server:
+ *
+ *   import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+ *   import { createServer } from "aira-sdk/extras/mcp";
+ *   const { listTools, callTool } = createServer(airaClient);
+ *   server.setRequestHandler(ListToolsRequestSchema, listTools);
+ *   server.setRequestHandler(CallToolRequestSchema, callTool);
+ */
+function createServer(client) {
+    return {
+        listTools: async () => ({ tools: getTools() }),
+        callTool: async (request) => {
+            const content = await handleToolCall(client, request.params.name, request.params.arguments ?? {});
+            return { content };
+        },
+    };
+}

package/dist/extras/openai-agents.d.ts

@@ -0,0 +1,29 @@
+/**
+ * OpenAI Node SDK integration — guardrail that notarizes tool calls.
+ *
+ * Requires: openai (peer dependency)
+ *
+ * Usage:
+ *   import { AiraGuardrail } from "aira-sdk/extras/openai-agents";
+ *   const guardrail = new AiraGuardrail(aira, "my-agent");
+ *   guardrail.onToolCall("search", { query: "test" });
+ */
+import type { Aira } from "../client";
+export declare class AiraGuardrail {
+    private client;
+    private agentId;
+    private modelId?;
+    constructor(client: Aira, agentId: string, options?: {
+        modelId?: string;
+    });
+    private notarize;
+    /** Call after a tool execution to notarize it. */
+    onToolCall(toolName: string, args?: Record<string, unknown>): void;
+    /** Call after a tool returns to notarize the result. */
+    onToolResult(toolName: string, result?: unknown): void;
+    /**
+     * Wraps a tool function to auto-notarize calls and results.
+     * No raw user data is sent — only tool name, arg keys, and output length.
+     */
+    wrapTool<T extends (...args: unknown[]) => unknown>(toolFn: T, toolName?: string): T;
+}

package/dist/extras/openai-agents.js

@@ -0,0 +1,69 @@
+"use strict";
+/**
+ * OpenAI Node SDK integration — guardrail that notarizes tool calls.
+ *
+ * Requires: openai (peer dependency)
+ *
+ * Usage:
+ *   import { AiraGuardrail } from "aira-sdk/extras/openai-agents";
+ *   const guardrail = new AiraGuardrail(aira, "my-agent");
+ *   guardrail.onToolCall("search", { query: "test" });
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AiraGuardrail = void 0;
+const MAX_DETAILS = 5000;
+class AiraGuardrail {
+    client;
+    agentId;
+    modelId;
+    constructor(client, agentId, options) {
+        this.client = client;
+        this.agentId = agentId;
+        this.modelId = options?.modelId;
+    }
+    notarize(actionType, details) {
+        try {
+            const params = {
+                actionType,
+                details: details.slice(0, MAX_DETAILS),
+                agentId: this.agentId,
+            };
+            if (this.modelId)
+                params.modelId = this.modelId;
+            this.client.notarize(params).catch((e) => {
+                console.warn("Aira notarize failed (non-blocking):", e);
+            });
+        }
+        catch (e) {
+            console.warn("Aira notarize failed (non-blocking):", e);
+        }
+    }
+    /** Call after a tool execution to notarize it. */
+    onToolCall(toolName, args) {
+        const argKeys = Object.keys(args ?? {});
+        this.notarize("tool_call", `Tool '${toolName}' called. Arg keys: [${argKeys.join(", ")}]`);
+    }
+    /** Call after a tool returns to notarize the result. */
+    onToolResult(toolName, result) {
+        this.notarize("tool_completed", `Tool '${toolName}' completed. Result length: ${String(result).length} chars`);
+    }
+    /**
+     * Wraps a tool function to auto-notarize calls and results.
+     * No raw user data is sent — only tool name, arg keys, and output length.
+     */
+    wrapTool(toolFn, toolName) {
+        const name = toolName ?? toolFn.name ?? "unknown";
+        const self = this;
+        const wrapped = async function (...args) {
+            const kwargs = args.length > 0 && typeof args[0] === "object" && args[0]
+                ? args[0]
+                : undefined;
+            self.onToolCall(name, kwargs);
+            const result = await toolFn.apply(this, args);
+            self.onToolResult(name, result);
+            return result;
+        };
+        return wrapped;
+    }
+}
+exports.AiraGuardrail = AiraGuardrail;

package/dist/extras/vercel-ai.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Vercel AI SDK integration — middleware that notarizes tool calls and completions.
+ *
+ * Requires: ai (Vercel AI SDK, peer dependency)
+ *
+ * Usage:
+ *   import { AiraVercelMiddleware } from "aira-sdk/extras/vercel-ai";
+ *   const middleware = new AiraVercelMiddleware(aira, "my-agent");
+ *   // Use as wrap around tool calls or stream callbacks
+ */
+import type { Aira } from "../client";
+export declare class AiraVercelMiddleware {
+    private client;
+    private agentId;
+    private modelId?;
+    constructor(client: Aira, agentId: string, options?: {
+        modelId?: string;
+    });
+    private notarize;
+    /** Call after a tool execution to notarize it. */
+    onToolCall(toolName: string, argKeys?: string[]): void;
+    /** Call after a tool returns to notarize the result. */
+    onToolResult(toolName: string, resultLength: number): void;
+    /** Call when a text generation step completes. */
+    onStepFinish(stepType: string, tokenCount?: number): void;
+    /** Call when the full generation completes. */
+    onFinish(finishReason: string, totalTokens?: number): void;
+    /**
+     * Returns a Vercel AI SDK-compatible callbacks object for streamText/generateText.
+     *
+     * Usage:
+     *   const result = await streamText({ ...opts, ...middleware.asCallbacks() });
+     */
+    asCallbacks(): Record<string, (...args: unknown[]) => void>;
+    /**
+     * Wraps a tool's execute function to auto-notarize calls and results.
+     */
+    wrapTool<T extends (...args: unknown[]) => unknown>(toolFn: T, toolName: string): T;
+}

package/dist/extras/vercel-ai.js

@@ -0,0 +1,89 @@
+"use strict";
+/**
+ * Vercel AI SDK integration — middleware that notarizes tool calls and completions.
+ *
+ * Requires: ai (Vercel AI SDK, peer dependency)
+ *
+ * Usage:
+ *   import { AiraVercelMiddleware } from "aira-sdk/extras/vercel-ai";
+ *   const middleware = new AiraVercelMiddleware(aira, "my-agent");
+ *   // Use as wrap around tool calls or stream callbacks
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AiraVercelMiddleware = void 0;
+const MAX_DETAILS = 5000;
+class AiraVercelMiddleware {
+    client;
+    agentId;
+    modelId;
+    constructor(client, agentId, options) {
+        this.client = client;
+        this.agentId = agentId;
+        this.modelId = options?.modelId;
+    }
+    notarize(actionType, details) {
+        try {
+            const params = {
+                actionType,
+                details: details.slice(0, MAX_DETAILS),
+                agentId: this.agentId,
+            };
+            if (this.modelId)
+                params.modelId = this.modelId;
+            this.client.notarize(params).catch((e) => {
+                console.warn("Aira notarize failed (non-blocking):", e);
+            });
+        }
+        catch (e) {
+            console.warn("Aira notarize failed (non-blocking):", e);
+        }
+    }
+    /** Call after a tool execution to notarize it. */
+    onToolCall(toolName, argKeys = []) {
+        this.notarize("tool_call", `Tool '${toolName}' called. Arg keys: [${argKeys.join(", ")}]`);
+    }
+    /** Call after a tool returns to notarize the result. */
+    onToolResult(toolName, resultLength) {
+        this.notarize("tool_completed", `Tool '${toolName}' completed. Result length: ${resultLength} chars`);
+    }
+    /** Call when a text generation step completes. */
+    onStepFinish(stepType, tokenCount) {
+        this.notarize("step_completed", `Step '${stepType}' completed.${tokenCount != null ? ` Tokens: ${tokenCount}` : ""}`);
+    }
+    /** Call when the full generation completes. */
+    onFinish(finishReason, totalTokens) {
+        this.notarize("generation_completed", `Generation completed. Reason: ${finishReason}.${totalTokens != null ? ` Total tokens: ${totalTokens}` : ""}`);
+    }
+    /**
+     * Returns a Vercel AI SDK-compatible callbacks object for streamText/generateText.
+     *
+     * Usage:
+     *   const result = await streamText({ ...opts, ...middleware.asCallbacks() });
+     */
+    asCallbacks() {
+        return {
+            onStepFinish: (step) => {
+                const s = step;
+                this.onStepFinish(s?.stepType ?? "unknown", s?.usage?.totalTokens);
+            },
+            onFinish: (result) => {
+                const r = result;
+                this.onFinish(r?.finishReason ?? "unknown", r?.usage?.totalTokens);
+            },
+        };
+    }
+    /**
+     * Wraps a tool's execute function to auto-notarize calls and results.
+     */
+    wrapTool(toolFn, toolName) {
+        const self = this;
+        const wrapped = async function (...args) {
+            self.onToolCall(toolName, args.length > 0 && typeof args[0] === "object" && args[0] ? Object.keys(args[0]) : []);
+            const result = await toolFn.apply(this, args);
+            self.onToolResult(toolName, String(result).length);
+            return result;
+        };
+        return wrapped;
+    }
+}
+exports.AiraVercelMiddleware = AiraVercelMiddleware;

package/dist/extras/webhooks.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Webhook signature verification and event parsing for Aira webhooks.
+ */
+/** Known Aira webhook event types. */
+export declare const WebhookEventType: {
+    readonly CASE_COMPLETE: "case.complete";
+    readonly CASE_REQUIRES_REVIEW: "case.requires_human_review";
+    readonly ACTION_NOTARIZED: "action.notarized";
+    readonly ACTION_AUTHORIZED: "action.authorized";
+    readonly AGENT_REGISTERED: "agent.registered";
+    readonly AGENT_DECOMMISSIONED: "agent.decommissioned";
+    readonly EVIDENCE_SEALED: "evidence.sealed";
+    readonly ESCROW_DEPOSITED: "escrow.deposited";
+    readonly ESCROW_RELEASED: "escrow.released";
+    readonly ESCROW_DISPUTED: "escrow.disputed";
+    readonly COMPLIANCE_SNAPSHOT: "compliance.snapshot_created";
+};
+export type WebhookEventTypeName = (typeof WebhookEventType)[keyof typeof WebhookEventType];
+/** Parsed webhook event. */
+export interface WebhookEvent {
+    eventType: string;
+    data: Record<string, unknown>;
+    timestamp?: string;
+    deliveryId?: string;
+}
+/**
+ * Verify webhook signature.
+ * Signature format: sha256={hex_digest}
+ */
+export declare function verifySignature(payload: Buffer | string, signature: string, secret: string): boolean;
+/**
+ * Parse raw webhook payload into a WebhookEvent.
+ */
+export declare function parseEvent(payload: Buffer | string): WebhookEvent;

package/dist/extras/webhooks.js

@@ -0,0 +1,59 @@
+"use strict";
+/**
+ * Webhook signature verification and event parsing for Aira webhooks.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebhookEventType = void 0;
+exports.verifySignature = verifySignature;
+exports.parseEvent = parseEvent;
+const crypto_1 = require("crypto");
+/** Known Aira webhook event types. */
+exports.WebhookEventType = {
+    CASE_COMPLETE: "case.complete",
+    CASE_REQUIRES_REVIEW: "case.requires_human_review",
+    ACTION_NOTARIZED: "action.notarized",
+    ACTION_AUTHORIZED: "action.authorized",
+    AGENT_REGISTERED: "agent.registered",
+    AGENT_DECOMMISSIONED: "agent.decommissioned",
+    EVIDENCE_SEALED: "evidence.sealed",
+    ESCROW_DEPOSITED: "escrow.deposited",
+    ESCROW_RELEASED: "escrow.released",
+    ESCROW_DISPUTED: "escrow.disputed",
+    COMPLIANCE_SNAPSHOT: "compliance.snapshot_created",
+};
+/**
+ * Verify webhook signature.
+ * Signature format: sha256={hex_digest}
+ */
+function verifySignature(payload, signature, secret) {
+    if (!signature.startsWith("sha256="))
+        return false;
+    const payloadBuf = typeof payload === "string" ? Buffer.from(payload, "utf-8") : payload;
+    const expected = (0, crypto_1.createHmac)("sha256", secret).update(payloadBuf).digest("hex");
+    const expectedSig = `sha256=${expected}`;
+    // Constant-time comparison
+    try {
+        return (0, crypto_1.timingSafeEqual)(Buffer.from(signature, "utf-8"), Buffer.from(expectedSig, "utf-8"));
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Parse raw webhook payload into a WebhookEvent.
+ */
+function parseEvent(payload) {
+    let data;
+    try {
+        data = JSON.parse(typeof payload === "string" ? payload : payload.toString("utf-8"));
+    }
+    catch (e) {
+        throw new Error(`Invalid webhook payload: ${e}`);
+    }
+    return {
+        eventType: data.event ?? "unknown",
+        data: data.data ?? data,
+        timestamp: data.timestamp,
+        deliveryId: data.delivery_id,
+    };
+}

package/dist/index.d.ts

@@ -1,3 +1,6 @@
 export { Aira } from "./client";
 export type { AiraOptions } from "./client";
+export { AiraSession } from "./session";
+export { OfflineQueue } from "./offline";
+export type { QueuedRequest } from "./offline";
 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

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

package/dist/offline.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Offline queue for Aira SDK — queues actions locally, syncs later.
+ */
+export interface QueuedRequest {
+    id: string;
+    method: string;
+    path: string;
+    body: Record<string, unknown>;
+}
+export declare class OfflineQueue {
+    private items;
+    enqueue(method: string, path: string, body: Record<string, unknown>): string;
+    get pendingCount(): number;
+    clear(): void;
+    drain(): QueuedRequest[];
+}

package/dist/offline.js

@@ -0,0 +1,27 @@
+"use strict";
+/**
+ * Offline queue for Aira SDK — queues actions locally, syncs later.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OfflineQueue = void 0;
+const crypto_1 = require("crypto");
+class OfflineQueue {
+    items = [];
+    enqueue(method, path, body) {
+        const id = `offline_${(0, crypto_1.randomUUID)().replace(/-/g, "").slice(0, 12)}`;
+        this.items.push({ id, method, path, body });
+        return id;
+    }
+    get pendingCount() {
+        return this.items.length;
+    }
+    clear() {
+        this.items = [];
+    }
+    drain() {
+        const drained = [...this.items];
+        this.items = [];
+        return drained;
+    }
+}
+exports.OfflineQueue = OfflineQueue;

package/dist/session.d.ts

@@ -0,0 +1,20 @@
+/**
+ * AiraSession — scoped session with pre-filled defaults.
+ */
+import type { Aira } from "./client";
+import type { ActionReceipt } from "./types";
+export declare class AiraSession {
+    private client;
+    private defaults;
+    constructor(client: Aira, agentId: string, defaults?: Record<string, unknown>);
+    notarize(params: {
+        actionType: string;
+        details: string;
+        modelId?: string;
+        modelVersion?: string;
+        instructionHash?: string;
+        parentActionId?: string;
+        storeDetails?: boolean;
+        idempotencyKey?: string;
+    }): Promise<ActionReceipt>;
+}

package/dist/session.js

@@ -0,0 +1,24 @@
+"use strict";
+/**
+ * AiraSession — scoped session with pre-filled defaults.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AiraSession = void 0;
+class AiraSession {
+    client;
+    defaults;
+    constructor(client, agentId, defaults) {
+        this.client = client;
+        this.defaults = { agentId, ...(defaults ?? {}) };
+    }
+    async notarize(params) {
+        const merged = {
+            agentId: this.defaults.agentId,
+            ...(this.defaults.modelId ? { modelId: this.defaults.modelId } : {}),
+            ...(this.defaults.agentVersion ? { agentVersion: this.defaults.agentVersion } : {}),
+            ...params,
+        };
+        return this.client.notarize(merged);
+    }
+}
+exports.AiraSession = AiraSession;