@botbotgo/agent-harness 0.0.74 → 0.0.76

package/dist/persistence/sqlite-store.js

@@ -0,0 +1,569 @@
+import path from "node:path";
+import { mkdir, rm } from "node:fs/promises";
+import { createClient } from "@libsql/client";
+import { fileExists, readJson, writeJson } from "../utils/fs.js";
+const RUNTIME_SQLITE_SCHEMA_VERSION = 1;
+const RUNTIME_SQLITE_SCHEMA_FAMILY = "agent-harness-runtime";
+function asRow(value) {
+    return value;
+}
+function asString(value) {
+    return typeof value === "string" ? value : String(value ?? "");
+}
+function asNullableString(value) {
+    return value == null ? null : asString(value);
+}
+function asBoolean(value) {
+    return value === true || value === 1 || value === "1";
+}
+function parseJson(value) {
+    return JSON.parse(asString(value));
+}
+function toSqliteUrl(filePath) {
+    return `file:${filePath}`;
+}
+function nowIso() {
+    return new Date(Date.now()).toISOString();
+}
+async function selectProtectedThreadIds(dbPath) {
+    if (!(await fileExists(dbPath))) {
+        return [];
+    }
+    const client = createClient({ url: toSqliteUrl(dbPath) });
+    const result = await client.execute(`SELECT DISTINCT thread_id
+     FROM runs
+     WHERE checkpoint_ref IS NOT NULL
+       AND checkpoint_ref != ''
+       AND (resumable = 1 OR state NOT IN ('completed', 'failed'))`);
+    return result.rows.map((row) => asString(asRow(row).thread_id)).filter((value) => value.length > 0);
+}
+export async function listProtectedCheckpointThreadIds(dbPath) {
+    return new Set(await selectProtectedThreadIds(dbPath));
+}
+export class SqlitePersistence {
+    runRoot;
+    dbPath;
+    client = null;
+    initialized = false;
+    initialization = null;
+    constructor(runRoot, dbFile = "runtime.sqlite") {
+        this.runRoot = runRoot;
+        this.dbPath = path.join(runRoot, dbFile);
+    }
+    async getClient() {
+        if (!this.client) {
+            await mkdir(this.runRoot, { recursive: true });
+            this.client = createClient({ url: toSqliteUrl(this.dbPath) });
+        }
+        return this.client;
+    }
+    async rawExecute(sql, args) {
+        const client = await this.getClient();
+        if (args) {
+            await client.execute(sql, args);
+            return;
+        }
+        await client.execute(sql);
+    }
+    async rawSelectAll(sql, args) {
+        const client = await this.getClient();
+        const result = args ? await client.execute(sql, args) : await client.execute(sql);
+        return result.rows.map((row) => asRow(row));
+    }
+    async ensureInitialized() {
+        if (this.initialized) {
+            return;
+        }
+        if (this.initialization) {
+            await this.initialization;
+            return;
+        }
+        this.initialization = (async () => {
+            await mkdir(this.runRoot, { recursive: true });
+            await this.getClient();
+            await this.rawExecute("PRAGMA journal_mode=WAL");
+            await this.rawExecute("PRAGMA foreign_keys=ON");
+            await this.rawExecute("PRAGMA busy_timeout=5000");
+            await this.rawExecute(`
+        CREATE TABLE IF NOT EXISTS runtime_metadata (
+          key TEXT PRIMARY KEY,
+          value TEXT NOT NULL
+        )
+      `);
+            await this.ensureSchemaMetadata();
+            await this.rawExecute(`
+        CREATE TABLE IF NOT EXISTS threads (
+          thread_id TEXT PRIMARY KEY,
+          workspace_id TEXT NOT NULL,
+          entry_agent_id TEXT NOT NULL,
+          status TEXT NOT NULL,
+          latest_run_id TEXT NOT NULL,
+          created_at TEXT NOT NULL,
+          updated_at TEXT NOT NULL
+        )
+      `);
+            await this.rawExecute(`
+        CREATE TABLE IF NOT EXISTS runs (
+          run_id TEXT PRIMARY KEY,
+          thread_id TEXT NOT NULL,
+          agent_id TEXT NOT NULL,
+          execution_mode TEXT NOT NULL,
+          adapter_kind TEXT,
+          created_at TEXT NOT NULL,
+          updated_at TEXT NOT NULL,
+          state TEXT NOT NULL,
+          previous_state TEXT,
+          state_entered_at TEXT NOT NULL,
+          last_transition_at TEXT NOT NULL,
+          resumable INTEGER NOT NULL,
+          checkpoint_ref TEXT,
+          FOREIGN KEY (thread_id) REFERENCES threads(thread_id)
+        )
+      `);
+            await this.rawExecute("CREATE INDEX IF NOT EXISTS runs_thread_updated_idx ON runs(thread_id, updated_at DESC)");
+            await this.rawExecute("CREATE INDEX IF NOT EXISTS runs_state_updated_idx ON runs(state, updated_at DESC)");
+            await this.rawExecute("CREATE INDEX IF NOT EXISTS runs_agent_updated_idx ON runs(agent_id, updated_at DESC)");
+            await this.rawExecute(`
+        CREATE TABLE IF NOT EXISTS thread_messages (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          thread_id TEXT NOT NULL,
+          role TEXT NOT NULL,
+          content_json TEXT NOT NULL,
+          run_id TEXT NOT NULL,
+          created_at TEXT NOT NULL,
+          FOREIGN KEY (thread_id) REFERENCES threads(thread_id)
+        )
+      `);
+            await this.rawExecute("CREATE INDEX IF NOT EXISTS thread_messages_thread_created_idx ON thread_messages(thread_id, created_at, id)");
+            await this.rawExecute(`
+        CREATE TABLE IF NOT EXISTS events (
+          thread_id TEXT NOT NULL,
+          run_id TEXT NOT NULL,
+          sequence INTEGER NOT NULL,
+          event_json TEXT NOT NULL,
+          created_at TEXT NOT NULL,
+          PRIMARY KEY (thread_id, run_id, sequence),
+          FOREIGN KEY (thread_id) REFERENCES threads(thread_id),
+          FOREIGN KEY (run_id) REFERENCES runs(run_id)
+        )
+      `);
+            await this.rawExecute(`
+        CREATE TABLE IF NOT EXISTS approvals (
+          approval_id TEXT PRIMARY KEY,
+          pending_action_id TEXT NOT NULL,
+          thread_id TEXT NOT NULL,
+          run_id TEXT NOT NULL,
+          tool_call_id TEXT NOT NULL,
+          tool_name TEXT NOT NULL,
+          status TEXT NOT NULL,
+          requested_at TEXT NOT NULL,
+          resolved_at TEXT,
+          allowed_decisions_json TEXT NOT NULL,
+          input_preview_json TEXT NOT NULL,
+          checkpoint_ref TEXT NOT NULL,
+          event_refs_json TEXT NOT NULL,
+          FOREIGN KEY (thread_id) REFERENCES threads(thread_id),
+          FOREIGN KEY (run_id) REFERENCES runs(run_id)
+        )
+      `);
+            await this.rawExecute("CREATE INDEX IF NOT EXISTS approvals_thread_run_idx ON approvals(thread_id, run_id)");
+            await this.rawExecute("CREATE INDEX IF NOT EXISTS approvals_status_idx ON approvals(status, requested_at DESC)");
+            await this.rawExecute(`
+        CREATE TABLE IF NOT EXISTS run_requests (
+          run_id TEXT PRIMARY KEY,
+          thread_id TEXT NOT NULL,
+          request_json TEXT NOT NULL,
+          saved_at TEXT NOT NULL,
+          FOREIGN KEY (thread_id) REFERENCES threads(thread_id),
+          FOREIGN KEY (run_id) REFERENCES runs(run_id)
+        )
+      `);
+            await this.rawExecute(`
+        CREATE TABLE IF NOT EXISTS recovery_intents (
+          run_id TEXT PRIMARY KEY,
+          thread_id TEXT NOT NULL,
+          intent_json TEXT NOT NULL,
+          saved_at TEXT NOT NULL,
+          FOREIGN KEY (thread_id) REFERENCES threads(thread_id),
+          FOREIGN KEY (run_id) REFERENCES runs(run_id)
+        )
+      `);
+            await this.rawExecute(`
+        CREATE TABLE IF NOT EXISTS artifacts (
+          artifact_id TEXT PRIMARY KEY,
+          thread_id TEXT NOT NULL,
+          run_id TEXT NOT NULL,
+          kind TEXT NOT NULL,
+          path TEXT NOT NULL,
+          created_at TEXT NOT NULL,
+          FOREIGN KEY (thread_id) REFERENCES threads(thread_id),
+          FOREIGN KEY (run_id) REFERENCES runs(run_id)
+        )
+      `);
+            await this.rawExecute("CREATE INDEX IF NOT EXISTS artifacts_thread_run_idx ON artifacts(thread_id, run_id, created_at)");
+            this.initialized = true;
+        })().finally(() => {
+            this.initialization = null;
+        });
+        await this.initialization;
+    }
+    threadDir(threadId) {
+        return path.join(this.runRoot, "threads", threadId);
+    }
+    runDir(threadId, runId) {
+        return path.join(this.threadDir(threadId), "runs", runId);
+    }
+    async execute(sql, args) {
+        await this.ensureInitialized();
+        const client = await this.getClient();
+        if (args) {
+            await client.execute(sql, args);
+            return;
+        }
+        await client.execute(sql);
+    }
+    async selectOne(sql, args) {
+        await this.ensureInitialized();
+        const client = await this.getClient();
+        const result = args ? await client.execute(sql, args) : await client.execute(sql);
+        const first = result.rows[0];
+        return first ? asRow(first) : null;
+    }
+    async selectAll(sql, args) {
+        await this.ensureInitialized();
+        const client = await this.getClient();
+        const result = args ? await client.execute(sql, args) : await client.execute(sql);
+        return result.rows.map((row) => asRow(row));
+    }
+    mapThreadSummary(row) {
+        return {
+            agentId: asString(row.entry_agent_id),
+            threadId: asString(row.thread_id),
+            latestRunId: asString(row.latest_run_id),
+            createdAt: asString(row.created_at),
+            updatedAt: asString(row.updated_at),
+            status: asString(row.status),
+        };
+    }
+    mapRunSummary(row) {
+        return {
+            runId: asString(row.run_id),
+            threadId: asString(row.thread_id),
+            agentId: asString(row.agent_id),
+            executionMode: asString(row.execution_mode),
+            adapterKind: asNullableString(row.adapter_kind) ?? undefined,
+            createdAt: asString(row.created_at),
+            updatedAt: asString(row.updated_at),
+            state: asString(row.state),
+            checkpointRef: asNullableString(row.checkpoint_ref),
+            resumable: asBoolean(row.resumable),
+        };
+    }
+    mapApproval(row) {
+        return {
+            approvalId: asString(row.approval_id),
+            pendingActionId: asString(row.pending_action_id),
+            threadId: asString(row.thread_id),
+            runId: asString(row.run_id),
+            toolCallId: asString(row.tool_call_id),
+            toolName: asString(row.tool_name),
+            status: asString(row.status),
+            requestedAt: asString(row.requested_at),
+            resolvedAt: asNullableString(row.resolved_at),
+            allowedDecisions: parseJson(row.allowed_decisions_json),
+            inputPreview: parseJson(row.input_preview_json),
+            checkpointRef: asString(row.checkpoint_ref),
+            eventRefs: parseJson(row.event_refs_json),
+        };
+    }
+    async initialize() {
+        await this.ensureInitialized();
+    }
+    async ensureSchemaMetadata() {
+        const rows = await this.rawSelectAll("SELECT key, value FROM runtime_metadata WHERE key IN ('schema_family', 'schema_version')");
+        const metadata = new Map(rows.map((row) => [asString(row.key), asString(row.value)]));
+        const family = metadata.get("schema_family");
+        const version = metadata.get("schema_version");
+        if (!family && !version) {
+            await this.rawExecute("INSERT OR REPLACE INTO runtime_metadata (key, value) VALUES (?, ?)", ["schema_family", RUNTIME_SQLITE_SCHEMA_FAMILY]);
+            await this.rawExecute("INSERT OR REPLACE INTO runtime_metadata (key, value) VALUES (?, ?)", ["schema_version", String(RUNTIME_SQLITE_SCHEMA_VERSION)]);
+            return;
+        }
+        if (family !== RUNTIME_SQLITE_SCHEMA_FAMILY) {
+            throw new Error(`Unsupported runtime sqlite schema family ${JSON.stringify(family)} in ${this.dbPath}. Expected ${JSON.stringify(RUNTIME_SQLITE_SCHEMA_FAMILY)}.`);
+        }
+        if (version !== String(RUNTIME_SQLITE_SCHEMA_VERSION)) {
+            throw new Error(`Unsupported runtime sqlite schema version ${JSON.stringify(version)} in ${this.dbPath}. Expected ${RUNTIME_SQLITE_SCHEMA_VERSION}.`);
+        }
+    }
+    async createThread(input) {
+        await mkdir(this.threadDir(input.threadId), { recursive: true });
+        await this.execute(`INSERT OR REPLACE INTO threads
+       (thread_id, workspace_id, entry_agent_id, status, latest_run_id, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?)`, [input.threadId, "default", input.agentId, input.status, input.runId, input.createdAt, input.createdAt]);
+    }
+    async createRun(input) {
+        await mkdir(path.join(this.runDir(input.threadId, input.runId), "events"), { recursive: true });
+        await this.execute(`INSERT OR REPLACE INTO runs
+       (run_id, thread_id, agent_id, execution_mode, adapter_kind, created_at, updated_at, state, previous_state, state_entered_at, last_transition_at, resumable, checkpoint_ref)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+            input.runId,
+            input.threadId,
+            input.agentId,
+            input.executionMode,
+            input.adapterKind ?? input.executionMode ?? null,
+            input.createdAt,
+            input.createdAt,
+            "running",
+            null,
+            input.createdAt,
+            input.createdAt,
+            0,
+            null,
+        ]);
+    }
+    async setRunState(threadId, runId, state, checkpointRef) {
+        const current = await this.getRunLifecycle(threadId, runId);
+        const now = nowIso();
+        const nextCheckpointRef = checkpointRef === undefined ? current.checkpointRef : checkpointRef;
+        const resumable = state === "waiting_for_approval" ? 1 : 0;
+        await this.execute(`UPDATE runs
+       SET state = ?, previous_state = ?, state_entered_at = ?, last_transition_at = ?, updated_at = ?, resumable = ?, checkpoint_ref = ?
+       WHERE run_id = ? AND thread_id = ?`, [state, current.state, now, now, now, resumable, nextCheckpointRef, runId, threadId]);
+        await this.execute(`UPDATE threads
+       SET status = ?, latest_run_id = ?, updated_at = ?
+       WHERE thread_id = ?`, [state, runId, now, threadId]);
+    }
+    async appendEvent(event) {
+        await this.execute(`INSERT OR REPLACE INTO events
+       (thread_id, run_id, sequence, event_json, created_at)
+       VALUES (?, ?, ?, ?, ?)`, [event.threadId, event.runId, event.sequence, JSON.stringify(event), event.timestamp]);
+    }
+    async listSessions() {
+        const rows = await this.selectAll(`SELECT thread_id, entry_agent_id, latest_run_id, created_at, updated_at, status
+       FROM threads
+       ORDER BY updated_at DESC`);
+        return rows.map((row) => this.mapThreadSummary(row));
+    }
+    async listRuns() {
+        const rows = await this.selectAll(`SELECT run_id, thread_id, agent_id, execution_mode, adapter_kind, created_at, updated_at, state, checkpoint_ref, resumable
+       FROM runs
+       ORDER BY updated_at DESC`);
+        return rows.map((row) => this.mapRunSummary(row));
+    }
+    async getRun(runId) {
+        const row = await this.selectOne(`SELECT run_id, thread_id, agent_id, execution_mode, adapter_kind, created_at, updated_at, state, checkpoint_ref, resumable
+       FROM runs
+       WHERE run_id = ?`, [runId]);
+        return row ? this.mapRunSummary(row) : null;
+    }
+    async getSession(threadId) {
+        const row = await this.selectOne(`SELECT thread_id, entry_agent_id, latest_run_id, created_at, updated_at, status
+       FROM threads
+       WHERE thread_id = ?`, [threadId]);
+        return row ? this.mapThreadSummary(row) : null;
+    }
+    async getThreadMeta(threadId) {
+        const row = await this.selectOne("SELECT * FROM threads WHERE thread_id = ?", [threadId]);
+        if (!row) {
+            return null;
+        }
+        return {
+            threadId: asString(row.thread_id),
+            workspaceId: asString(row.workspace_id),
+            entryAgentId: asString(row.entry_agent_id),
+            createdAt: asString(row.created_at),
+            updatedAt: asString(row.updated_at),
+            status: asString(row.status),
+            latestRunId: asString(row.latest_run_id),
+        };
+    }
+    async listThreadRuns(threadId) {
+        const rows = await this.selectAll(`SELECT run_id, thread_id, agent_id, execution_mode, adapter_kind, created_at, updated_at, state, checkpoint_ref, resumable
+       FROM runs
+       WHERE thread_id = ?
+       ORDER BY created_at DESC`, [threadId]);
+        return rows.map((row) => this.mapRunSummary(row));
+    }
+    async listRunEvents(threadId, runId) {
+        const rows = await this.selectAll(`SELECT event_json
+       FROM events
+       WHERE thread_id = ? AND run_id = ?
+       ORDER BY sequence ASC`, [threadId, runId]);
+        return rows.map((row) => parseJson(row.event_json));
+    }
+    async listApprovals() {
+        const rows = await this.selectAll("SELECT * FROM approvals ORDER BY requested_at ASC, approval_id ASC");
+        return rows.map((row) => this.mapApproval(row));
+    }
+    async getApproval(approvalId) {
+        const row = await this.selectOne("SELECT * FROM approvals WHERE approval_id = ?", [approvalId]);
+        return row ? this.mapApproval(row) : null;
+    }
+    async getRunApprovals(threadId, runId) {
+        const rows = await this.selectAll("SELECT * FROM approvals WHERE thread_id = ? AND run_id = ? ORDER BY requested_at ASC, approval_id ASC", [threadId, runId]);
+        return rows.map((row) => this.mapApproval(row));
+    }
+    async getRunMeta(threadId, runId) {
+        const row = await this.selectOne(`SELECT run_id, thread_id, agent_id, execution_mode, adapter_kind, created_at, updated_at
+       FROM runs
+       WHERE thread_id = ? AND run_id = ?`, [threadId, runId]);
+        if (!row) {
+            throw new Error(`Missing run ${runId} for thread ${threadId}`);
+        }
+        return {
+            runId: asString(row.run_id),
+            threadId: asString(row.thread_id),
+            agentId: asString(row.agent_id),
+            executionMode: asString(row.execution_mode),
+            adapterKind: asNullableString(row.adapter_kind) ?? undefined,
+            createdAt: asString(row.created_at),
+            updatedAt: asString(row.updated_at),
+        };
+    }
+    async getRunLifecycle(threadId, runId) {
+        const row = await this.selectOne(`SELECT state, previous_state, state_entered_at, last_transition_at, resumable, checkpoint_ref
+       FROM runs
+       WHERE thread_id = ? AND run_id = ?`, [threadId, runId]);
+        if (!row) {
+            throw new Error(`Missing run lifecycle ${runId} for thread ${threadId}`);
+        }
+        return {
+            state: asString(row.state),
+            previousState: asNullableString(row.previous_state),
+            stateEnteredAt: asString(row.state_entered_at),
+            lastTransitionAt: asString(row.last_transition_at),
+            resumable: asBoolean(row.resumable),
+            checkpointRef: asNullableString(row.checkpoint_ref),
+        };
+    }
+    async deleteThread(threadId) {
+        const exists = await this.getSession(threadId);
+        if (!exists) {
+            return false;
+        }
+        await this.execute("DELETE FROM artifacts WHERE thread_id = ?", [threadId]);
+        await this.execute("DELETE FROM approvals WHERE thread_id = ?", [threadId]);
+        await this.execute("DELETE FROM events WHERE thread_id = ?", [threadId]);
+        await this.execute("DELETE FROM run_requests WHERE thread_id = ?", [threadId]);
+        await this.execute("DELETE FROM recovery_intents WHERE thread_id = ?", [threadId]);
+        await this.execute("DELETE FROM thread_messages WHERE thread_id = ?", [threadId]);
+        await this.execute("DELETE FROM runs WHERE thread_id = ?", [threadId]);
+        await this.execute("DELETE FROM threads WHERE thread_id = ?", [threadId]);
+        await rm(this.threadDir(threadId), { recursive: true, force: true });
+        return true;
+    }
+    async saveRunRequest(threadId, runId, request) {
+        await this.execute(`INSERT OR REPLACE INTO run_requests
+       (run_id, thread_id, request_json, saved_at)
+       VALUES (?, ?, ?, ?)`, [runId, threadId, JSON.stringify(request), request.savedAt]);
+    }
+    async getRunRequest(threadId, runId) {
+        const row = await this.selectOne("SELECT request_json FROM run_requests WHERE thread_id = ? AND run_id = ?", [threadId, runId]);
+        return row ? parseJson(row.request_json) : null;
+    }
+    async clearRunRequest(threadId, runId) {
+        await this.execute("DELETE FROM run_requests WHERE thread_id = ? AND run_id = ?", [threadId, runId]);
+    }
+    async createApproval(record) {
+        await this.execute(`INSERT OR REPLACE INTO approvals
+       (approval_id, pending_action_id, thread_id, run_id, tool_call_id, tool_name, status, requested_at, resolved_at, allowed_decisions_json, input_preview_json, checkpoint_ref, event_refs_json)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+            record.approvalId,
+            record.pendingActionId,
+            record.threadId,
+            record.runId,
+            record.toolCallId,
+            record.toolName,
+            record.status,
+            record.requestedAt,
+            record.resolvedAt,
+            JSON.stringify(record.allowedDecisions),
+            JSON.stringify(record.inputPreview),
+            record.checkpointRef,
+            JSON.stringify(record.eventRefs),
+        ]);
+    }
+    async resolveApproval(threadId, runId, approvalId, status) {
+        const current = await this.getApproval(approvalId);
+        if (!current || current.threadId !== threadId || current.runId !== runId) {
+            throw new Error(`Missing approval ${approvalId} for run ${runId}`);
+        }
+        const updated = {
+            ...current,
+            status,
+            resolvedAt: nowIso(),
+        };
+        await this.createApproval(updated);
+        return updated;
+    }
+    async createArtifact(threadId, runId, artifact, content) {
+        const filePath = path.join(this.runDir(threadId, runId), artifact.path);
+        await mkdir(path.dirname(filePath), { recursive: true });
+        await writeJson(filePath, content);
+        await this.execute(`INSERT OR REPLACE INTO artifacts
+       (artifact_id, thread_id, run_id, kind, path, created_at)
+       VALUES (?, ?, ?, ?, ?, ?)`, [artifact.artifactId, threadId, runId, artifact.kind, artifact.path, artifact.createdAt]);
+        return artifact;
+    }
+    async listArtifacts(threadId, runId) {
+        const rows = await this.selectAll(`SELECT artifact_id, kind, path, created_at
+       FROM artifacts
+       WHERE thread_id = ? AND run_id = ?
+       ORDER BY created_at ASC, artifact_id ASC`, [threadId, runId]);
+        return {
+            threadId,
+            runId,
+            items: rows.map((row) => ({
+                artifactId: asString(row.artifact_id),
+                kind: asString(row.kind),
+                path: asString(row.path),
+                createdAt: asString(row.created_at),
+            })),
+        };
+    }
+    async appendThreadMessage(threadId, message) {
+        await this.execute(`INSERT INTO thread_messages
+       (thread_id, role, content_json, run_id, created_at)
+       VALUES (?, ?, ?, ?, ?)`, [threadId, message.role, JSON.stringify(message.content), message.runId, message.createdAt]);
+    }
+    async listThreadMessages(threadId, limit = 12) {
+        const rows = await this.selectAll(`SELECT role, content_json, run_id, created_at
+       FROM (
+         SELECT role, content_json, run_id, created_at, id
+         FROM thread_messages
+         WHERE thread_id = ?
+         ORDER BY created_at DESC, id DESC
+         LIMIT ?
+       ) recent
+       ORDER BY created_at ASC, id ASC`, [threadId, limit]);
+        return rows.map((row) => ({
+            role: asString(row.role),
+            content: parseJson(row.content_json),
+            runId: asString(row.run_id),
+            createdAt: asString(row.created_at),
+        }));
+    }
+    async saveRecoveryIntent(threadId, runId, intent) {
+        const savedAt = typeof intent.savedAt === "string"
+            ? (intent.savedAt)
+            : nowIso();
+        await this.execute(`INSERT OR REPLACE INTO recovery_intents
+       (run_id, thread_id, intent_json, saved_at)
+       VALUES (?, ?, ?, ?)`, [runId, threadId, JSON.stringify(intent), savedAt]);
+    }
+    async getRecoveryIntent(threadId, runId) {
+        const row = await this.selectOne("SELECT intent_json FROM recovery_intents WHERE thread_id = ? AND run_id = ?", [threadId, runId]);
+        return row ? parseJson(row.intent_json) : null;
+    }
+    async clearRecoveryIntent(threadId, runId) {
+        await this.execute("DELETE FROM recovery_intents WHERE thread_id = ? AND run_id = ?", [threadId, runId]);
+    }
+    async readArtifact(threadId, runId, artifactPath) {
+        const filePath = path.join(this.runDir(threadId, runId), artifactPath);
+        if (!(await fileExists(filePath))) {
+            return null;
+        }
+        return readJson(filePath);
+    }
+}

