stitchkit 0.100.2 → 0.100.3

package/dist/{index-vqr7f7v8.js → index-ssmd41kh.js}

@@ -1,116 +1,116 @@
 import {
-  AcceptInputAndAssignRunSchema,
-  AcquireAgentRunSchema,
-  AgentRecoverablePageSchema,
-  AgentRunViewSchema,
-  AgentStoreEventPageSchema,
-  AgentStoreTransitionSchema,
-  AppendAgentStoreEventSchema,
-  CheckpointRunAssistantSchema,
-  CommitRunTerminalSchema,
-  ReadAgentStoreEventsSchema,
-  RecordRunOperationSchema,
-  RecoverAgentRunSchema,
-  ReplaceCompactedRangeSchema,
-  RequestRunInterruptSchema,
-  SeedConversationInputSchema,
-  agentStoreEventDraft,
-  assistantStatus,
-  canonicalAgentJson,
-  decodeAgentConversationArchive,
-  encodeAgentConversationArchive
-} from "./index-cyktc4bp.js";
+  AgentRecordIdSchema2,
+  AgentRecordVersionSchema2,
+  AgentMessageSchema2,
+  runStateForTerminalReason2,
+  AgentRunSchema2,
+  AgentSnapshotSchema2
+} from "./index-8kzct1d6.js";
 import {
-  AgentMessageSchema,
-  AgentRecordIdSchema,
-  AgentRecordVersionSchema,
-  AgentRunSchema,
-  AgentSnapshotSchema,
-  runStateForTerminalReason
-} from "./index-gtj3zc53.js";
+  AppendAgentStoreEventSchema2,
+  ReadAgentStoreEventsSchema2,
+  AgentStoreEventPageSchema2,
+  AgentRunViewSchema2,
+  AcceptInputAndAssignRunSchema2,
+  AcquireAgentRunSchema2,
+  CheckpointRunAssistantSchema2,
+  RecordRunOperationSchema2,
+  CommitRunTerminalSchema2,
+  RequestRunInterruptSchema2,
+  RecoverAgentRunSchema2,
+  ReplaceCompactedRangeSchema2,
+  SeedConversationInputSchema2,
+  AgentRecoverablePageSchema2,
+  AgentStoreTransitionSchema2,
+  agentStoreEventDraft,
+  canonicalAgentJson2,
+  encodeAgentConversationArchive2,
+  decodeAgentConversationArchive2,
+  assistantStatus
+} from "./index-r5hsgkz5.js";
 
 // src/agent-runtime/purge.ts
 import { z } from "zod";
-var AgentConversationPurgeInputSchema = z.strictObject({
-  conversationId: AgentRecordIdSchema,
-  expectedVersion: AgentRecordVersionSchema.optional()
+var AgentConversationPurgeInputSchema2 = z.strictObject({
+  conversationId: AgentRecordIdSchema2,
+  expectedVersion: AgentRecordVersionSchema2.optional()
 });
-var AgentConversationPurgeResultSchema = z.discriminatedUnion("outcome", [
+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(AgentRecordIdSchema).min(1)
+    runIds: z.array(AgentRecordIdSchema2).min(1)
   }),
-  z.strictObject({ outcome: z.literal("conflict"), actualVersion: AgentRecordVersionSchema })
+  z.strictObject({ outcome: z.literal("conflict"), actualVersion: AgentRecordVersionSchema2 })
 ]);
 
-class AgentConversationPurgedError extends Error {
+class AgentConversationPurgedError2 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);
+async function purgeAgentConversation2(store, input) {
+  const parsed = AgentConversationPurgeInputSchema2.parse(input);
   if (!store.purgeConversation)
     return { outcome: "unsupported" };
-  return AgentConversationPurgeResultSchema.parse(await store.purgeConversation(parsed));
+  return AgentConversationPurgeResultSchema2.parse(await store.purgeConversation(parsed));
 }
 
 // src/agent-runtime/store-driver-contract.ts
 import { z as z2 } from "zod";
