stitchkit 0.92.0 → 0.94.0

package/dist/index-fadnxwna.js

@@ -1,1046 +0,0 @@
-import {
-  AgentConversationMessagePageSchema,
-  AgentConversationPageSchema
-} from "./index-crykmqkr.js";
-import {
-  AgentAdmissionReceiptSchema,
-  AgentConversationPurgedError,
-  AgentHistoryMutationSchema,
-  AgentRuntimeHeadSchema,
-  AgentSeedReceiptSchema,
-  AgentStoredRunSchema,
-  createAgentRuntimeStore
-} from "./index-hrbajay7.js";
-import {
-  AgentRecoverableDescriptorSchema,
-  AgentRecoverablePageSchema,
-  AgentStoreEventEnvelopeSchema,
-  AgentStoreEventPageSchema,
-  AppendAgentStoreEventSchema,
-  agentStoreEventDraft,
-  canonicalAgentJson
-} from "./index-zwkgfq1s.js";
-import {
-  AgentMessageSchema,
-  AgentRunSchema
-} from "./index-gtj3zc53.js";
-
-// src/agent-runtime/sqlite.ts
-import { AsyncLocalStorage } from "node:async_hooks";
-import { createHash } from "node:crypto";
-import { z as z2 } from "zod";
-
-// src/agent-runtime/sqlite-purge.ts
-var OWNED_TABLES = [
-  "stitchkit_agent_runtime_spills",
-  "stitchkit_agent_runtime_schedules",
-  "stitchkit_agent_runtime_projections",
-  "stitchkit_agent_runtime_events",
-  "stitchkit_agent_runtime_messages",
-  "stitchkit_agent_runtime_seeds",
-  "stitchkit_agent_runtime_admissions",
-  "stitchkit_agent_runtime_runs",
-  "stitchkit_agent_runtime_heads"
-];
-function initializeSqliteConversationPurge(database) {
-  database.exec(`
-    CREATE TABLE IF NOT EXISTS stitchkit_agent_runtime_purged (
-      conversation_id TEXT PRIMARY KEY
-    );
-  `);
-  for (const table of OWNED_TABLES) {
-    for (const operation of ["INSERT", "UPDATE"]) {
-      database.exec(`
-        CREATE TRIGGER IF NOT EXISTS ${table}_purge_${operation.toLowerCase()}
-        BEFORE ${operation} ON ${table}
-        WHEN EXISTS (
-          SELECT 1 FROM stitchkit_agent_runtime_purged WHERE conversation_id = NEW.conversation_id
-        )
-        BEGIN SELECT RAISE(ABORT, 'Agent conversation has been purged'); END;
-      `);
-    }
-  }
-}
-function sqliteConversationPurge(database) {
-  const table = database.prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'stitchkit_agent_runtime_purged'").get();
-  if (table === null || table === undefined)
-    return;
-  return {
-    async isPurged(transaction, conversationId) {
-      const row = transaction.prepare("SELECT conversation_id FROM stitchkit_agent_runtime_purged WHERE conversation_id = ?").get(conversationId);
-      return row !== null && row !== undefined;
-    },
-    async remove(transaction, conversationId) {
-      transaction.prepare("INSERT INTO stitchkit_agent_runtime_purged (conversation_id) VALUES (?)").run(conversationId);
-      for (const table2 of OWNED_TABLES) {
-        transaction.prepare(`DELETE FROM ${table2} WHERE conversation_id = ?`).run(conversationId);
-      }
-      transaction.prepare("DELETE FROM stitchkit_agent_runtime_children WHERE parent_conversation_id = ? OR child_conversation_id = ?").run(conversationId, conversationId);
-    }
-  };
-}
-
-// src/agent-runtime/store-migrations/v1-to-v2.ts
-import { randomUUID } from "node:crypto";
-import { z } from "zod";
-var ConversationRowSchema = z.object({
-  conversation_id: z.string().min(1),
-  version: z.int().nonnegative()
-});
-var PayloadRowSchema = z.object({
-  payload: z.string(),
-  terminal_assistant_payload: z.string().nullable().optional()
-});
-var HistoryRowSchema = z.object({
-  payload: z.string(),
-  active: z.union([z.literal(0), z.literal(1)])
-});
-var AdmissionRowSchema = z.object({
-  conversation_id: z.string(),
-  idempotency_key: z.string(),
-  input_payload: z.string(),
-  run_id: z.string(),
-  assistant_message_id: z.string()
-});
-function parseJson(value) {
-  return JSON.parse(value);
-}
-function createDurableTables(database) {
-  database.exec(`
-    CREATE TABLE IF NOT EXISTS stitchkit_agent_runtime_events (
-      row_id INTEGER PRIMARY KEY AUTOINCREMENT,
-      conversation_id TEXT NOT NULL,
-      seq INTEGER NOT NULL CHECK (seq > 0),
-      event_id TEXT NOT NULL UNIQUE,
-      schema_version INTEGER NOT NULL CHECK (schema_version > 0),
-      kind TEXT NOT NULL,
-      occurred_at TEXT NOT NULL,
-      ignorable INTEGER NOT NULL DEFAULT 0 CHECK (ignorable IN (0, 1)),
-      payload TEXT NOT NULL,
-      UNIQUE (conversation_id, seq)
-    );
-    CREATE INDEX IF NOT EXISTS stitchkit_agent_runtime_events_time
-      ON stitchkit_agent_runtime_events (conversation_id, occurred_at, seq);
-    CREATE TABLE IF NOT EXISTS stitchkit_agent_runtime_projections (
-      conversation_id TEXT NOT NULL,
-      name TEXT NOT NULL,
-      version INTEGER NOT NULL CHECK (version > 0),
-      upto_seq INTEGER NOT NULL CHECK (upto_seq >= 0),
-      payload TEXT NOT NULL,
-      updated_at TEXT NOT NULL,
-      PRIMARY KEY (conversation_id, name)
-    );
-    CREATE INDEX IF NOT EXISTS stitchkit_agent_runtime_projection_updates
-      ON stitchkit_agent_runtime_projections (name, updated_at, conversation_id);
-    CREATE TABLE IF NOT EXISTS stitchkit_agent_runtime_spills (
-      reference_id TEXT PRIMARY KEY,
-      conversation_id TEXT NOT NULL,
-      run_id TEXT,
-      tool_call_id TEXT,
-      media_type TEXT NOT NULL,
-      bytes INTEGER NOT NULL CHECK (bytes >= 0),
-      sha256 TEXT NOT NULL,
-      created_at TEXT NOT NULL,
-      expires_at TEXT,
-      authorization_payload TEXT,
-      payload BLOB NOT NULL
-    );
-    CREATE INDEX IF NOT EXISTS stitchkit_agent_runtime_spills_owner
-      ON stitchkit_agent_runtime_spills (conversation_id, created_at);
-    CREATE TABLE IF NOT EXISTS stitchkit_agent_runtime_schedules (
-      id TEXT PRIMARY KEY,
-      conversation_id TEXT NOT NULL,
-      kind TEXT NOT NULL,
-      next_at TEXT NOT NULL,
-      interval_ms INTEGER,
-      time_zone TEXT,
-      input_payload TEXT NOT NULL,
-      state TEXT NOT NULL,
-      occurrence INTEGER NOT NULL DEFAULT 0 CHECK (occurrence >= 0),
-      claim_owner TEXT,
-      claim_until TEXT,
-      created_at TEXT NOT NULL,
-      updated_at TEXT NOT NULL
-    );
-    CREATE INDEX IF NOT EXISTS stitchkit_agent_runtime_schedules_due
-      ON stitchkit_agent_runtime_schedules (state, next_at);
-    CREATE TABLE IF NOT EXISTS stitchkit_agent_runtime_children (
-      parent_conversation_id TEXT NOT NULL,
-      child_conversation_id TEXT NOT NULL UNIQUE,
-      seed_upto_seq INTEGER,
-      state TEXT NOT NULL,
-      budget_payload TEXT NOT NULL,
-      usage_payload TEXT NOT NULL,
-      result_reference TEXT,
-      created_at TEXT NOT NULL,
-      updated_at TEXT NOT NULL,
-      PRIMARY KEY (parent_conversation_id, child_conversation_id)
-    );
-  `);
-  try {
-    database.exec(`
-      CREATE VIRTUAL TABLE IF NOT EXISTS stitchkit_agent_runtime_events_fts
-      USING fts5(
-        conversation_id UNINDEXED,
-        event_seq UNINDEXED,
-        occurred_at UNINDEXED,
-        body,
-        tokenize = 'unicode61 remove_diacritics 2'
-      );
-      CREATE TRIGGER IF NOT EXISTS stitchkit_agent_runtime_events_fts_insert
-      AFTER INSERT ON stitchkit_agent_runtime_events BEGIN
-        INSERT INTO stitchkit_agent_runtime_events_fts(
-          rowid, conversation_id, event_seq, occurred_at, body
-        ) VALUES (new.row_id, new.conversation_id, new.seq, new.occurred_at, new.payload);
-      END;
-      CREATE TRIGGER IF NOT EXISTS stitchkit_agent_runtime_events_fts_delete
-      AFTER DELETE ON stitchkit_agent_runtime_events BEGIN
-        DELETE FROM stitchkit_agent_runtime_events_fts WHERE rowid = old.row_id;
-      END;
-    `);
-  } catch (error) {
-    throw new Error("SQLite agent-runtime requires FTS5 support", { cause: error });
-  }
-}
-function writeBaselines(database, migratedAt) {
-  const conversations = database.prepare("SELECT conversation_id, version FROM stitchkit_agent_runtime_heads ORDER BY conversation_id").all().map((row) => ConversationRowSchema.parse(row));
-  const insert = database.prepare(`
-    INSERT INTO stitchkit_agent_runtime_events (
-      conversation_id, seq, event_id, schema_version, kind, occurred_at, ignorable, payload
-    ) VALUES (?, 1, ?, 1, 'runtime/baseline', ?, 0, ?)
-  `);
-  for (const conversation of conversations) {
-    const rows = database.prepare("SELECT payload, active FROM stitchkit_agent_runtime_messages WHERE conversation_id = ? ORDER BY position, rowid").all(conversation.conversation_id).map((row) => {
-      const parsed = HistoryRowSchema.parse(row);
-      return {
-        message: AgentMessageSchema.parse(parseJson(parsed.payload)),
-        active: parsed.active === 1
-      };
-    });
-    const messages = rows.map((row) => row.message);
-    const compacted = rows.filter((row) => !row.active).map((row) => row.message.id);
-    const runs = database.prepare("SELECT payload, terminal_assistant_payload FROM stitchkit_agent_runtime_runs WHERE conversation_id = ? ORDER BY created_at, run_id").all(conversation.conversation_id).map((value) => {
-      const row = PayloadRowSchema.parse(value);
-      return {
-        schemaVersion: 1,
-        run: AgentRunSchema.parse(parseJson(row.payload)),
-        ...row.terminal_assistant_payload ? {
-          terminalAssistant: AgentMessageSchema.parse(parseJson(row.terminal_assistant_payload))
-        } : {}
-      };
-    });
-    const admissions = database.prepare("SELECT conversation_id, idempotency_key, input_payload, run_id, assistant_message_id FROM stitchkit_agent_runtime_admissions WHERE conversation_id = ? ORDER BY idempotency_key").all(conversation.conversation_id).map((value) => {
-      const row = AdmissionRowSchema.parse(value);
-      return {
-        schemaVersion: 1,
-        conversationId: row.conversation_id,
-        idempotencyKey: row.idempotency_key,
-        input: AgentMessageSchema.parse(parseJson(row.input_payload)),
-        runId: row.run_id,
-        assistantMessageId: row.assistant_message_id
-      };
-    });
-    const asOf = messages.at(-1)?.createdAt ?? runs.at(-1)?.run.createdAt;
-    insert.run(conversation.conversation_id, randomUUID(), migratedAt, canonicalAgentJson({
-      migratedAt,
-      ...asOf !== undefined && { asOf },
-      head: {
-        schemaVersion: 1,
-        conversationId: conversation.conversation_id,
-        version: conversation.version
-      },
-      messages,
-      ...compacted.length > 0 && { compacted },
-      runs,
-      admissions
-    }));
-  }
-}
-function migrateAgentRuntimeSqliteV1ToV2(database, migratedAt = new Date().toISOString()) {
-  createDurableTables(database);
-  writeBaselines(database, migratedAt);
-  database.prepare("UPDATE stitchkit_agent_runtime_meta SET value = '2' WHERE key = 'schema_version'").run();
-}
-function createAgentRuntimeSqliteV2Tables(database) {
-  createDurableTables(database);
-}
-
-// src/agent-runtime/store-migrations/v2-to-v3.ts
-function createAgentRuntimeSqliteV3Tables(database) {
-  database.exec(`
-    CREATE TABLE IF NOT EXISTS stitchkit_agent_runtime_seeds (
-      conversation_id TEXT NOT NULL,
-      seed_key TEXT NOT NULL,
-      message_ids TEXT NOT NULL,
-      created_at TEXT NOT NULL,
-      PRIMARY KEY (conversation_id, seed_key)
-    );
-  `);
-}
-function migrateAgentRuntimeSqliteV2ToV3(database) {
-  createAgentRuntimeSqliteV3Tables(database);
-  database.prepare("UPDATE stitchkit_agent_runtime_meta SET value = '3' WHERE key = 'schema_version'").run();
-}
-
-// src/agent-runtime/sqlite.ts
-var HeadRowSchema = z2.object({ version: z2.number().int().nonnegative() });
-var RunRowSchema = z2.object({
-  payload: z2.string(),
-  terminal_assistant_payload: z2.string().nullable()
-});
-var AdmissionRowSchema2 = z2.object({
-  conversation_id: z2.string(),
-  idempotency_key: z2.string(),
-  input_payload: z2.string(),
-  run_id: z2.string(),
-  assistant_message_id: z2.string()
-});
-var SeedRowSchema = z2.object({
-  conversation_id: z2.string(),
-  seed_key: z2.string(),
-  message_ids: z2.string()
-});
-var MessageRowSchema = z2.object({ payload: z2.string() });
-var PositionedMessageRowSchema = z2.object({ position: z2.number().int().nonnegative() });
-var RecoverableRowSchema = z2.object({
-  conversation_id: z2.string(),
-  run_id: z2.string(),
-  payload: z2.string()
-});
-var MetaRowSchema = z2.object({ value: z2.string() });
-var TableRowSchema = z2.object({ name: z2.string() });
-var ConversationHeadRowSchema = z2.object({
-  conversation_id: z2.string(),
-  version: z2.number().int().nonnegative()
-});
-var CountRowSchema = z2.object({ count: z2.number().int().nonnegative() });
-var MessagePageRowSchema = z2.object({
-  row_id: z2.number().int().positive(),
-  position: z2.number().int().nonnegative(),
-  active: z2.union([z2.literal(0), z2.literal(1)]),
-  payload: z2.string()
-});
-var EventRowSchema = z2.object({
-  event_id: z2.string(),
-  conversation_id: z2.string(),
-  seq: z2.int().positive(),
-  schema_version: z2.int().positive(),
-  kind: z2.string(),
-  occurred_at: z2.string(),
-  ignorable: z2.union([z2.literal(0), z2.literal(1)]),
-  payload: z2.string()
-});
-var ArchiveProjectionRowSchema = z2.object({
-  name: z2.string(),
-  version: z2.int().positive(),
-  upto_seq: z2.int().nonnegative(),
-  payload: z2.string(),
-  updated_at: z2.string()
-});
-var ArchiveSpillRowSchema = z2.object({
-  reference_id: z2.string(),
-  run_id: z2.string().nullable(),
-  tool_call_id: z2.string().nullable(),
-  media_type: z2.string(),
-  bytes: z2.int().nonnegative(),
-  sha256: z2.string(),
-  created_at: z2.string(),
-  expires_at: z2.string().nullable(),
-  authorization_payload: z2.string().nullable(),
-  payload: z2.instanceof(Uint8Array)
-});
-var SCHEMA_VERSION = 3;
-var TABLES = [
-  "stitchkit_agent_runtime_heads",
-  "stitchkit_agent_runtime_runs",
-  "stitchkit_agent_runtime_admissions",
-  "stitchkit_agent_runtime_messages",
-  "stitchkit_agent_runtime_seeds",
-  "stitchkit_agent_runtime_events",
-  "stitchkit_agent_runtime_projections",
-  "stitchkit_agent_runtime_spills",
-  "stitchkit_agent_runtime_schedules",
-  "stitchkit_agent_runtime_children"
-];
-function parseJson2(value) {
-  return JSON.parse(value);
-}
-function encodeJson(value) {
-  return JSON.stringify(value);
-}
-function missing(value) {
-  return value === null || value === undefined;
-}
-function placeholders(count) {
-  return Array.from({ length: count }, () => "?").join(", ");
-}
-function parseRunRow(value) {
-  const row = RunRowSchema.parse(value);
-  return AgentStoredRunSchema.parse({
-    schemaVersion: 1,
-    run: AgentRunSchema.parse(parseJson2(row.payload)),
-    ...row.terminal_assistant_payload === null ? {} : {
-      terminalAssistant: AgentMessageSchema.parse(parseJson2(row.terminal_assistant_payload))
-    }
-  });
-}
-function parseEventRow(value) {
-  const row = EventRowSchema.parse(value);
-  return AgentStoreEventEnvelopeSchema.parse({
-    schemaVersion: row.schema_version,
-    eventId: row.event_id,
-    conversationId: row.conversation_id,
-    seq: row.seq,
-    kind: row.kind,
-    occurredAt: row.occurred_at,
-    payload: parseJson2(row.payload),
-    ...row.ignorable === 1 && { ignorable: true }
-  });
-}
-function recoveryCursor(conversationId, runId) {
-  return encodeJson([conversationId, runId]);
-}
-function parseRecoveryCursor(cursor) {
-  return z2.tuple([z2.string().min(1), z2.string().min(1)]).parse(parseJson2(cursor));
-}
-function conversationCursor(conversationId) {
-  return encodeJson([conversationId]);
-}
-function parseConversationCursor(cursor) {
-  return z2.tuple([z2.string().min(1)]).parse(parseJson2(cursor))[0];
-}
-function messageCursor(position, rowId) {
-  return encodeJson([position, rowId]);
-}
-function parseMessageCursor(cursor) {
-  const parsed = z2.union([
-    z2.tuple([z2.int().nonnegative(), z2.int().positive()]),
-    z2.tuple([z2.int().nonnegative()])
-  ]).parse(parseJson2(cursor));
-  const [position, rowId] = parsed;
-  return { position, ...rowId !== undefined && { rowId } };
-}
-function messagePreview(message) {
-  const text = message.parts.find((part) => part.type === "text");
-  return text?.type === "text" ? text.text.slice(0, 160) : message.role;
-}
-function initializeAgentRuntimeSqlite(database) {
-  database.exec("BEGIN IMMEDIATE");
-  try {
-    const existing = database.prepare(`SELECT name FROM sqlite_master WHERE type = 'table' AND name LIKE 'stitchkit_agent_runtime_%' ORDER BY name`).all().map((row) => TableRowSchema.parse(row).name);
-    const hasMeta = existing.includes("stitchkit_agent_runtime_meta");
-    if (!hasMeta && existing.length > 0) {
-      throw new Error("Refusing an unversioned partial Stitchkit agent-runtime SQLite schema");
-    }
-    database.exec(`
-      CREATE TABLE IF NOT EXISTS stitchkit_agent_runtime_meta (
-        key TEXT PRIMARY KEY,
-        value TEXT NOT NULL
-      );
-    `);
-    const versionRow = database.prepare("SELECT value FROM stitchkit_agent_runtime_meta WHERE key = 'schema_version'").get();
-    if (!missing(versionRow)) {
-      const version = Number(MetaRowSchema.parse(versionRow).value);
-      if (version === 1) {
-        migrateAgentRuntimeSqliteV1ToV2(database);
-        migrateAgentRuntimeSqliteV2ToV3(database);
-        initializeSqliteConversationPurge(database);
-        database.exec("COMMIT");
-        return;
-      }
-      if (version === 2) {
-        migrateAgentRuntimeSqliteV2ToV3(database);
-        initializeSqliteConversationPurge(database);
-        database.exec("COMMIT");
-        return;
-      }
-      if (version !== SCHEMA_VERSION) {
-        throw new Error(`Unsupported Stitchkit agent-runtime SQLite schema version ${version}; expected ${SCHEMA_VERSION}`);
-      }
-      const missingTables = TABLES.filter((table) => !existing.includes(table));
-      if (missingTables.length > 0) {
-        throw new Error(`Refusing a partial Stitchkit agent-runtime SQLite schema; missing ${missingTables.join(", ")}`);
-      }
-      initializeSqliteConversationPurge(database);
-      database.exec("COMMIT");
-      return;
-    }
-    if (existing.some((table) => table !== "stitchkit_agent_runtime_meta")) {
-      throw new Error("Refusing an unversioned partial Stitchkit agent-runtime SQLite schema");
-    }
-    database.exec(`
-      CREATE TABLE stitchkit_agent_runtime_heads (
-        conversation_id TEXT PRIMARY KEY,
-        version INTEGER NOT NULL CHECK (version >= 0)
-      );
-      CREATE TABLE stitchkit_agent_runtime_runs (
-        conversation_id TEXT NOT NULL,
-        run_id TEXT NOT NULL,
-        assistant_message_id TEXT NOT NULL,
-        state TEXT NOT NULL,
-        created_at TEXT NOT NULL,
-        payload TEXT NOT NULL,
-        terminal_assistant_payload TEXT,
-        PRIMARY KEY (conversation_id, run_id),
-        UNIQUE (conversation_id, assistant_message_id)
-      );
-      CREATE INDEX stitchkit_agent_runtime_recoverable
-        ON stitchkit_agent_runtime_runs (state, conversation_id, run_id);
-      CREATE TABLE stitchkit_agent_runtime_admissions (
-        conversation_id TEXT NOT NULL,
-        idempotency_key TEXT NOT NULL,
-        input_message_id TEXT NOT NULL,
-        run_id TEXT NOT NULL,
-        assistant_message_id TEXT NOT NULL,
-        input_payload TEXT NOT NULL,
-        PRIMARY KEY (conversation_id, idempotency_key),
-        UNIQUE (conversation_id, input_message_id)
-      );
-      CREATE TABLE stitchkit_agent_runtime_messages (
-        conversation_id TEXT NOT NULL,
-        id TEXT NOT NULL,
-        position INTEGER NOT NULL CHECK (position >= 0),
-        active INTEGER NOT NULL DEFAULT 1 CHECK (active IN (0, 1)),
-        payload TEXT NOT NULL,
-        PRIMARY KEY (conversation_id, id)
-      );
-    `);
-    createAgentRuntimeSqliteV2Tables(database);
-    createAgentRuntimeSqliteV3Tables(database);
-    database.prepare("INSERT INTO stitchkit_agent_runtime_meta (key, value) VALUES ('schema_version', '3')").run();
-    initializeSqliteConversationPurge(database);
-    database.exec("COMMIT");
-  } catch (error) {
-    database.exec("ROLLBACK");
-    throw error;
-  }
-}
-function createSqliteAgentRuntimeStore(config) {
-  const database = config.database;
-  if (config.initialize !== false) {
-    try {
-      initializeAgentRuntimeSqlite(database);
-    } catch (error) {
-      database.close();
-      throw error;
-    }
-  }
-  let closing = false;
-  let closed = false;
-  let tail = Promise.resolve();
-  const insideScope = new AsyncLocalStorage;
-  const serial = (work) => {
-    if (closing || closed) {
-      return Promise.reject(new Error("SQLite agent-runtime store is closing"));
-    }
-    if (insideScope.getStore()) {
-      return Promise.reject(new Error("SQLite agent-runtime store called from inside its own transaction scope; use scope.database and scope.appendEvent"));
-    }
-    const result = tail.then(work, work);
-    tail = result.then(() => {
-      return;
-    }, () => {
-      return;
-    });
-    return result;
-  };
-  const runTransaction = (access, work) => serial(async () => {
-    database.exec(access === "read" ? "BEGIN" : "BEGIN IMMEDIATE");
-    try {
-      const result = await work(database);
-      database.exec("COMMIT");
-      return result;
-    } catch (error) {
-      database.exec("ROLLBACK");
-      throw error;
-    }
-  });
-  const driver = {
-    conversations: sqliteConversationPurge(database),
-    transaction: (work, options) => runTransaction(options?.access ?? "write", work),
-    head: {
-      async load(transaction, conversationId) {
-        const value = transaction.prepare("SELECT version FROM stitchkit_agent_runtime_heads WHERE conversation_id = ?").get(conversationId);
-        if (missing(value))
-          return;
-        const row = HeadRowSchema.parse(value);
-        return AgentRuntimeHeadSchema.parse({
-          schemaVersion: 1,
-          conversationId,
-          version: row.version
-        });
-      },
-      async compareAndSwap(transaction, input) {
-        const current = transaction.prepare("SELECT version FROM stitchkit_agent_runtime_heads WHERE conversation_id = ?").get(input.conversationId);
-        const actualVersion = missing(current) ? 0 : HeadRowSchema.parse(current).version;
-        if (actualVersion !== input.expectedVersion)
-          return { outcome: "conflict", actualVersion };
-        transaction.prepare(`
-            INSERT INTO stitchkit_agent_runtime_heads (conversation_id, version)
-            VALUES (?, ?)
-            ON CONFLICT (conversation_id) DO UPDATE SET version = excluded.version
-          `).run(input.conversationId, input.next.version);
-        return { outcome: "applied" };
-      }
-    },
-    runs: {
-      async load(transaction, input) {
-        const row = transaction.prepare(`
-            SELECT payload, terminal_assistant_payload
-            FROM stitchkit_agent_runtime_runs
-            WHERE conversation_id = ? AND run_id = ?
-          `).get(input.conversationId, input.runId);
-        return missing(row) ? undefined : parseRunRow(row);
-      },
-      async loadByAssistantMessageId(transaction, input) {
-        const row = transaction.prepare(`
-            SELECT payload, terminal_assistant_payload
-            FROM stitchkit_agent_runtime_runs
-            WHERE conversation_id = ? AND assistant_message_id = ?
-          `).get(input.conversationId, input.assistantMessageId);
-        return missing(row) ? undefined : parseRunRow(row);
-      },
-      async loadMany(transaction, input) {
-        if (input.runIds.length === 0)
-          return [];
-        return transaction.prepare(`
-            SELECT payload, terminal_assistant_payload
-            FROM stitchkit_agent_runtime_runs
-            WHERE conversation_id = ? AND run_id IN (${placeholders(input.runIds.length)})
-          `).all(input.conversationId, ...input.runIds).map(parseRunRow);
-      },
-      async listActive(transaction, conversationId) {
-        return transaction.prepare(`
-            SELECT payload, terminal_assistant_payload
-            FROM stitchkit_agent_runtime_runs
-            WHERE conversation_id = ? AND state IN ('queued', 'running', 'interrupt_requested')
-          `).all(conversationId).map(parseRunRow);
-      },
-      async save(transaction, rawRecord) {
-        const record = AgentStoredRunSchema.parse(rawRecord);
-        transaction.prepare(`
-            INSERT INTO stitchkit_agent_runtime_runs (
-              conversation_id, run_id, assistant_message_id, state, created_at, payload,
-              terminal_assistant_payload
-            ) VALUES (?, ?, ?, ?, ?, ?, ?)
-            ON CONFLICT (conversation_id, run_id) DO UPDATE SET
-              assistant_message_id = excluded.assistant_message_id,
-              state = excluded.state,
-              created_at = excluded.created_at,
-              payload = excluded.payload,
-              terminal_assistant_payload = excluded.terminal_assistant_payload
-          `).run(record.run.conversationId, record.run.id, record.run.assistantMessageId, record.run.state, record.run.createdAt, encodeJson(record.run), record.terminalAssistant ? encodeJson(record.terminalAssistant) : null);
-      }
-    },
-    admissions: {
-      async load(transaction, input) {
-        const value = transaction.prepare(`
-            SELECT conversation_id, idempotency_key, input_payload, run_id, assistant_message_id
-            FROM stitchkit_agent_runtime_admissions
-            WHERE conversation_id = ? AND idempotency_key = ?
-          `).get(input.conversationId, input.idempotencyKey);
-        if (missing(value))
-          return;
-        const row = AdmissionRowSchema2.parse(value);
-        return AgentAdmissionReceiptSchema.parse({
-          schemaVersion: 1,
-          conversationId: row.conversation_id,
-          idempotencyKey: row.idempotency_key,
-          input: AgentMessageSchema.parse(parseJson2(row.input_payload)),
-          runId: row.run_id,
-          assistantMessageId: row.assistant_message_id
-        });
-      },
-      async loadByInputMessageId(transaction, input) {
-        const value = transaction.prepare(`
-            SELECT conversation_id, idempotency_key, input_payload, run_id, assistant_message_id
-            FROM stitchkit_agent_runtime_admissions
-            WHERE conversation_id = ? AND input_message_id = ?
-          `).get(input.conversationId, input.inputMessageId);
-        if (missing(value))
-          return;
-        const row = AdmissionRowSchema2.parse(value);
-        return AgentAdmissionReceiptSchema.parse({
-          schemaVersion: 1,
-          conversationId: row.conversation_id,
-          idempotencyKey: row.idempotency_key,
-          input: AgentMessageSchema.parse(parseJson2(row.input_payload)),
-          runId: row.run_id,
-          assistantMessageId: row.assistant_message_id
-        });
-      },
-      async create(transaction, rawReceipt) {
-        const receipt = AgentAdmissionReceiptSchema.parse(rawReceipt);
-        transaction.prepare(`
-            INSERT INTO stitchkit_agent_runtime_admissions (
-              conversation_id, idempotency_key, input_message_id, run_id,
-              assistant_message_id, input_payload
-            ) VALUES (?, ?, ?, ?, ?, ?)
-          `).run(receipt.conversationId, receipt.idempotencyKey, receipt.input.id, receipt.runId, receipt.assistantMessageId, encodeJson(receipt.input));
-      }
-    },
-    seeds: {
-      async load(transaction, input) {
-        const value = transaction.prepare(`
-            SELECT conversation_id, seed_key, message_ids
-            FROM stitchkit_agent_runtime_seeds
-            WHERE conversation_id = ? AND seed_key = ?
-          `).get(input.conversationId, input.seedKey);
-        if (missing(value))
-          return;
-        const row = SeedRowSchema.parse(value);
-        return AgentSeedReceiptSchema.parse({
-          schemaVersion: 1,
-          conversationId: row.conversation_id,
-          seedKey: row.seed_key,
-          messageIds: z2.array(z2.string().min(1)).parse(parseJson2(row.message_ids))
-        });
-      },
-      async create(transaction, rawReceipt) {
-        const receipt = AgentSeedReceiptSchema.parse(rawReceipt);
-        transaction.prepare(`
-            INSERT INTO stitchkit_agent_runtime_seeds (
-              conversation_id, seed_key, message_ids, created_at
-            ) VALUES (?, ?, ?, ?)
-          `).run(receipt.conversationId, receipt.seedKey, encodeJson(receipt.messageIds), new Date().toISOString());
-      }
-    },
-    history: {
-      async load(transaction, conversationId) {
-        return transaction.prepare(`
-            SELECT payload FROM stitchkit_agent_runtime_messages
-            WHERE conversation_id = ? AND active = 1 ORDER BY position ASC
-          `).all(conversationId).map((value) => AgentMessageSchema.parse(parseJson2(MessageRowSchema.parse(value).payload)));
-      },
-      async hasMessage(transaction, input) {
-        const row = transaction.prepare(`
-            SELECT count(*) AS count FROM stitchkit_agent_runtime_messages
-            WHERE conversation_id = ? AND id = ?
-          `).get(input.conversationId, input.messageId);
-        return CountRowSchema.parse(row).count > 0;
-      },
-      async apply(transaction, rawMutation) {
-        const mutation = AgentHistoryMutationSchema.parse(rawMutation);
-        const message = mutation.type === "admit" ? mutation.input : mutation.type === "upsert-assistant" ? mutation.message : mutation.type === "seed" ? mutation.message : mutation.summary;
-        if (mutation.type === "seed") {
-          transaction.prepare(`
-              UPDATE stitchkit_agent_runtime_messages SET position = position + 1
-              WHERE conversation_id = ?
-            `).run(mutation.message.conversationId);
-          transaction.prepare(`
-              INSERT INTO stitchkit_agent_runtime_messages
-                (conversation_id, id, position, active, payload)
-              VALUES (?, ?, 0, 1, ?)
-              ON CONFLICT (conversation_id, id) DO UPDATE SET
-                position = excluded.position,
-                active = excluded.active,
-                payload = excluded.payload
-            `).run(mutation.message.conversationId, mutation.message.id, encodeJson(mutation.message));
-          return;
-        }
-        if (mutation.type === "replace-compacted-range") {
-          const parameters = mutation.replacedMessageIds;
-          const rows = transaction.prepare(`
-              SELECT position FROM stitchkit_agent_runtime_messages
-              WHERE conversation_id = ? AND active = 1
-                AND id IN (${placeholders(parameters.length)})
-              ORDER BY position ASC
-            `).all(message.conversationId, ...parameters).map((row) => PositionedMessageRowSchema.parse(row));
-          const anchor = rows.at(-1);
-          if (!anchor || rows.length !== parameters.length) {
-            throw new Error("Compaction range changed inside the transaction");
-          }
-          transaction.prepare(`
-              UPDATE stitchkit_agent_runtime_messages SET active = 0
-              WHERE conversation_id = ? AND id IN (${placeholders(parameters.length)})
-            `).run(message.conversationId, ...parameters);
-          transaction.prepare(`
-              INSERT INTO stitchkit_agent_runtime_messages
-                (conversation_id, id, position, active, payload)
-              VALUES (?, ?, ?, 1, ?)
-            `).run(message.conversationId, message.id, anchor.position, encodeJson(message));
-          return;
-        }
-        const existing = transaction.prepare(`
-            SELECT position FROM stitchkit_agent_runtime_messages
-            WHERE conversation_id = ? AND id = ?
-          `).get(message.conversationId, message.id);
-        if (!missing(existing)) {
-          transaction.prepare(`
-              UPDATE stitchkit_agent_runtime_messages SET payload = ?, active = 1
-              WHERE conversation_id = ? AND id = ?
-            `).run(encodeJson(message), message.conversationId, message.id);
-          return;
-        }
-        const last = transaction.prepare(`
-            SELECT position FROM stitchkit_agent_runtime_messages
-            WHERE conversation_id = ? ORDER BY position DESC LIMIT 1
-          `).get(message.conversationId);
-        const position = missing(last) ? 0 : PositionedMessageRowSchema.parse(last).position + 1;
-        transaction.prepare(`
-            INSERT INTO stitchkit_agent_runtime_messages
-              (conversation_id, id, position, active, payload)
-            VALUES (?, ?, ?, 1, ?)
-          `).run(message.conversationId, message.id, position, encodeJson(message));
-      }
-    },
-    events: {
-      async append(transaction, rawEvent) {
-        const event = rawEvent;
-        const last = transaction.prepare("SELECT COALESCE(MAX(seq), 0) AS count FROM stitchkit_agent_runtime_events WHERE conversation_id = ?").get(event.conversationId);
-        const seq = CountRowSchema.parse(last).count + 1;
-        transaction.prepare(`
-            INSERT INTO stitchkit_agent_runtime_events (
-              conversation_id, seq, event_id, schema_version, kind, occurred_at, ignorable, payload
-            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-          `).run(event.conversationId, seq, event.eventId, event.schemaVersion, event.kind, event.occurredAt, event.ignorable ? 1 : 0, encodeJson(event.payload));
-        return AgentStoreEventEnvelopeSchema.parse({ ...event, seq });
-      },
-      async list(transaction, input) {
-        const clauses = ["conversation_id = ?"];
-        const values = [input.conversationId];
-        if (input.fromSeq !== undefined) {
-          clauses.push("seq >= ?");
-          values.push(input.fromSeq);
-        }
-        if (input.toSeq !== undefined) {
-          clauses.push("seq <= ?");
-          values.push(input.toSeq);
-        }
-        const rows = transaction.prepare(`
-            SELECT event_id, conversation_id, seq, schema_version, kind, occurred_at,
-              ignorable, payload
-            FROM stitchkit_agent_runtime_events
-            WHERE ${clauses.join(" AND ")}
-            ORDER BY seq ASC LIMIT ?
-          `).all(...values, input.limit + 1).map(parseEventRow);
-        const hasMore = rows.length > input.limit;
-        const items = rows.slice(0, input.limit);
-        const lastEvent = items.at(-1);
-        return AgentStoreEventPageSchema.parse({
-          items,
-          ...hasMore && lastEvent ? { nextSeq: lastEvent.seq + 1 } : {}
-        });
-      }
-    },
-    archive: {
-      async export(transaction, conversationId) {
-        const projections = transaction.prepare(`
-            SELECT name, version, upto_seq, payload, updated_at
-            FROM stitchkit_agent_runtime_projections
-            WHERE conversation_id = ? ORDER BY name
-          `).all(conversationId).map((raw) => {
-          const row = ArchiveProjectionRowSchema.parse(raw);
-          return {
-            name: row.name,
-            version: row.version,
-            uptoSeq: row.upto_seq,
-            value: z2.json().parse(parseJson2(row.payload)),
-            updatedAt: row.updated_at
-          };
-        });
-        const spills = transaction.prepare(`
-            SELECT reference_id, run_id, tool_call_id, media_type, bytes, sha256,
-              created_at, expires_at, authorization_payload, payload
-            FROM stitchkit_agent_runtime_spills
-            WHERE conversation_id = ? ORDER BY created_at, reference_id
-          `).all(conversationId).map((raw) => {
-          const row = ArchiveSpillRowSchema.parse(raw);
-          return {
-            reference: row.reference_id,
-            ...row.run_id && { runId: row.run_id },
-            ...row.tool_call_id && { toolCallId: row.tool_call_id },
-            mediaType: row.media_type,
-            bytes: row.bytes,
-            sha256: row.sha256,
-            createdAt: row.created_at,
-            ...row.expires_at && { expiresAt: row.expires_at },
-            ...row.authorization_payload && {
-              authorization: z2.json().parse(parseJson2(row.authorization_payload))
-            },
-            base64: Buffer.from(row.payload).toString("base64")
-          };
-        });
-        return { projections, spills };
-      },
-      async import(transaction, archive) {
-        for (const raw of archive.projections) {
-          if (typeof raw === "object" && raw !== null && !Array.isArray(raw) && raw.archiveType === "runtime-snapshot") {
-            continue;
-          }
-          const projection = z2.object({
-            name: z2.string(),
-            version: z2.int().positive(),
-            uptoSeq: z2.int().nonnegative(),
-            value: z2.json(),
-            updatedAt: z2.string()
-          }).strict().parse(raw);
-          transaction.prepare(`
-              INSERT INTO stitchkit_agent_runtime_projections
-                (conversation_id, name, version, upto_seq, payload, updated_at)
-              VALUES (?, ?, ?, ?, ?, ?)
-            `).run(archive.conversationId, projection.name, projection.version, projection.uptoSeq, encodeJson(projection.value), projection.updatedAt);
-        }
-        for (const raw of archive.spills) {
-          const spill = z2.object({
-            reference: z2.string(),
-            runId: z2.string().optional(),
-            toolCallId: z2.string().optional(),
-            mediaType: z2.string(),
-            bytes: z2.int().nonnegative(),
-            sha256: z2.string(),
-            createdAt: z2.string(),
-            expiresAt: z2.string().optional(),
-            authorization: z2.json().optional(),
-            base64: z2.string()
-          }).strict().parse(raw);
-          const payload = Buffer.from(spill.base64, "base64");
-          if (payload.byteLength !== spill.bytes) {
-            throw new TypeError("Conversation archive spill byte count is inconsistent");
-          }
-          if (createHash("sha256").update(payload).digest("hex") !== spill.sha256) {
-            throw new TypeError("Conversation archive spill digest is inconsistent");
-          }
-          transaction.prepare(`
-              INSERT INTO stitchkit_agent_runtime_spills (
-                reference_id, conversation_id, run_id, tool_call_id, media_type,
-                bytes, sha256, created_at, expires_at, authorization_payload, payload
-              ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-            `).run(spill.reference, archive.conversationId, spill.runId ?? null, spill.toolCallId ?? null, spill.mediaType, spill.bytes, spill.sha256, spill.createdAt, spill.expiresAt ?? null, spill.authorization ? encodeJson(spill.authorization) : null, payload);
-        }
-      }
-    },
-    scanRecoverable: (input) => runTransaction("read", async () => {
-      const cursor = input.cursor ? parseRecoveryCursor(input.cursor) : undefined;
-      const values = cursor ? [cursor[0], cursor[0], cursor[1], input.limit + 1] : [input.limit + 1];
-      const rows = database.prepare(`
-            SELECT conversation_id, run_id, payload
-            FROM stitchkit_agent_runtime_runs
-            WHERE state IN ('queued', 'running', 'interrupt_requested')
-            ${cursor ? "AND (conversation_id > ? OR (conversation_id = ? AND run_id > ?))" : ""}
-            ORDER BY conversation_id ASC, run_id ASC LIMIT ?
-          `).all(...values).map((row) => RecoverableRowSchema.parse(row));
-      const hasMore = rows.length > input.limit;
-      const pageRows = rows.slice(0, input.limit);
-      const items = pageRows.map((row) => {
-        const run = AgentRunSchema.parse(parseJson2(row.payload));
-        return AgentRecoverableDescriptorSchema.parse({
-          conversationId: row.conversation_id,
-          run
-        });
-      });
-      const last = pageRows.at(-1);
-      return AgentRecoverablePageSchema.parse({
-        items,
-        ...hasMore && last ? { nextCursor: recoveryCursor(last.conversation_id, last.run_id) } : {}
-      });
-    })
-  };
-  return {
-    store: createAgentRuntimeStore(driver),
-    database,
-    transaction: (work) => runTransaction("write", (transaction) => insideScope.run(true, () => work({
-      database: transaction,
-      appendEvent: async (input) => {
-        const parsed = AppendAgentStoreEventSchema.parse(input);
-        if (await driver.conversations?.isPurged(transaction, parsed.conversationId)) {
-          throw new AgentConversationPurgedError;
-        }
-        return driver.events.append(transaction, agentStoreEventDraft(parsed));
-      }
-    }))),
-    conversations: {
-      list: (input) => runTransaction("read", async () => {
-        if (!Number.isSafeInteger(input.limit) || input.limit < 1 || input.limit > 1000) {
-          throw new TypeError("Conversation page limit must be between 1 and 1000");
-        }
-        const cursor = input.cursor ? parseConversationCursor(input.cursor) : undefined;
-        const search = input.search?.trim();
-        const clauses = [
-          ...cursor ? ["conversation_id > ?"] : [],
-          ...search ? ["instr(conversation_id, ?) > 0"] : []
-        ];
-        const parameters = [
-          ...cursor ? [cursor] : [],
-          ...search ? [search] : [],
-          input.limit + 1
-        ];
-        const rows = database.prepare(`
-              SELECT conversation_id, version FROM stitchkit_agent_runtime_heads
-              ${clauses.length > 0 ? `WHERE ${clauses.join(" AND ")}` : ""}
-              ORDER BY conversation_id ASC LIMIT ?
-            `).all(...parameters).map((row) => ConversationHeadRowSchema.parse(row));
-        const hasMore = rows.length > input.limit;
-        const pageRows = rows.slice(0, input.limit);
-        const items = pageRows.map((row) => {
-          const latestRaw = database.prepare(`
-                SELECT payload FROM stitchkit_agent_runtime_messages
-                WHERE conversation_id = ? AND active = 1
-                ORDER BY position DESC LIMIT 1
-              `).get(row.conversation_id);
-          if (missing(latestRaw)) {
-            throw new Error("Agent conversation head has no active history");
-          }
-          const latest = AgentMessageSchema.parse(parseJson2(MessageRowSchema.parse(latestRaw).payload));
-          const active = CountRowSchema.parse(database.prepare(`
-                  SELECT count(*) AS count FROM stitchkit_agent_runtime_runs
-                  WHERE conversation_id = ?
-                    AND state IN ('queued', 'running', 'interrupt_requested')
-                `).get(row.conversation_id));
-          return {
-            conversationId: row.conversation_id,
-            version: row.version,
-            updatedAt: latest.updatedAt,
-            preview: messagePreview(latest),
-            activeRuns: active.count
-          };
-        });
-        const last = pageRows.at(-1);
-        return AgentConversationPageSchema.parse({
-          items,
-          ...hasMore && last ? { nextCursor: conversationCursor(last.conversation_id) } : {}
-        });
-      }),
-      messages: (input) => runTransaction("read", async () => {
-        if (!Number.isSafeInteger(input.limit) || input.limit < 1 || input.limit > 1000) {
-          throw new TypeError("Conversation message page limit must be between 1 and 1000");
-        }
-        const cursor = input.cursor ? parseMessageCursor(input.cursor) : undefined;
-        const before = input.direction === "before";
-        const direction = before ? "DESC" : "ASC";
-        const comparison = cursor === undefined ? "" : cursor.rowId === undefined ? `AND position ${before ? "<" : ">"} ?` : `AND (position, rowid) ${before ? "<" : ">"} (?, ?)`;
-        const rows = database.prepare(`
-              SELECT rowid AS row_id, position, active, payload
-              FROM stitchkit_agent_runtime_messages
-              WHERE conversation_id = ?
-              ${input.includeCompacted === true ? "" : "AND active = 1"}
-              ${comparison}
-              ORDER BY position ${direction}, rowid ${direction} LIMIT ?
-            `).all(input.conversationId, ...cursor === undefined ? [] : cursor.rowId === undefined ? [cursor.position] : [cursor.position, cursor.rowId], input.limit + 1).map((row) => MessagePageRowSchema.parse(row));
-        const hasMore = rows.length > input.limit;
-        const pageRows = rows.slice(0, input.limit);
-        const ordered = before ? [...pageRows].reverse() : pageRows;
-        const boundary = pageRows.at(-1);
-        const items = ordered.map((row) => ({
-          message: AgentMessageSchema.parse(parseJson2(row.payload)),
-          active: row.active === 1
-        }));
-        return AgentConversationMessagePageSchema.parse({
-          items: items.map((entry) => entry.message),
-          compacted: items.filter((entry) => !entry.active).map((entry) => entry.message.id),
-          ...hasMore && boundary ? { nextCursor: messageCursor(boundary.position, boundary.row_id) } : {}
-        });
-      })
-    },
-    async close() {
-      if (closed)
-        return;
-      closing = true;
-      await tail;
-      database.close();
-      closed = true;
-    }
-  };
-}
-
-export { initializeAgentRuntimeSqlite, createSqliteAgentRuntimeStore };