stitchkit 0.93.0 → 0.94.1

package/dist/index-wsm5w4ee.js

@@ -0,0 +1,1023 @@
+import {
+  AcceptInputAndAssignRunSchema,
+  AcquireAgentRunSchema,
+  AgentRecoverablePageSchema,
+  AgentRunViewSchema,
+  AgentStoreEventPageSchema,
+  AgentStoreTransitionSchema,
+  AppendAgentStoreEventSchema,
+  CheckpointRunAssistantSchema,
+  CommitRunTerminalSchema,
+  ReadAgentStoreEventsSchema,
+  RecordRunOperationSchema,
+  RecoverAgentRunSchema,
+  ReplaceCompactedRangeSchema,
+  RequestRunInterruptSchema,
+  SeedConversationInputSchema,
+  agentStoreEventDraft,
+  assistantStatus,
+  canonicalAgentJson,
+  decodeAgentConversationArchive,
+  encodeAgentConversationArchive
+} from "./index-gxrt5h6v.js";
+import {
+  AgentMessageSchema,
+  AgentRecordIdSchema,
+  AgentRecordVersionSchema,
+  AgentRunSchema,
+  AgentSnapshotSchema,
+  runStateForTerminalReason
+} from "./index-gtj3zc53.js";
+
+// src/agent-runtime/purge.ts
+import { z } from "zod";
+var AgentConversationPurgeInputSchema = z.strictObject({
+  conversationId: AgentRecordIdSchema,
+  expectedVersion: AgentRecordVersionSchema.optional()
+});
+var AgentConversationPurgeResultSchema = z.discriminatedUnion("outcome", [
+  z.strictObject({ outcome: z.literal("purged") }),
+  z.strictObject({ outcome: z.literal("already_purged") }),
+  z.strictObject({ outcome: z.literal("unsupported") }),
+  z.strictObject({
+    outcome: z.literal("active"),
+    runIds: z.array(AgentRecordIdSchema).min(1)
+  }),
+  z.strictObject({ outcome: z.literal("conflict"), actualVersion: AgentRecordVersionSchema })
+]);
+
+class AgentConversationPurgedError extends Error {
+  constructor() {
+    super("Agent conversation has been purged; use a new conversation ID");
+    this.name = "AgentConversationPurgedError";
+  }
+}
+async function purgeAgentConversation(store, input) {
+  const parsed = AgentConversationPurgeInputSchema.parse(input);
+  if (!store.purgeConversation)
+    return { outcome: "unsupported" };
+  return AgentConversationPurgeResultSchema.parse(await store.purgeConversation(parsed));
+}
+
+// src/agent-runtime/store-driver-contract.ts
+import { z as z2 } from "zod";
+var AgentRuntimeHeadSchema = z2.object({
+  schemaVersion: z2.literal(1),
+  conversationId: AgentRecordIdSchema,
+  version: AgentRecordVersionSchema
+});
+var AgentStoredRunSchema = z2.object({
+  schemaVersion: z2.literal(1),
+  run: AgentRunSchema,
+  terminalAssistant: AgentMessageSchema.optional()
+});
+var AgentAdmissionReceiptSchema = z2.object({
+  schemaVersion: z2.literal(1),
+  conversationId: AgentRecordIdSchema,
+  idempotencyKey: z2.string().min(1),
+  input: AgentMessageSchema,
+  runId: AgentRecordIdSchema,
+  assistantMessageId: AgentRecordIdSchema
+});
+var AgentSeedReceiptSchema = z2.object({
+  schemaVersion: z2.literal(1),
+  conversationId: AgentRecordIdSchema,
+  seedKey: z2.string().min(1),
+  messageIds: z2.array(AgentRecordIdSchema).min(1)
+});
+var AgentHistoryMutationSchema = z2.discriminatedUnion("type", [
+  z2.object({ type: z2.literal("admit"), input: AgentMessageSchema }),
+  z2.object({
+    type: z2.literal("upsert-assistant"),
+    message: AgentMessageSchema
+  }),
+  z2.object({
+    type: z2.literal("replace-compacted-range"),
+    replacedMessageIds: z2.array(AgentRecordIdSchema).min(1),
+    summary: AgentMessageSchema
+  }),
+  z2.object({
+    type: z2.literal("seed"),
+    message: AgentMessageSchema
+  })
+]);
+var ACTIVE_AGENT_RUN_STATES = [
+  "queued",
+  "running",
+  "interrupt_requested"
+];
+function isActiveRunState(state) {
+  return ACTIVE_AGENT_RUN_STATES.includes(state);
+}
+function emptyHead(conversationId) {
+  return AgentRuntimeHeadSchema.parse({
+    schemaVersion: 1,
+    conversationId,
+    version: 0
+  });
+}
+
+// src/agent-runtime/store-create.ts
+import { z as z5 } from "zod";
+
+// src/agent-runtime/store-archive.ts
+import { z as z3 } from "zod";
+
+// src/agent-runtime/store-snapshot.ts
+function historyPositions(messages) {
+  const positions = new Map;
+  messages.forEach((message, index) => {
+    if (!positions.has(message.id))
+      positions.set(message.id, index);
+  });
+  return (run) => {
+    let earliest = Number.MAX_SAFE_INTEGER;
+    for (const id of [...run.inputMessageIds, run.assistantMessageId]) {
+      const position = positions.get(id);
+      if (position !== undefined && position < earliest)
+        earliest = position;
+    }
+    return earliest;
+  };
+}
+function orderRuns(messages, runs) {
+  const positionOf = historyPositions(messages);
+  const fallback = (left, right) => left.createdAt.localeCompare(right.createdAt) || positionOf(left) - positionOf(right) || left.id.localeCompare(right.id);
+  return [...runs].sort((left, right) => {
+    if (left.executionSequence !== undefined && right.executionSequence !== undefined && left.executionSequence !== right.executionSequence) {
+      return left.executionSequence - right.executionSequence;
+    }
+    const leftStarted = left.executionSequence !== undefined || left.state !== "queued";
+    const rightStarted = right.executionSequence !== undefined || right.state !== "queued";
+    if (leftStarted !== rightStarted)
+      return leftStarted ? -1 : 1;
+    if (!leftStarted && !rightStarted) {
+      const priority = Number(right.queuePriority !== undefined) - Number(left.queuePriority !== undefined);
+      if (priority !== 0)
+        return priority;
+    }
+    return fallback(left, right);
+  });
+}
+function orderRunMessages(messages, runs) {
+  const byId = new Map(messages.map((message) => [message.id, message]));
+  const ownedIds = new Set(runs.flatMap((run) => [...run.inputMessageIds, run.assistantMessageId]));
+  const orderedOwned = runs.flatMap((run) => [...run.inputMessageIds, run.assistantMessageId].flatMap((id) => {
+    const message = byId.get(id);
+    return message ? [message] : [];
+  }));
+  let ownedIndex = 0;
+  return messages.map((message) => {
+    if (!ownedIds.has(message.id))
+      return message;
+    const ordered = orderedOwned[ownedIndex];
+    if (!ordered)
+      throw new TypeError("Stored agent history lost a run-owned message");
+    ownedIndex += 1;
+    return ordered;
+  });
+}
+function snapshotOf(head, messages, records) {
+  validateSnapshot(head, messages, records);
+  const runs = orderRuns(messages, records.map((record) => record.run));
+  return AgentSnapshotSchema.parse({
+    schemaVersion: 1,
+    conversationId: head.conversationId,
+    version: head.version,
+    messages: orderRunMessages(messages, runs),
+    runs
+  });
+}
+function validateSnapshot(head, messages, records) {
+  const runIds = new Set;
+  const assistantIds = new Set;
+  const messageIds = new Set;
+  for (const record of records) {
+    const run = record.run;
+    if (run.conversationId !== head.conversationId || runIds.has(run.id) || assistantIds.has(run.assistantMessageId)) {
+      throw new TypeError("Stored agent runs contain inconsistent identities");
+    }
+    if (record.terminalAssistant && (record.terminalAssistant.id !== run.assistantMessageId || record.terminalAssistant.conversationId !== run.conversationId || record.terminalAssistant.runId !== run.id || record.terminalAssistant.role !== "assistant" || run.terminalReason === undefined)) {
+      throw new TypeError("Retained terminal assistant does not match its run");
+    }
+    runIds.add(run.id);
+    assistantIds.add(run.assistantMessageId);
+  }
+  for (const message of messages) {
+    if (message.conversationId !== head.conversationId || messageIds.has(message.id)) {
+      throw new TypeError("Stored agent history contains inconsistent message identities");
+    }
+    messageIds.add(message.id);
+    if (assistantIds.has(message.id) && message.runId === undefined) {
+      throw new TypeError("Stored history occupies a reserved assistant identity");
+    }
+    if (message.runId !== undefined) {
+      const run = records.find((candidate) => candidate.run.id === message.runId)?.run;
+      if (!run || message.role !== "assistant" || run.assistantMessageId !== message.id) {
+        throw new TypeError("Stored assistant history does not match its reserved run identity");
+      }
+    }
+  }
+}
+function replaceRun(runs, next) {
+  return runs.map((run) => run.id === next.id ? next : run);
+}
+function replaceMessage(messages, next) {
+  return messages.some((message) => message.id === next.id) ? messages.map((message) => message.id === next.id ? next : message) : [...messages, next];
+}
+function mergeRunRecords(...groups) {
+  const records = new Map;
+  for (const group of groups) {
+    for (const rawRecord of group) {
+      const record = AgentStoredRunSchema.parse(rawRecord);
+      const previous = records.get(record.run.id);
+      if (previous && previous.run.assistantMessageId !== record.run.assistantMessageId) {
+        throw new TypeError("Stored agent run identity changed across normalized records");
+      }
+      records.set(record.run.id, record);
+    }
+  }
+  return [...records.values()];
+}
+function referencedRunIds(messages) {
+  return [...new Set(messages.flatMap((message) => message.runId ? [message.runId] : []))];
+}
+
+// src/agent-runtime/store-reads.ts
+async function snapshotIn(driver, transaction, conversationId) {
+  const [stored, messages, activeRecords] = await Promise.all([
+    driver.head.load(transaction, conversationId),
+    driver.history.load(transaction, conversationId),
+    driver.runs.listActive(transaction, conversationId)
+  ]);
+  const head = AgentRuntimeHeadSchema.parse(stored ?? emptyHead(conversationId));
+  const referencedRecords = await driver.runs.loadMany(transaction, {
+    conversationId,
+    runIds: referencedRunIds(messages)
+  });
+  return snapshotOf(head, messages, mergeRunRecords(activeRecords, referencedRecords));
+}
+function loadSnapshot(driver, conversationId) {
+  return driver.transaction((transaction) => snapshotIn(driver, transaction, conversationId), {
+    access: "read"
+  });
+}
+function loadRun(driver, input) {
+  return driver.transaction(async (transaction) => {
+    const [stored, record] = await Promise.all([
+      driver.head.load(transaction, input.conversationId),
+      driver.runs.load(transaction, input)
+    ]);
+    if (!record)
+      return;
+    const parsed = AgentStoredRunSchema.parse(record);
+    if (parsed.run.conversationId !== input.conversationId || parsed.run.id !== input.runId) {
+      throw new TypeError("Stored run does not match the identity it was loaded by");
+    }
+    const head = AgentRuntimeHeadSchema.parse(stored ?? emptyHead(input.conversationId));
+    return AgentRunViewSchema.parse({
+      snapshotVersion: head.version,
+      run: parsed.run,
+      ...parsed.terminalAssistant && { assistant: parsed.terminalAssistant }
+    });
+  }, { access: "read" });
+}
+function listActiveRuns(driver, conversationId) {
+  return driver.transaction(async (transaction) => {
+    const [records, messages] = await Promise.all([
+      driver.runs.listActive(transaction, conversationId),
+      driver.history.load(transaction, conversationId)
+    ]);
+    const runs = records.map((record) => AgentStoredRunSchema.parse(record).run);
+    for (const run of runs) {
+      if (run.conversationId !== conversationId) {
+        throw new TypeError("Active run belongs to another conversation");
+      }
+      if (!isActiveRunState(run.state)) {
+        throw new TypeError("Active run listing returned a terminal run");
+      }
+    }
+    return orderRuns(messages, runs);
+  }, { access: "read" });
+}
+function appendEvent(driver, input) {
+  const parsed = AppendAgentStoreEventSchema.parse(input);
+  return driver.transaction((transaction) => appendEventIn(driver, transaction, parsed));
+}
+async function appendEventIn(driver, transaction, parsed) {
+  if (await driver.conversations?.isPurged(transaction, parsed.conversationId)) {
+    throw new AgentConversationPurgedError;
+  }
+  return driver.events.append(transaction, agentStoreEventDraft(parsed));
+}
+function readEvents(driver, input) {
+  const parsed = ReadAgentStoreEventsSchema.parse(input);
+  return driver.transaction(async (transaction) => AgentStoreEventPageSchema.parse(await driver.events.list(transaction, parsed)), { access: "read" });
+}
+
+// src/agent-runtime/store-archive.ts
+function exportConversation(driver, conversationId) {
+  return driver.transaction(async (transaction) => {
+    const events = [];
+    let fromSeq;
+    do {
+      const page = AgentStoreEventPageSchema.parse(await driver.events.list(transaction, ReadAgentStoreEventsSchema.parse({
+        conversationId,
+        ...fromSeq && { fromSeq },
+        limit: 1e4
+      })));
+      events.push(...page.items);
+      fromSeq = page.nextSeq;
+    } while (fromSeq !== undefined);
+    const durable = await driver.archive?.export(transaction, conversationId) ?? {
+      projections: [],
+      spills: []
+    };
+    const snapshot = await snapshotIn(driver, transaction, conversationId);
+    return encodeAgentConversationArchive({
+      format: "stitchkit.agent-conversation",
+      formatVersion: 1,
+      conversationId,
+      events,
+      projections: [
+        { archiveType: "runtime-snapshot", snapshot: z3.json().parse(snapshot) },
+        ...durable.projections
+      ],
+      spills: durable.spills
+    });
+  }, { access: "read" });
+}
+async function importConversation(driver, bytes) {
+  const archive = decodeAgentConversationArchive(bytes);
+  return driver.transaction(async (transaction) => {
+    const existing = await driver.events.list(transaction, {
+      conversationId: archive.conversationId,
+      limit: 1
+    });
+    if (existing.items.length > 0) {
+      throw new TypeError("Conversation event log must be empty before import");
+    }
+    for (const event of archive.events) {
+      const appended = await driver.events.append(transaction, {
+        schemaVersion: event.schemaVersion,
+        eventId: event.eventId,
+        conversationId: event.conversationId,
+        kind: event.kind,
+        occurredAt: event.occurredAt,
+        payload: event.payload,
+        ...event.ignorable && { ignorable: true }
+      });
+      if (appended.seq !== event.seq) {
+        throw new TypeError("Conversation archive event sequence is not contiguous");
+      }
+    }
+    const snapshotEntry = archive.projections.find((entry) => typeof entry === "object" && entry !== null && !Array.isArray(entry) && entry.archiveType === "runtime-snapshot");
+    if (snapshotEntry && typeof snapshotEntry === "object" && !Array.isArray(snapshotEntry)) {
+      const snapshot = AgentSnapshotSchema.parse(snapshotEntry.snapshot);
+      if (snapshot.conversationId !== archive.conversationId) {
+        throw new TypeError("Conversation archive snapshot belongs to another conversation");
+      }
+      if (snapshot.version > 0 || snapshot.messages.length > 0 || snapshot.runs.length > 0) {
+        const outcome = await driver.head.compareAndSwap(transaction, {
+          conversationId: snapshot.conversationId,
+          expectedVersion: 0,
+          next: AgentRuntimeHeadSchema.parse({
+            schemaVersion: 1,
+            conversationId: snapshot.conversationId,
+            version: snapshot.version
+          })
+        });
+        if (outcome.outcome !== "applied") {
+          throw new TypeError("Conversation archive snapshot target is not empty");
+        }
+      }
+      for (const run of snapshot.runs) {
+        const terminalAssistant = snapshot.messages.find((message) => message.id === run.assistantMessageId);
+        await driver.runs.save(transaction, AgentStoredRunSchema.parse({
+          schemaVersion: 1,
+          run,
+          ...terminalAssistant && { terminalAssistant }
+        }));
+      }
+      for (const message of snapshot.messages) {
+        await driver.history.apply(transaction, { type: "admit", input: message });
+      }
+      for (const event of archive.events) {
+        if (event.kind !== "runtime/transition")
+          continue;
+        const transition = AgentStoreTransitionSchema.parse(event.payload);
+        if (transition.type !== "accept")
+          continue;
+        const assigned = snapshot.runs.find((run) => run.inputMessageIds.includes(transition.input.input.id));
+        if (!assigned) {
+          throw new TypeError("Conversation archive admission has no assigned run");
+        }
+        await driver.admissions.create(transaction, AgentAdmissionReceiptSchema.parse({
+          schemaVersion: 1,
+          conversationId: archive.conversationId,
+          idempotencyKey: transition.input.idempotencyKey,
+          input: transition.input.input,
+          runId: assigned.id,
+          assistantMessageId: assigned.assistantMessageId
+        }));
+      }
+    }
+    await driver.archive?.import(transaction, archive);
+    return { conversationId: archive.conversationId, events: archive.events.length };
+  });
+}
+
+// src/agent-runtime/store-mutate.ts
+import { z as z4 } from "zod";
+
+// src/agent-runtime/store-reduce-shared.ts
+function conflict(actualVersion) {
+  return { outcome: "conflict", actualVersion };
+}
+function applied(current, input, effects) {
+  const runs = input.runs ?? current.runs;
+  const messages = input.messages ?? current.messages;
+  return {
+    outcome: "applied",
+    snapshot: AgentSnapshotSchema.parse({
+      ...current,
+      version: current.version + 1,
+      runs,
+      messages: orderRunMessages(messages, runs)
+    }),
+    ...effects?.runRecords?.length && { runRecords: effects.runRecords },
+    ...effects?.admissionReceipt && { admissionReceipt: effects.admissionReceipt },
+    ...effects?.seedReceipt && { seedReceipt: effects.seedReceipt },
+    ...effects?.historyMutations?.length && { historyMutations: effects.historyMutations }
+  };
+}
+
+// src/agent-runtime/store-reducer.ts
+import { createHash } from "node:crypto";
+
+// src/agent-runtime/store-reduce-history.ts
+function reduceAccept(current, input) {
+  if (input.expectedVersion !== undefined && input.expectedVersion !== current.version) {
+    return conflict(current.version);
+  }
+  const coalescedRun = input.coalesceIntoRunId ? current.runs.find((candidate) => candidate.id === input.coalesceIntoRunId) : undefined;
+  if (input.coalesceIntoRunId !== undefined && (!coalescedRun || coalescedRun.conversationId !== input.input.conversationId || coalescedRun.state !== "queued" || coalescedRun.ownerId !== undefined || coalescedRun.terminalReason !== undefined)) {
+    return coalescedRun ? conflict(coalescedRun.revision) : { outcome: "not_found" };
+  }
+  if (input.run.conversationId !== input.input.conversationId || input.run.inputMessageIds.length !== 1 || input.run.inputMessageIds[0] !== input.input.id || input.run.state !== "queued" || input.run.revision !== 0 || input.run.executionSequence !== undefined || input.run.ownerId !== undefined || input.run.terminalReason !== undefined || input.run.terminalPolicyName !== undefined || input.input.role !== "user" && input.input.role !== "tool" || input.input.status !== "committed" || input.input.runId !== undefined || current.messages.some((message) => message.id === input.input.id) || coalescedRun !== undefined && input.input.id === coalescedRun.assistantMessageId || !coalescedRun && (input.run.assistantMessageId === input.input.id || current.runs.some((candidate) => candidate.id === input.run.id) || current.runs.some((candidate) => candidate.assistantMessageId === input.run.assistantMessageId) || current.messages.some((message) => message.id === input.run.assistantMessageId))) {
+    throw new TypeError("Input and queued run do not form one valid assignment");
+  }
+  const assignedRun = coalescedRun ? AgentRunSchema.parse({
+    ...coalescedRun,
+    inputMessageIds: [...coalescedRun.inputMessageIds, input.input.id],
+    revision: coalescedRun.revision + 1,
+    updatedAt: new Date().toISOString()
+  }) : input.run;
+  const admissionReceipt = AgentAdmissionReceiptSchema.parse({
+    schemaVersion: 1,
+    conversationId: input.input.conversationId,
+    idempotencyKey: input.idempotencyKey,
+    input: input.input,
+    runId: assignedRun.id,
+    assistantMessageId: assignedRun.assistantMessageId
+  });
+  return applied(current, {
+    messages: [...current.messages, input.input],
+    runs: coalescedRun ? replaceRun(current.runs, assignedRun) : [...current.runs, assignedRun]
+  }, {
+    runRecords: [AgentStoredRunSchema.parse({ schemaVersion: 1, run: assignedRun })],
+    admissionReceipt,
+    historyMutations: [{ type: "admit", input: input.input }]
+  });
+}
+function reduceSeed(current, input) {
+  const conversationId = input.conversationId;
+  if (current.conversationId !== conversationId)
+    return { outcome: "not_found" };
+  for (const message of input.inputs) {
+    if (message.conversationId !== conversationId || message.role !== "user" || message.status !== "committed" || message.runId !== undefined) {
+      throw new TypeError("Seeded conversation input must be committed unowned user messages");
+    }
+  }
+  return applied(current, { messages: [...input.inputs, ...current.messages] }, {
+    seedReceipt: AgentSeedReceiptSchema.parse({
+      schemaVersion: 1,
+      conversationId,
+      seedKey: input.seedKey,
+      messageIds: input.inputs.map((message) => message.id)
+    }),
+    historyMutations: [...input.inputs].reverse().map((message) => ({
+      type: "seed",
+      message
+    }))
+  });
+}
+function reduceCompact(current, input) {
+  if (current.conversationId !== input.conversationId)
+    return { outcome: "not_found" };
+  if (current.version !== input.expectedVersion)
+    return conflict(current.version);
+  const replaced = new Set(input.replacedMessageIds);
+  if (!input.replacedMessageIds.every((id) => current.messages.some((m) => m.id === id))) {
+    return { outcome: "not_found" };
+  }
+  const liveAssistant = current.runs.find((candidate) => isActiveRunState(candidate.state) && replaced.has(candidate.assistantMessageId));
+  if (liveAssistant) {
+    throw new TypeError(`Compaction may not replace the assistant message of run ${liveAssistant.id}, which has not finished`);
+  }
+  const positions = current.messages.map((message, index) => replaced.has(message.id) ? index : undefined).filter((index) => index !== undefined);
+  const first = positions[0];
+  if (first === undefined || positions.some((position, offset) => position !== first + offset) || input.summary.conversationId !== input.conversationId || input.summary.runId !== undefined || input.summary.role !== "summary" || input.summary.status !== "committed" || current.messages.some((message) => message.id === input.summary.id) || current.runs.some((candidate) => candidate.assistantMessageId === input.summary.id)) {
+    throw new TypeError("Compaction replacement must be one valid contiguous history range");
+  }
+  const messages = [
+    ...current.messages.slice(0, first),
+    input.summary,
+    ...current.messages.slice(first + positions.length)
+  ];
+  return applied(current, { messages }, {
+    historyMutations: [
+      {
+        type: "replace-compacted-range",
+        replacedMessageIds: input.replacedMessageIds,
+        summary: input.summary
+      }
+    ]
+  });
+}
+
+// src/agent-runtime/store-reduce-run.ts
+function reduceAcquire(current, run, input) {
+  const runPosition = current.runs.findIndex((candidate) => candidate.id === run.id);
+  const acquisitionBlocked = current.runs.some((candidate, index) => candidate.id !== run.id && (candidate.state === "running" || candidate.state === "interrupt_requested" || index < runPosition && candidate.state === "queued"));
+  if (run.revision !== input.expectedRevision || run.state !== "queued" || acquisitionBlocked) {
+    return conflict(run.revision);
+  }
+  const next = AgentRunSchema.parse({
+    ...run,
+    state: "running",
+    executionSequence: run.executionSequence ?? current.version + 1,
+    ownerId: input.ownerId,
+    fencingToken: (run.fencingToken ?? 0) + 1,
+    revision: run.revision + 1,
+    updatedAt: new Date().toISOString()
+  });
+  return applied(current, { runs: replaceRun(current.runs, next) }, {
+    runRecords: [AgentStoredRunSchema.parse({ schemaVersion: 1, run: next })]
+  });
+}
+function reduceCheckpoint(current, run, input) {
+  if (run.revision !== input.expectedRevision || run.state !== "running" || run.ownerId !== input.ownerId || input.fencingToken !== undefined && run.fencingToken !== input.fencingToken || input.assistant.runId !== run.id || input.assistant.id !== run.assistantMessageId || input.assistant.conversationId !== run.conversationId || input.assistant.role !== "assistant" || input.assistant.status !== "streaming") {
+    return conflict(run.revision);
+  }
+  const next = AgentRunSchema.parse({
+    ...run,
+    ...input.usage && { usage: input.usage },
+    revision: run.revision + 1,
+    updatedAt: new Date().toISOString()
+  });
+  return applied(current, {
+    runs: replaceRun(current.runs, next),
+    messages: replaceMessage(current.messages, input.assistant)
+  }, {
+    runRecords: [AgentStoredRunSchema.parse({ schemaVersion: 1, run: next })],
+    historyMutations: [{ type: "upsert-assistant", message: input.assistant }]
+  });
+}
+function reduceOperation(current, run, input) {
+  if (run.revision !== input.expectedRevision || run.state !== "running" && run.state !== "interrupt_requested" || run.ownerId !== input.ownerId || input.fencingToken !== undefined && run.fencingToken !== input.fencingToken) {
+    return conflict(run.revision);
+  }
+  const next = AgentRunSchema.parse({
+    ...run,
+    lastOperation: input.operation,
+    revision: run.revision + 1,
+    updatedAt: new Date().toISOString()
+  });
+  return applied(current, { runs: replaceRun(current.runs, next) }, { runRecords: [AgentStoredRunSchema.parse({ schemaVersion: 1, run: next })] });
+}
+function reduceInterrupt(current, run, input) {
+  if (run.revision !== input.expectedRevision || run.state !== "running") {
+    return conflict(run.revision);
+  }
+  const next = AgentRunSchema.parse({
+    ...run,
+    state: "interrupt_requested",
+    revision: run.revision + 1,
+    updatedAt: new Date().toISOString()
+  });
+  return applied(current, { runs: replaceRun(current.runs, next) }, {
+    runRecords: [AgentStoredRunSchema.parse({ schemaVersion: 1, run: next })]
+  });
+}
+function reduceRecover(current, run, input) {
+  if (run.revision !== input.expectedRevision || !isActiveRunState(run.state)) {
+    return conflict(run.revision);
+  }
+  if (input.action === "requeue" && run.state !== "queued" && input.replaySafe !== true) {
+    throw new TypeError("Recovering an acquired run requires explicit replaySafe evidence");
+  }
+  const { ownerId: _released, ...carried } = run;
+  const next = AgentRunSchema.parse({
+    ...carried,
+    state: input.action === "requeue" ? "queued" : "abandoned",
+    revision: run.revision + 1,
+    ...input.action === "abandon" && { terminalReason: "abandoned" },
+    updatedAt: new Date().toISOString()
+  });
+  if (input.action === "abandon") {
+    const existingAssistant = current.messages.find((message) => message.id === run.assistantMessageId);
+    const assistant = AgentMessageSchema.parse({
+      ...existingAssistant ?? {
+        schemaVersion: 1,
+        id: run.assistantMessageId,
+        conversationId: run.conversationId,
+        runId: run.id,
+        role: "assistant",
+        parts: [],
+        createdAt: run.createdAt
+      },
+      status: "failed",
+      updatedAt: new Date().toISOString()
+    });
+    return applied(current, {
+      runs: replaceRun(current.runs, next),
+      messages: replaceMessage(current.messages, assistant)
+    }, {
+      runRecords: [
+        AgentStoredRunSchema.parse({
+          schemaVersion: 1,
+          run: next,
+          terminalAssistant: assistant
+        })
+      ],
+      historyMutations: [{ type: "upsert-assistant", message: assistant }]
+    });
+  }
+  return applied(current, { runs: replaceRun(current.runs, next) }, {
+    runRecords: [AgentStoredRunSchema.parse({ schemaVersion: 1, run: next })]
+  });
+}
+
+// src/agent-runtime/store-reduce-terminal.ts
+function reduceTerminal(current, run, input) {
+  if (input.reason === "absorbed") {
+    throw new TypeError("A run is absorbed by another run, never terminalized as absorbed");
+  }
+  if (run.revision !== input.expectedRevision || run.state !== "running" && run.state !== "interrupt_requested" || run.ownerId !== input.ownerId || input.fencingToken !== undefined && run.fencingToken !== input.fencingToken || input.assistant.runId !== run.id || input.assistant.id !== run.assistantMessageId || input.assistant.conversationId !== run.conversationId || input.assistant.role !== "assistant" || input.assistant.status !== assistantStatus(input.reason)) {
+    return conflict(run.revision);
+  }
+  if (input.absorb && runStateForTerminalReason(input.reason) !== "completed") {
+    throw new TypeError("Only a completing run may absorb a queued successor");
+  }
+  const named = new Set((input.absorb ?? []).map((entry) => entry.runId));
+  if (named.size !== (input.absorb ?? []).length || named.has(run.id)) {
+    throw new TypeError("An absorption names each successor once, and never the absorbing run");
+  }
+  const absorbable = (input.absorb ?? []).filter((entry) => {
+    const candidate = current.runs.find((item) => item.id === entry.runId);
+    return candidate !== undefined && candidate.id !== run.id && candidate.state === "queued" && candidate.conversationId === run.conversationId && candidate.inputMessageIds.length === entry.inputMessageIds.length && candidate.inputMessageIds.every((id, index) => id === entry.inputMessageIds[index]);
+  });
+  const absorbedIds = new Set(absorbable.flatMap((entry) => entry.inputMessageIds));
+  const next = AgentRunSchema.parse({
+    ...run,
+    state: runStateForTerminalReason(input.reason),
+    terminalReason: input.reason,
+    ...input.policyName && { terminalPolicyName: input.policyName },
+    ...input.usage && { usage: input.usage },
+    ...absorbedIds.size > 0 && {
+      inputMessageIds: [
+        ...run.inputMessageIds,
+        ...[...absorbedIds].filter((id) => !run.inputMessageIds.includes(id))
+      ]
+    },
+    revision: run.revision + 1,
+    updatedAt: new Date().toISOString()
+  });
+  const absorbedRuns = absorbable.map((entry) => {
+    const candidate = current.runs.find((item) => item.id === entry.runId);
+    if (!candidate)
+      throw new TypeError("Absorbed run disappeared inside the reducer");
+    return AgentRunSchema.parse({
+      ...candidate,
+      state: runStateForTerminalReason("absorbed"),
+      terminalReason: "absorbed",
+      absorbedIntoRunId: next.id,
+      revision: candidate.revision + 1,
+      updatedAt: new Date().toISOString()
+    });
+  });
+  const runs = absorbedRuns.reduce((accumulated, absorbed) => replaceRun(accumulated, absorbed), replaceRun(current.runs, next));
+  return applied(current, {
+    runs,
+    messages: replaceMessage(current.messages, input.assistant)
+  }, {
+    runRecords: [
+      AgentStoredRunSchema.parse({
+        schemaVersion: 1,
+        run: next,
+        terminalAssistant: input.assistant
+      }),
+      ...absorbedRuns.map((absorbed) => AgentStoredRunSchema.parse({ schemaVersion: 1, run: absorbed }))
+    ],
+    historyMutations: [{ type: "upsert-assistant", message: input.assistant }]
+  });
+}
+
+// src/agent-runtime/store-reducer.ts
+function transitionRecord(operation) {
+  if (operation.type !== "checkpoint")
+    return operation;
+  const { assistant, ...rest } = operation.input;
+  const body = canonicalAgentJson(assistant);
+  return {
+    type: operation.type,
+    input: {
+      ...rest,
+      assistant: {
+        id: assistant.id,
+        status: assistant.status,
+        sha256: createHash("sha256").update(body).digest("hex"),
+        parts: assistant.parts.length,
+        bytes: Buffer.byteLength(body)
+      }
+    }
+  };
+}
+function reduceStore(current, operation) {
+  if (operation.type === "accept")
+    return reduceAccept(current, operation.input);
+  if (operation.type === "seed")
+    return reduceSeed(current, operation.input);
+  if (operation.type === "compact")
+    return reduceCompact(current, operation.input);
+  const run = current.runs.find((candidate) => candidate.id === operation.input.runId);
+  if (!run)
+    return { outcome: "not_found" };
+  switch (operation.type) {
+    case "acquire":
+      return reduceAcquire(current, run, operation.input);
+    case "checkpoint":
+      return reduceCheckpoint(current, run, operation.input);
+    case "operation":
+      return reduceOperation(current, run, operation.input);
+    case "interrupt":
+      return reduceInterrupt(current, run, operation.input);
+    case "recover":
+      return reduceRecover(current, run, operation.input);
+    case "terminal":
+      return reduceTerminal(current, run, operation.input);
+  }
+}
+function operationConversationId(operation) {
+  return operation.type === "accept" ? operation.input.input.conversationId : operation.input.conversationId;
+}
+
+// src/agent-runtime/store-mutate.ts
+function validateAdmissionReceipt(receipt, record, conversationId) {
+  const input = receipt.input;
+  const run = record.run;
+  if (receipt.conversationId !== conversationId || input.conversationId !== conversationId || input.role !== "user" || input.status !== "committed" || input.runId !== undefined || receipt.runId !== run.id || receipt.assistantMessageId !== run.assistantMessageId || !run.inputMessageIds.includes(input.id)) {
+    throw new TypeError("Admission receipt does not match its canonical run assignment");
+  }
+}
+async function readForMutation(driver, transaction, operation) {
+  const conversationId = operationConversationId(operation);
+  if (await driver.conversations?.isPurged(transaction, conversationId)) {
+    throw new AgentConversationPurgedError;
+  }
+  const operationRunId = operation.type === "accept" ? operation.input.coalesceIntoRunId : operation.type === "compact" || operation.type === "seed" ? undefined : operation.input.runId;
+  const [stored, messages, activeRecords, operationRecord, duplicateReceipt] = await Promise.all([
+    driver.head.load(transaction, conversationId),
+    driver.history.load(transaction, conversationId),
+    driver.runs.listActive(transaction, conversationId),
+    operationRunId ? driver.runs.load(transaction, { conversationId, runId: operationRunId }) : undefined,
+    operation.type === "accept" ? driver.admissions.load(transaction, {
+      conversationId,
+      idempotencyKey: operation.input.idempotencyKey
+    }) : undefined
+  ]);
+  const head = AgentRuntimeHeadSchema.parse(stored ?? emptyHead(conversationId));
+  const referencedRecords = await driver.runs.loadMany(transaction, {
+    conversationId,
+    runIds: referencedRunIds(messages)
+  });
+  const records = mergeRunRecords(activeRecords, referencedRecords, operationRecord ? [operationRecord] : []);
+  const current = snapshotOf(head, messages, records);
+  return { conversationId, head, messages, records, current, duplicateReceipt };
+}
+async function settledSeed(driver, transaction, read, input) {
+  const { conversationId, current } = read;
+  const existing = await driver.seeds.load(transaction, {
+    conversationId,
+    seedKey: input.seedKey
+  });
+  if (existing)
+    return { outcome: "applied", snapshot: current };
+  let collisions = 0;
+  for (const message of input.inputs) {
+    if (current.messages.some((candidate) => candidate.id === message.id) || driver.history.hasMessage && await driver.history.hasMessage(transaction, {
+      conversationId,
+      messageId: message.id
+    }))
+      collisions++;
+  }
+  if (collisions > 0 && collisions < input.inputs.length) {
+    throw new TypeError("Partial instruction seed collision: restore the complete seed before retrying");
+  }
+  if (collisions > 0) {
+    await driver.seeds.create(transaction, AgentSeedReceiptSchema.parse({
+      schemaVersion: 1,
+      conversationId,
+      seedKey: input.seedKey,
+      messageIds: input.inputs.map((message) => message.id)
+    }));
+    return { outcome: "applied", snapshot: current };
+  }
+  return;
+}
+async function duplicateAdmission(driver, transaction, read, duplicateReceipt) {
+  const { conversationId, head, messages, records } = read;
+  const duplicateRecord = await driver.runs.load(transaction, {
+    conversationId,
+    runId: duplicateReceipt.runId
+  });
+  if (!duplicateRecord) {
+    throw new TypeError("Admission receipt points to a missing canonical run");
+  }
+  validateAdmissionReceipt(duplicateReceipt, duplicateRecord, conversationId);
+  const answering = duplicateRecord.run.absorbedIntoRunId ? await driver.runs.load(transaction, {
+    conversationId,
+    runId: duplicateRecord.run.absorbedIntoRunId
+  }) : undefined;
+  if (duplicateRecord.run.absorbedIntoRunId && !answering) {
+    throw new TypeError("Absorbed run points to a missing absorbing run");
+  }
+  const canonical = answering ?? duplicateRecord;
+  return {
+    outcome: "duplicate",
+    input: duplicateReceipt.input,
+    inputMessageId: duplicateReceipt.input.id,
+    runId: canonical.run.id,
+    assistantMessageId: canonical.run.assistantMessageId,
+    run: canonical.run,
+    ...canonical.terminalAssistant && {
+      assistant: canonical.terminalAssistant
+    },
+    snapshot: snapshotOf(head, messages, mergeRunRecords(records, [duplicateRecord], answering ? [answering] : []))
+  };
+}
+async function assertAdmissionIdentitiesFree(driver, transaction, conversationId, input) {
+  const inputCollision = await driver.admissions.loadByInputMessageId(transaction, {
+    conversationId,
+    inputMessageId: input.input.id
+  });
+  if (inputCollision) {
+    throw new TypeError("Input message identity is already assigned to an admission");
+  }
+  if (!input.coalesceIntoRunId) {
+    const [runCollision, assistantCollision] = await Promise.all([
+      driver.runs.load(transaction, {
+        conversationId,
+        runId: input.run.id
+      }),
+      driver.runs.loadByAssistantMessageId(transaction, {
+        conversationId,
+        assistantMessageId: input.run.assistantMessageId
+      })
+    ]);
+    if (runCollision || assistantCollision) {
+      throw new TypeError("Queued run identities are already reserved");
+    }
+  }
+}
+async function persistApplied(driver, transaction, read, operation, reduced) {
+  const { conversationId, current } = read;
+  const nextHead = AgentRuntimeHeadSchema.parse({
+    schemaVersion: 1,
+    conversationId,
+    version: reduced.snapshot.version
+  });
+  const outcome = await driver.head.compareAndSwap(transaction, {
+    conversationId,
+    expectedVersion: current.version,
+    next: nextHead
+  });
+  if (outcome.outcome === "conflict")
+    return conflict(outcome.actualVersion);
+  for (const record of reduced.runRecords ?? []) {
+    await driver.runs.save(transaction, record);
+  }
+  if (reduced.admissionReceipt) {
+    await driver.admissions.create(transaction, reduced.admissionReceipt);
+  }
+  if (reduced.seedReceipt) {
+    await driver.seeds.create(transaction, reduced.seedReceipt);
+  }
+  for (const mutation of reduced.historyMutations ?? []) {
+    await driver.history.apply(transaction, mutation);
+  }
+  await driver.events.append(transaction, agentStoreEventDraft({
+    conversationId,
+    kind: "runtime/transition",
+    payload: z4.json().parse(transitionRecord(operation))
+  }));
+  return { outcome: "applied", snapshot: reduced.snapshot };
+}
+function mutateStore(driver, operation) {
+  return driver.transaction(async (transaction) => {
+    const read = await readForMutation(driver, transaction, operation);
+    if (operation.type === "seed") {
+      const settled = await settledSeed(driver, transaction, read, operation.input);
+      if (settled)
+        return settled;
+    }
+    if (read.duplicateReceipt) {
+      return duplicateAdmission(driver, transaction, read, read.duplicateReceipt);
+    }
+    if (operation.type === "accept") {
+      await assertAdmissionIdentitiesFree(driver, transaction, read.conversationId, operation.input);
+    }
+    const reduced = reduceStore(read.current, operation);
+    if (reduced.outcome !== "applied")
+      return reduced;
+    return persistApplied(driver, transaction, read, operation, reduced);
+  });
+}
+
+// src/agent-runtime/store-purge.ts
+function createStoreConversationPurge(driver, conversations) {
+  return async (input) => {
+    const { conversationId, expectedVersion } = AgentConversationPurgeInputSchema.parse(input);
+    return driver.transaction(async (transaction) => {
+      if (await conversations.isPurged(transaction, conversationId)) {
+        return { outcome: "already_purged" };
+      }
+      const head = await driver.head.load(transaction, conversationId);
+      const actualVersion = head?.version ?? 0;
+      if (expectedVersion !== undefined && expectedVersion !== actualVersion) {
+        return { outcome: "conflict", actualVersion };
+      }
+      const active = await driver.runs.listActive(transaction, conversationId);
+      if (active.length > 0) {
+        return { outcome: "active", runIds: active.map((record) => record.run.id) };
+      }
+      await conversations.remove(transaction, conversationId);
+      return { outcome: "purged" };
+    });
+  };
+}
+
+// src/agent-runtime/store-create.ts
+var AgentRecoverableScanInputSchema = z5.object({
+  cursor: z5.string().min(1).optional(),
+  limit: z5.number().int().min(1).max(1000)
+});
+function createAgentRuntimeStore(driver) {
+  const mutate = (operation) => mutateStore(driver, operation);
+  return {
+    loadSnapshot: (conversationId) => loadSnapshot(driver, conversationId),
+    loadRun: (input) => loadRun(driver, input),
+    listActiveRuns: (conversationId) => listActiveRuns(driver, conversationId),
+    appendEvent: (input) => appendEvent(driver, input),
+    readEvents: (input) => readEvents(driver, input),
+    exportConversation: (conversationId) => exportConversation(driver, conversationId),
+    importConversation: (bytes) => importConversation(driver, bytes),
+    ...driver.conversations && {
+      purgeConversation: createStoreConversationPurge(driver, driver.conversations)
+    },
+    acceptInputAndAssignRun: (input) => mutate({
+      type: "accept",
+      input: AcceptInputAndAssignRunSchema.parse(input)
+    }),
+    acquireRun: (input) => mutate({ type: "acquire", input: AcquireAgentRunSchema.parse(input) }),
+    checkpointRunAssistant: (input) => mutate({
+      type: "checkpoint",
+      input: CheckpointRunAssistantSchema.parse(input)
+    }),
+    recordRunOperation: (input) => mutate({
+      type: "operation",
+      input: RecordRunOperationSchema.parse(input)
+    }),
+    requestRunInterrupt: (input) => mutate({
+      type: "interrupt",
+      input: RequestRunInterruptSchema.parse(input)
+    }),
+    recoverRun: (input) => mutate({ type: "recover", input: RecoverAgentRunSchema.parse(input) }),
+    commitRunTerminal: (input) => mutate({ type: "terminal", input: CommitRunTerminalSchema.parse(input) }),
+    replaceCompactedRange: (input) => mutate({
+      type: "compact",
+      input: ReplaceCompactedRangeSchema.parse(input)
+    }),
+    seedConversationInput: (input) => mutate({
+      type: "seed",
+      input: SeedConversationInputSchema.parse(input)
+    }),
+    async scanRecoverable(input) {
+      const parsed = AgentRecoverableScanInputSchema.parse(input);
+      return AgentRecoverablePageSchema.parse(await driver.scanRecoverable(parsed));
+    }
+  };
+}
+
+export { AgentConversationPurgeInputSchema, AgentConversationPurgeResultSchema, AgentConversationPurgedError, purgeAgentConversation, AgentRuntimeHeadSchema, AgentStoredRunSchema, AgentAdmissionReceiptSchema, AgentSeedReceiptSchema, AgentHistoryMutationSchema, ACTIVE_AGENT_RUN_STATES, isActiveRunState, replaceMessage, appendEventIn, createAgentRuntimeStore };