-var AgentRuntimeHeadSchema = z2.object({
+var AgentRuntimeHeadSchema2 = z2.object({
   schemaVersion: z2.literal(1),
-  conversationId: AgentRecordIdSchema,
-  version: AgentRecordVersionSchema
+  conversationId: AgentRecordIdSchema2,
+  version: AgentRecordVersionSchema2
 });
-var AgentStoredRunSchema = z2.object({
+var AgentStoredRunSchema2 = z2.object({
   schemaVersion: z2.literal(1),
-  run: AgentRunSchema,
-  terminalAssistant: AgentMessageSchema.optional()
+  run: AgentRunSchema2,
+  terminalAssistant: AgentMessageSchema2.optional()
 });
-var AgentAdmissionReceiptSchema = z2.object({
+var AgentAdmissionReceiptSchema2 = z2.object({
   schemaVersion: z2.literal(1),
-  conversationId: AgentRecordIdSchema,
+  conversationId: AgentRecordIdSchema2,
   idempotencyKey: z2.string().min(1),
-  input: AgentMessageSchema,
-  runId: AgentRecordIdSchema,
-  assistantMessageId: AgentRecordIdSchema
+  input: AgentMessageSchema2,
+  runId: AgentRecordIdSchema2,
+  assistantMessageId: AgentRecordIdSchema2
 });
-var AgentSeedReceiptSchema = z2.object({
+var AgentSeedReceiptSchema2 = z2.object({
   schemaVersion: z2.literal(1),
-  conversationId: AgentRecordIdSchema,
+  conversationId: AgentRecordIdSchema2,
   seedKey: z2.string().min(1),
-  messageIds: z2.array(AgentRecordIdSchema).min(1)
+  messageIds: z2.array(AgentRecordIdSchema2).min(1)
 });
-var AgentHistoryMutationSchema = z2.discriminatedUnion("type", [
-  z2.object({ type: z2.literal("admit"), input: AgentMessageSchema }),
+var AgentHistoryMutationSchema2 = z2.discriminatedUnion("type", [
+  z2.object({ type: z2.literal("admit"), input: AgentMessageSchema2 }),
   z2.object({
     type: z2.literal("upsert-assistant"),
-    message: AgentMessageSchema
+    message: AgentMessageSchema2
   }),
   z2.object({
     type: z2.literal("replace-compacted-range"),
-    replacedMessageIds: z2.array(AgentRecordIdSchema).min(1),
-    summary: AgentMessageSchema
+    replacedMessageIds: z2.array(AgentRecordIdSchema2).min(1),
+    summary: AgentMessageSchema2
   }),
   z2.object({
     type: z2.literal("seed"),
-    message: AgentMessageSchema
+    message: AgentMessageSchema2
   })
 ]);
-var ACTIVE_AGENT_RUN_STATES = [
+var ACTIVE_AGENT_RUN_STATES2 = [
   "queued",
   "running",
   "interrupt_requested"
 ];
 function isActiveRunState(state) {
-  return ACTIVE_AGENT_RUN_STATES.includes(state);
+  return ACTIVE_AGENT_RUN_STATES2.includes(state);
 }
 function emptyHead(conversationId) {
-  return AgentRuntimeHeadSchema.parse({
+  return AgentRuntimeHeadSchema2.parse({
     schemaVersion: 1,
     conversationId,
     version: 0
@@ -180,7 +180,7 @@ function orderRunMessages(messages, runs) {
 function snapshotOf(head, messages, records) {
   validateSnapshot(head, messages, records);
   const runs = orderRuns(messages, records.map((record) => record.run));
-  return AgentSnapshotSchema.parse({
+  return AgentSnapshotSchema2.parse({
     schemaVersion: 1,
     conversationId: head.conversationId,
     version: head.version,
@@ -229,7 +229,7 @@ function mergeRunRecords(...groups) {
   const records = new Map;
   for (const group of groups) {
     for (const rawRecord of group) {
-      const record = AgentStoredRunSchema.parse(rawRecord);
+      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");
@@ -250,7 +250,7 @@ async function snapshotIn(driver, transaction, conversationId) {
     driver.history.load(transaction, conversationId),
     driver.runs.listActive(transaction, conversationId)
   ]);
-  const head = AgentRuntimeHeadSchema.parse(stored ?? emptyHead(conversationId));
+  const head = AgentRuntimeHeadSchema2.parse(stored ?? emptyHead(conversationId));
   const referencedRecords = await driver.runs.loadMany(transaction, {
     conversationId,
     runIds: referencedRunIds(messages)
@@ -270,12 +270,12 @@ function loadRun(driver, input) {
     ]);
     if (!record)
       return;
-    const parsed = AgentStoredRunSchema.parse(record);
+    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 = AgentRuntimeHeadSchema.parse(stored ?? emptyHead(input.conversationId));
-    return AgentRunViewSchema.parse({
+    const head = AgentRuntimeHeadSchema2.parse(stored ?? emptyHead(input.conversationId));
+    return AgentRunViewSchema2.parse({
       snapshotVersion: head.version,
       run: parsed.run,
       ...parsed.terminalAssistant && { assistant: parsed.terminalAssistant }
@@ -288,7 +288,7 @@ function listActiveRuns(driver, conversationId) {
       driver.runs.listActive(transaction, conversationId),
       driver.history.load(transaction, conversationId)
     ]);
-    const runs = records.map((record) => AgentStoredRunSchema.parse(record).run);
+    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");
@@ -301,18 +301,18 @@ function listActiveRuns(driver, conversationId) {
   }, { access: "read" });
 }
 function appendEvent(driver, input) {
-  const parsed = AppendAgentStoreEventSchema.parse(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 AgentConversationPurgedError;
+    throw new AgentConversationPurgedError2;
   }
   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" });
+  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
@@ -321,7 +321,7 @@ function exportConversation(driver, conversationId) {
     const events = [];
     let fromSeq;
     do {
-      const page = AgentStoreEventPageSchema.parse(await driver.events.list(transaction, ReadAgentStoreEventsSchema.parse({
+      const page = AgentStoreEventPageSchema2.parse(await driver.events.list(transaction, ReadAgentStoreEventsSchema2.parse({
         conversationId,
         ...fromSeq && { fromSeq },
         limit: 1e4
@@ -334,7 +334,7 @@ function exportConversation(driver, conversationId) {
       spills: []
     };
     const snapshot = await snapshotIn(driver, transaction, conversationId);
-    return encodeAgentConversationArchive({
+    return encodeAgentConversationArchive2({
       format: "stitchkit.agent-conversation",
       formatVersion: 1,
       conversationId,
@@ -348,7 +348,7 @@ function exportConversation(driver, conversationId) {
   }, { access: "read" });
 }
 async function importConversation(driver, bytes) {
-  const archive = decodeAgentConversationArchive(bytes);
+  const archive = decodeAgentConversationArchive2(bytes);
   return driver.transaction(async (transaction) => {
     const existing = await driver.events.list(transaction, {
       conversationId: archive.conversationId,
@@ -373,7 +373,7 @@ async function importConversation(driver, bytes) {
     }
     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);
+      const snapshot = AgentSnapshotSchema2.parse(snapshotEntry.snapshot);
       if (snapshot.conversationId !== archive.conversationId) {
         throw new TypeError("Conversation archive snapshot belongs to another conversation");
       }
@@ -381,7 +381,7 @@ async function importConversation(driver, bytes) {
         const outcome = await driver.head.compareAndSwap(transaction, {
           conversationId: snapshot.conversationId,
           expectedVersion: 0,
-          next: AgentRuntimeHeadSchema.parse({
+          next: AgentRuntimeHeadSchema2.parse({
             schemaVersion: 1,
             conversationId: snapshot.conversationId,
             version: snapshot.version
@@ -393,7 +393,7 @@ async function importConversation(driver, bytes) {
       }
       for (const run of snapshot.runs) {
         const terminalAssistant = snapshot.messages.find((message) => message.id === run.assistantMessageId);
-        await driver.runs.save(transaction, AgentStoredRunSchema.parse({
+        await driver.runs.save(transaction, AgentStoredRunSchema2.parse({
           schemaVersion: 1,
           run,
           ...terminalAssistant && { terminalAssistant }
@@ -405,14 +405,14 @@ async function importConversation(driver, bytes) {
       for (const event of archive.events) {
         if (event.kind !== "runtime/transition")
           continue;
-        const transition = AgentStoreTransitionSchema.parse(event.payload);
+        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, AgentAdmissionReceiptSchema.parse({
+        await driver.admissions.create(transaction, AgentAdmissionReceiptSchema2.parse({
           schemaVersion: 1,
           conversationId: archive.conversationId,
           idempotencyKey: transition.input.idempotencyKey,
@@ -452,11 +452,11 @@ async function findEvent(driver, transaction, conversationId, eventId) {
   return;
 }
 function appendEventOnce(driver, input, key) {
-  const parsed = AppendAgentStoreEventSchema.parse(input);
+  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 AgentConversationPurgedError;
+      throw new AgentConversationPurgedError2;
     }
     const previous = await findEvent(driver, transaction, parsed.conversationId, eventId);
     if (previous)
@@ -485,7 +485,7 @@ function applied(current, input, effects) {
   const messages = input.messages ?? current.messages;
   return {
     outcome: "applied",
-    snapshot: AgentSnapshotSchema.parse({
+    snapshot: AgentSnapshotSchema2.parse({
       ...current,
       version: current.version + 1,
       runs,
@@ -513,13 +513,13 @@ function reduceAccept(current, input) {
   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({
+  const assignedRun = coalescedRun ? AgentRunSchema2.parse({
     ...coalescedRun,
     inputMessageIds: [...coalescedRun.inputMessageIds, input.input.id],
     revision: coalescedRun.revision + 1,
     updatedAt: new Date().toISOString()
   }) : input.run;
-  const admissionReceipt = AgentAdmissionReceiptSchema.parse({
+  const admissionReceipt = AgentAdmissionReceiptSchema2.parse({
     schemaVersion: 1,
     conversationId: input.input.conversationId,
     idempotencyKey: input.idempotencyKey,
@@ -531,7 +531,7 @@ function reduceAccept(current, input) {
     messages: [...current.messages, input.input],
     runs: coalescedRun ? replaceRun(current.runs, assignedRun) : [...current.runs, assignedRun]
   }, {
-    runRecords: [AgentStoredRunSchema.parse({ schemaVersion: 1, run: assignedRun })],
+    runRecords: [AgentStoredRunSchema2.parse({ schemaVersion: 1, run: assignedRun })],
     admissionReceipt,
     historyMutations: [{ type: "admit", input: input.input }]
   });
@@ -546,7 +546,7 @@ function reduceSeed(current, input) {
     }
   }
   return applied(current, { messages: [...input.inputs, ...current.messages] }, {
-    seedReceipt: AgentSeedReceiptSchema.parse({
+    seedReceipt: AgentSeedReceiptSchema2.parse({
       schemaVersion: 1,
       conversationId,
       seedKey: input.seedKey,
@@ -599,7 +599,7 @@ function reduceAcquire(current, run, input) {
   if (run.revision !== input.expectedRevision || run.state !== "queued" || acquisitionBlocked) {
     return conflict(run.revision);
   }
-  const next = AgentRunSchema.parse({
+  const next = AgentRunSchema2.parse({
     ...run,
     state: "running",
     executionSequence: run.executionSequence ?? current.version + 1,
@@ -609,14 +609,14 @@ function reduceAcquire(current, run, input) {
     updatedAt: new Date().toISOString()
   });
   return applied(current, { runs: replaceRun(current.runs, next) }, {
-    runRecords: [AgentStoredRunSchema.parse({ schemaVersion: 1, run: 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 = AgentRunSchema.parse({
+  const next = AgentRunSchema2.parse({
     ...run,
     ...input.usage && { usage: input.usage },
     revision: run.revision + 1,
@@ -626,7 +626,7 @@ function reduceCheckpoint(current, run, input) {
     runs: replaceRun(current.runs, next),
     messages: replaceMessage(current.messages, input.assistant)
   }, {
-    runRecords: [AgentStoredRunSchema.parse({ schemaVersion: 1, run: next })],
+    runRecords: [AgentStoredRunSchema2.parse({ schemaVersion: 1, run: next })],
     historyMutations: [{ type: "upsert-assistant", message: input.assistant }]
   });
 }
@@ -634,26 +634,26 @@ 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({
+  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: [AgentStoredRunSchema.parse({ schemaVersion: 1, run: next })] });
+  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 = AgentRunSchema.parse({
+  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: [AgentStoredRunSchema.parse({ schemaVersion: 1, run: next })]
+    runRecords: [AgentStoredRunSchema2.parse({ schemaVersion: 1, run: next })]
   });
 }
 function reduceRecover(current, run, input) {
@@ -664,7 +664,7 @@ function reduceRecover(current, run, input) {
     throw new TypeError("Recovering an acquired run requires explicit replaySafe evidence");
   }
   const { ownerId: _released, ...carried } = run;
-  const next = AgentRunSchema.parse({
+  const next = AgentRunSchema2.parse({
     ...carried,
     state: input.action === "requeue" ? "queued" : "abandoned",
     revision: run.revision + 1,
@@ -673,7 +673,7 @@ function reduceRecover(current, run, input) {
   });
   if (input.action === "abandon") {
     const existingAssistant = current.messages.find((message) => message.id === run.assistantMessageId);
-    const assistant = AgentMessageSchema.parse({
+    const assistant = AgentMessageSchema2.parse({
       ...existingAssistant ?? {
         schemaVersion: 1,
         id: run.assistantMessageId,
@@ -691,7 +691,7 @@ function reduceRecover(current, run, input) {
       messages: replaceMessage(current.messages, assistant)
     }, {
       runRecords: [
-        AgentStoredRunSchema.parse({
+        AgentStoredRunSchema2.parse({
           schemaVersion: 1,
           run: next,
           terminalAssistant: assistant
@@ -701,7 +701,7 @@ function reduceRecover(current, run, input) {
     });
   }
   return applied(current, { runs: replaceRun(current.runs, next) }, {
-    runRecords: [AgentStoredRunSchema.parse({ schemaVersion: 1, run: next })]
+    runRecords: [AgentStoredRunSchema2.parse({ schemaVersion: 1, run: next })]
   });
 }
 
@@ -713,7 +713,7 @@ function reduceTerminal(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 || 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") {
+  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));
@@ -725,9 +725,9 @@ function reduceTerminal(current, run, input) {
     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({
+  const next = AgentRunSchema2.parse({
     ...run,
-    state: runStateForTerminalReason(input.reason),
+    state: runStateForTerminalReason2(input.reason),
     terminalReason: input.reason,
     ...input.policyName && { terminalPolicyName: input.policyName },
     ...input.usage && { usage: input.usage },
@@ -744,9 +744,9 @@ function reduceTerminal(current, run, input) {
     const candidate = current.runs.find((item) => item.id === entry.runId);
     if (!candidate)
       throw new TypeError("Absorbed run disappeared inside the reducer");
-    return AgentRunSchema.parse({
+    return AgentRunSchema2.parse({
       ...candidate,
-      state: runStateForTerminalReason("absorbed"),
+      state: runStateForTerminalReason2("absorbed"),
       terminalReason: "absorbed",
       absorbedIntoRunId: next.id,
       revision: candidate.revision + 1,
@@ -759,12 +759,12 @@ function reduceTerminal(current, run, input) {
     messages: replaceMessage(current.messages, input.assistant)
   }, {
     runRecords: [
-      AgentStoredRunSchema.parse({
+      AgentStoredRunSchema2.parse({
         schemaVersion: 1,
         run: next,
         terminalAssistant: input.assistant
       }),
-      ...absorbedRuns.map((absorbed) => AgentStoredRunSchema.parse({ schemaVersion: 1, run: absorbed }))
+      ...absorbedRuns.map((absorbed) => AgentStoredRunSchema2.parse({ schemaVersion: 1, run: absorbed }))
     ],
     historyMutations: [{ type: "upsert-assistant", message: input.assistant }]
   });
@@ -775,7 +775,7 @@ function transitionRecord(operation) {
   if (operation.type !== "checkpoint")
     return operation;
   const { assistant, ...rest } = operation.input;
-  const body = canonicalAgentJson(assistant);
+  const body = canonicalAgentJson2(assistant);
   return {
     type: operation.type,
     input: {
@@ -830,7 +830,7 @@ function validateAdmissionReceipt(receipt, record, conversationId) {
 async function readForMutation(driver, transaction, operation) {
   const conversationId = operationConversationId(operation);
   if (await driver.conversations?.isPurged(transaction, conversationId)) {
-    throw new AgentConversationPurgedError;
+    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([
@@ -843,7 +843,7 @@ async function readForMutation(driver, transaction, operation) {
       idempotencyKey: operation.input.idempotencyKey
     }) : undefined
   ]);
-  const head = AgentRuntimeHeadSchema.parse(stored ?? emptyHead(conversationId));
+  const head = AgentRuntimeHeadSchema2.parse(stored ?? emptyHead(conversationId));
   const referencedRecords = await driver.runs.loadMany(transaction, {
     conversationId,
     runIds: referencedRunIds(messages)
@@ -872,7 +872,7 @@ async function settledSeed(driver, transaction, read, input) {
     throw new TypeError("Partial instruction seed collision: restore the complete seed before retrying");
   }
   if (collisions > 0) {
-    await driver.seeds.create(transaction, AgentSeedReceiptSchema.parse({
+    await driver.seeds.create(transaction, AgentSeedReceiptSchema2.parse({
       schemaVersion: 1,
       conversationId,
       seedKey: input.seedKey,
@@ -939,7 +939,7 @@ async function assertAdmissionIdentitiesFree(driver, transaction, conversationId
 }
 async function persistApplied(driver, transaction, read, operation, reduced) {
   const { conversationId, current } = read;
-  const nextHead = AgentRuntimeHeadSchema.parse({
+  const nextHead = AgentRuntimeHeadSchema2.parse({
     schemaVersion: 1,
     conversationId,
     version: reduced.snapshot.version
@@ -994,7 +994,7 @@ function mutateStore(driver, operation) {
 // src/agent-runtime/store-purge.ts
 function createStoreConversationPurge(driver, conversations) {
   return async (input) => {
-    const { conversationId, expectedVersion } = AgentConversationPurgeInputSchema.parse(input);
+    const { conversationId, expectedVersion } = AgentConversationPurgeInputSchema2.parse(input);
     return driver.transaction(async (transaction) => {
       if (await conversations.isPurged(transaction, conversationId)) {
         return { outcome: "already_purged" };
@@ -1019,7 +1019,7 @@ var AgentRecoverableScanInputSchema = z5.object({
   cursor: z5.string().min(1).optional(),
   limit: z5.number().int().min(1).max(1000)
 });
-function createAgentRuntimeStore(driver) {
+function createAgentRuntimeStore2(driver) {
   const mutate = (operation) => mutateStore(driver, operation);
   return {
     loadSnapshot: (conversationId) => loadSnapshot(driver, conversationId),
@@ -1036,36 +1036,36 @@ function createAgentRuntimeStore(driver) {
     },
     acceptInputAndAssignRun: (input) => mutate({
       type: "accept",
-      input: AcceptInputAndAssignRunSchema.parse(input)
+      input: AcceptInputAndAssignRunSchema2.parse(input)
     }),
-    acquireRun: (input) => mutate({ type: "acquire", input: AcquireAgentRunSchema.parse(input) }),
+    acquireRun: (input) => mutate({ type: "acquire", input: AcquireAgentRunSchema2.parse(input) }),
     checkpointRunAssistant: (input) => mutate({
       type: "checkpoint",
-      input: CheckpointRunAssistantSchema.parse(input)
+      input: CheckpointRunAssistantSchema2.parse(input)
     }),
     recordRunOperation: (input) => mutate({
       type: "operation",
-      input: RecordRunOperationSchema.parse(input)
+      input: RecordRunOperationSchema2.parse(input)
     }),
     requestRunInterrupt: (input) => mutate({
       type: "interrupt",
-      input: RequestRunInterruptSchema.parse(input)
+      input: RequestRunInterruptSchema2.parse(input)
     }),
-    recoverRun: (input) => mutate({ type: "recover", input: RecoverAgentRunSchema.parse(input) }),
-    commitRunTerminal: (input) => mutate({ type: "terminal", input: CommitRunTerminalSchema.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: ReplaceCompactedRangeSchema.parse(input)
+      input: ReplaceCompactedRangeSchema2.parse(input)
     }),
     seedConversationInput: (input) => mutate({
       type: "seed",
-      input: SeedConversationInputSchema.parse(input)
+      input: SeedConversationInputSchema2.parse(input)
     }),
     async scanRecoverable(input) {
       const parsed = AgentRecoverableScanInputSchema.parse(input);
-      return AgentRecoverablePageSchema.parse(await driver.scanRecoverable(parsed));
+      return AgentRecoverablePageSchema2.parse(await driver.scanRecoverable(parsed));
     }
   };
 }
 
-export { AgentConversationPurgeInputSchema, AgentConversationPurgeResultSchema, AgentConversationPurgedError, purgeAgentConversation, AgentRuntimeHeadSchema, AgentStoredRunSchema, AgentAdmissionReceiptSchema, AgentSeedReceiptSchema, AgentHistoryMutationSchema, ACTIVE_AGENT_RUN_STATES, isActiveRunState, replaceMessage, appendEventIn, createAgentRuntimeStore };
+export { AgentConversationPurgeInputSchema2, AgentConversationPurgeResultSchema2, AgentConversationPurgedError2, purgeAgentConversation2, AgentRuntimeHeadSchema2, AgentStoredRunSchema2, AgentAdmissionReceiptSchema2, AgentSeedReceiptSchema2, AgentHistoryMutationSchema2, ACTIVE_AGENT_RUN_STATES2, isActiveRunState, replaceMessage, appendEventIn, createAgentRuntimeStore2 };