package/dist/persistence/types.d.ts

@@ -0,0 +1,83 @@
+import type { ArtifactListing, ArtifactRecord, HarnessEvent, InternalApprovalRecord, InvocationEnvelope, MessageContent, RunState, RunSummary, ThreadRunRecord, ThreadSummary, TranscriptMessage } from "../contracts/types.js";
+export type PersistenceThreadMeta = {
+    threadId: string;
+    workspaceId: string;
+    entryAgentId: string;
+    createdAt: string;
+    updatedAt: string;
+    status: RunState;
+    latestRunId: string;
+};
+export type PersistenceRunMeta = {
+    runId: string;
+    threadId: string;
+    agentId: string;
+    executionMode: string;
+    adapterKind?: string;
+    createdAt: string;
+    updatedAt: string;
+};
+export type PersistenceLifecycle = {
+    state: RunState;
+    previousState: RunState | null;
+    stateEnteredAt: string;
+    lastTransitionAt: string;
+    resumable: boolean;
+    checkpointRef: string | null;
+};
+export type PersistedRunRequest = {
+    input: MessageContent;
+    invocation?: InvocationEnvelope;
+    savedAt: string;
+};
+export type RecoveryIntent = {
+    kind: "approval-decision";
+    savedAt: string;
+    checkpointRef: string | null;
+    resumePayload: unknown;
+    attempts: number;
+};
+export interface RuntimePersistence {
+    initialize(): Promise<void>;
+    createThread(input: {
+        threadId: string;
+        agentId: string;
+        runId: string;
+        status: RunState;
+        createdAt: string;
+    }): Promise<void>;
+    createRun(input: {
+        threadId: string;
+        runId: string;
+        agentId: string;
+        executionMode: string;
+        adapterKind?: string;
+        createdAt: string;
+    }): Promise<void>;
+    setRunState(threadId: string, runId: string, state: RunState, checkpointRef?: string | null): Promise<void>;
+    appendEvent(event: HarnessEvent): Promise<void>;
+    listSessions(): Promise<ThreadSummary[]>;
+    listRuns(): Promise<RunSummary[]>;
+    getRun(runId: string): Promise<RunSummary | null>;
+    getSession(threadId: string): Promise<ThreadSummary | null>;
+    getThreadMeta(threadId: string): Promise<PersistenceThreadMeta | null>;
+    listThreadRuns(threadId: string): Promise<ThreadRunRecord[]>;
+    listApprovals(): Promise<InternalApprovalRecord[]>;
+    getApproval(approvalId: string): Promise<InternalApprovalRecord | null>;
+    getRunApprovals(threadId: string, runId: string): Promise<InternalApprovalRecord[]>;
+    getRunMeta(threadId: string, runId: string): Promise<PersistenceRunMeta>;
+    getRunLifecycle(threadId: string, runId: string): Promise<PersistenceLifecycle>;
+    deleteThread(threadId: string): Promise<boolean>;
+    saveRunRequest(threadId: string, runId: string, request: PersistedRunRequest): Promise<void>;
+    getRunRequest(threadId: string, runId: string): Promise<PersistedRunRequest | null>;
+    clearRunRequest(threadId: string, runId: string): Promise<void>;
+    createApproval(record: InternalApprovalRecord): Promise<void>;
+    resolveApproval(threadId: string, runId: string, approvalId: string, status: InternalApprovalRecord["status"]): Promise<InternalApprovalRecord>;
+    createArtifact(threadId: string, runId: string, artifact: ArtifactRecord, content: unknown): Promise<ArtifactRecord>;
+    listArtifacts(threadId: string, runId: string): Promise<ArtifactListing>;
+    appendThreadMessage(threadId: string, message: TranscriptMessage): Promise<void>;
+    listThreadMessages(threadId: string, limit?: number): Promise<TranscriptMessage[]>;
+    saveRecoveryIntent(threadId: string, runId: string, intent: RecoveryIntent): Promise<void>;
+    getRecoveryIntent(threadId: string, runId: string): Promise<RecoveryIntent | null>;
+    clearRecoveryIntent(threadId: string, runId: string): Promise<void>;
+}

package/dist/persistence/types.js

@@ -0,0 +1 @@
+export {};

package/dist/runtime/agent-runtime-adapter.d.ts

@@ -24,6 +24,9 @@ export declare class AgentRuntimeAdapter {
     constructor(options?: RuntimeAdapterOptions);
     private resolveBindingTimeout;
     private resolveStreamIdleTimeout;
+    private resolveProviderRetryPolicy;
+    private isRetryableProviderError;
+    private invokeWithProviderRetry;
     private withTimeout;
     private iterateWithTimeout;
     private materializeModelStream;