stitchkit 0.110.1 → 0.110.3

package/dist/index-d2h99n7d.js

@@ -1,1071 +0,0 @@
-import {
-  AgentRecordIdSchema2,
-  AgentRecordVersionSchema2,
-  AgentMessageSchema2,
-  runStateForTerminalReason2,
-  AgentRunSchema2,
-  AgentSnapshotSchema2
-} from "./index-8kzct1d6.js";
-import {
-  AppendAgentStoreEventSchema2,
-  ReadAgentStoreEventsSchema2,
-  AgentStoreEventPageSchema2,
-  AgentRunViewSchema2,
-  AcceptInputAndAssignRunSchema2,
-  AcquireAgentRunSchema2,
-  CheckpointRunAssistantSchema2,
-  RecordRunOperationSchema2,
-  CommitRunTerminalSchema2,
-  RequestRunInterruptSchema2,
-  RecoverAgentRunSchema2,
-  ReplaceCompactedRangeSchema2,
-  SeedConversationInputSchema2,
-  AgentRecoverablePageSchema2,
-  AgentStoreTransitionSchema2,
-  agentStoreEventDraft,
-  canonicalAgentJson2,
-  encodeAgentConversationArchive2,
-  decodeAgentConversationArchive2,
-  assistantStatus
-} from "./index-0gs4ymfj.js";
-
-// src/agent-runtime/purge.ts
-import { z } from "zod";
-var AgentConversationPurgeInputSchema2 = z.strictObject({
-  conversationId: AgentRecordIdSchema2,
-  expectedVersion: AgentRecordVersionSchema2.optional()
-});
-var AgentConversationPurgeResultSchema2 = 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(AgentRecordIdSchema2).min(1)
-  }),
-  z.strictObject({ outcome: z.literal("conflict"), actualVersion: AgentRecordVersionSchema2 })
-]);
-
-class AgentConversationPurgedError2 extends Error {
-  constructor() {
-    super("Agent conversation has been purged; use a new conversation ID");
-    this.name = "AgentConversationPurgedError";
-  }
-}
-async function purgeAgentConversation2(store, input) {
-  const parsed = AgentConversationPurgeInputSchema2.parse(input);
-  if (!store.purgeConversation)
-    return { outcome: "unsupported" };
-  return AgentConversationPurgeResultSchema2.parse(await store.purgeConversation(parsed));
-}
-
-// src/agent-runtime/store-driver-contract.ts
-import { z as z2 } from "zod";
-var AgentRuntimeHeadSchema2 = z2.object({
-  schemaVersion: z2.literal(1),
-  conversationId: AgentRecordIdSchema2,
-  version: AgentRecordVersionSchema2
-});
-var AgentStoredRunSchema2 = z2.object({
-  schemaVersion: z2.literal(1),
-  run: AgentRunSchema2,
-  terminalAssistant: AgentMessageSchema2.optional()
-});
-var AgentAdmissionReceiptSchema2 = z2.object({
-  schemaVersion: z2.literal(1),
-  conversationId: AgentRecordIdSchema2,
-  idempotencyKey: z2.string().min(1),
-  input: AgentMessageSchema2,
-  runId: AgentRecordIdSchema2,
-  assistantMessageId: AgentRecordIdSchema2
-});
-var AgentSeedReceiptSchema2 = z2.object({
-  schemaVersion: z2.literal(1),
-  conversationId: AgentRecordIdSchema2,
-  seedKey: z2.string().min(1),
-  messageIds: z2.array(AgentRecordIdSchema2).min(1)
-});
-var AgentHistoryMutationSchema2 = z2.discriminatedUnion("type", [
-  z2.object({ type: z2.literal("admit"), input: AgentMessageSchema2 }),
-  z2.object({
-    type: z2.literal("upsert-assistant"),
-    message: AgentMessageSchema2
-  }),
-  z2.object({
-    type: z2.literal("replace-compacted-range"),
-    replacedMessageIds: z2.array(AgentRecordIdSchema2).min(1),
-    summary: AgentMessageSchema2
-  }),
-  z2.object({
-    type: z2.literal("seed"),
-    message: AgentMessageSchema2
-  })
-]);
-var ACTIVE_AGENT_RUN_STATES2 = [
-  "queued",
-  "running",
-  "interrupt_requested"
-];
-function isActiveRunState(state) {
-  return ACTIVE_AGENT_RUN_STATES2.includes(state);
-}
-function emptyHead(conversationId) {
-  return AgentRuntimeHeadSchema2.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 AgentSnapshotSchema2.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 = AgentStoredRunSchema2.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 = AgentRuntimeHeadSchema2.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 = AgentStoredRunSchema2.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 = AgentRuntimeHeadSchema2.parse(stored ?? emptyHead(input.conversationId));
-    return AgentRunViewSchema2.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) => AgentStoredRunSchema2.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 = AppendAgentStoreEventSchema2.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 AgentConversationPurgedError2;
-  }
-  return driver.events.append(transaction, agentStoreEventDraft(parsed));
-}
-function readEvents(driver, input) {
-  const parsed = ReadAgentStoreEventsSchema2.parse(input);
-  return driver.transaction(async (transaction) => AgentStoreEventPageSchema2.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 = AgentStoreEventPageSchema2.parse(await driver.events.list(transaction, ReadAgentStoreEventsSchema2.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 encodeAgentConversationArchive2({
-      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 = decodeAgentConversationArchive2(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 = AgentSnapshotSchema2.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: AgentRuntimeHeadSchema2.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, AgentStoredRunSchema2.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 = AgentStoreTransitionSchema2.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, AgentAdmissionReceiptSchema2.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-event-once.ts
-import { createHash } from "node:crypto";
-function eventOnceId(conversationId, kind, key) {
-  if (!key)
-    throw new TypeError("Event admission key must not be empty");
-  return createHash("sha256").update(JSON.stringify([conversationId, kind, key])).digest("hex");
-}
-async function findEvent(driver, transaction, conversationId, eventId) {
-  if (driver.events.find)
-    return driver.events.find(transaction, { conversationId, eventId });
-  let fromSeq;
-  do {
-    const page = await driver.events.list(transaction, {
-      conversationId,
-      fromSeq,
-      limit: 1e4
-    });
-    const found = page.items.find((event) => event.eventId === eventId);
-    if (found)
-      return found;
-    fromSeq = page.nextSeq;
-  } while (fromSeq !== undefined);
-  return;
-}
-function appendEventOnce(driver, input, key) {
-  const parsed = AppendAgentStoreEventSchema2.parse(input);
-  const eventId = eventOnceId(parsed.conversationId, parsed.kind, key);
-  return driver.transaction(async (transaction) => {
-    if (await driver.conversations?.isPurged(transaction, parsed.conversationId)) {
-      throw new AgentConversationPurgedError2;
-    }
-    const previous = await findEvent(driver, transaction, parsed.conversationId, eventId);
-    if (previous)
-      return { outcome: "duplicate", event: previous };
-    const event = await driver.events.append(transaction, {
-      ...agentStoreEventDraft(parsed),
-      eventId
-    });
-    return { outcome: "applied", event };
-  });
-}
-function findEventOnce(driver, input) {
-  const eventId = eventOnceId(input.conversationId, input.kind, input.key);
-  return driver.transaction((transaction) => findEvent(driver, transaction, input.conversationId, eventId), { access: "read" });
-}
-
-// 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: AgentSnapshotSchema2.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 as createHash2 } 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 ? AgentRunSchema2.parse({
-    ...coalescedRun,
-    inputMessageIds: [...coalescedRun.inputMessageIds, input.input.id],
-    revision: coalescedRun.revision + 1,
-    updatedAt: new Date().toISOString()
-  }) : input.run;
-  const admissionReceipt = AgentAdmissionReceiptSchema2.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: [AgentStoredRunSchema2.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: AgentSeedReceiptSchema2.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 = AgentRunSchema2.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: [AgentStoredRunSchema2.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 = AgentRunSchema2.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: [AgentStoredRunSchema2.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 = AgentRunSchema2.parse({
-    ...run,
-    lastOperation: input.operation,
-    revision: run.revision + 1,
-    updatedAt: new Date().toISOString()
-  });
-  return applied(current, { runs: replaceRun(current.runs, next) }, { runRecords: [AgentStoredRunSchema2.parse({ schemaVersion: 1, run: next })] });
-}
-function reduceInterrupt(current, run, input) {
-  if (run.revision !== input.expectedRevision || run.state !== "running") {
-    return conflict(run.revision);
-  }
-  const next = AgentRunSchema2.parse({
-    ...run,
-    state: "interrupt_requested",
-    revision: run.revision + 1,
-    updatedAt: new Date().toISOString()
-  });
-  return applied(current, { runs: replaceRun(current.runs, next) }, {
-    runRecords: [AgentStoredRunSchema2.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 = AgentRunSchema2.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 = AgentMessageSchema2.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: [
-        AgentStoredRunSchema2.parse({
-          schemaVersion: 1,
-          run: next,
-          terminalAssistant: assistant
-        })
-      ],
-      historyMutations: [{ type: "upsert-assistant", message: assistant }]
-    });
-  }
-  return applied(current, { runs: replaceRun(current.runs, next) }, {
-    runRecords: [AgentStoredRunSchema2.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 && runStateForTerminalReason2(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 = AgentRunSchema2.parse({
-    ...run,
-    state: runStateForTerminalReason2(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 AgentRunSchema2.parse({
-      ...candidate,
-      state: runStateForTerminalReason2("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: [
-      AgentStoredRunSchema2.parse({
-        schemaVersion: 1,
-        run: next,
-        terminalAssistant: input.assistant
-      }),
-      ...absorbedRuns.map((absorbed) => AgentStoredRunSchema2.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 = canonicalAgentJson2(assistant);
-  return {
-    type: operation.type,
-    input: {
-      ...rest,
-      assistant: {
-        id: assistant.id,
-        status: assistant.status,
-        sha256: createHash2("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 AgentConversationPurgedError2;
-  }
-  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 = AgentRuntimeHeadSchema2.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, AgentSeedReceiptSchema2.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 = AgentRuntimeHeadSchema2.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 } = AgentConversationPurgeInputSchema2.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 createAgentRuntimeStore2(driver) {
-  const mutate = (operation) => mutateStore(driver, operation);
-  return {
-    loadSnapshot: (conversationId) => loadSnapshot(driver, conversationId),
-    loadRun: (input) => loadRun(driver, input),
-    listActiveRuns: (conversationId) => listActiveRuns(driver, conversationId),
-    appendEventOnce: (input, key) => appendEventOnce(driver, input, key),
-    findEventOnce: (input) => findEventOnce(driver, input),
-    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: AcceptInputAndAssignRunSchema2.parse(input)
-    }),
-    acquireRun: (input) => mutate({ type: "acquire", input: AcquireAgentRunSchema2.parse(input) }),
-    checkpointRunAssistant: (input) => mutate({
-      type: "checkpoint",
-      input: CheckpointRunAssistantSchema2.parse(input)
-    }),
-    recordRunOperation: (input) => mutate({
-      type: "operation",
-      input: RecordRunOperationSchema2.parse(input)
-    }),
-    requestRunInterrupt: (input) => mutate({
-      type: "interrupt",
-      input: RequestRunInterruptSchema2.parse(input)
-    }),
-    recoverRun: (input) => mutate({ type: "recover", input: RecoverAgentRunSchema2.parse(input) }),
-    commitRunTerminal: (input) => mutate({ type: "terminal", input: CommitRunTerminalSchema2.parse(input) }),
-    replaceCompactedRange: (input) => mutate({
-      type: "compact",
-      input: ReplaceCompactedRangeSchema2.parse(input)
-    }),
-    seedConversationInput: (input) => mutate({
-      type: "seed",
-      input: SeedConversationInputSchema2.parse(input)
-    }),
-    async scanRecoverable(input) {
-      const parsed = AgentRecoverableScanInputSchema.parse(input);
-      return AgentRecoverablePageSchema2.parse(await driver.scanRecoverable(parsed));
-    }
-  };
-}
-
-export { AgentConversationPurgeInputSchema2, AgentConversationPurgeResultSchema2, AgentConversationPurgedError2, purgeAgentConversation2, AgentRuntimeHeadSchema2, AgentStoredRunSchema2, AgentAdmissionReceiptSchema2, AgentSeedReceiptSchema2, AgentHistoryMutationSchema2, ACTIVE_AGENT_RUN_STATES2, isActiveRunState, replaceMessage, appendEventIn, createAgentRuntimeStore2 };