stitchkit 0.68.7 → 0.68.9

package/dist/index-hqza5nde.js

@@ -0,0 +1,914 @@
+import {
+  AgentMessageSchema,
+  AgentRecordIdSchema,
+  AgentRecordVersionSchema,
+  AgentRunSchema,
+  AgentSnapshotSchema,
+  AgentTerminalReasonSchema,
+  AgentUsageSchema,
+  runStateForTerminalReason
+} from "./index-ysphyxax.js";
+
+// src/agent-runtime/store.ts
+import { z } from "zod";
+var AgentStoreConflictSchema = z.object({
+  outcome: z.literal("conflict"),
+  actualVersion: AgentRecordVersionSchema
+});
+var AgentStoreNotFoundSchema = z.object({ outcome: z.literal("not_found") });
+var AgentStoreAppliedSchema = z.object({
+  outcome: z.literal("applied"),
+  snapshot: AgentSnapshotSchema
+});
+var AgentStoreDuplicateSchema = z.object({
+  outcome: z.literal("duplicate"),
+  input: AgentMessageSchema,
+  inputMessageId: AgentRecordIdSchema,
+  runId: AgentRecordIdSchema,
+  assistantMessageId: AgentRecordIdSchema,
+  run: AgentRunSchema,
+  assistant: AgentMessageSchema.optional(),
+  snapshot: AgentSnapshotSchema
+});
+var AgentStoreMutationResultSchema = z.discriminatedUnion("outcome", [
+  AgentStoreAppliedSchema,
+  AgentStoreDuplicateSchema,
+  AgentStoreConflictSchema,
+  AgentStoreNotFoundSchema
+]);
+var AgentRunViewSchema = z.object({
+  snapshotVersion: AgentRecordVersionSchema,
+  run: AgentRunSchema,
+  assistant: AgentMessageSchema.optional()
+});
+var AcceptInputAndAssignRunSchema = z.object({
+  idempotencyKey: z.string().min(1),
+  expectedVersion: AgentRecordVersionSchema.optional(),
+  input: AgentMessageSchema,
+  run: AgentRunSchema,
+  coalesceIntoRunId: AgentRecordIdSchema.optional()
+});
+var AcquireAgentRunSchema = z.object({
+  conversationId: AgentRecordIdSchema,
+  runId: AgentRecordIdSchema,
+  expectedRevision: AgentRecordVersionSchema,
+  ownerId: z.string().min(1)
+});
+var CheckpointRunAssistantSchema = z.object({
+  conversationId: AgentRecordIdSchema,
+  runId: AgentRecordIdSchema,
+  expectedRevision: AgentRecordVersionSchema,
+  ownerId: z.string().min(1),
+  fencingToken: AgentRecordVersionSchema.optional(),
+  assistant: AgentMessageSchema,
+  usage: AgentUsageSchema.optional()
+});
+var CommitRunTerminalSchema = z.object({
+  conversationId: AgentRecordIdSchema,
+  runId: AgentRecordIdSchema,
+  expectedRevision: AgentRecordVersionSchema,
+  ownerId: z.string().min(1),
+  fencingToken: AgentRecordVersionSchema.optional(),
+  assistant: AgentMessageSchema,
+  reason: AgentTerminalReasonSchema,
+  policyName: z.string().min(1).optional(),
+  usage: AgentUsageSchema.optional(),
+  absorb: z.array(z.object({
+    runId: AgentRecordIdSchema,
+    inputMessageIds: z.array(AgentRecordIdSchema).min(1)
+  })).min(1).optional()
+});
+var RequestRunInterruptSchema = z.object({
+  conversationId: AgentRecordIdSchema,
+  runId: AgentRecordIdSchema,
+  expectedRevision: AgentRecordVersionSchema
+});
+var RecoverAgentRunSchema = z.object({
+  conversationId: AgentRecordIdSchema,
+  runId: AgentRecordIdSchema,
+  expectedRevision: AgentRecordVersionSchema,
+  action: z.enum(["requeue", "abandon"]),
+  replaySafe: z.boolean().optional()
+});
+var ReplaceCompactedRangeSchema = z.object({
+  conversationId: AgentRecordIdSchema,
+  expectedVersion: AgentRecordVersionSchema,
+  replacedMessageIds: z.array(AgentRecordIdSchema).min(1),
+  summary: AgentMessageSchema
+});
+
+// src/agent-runtime/store-driver.ts
+import { z as z2 } from "zod";
+
+// src/agent-runtime/terminal-status.ts
+function isSpeakableAssistantStatus(status) {
+  return status === "completed" || status === "interrupted" || status === "committed";
+}
+function assistantStatus(reason) {
+  if (reason === "success" || reason === "policy_stop" || reason === "provider_stop") {
+    return "completed";
+  }
+  if (reason === "superseded")
+    return "superseded";
+  if (reason === "absorbed")
+    return "superseded";
+  if (reason === "interrupted" || reason === "cancelled" || reason === "shutdown") {
+    return "interrupted";
+  }
+  return "failed";
+}
+
+// src/agent-runtime/store-driver.ts
+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 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
+  })
+]);
+var AgentRecoverableDescriptorSchema = z2.object({
+  conversationId: AgentRecordIdSchema,
+  run: AgentRunSchema
+});
+var AgentRecoverablePageSchema = z2.object({
+  items: z2.array(AgentRecoverableDescriptorSchema),
+  nextCursor: z2.string().min(1).optional()
+});
+var AgentRecoverableScanInputSchema = z2.object({
+  cursor: z2.string().min(1).optional(),
+  limit: z2.number().int().min(1).max(1000)
+});
+function emptyHead(conversationId) {
+  return AgentRuntimeHeadSchema.parse({
+    schemaVersion: 1,
+    conversationId,
+    version: 0
+  });
+}
+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");
+      }
+    }
+  }
+}
+var RecoverableCursorSchema = z2.tuple([AgentRecordIdSchema, AgentRecordIdSchema]);
+function recoverableCursor(input) {
+  return JSON.stringify([input.conversationId, input.run.id]);
+}
+function parseRecoverableCursor(cursor) {
+  return RecoverableCursorSchema.parse(JSON.parse(cursor));
+}
+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];
+}
+var ACTIVE_AGENT_RUN_STATES = [
+  "queued",
+  "running",
+  "interrupt_requested"
+];
+function isActiveRunState(state) {
+  return ACTIVE_AGENT_RUN_STATES.includes(state);
+}
+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?.historyMutations?.length && { historyMutations: effects.historyMutations }
+  };
+}
+function reduceStore(current, operation) {
+  if (operation.type === "accept") {
+    const input = operation.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.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 }]
+    });
+  }
+  const conversationId = operation.input.conversationId;
+  const run = operation.type === "compact" ? undefined : current.runs.find((candidate) => candidate.id === operation.input.runId);
+  if (operation.type !== "compact" && !run)
+    return { outcome: "not_found" };
+  if (operation.type === "acquire" && run) {
+    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 !== operation.input.expectedRevision || run.state !== "queued" || acquisitionBlocked) {
+      return conflict(run.revision);
+    }
+    const next = AgentRunSchema.parse({
+      ...run,
+      state: "running",
+      executionSequence: run.executionSequence ?? current.version + 1,
+      ownerId: operation.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 })]
+    });
+  }
+  if (operation.type === "checkpoint" && run) {
+    const input = operation.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 }]
+    });
+  }
+  if (operation.type === "interrupt" && run) {
+    if (run.revision !== operation.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 })]
+    });
+  }
+  if (operation.type === "recover" && run) {
+    const input = operation.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 })]
+    });
+  }
+  if (operation.type === "terminal" && run) {
+    const input = operation.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 }]
+    });
+  }
+  if (operation.type === "compact") {
+    const input = operation.input;
+    if (current.conversationId !== 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
+        }
+      ]
+    });
+  }
+  return { outcome: "not_found" };
+}
+function operationConversationId(operation) {
+  return operation.type === "accept" ? operation.input.input.conversationId : operation.input.conversationId;
+}
+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] : []))];
+}
+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");
+  }
+}
+function createAgentRuntimeStore(driver) {
+  const loadSnapshot = (conversationId) => driver.transaction(async (transaction) => {
+    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));
+  });
+  const loadRun = (input) => 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 }
+    });
+  });
+  const listActiveRuns = (conversationId) => 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);
+  });
+  const mutate = (operation) => driver.transaction(async (transaction) => {
+    const conversationId = operationConversationId(operation);
+    const operationRunId = operation.type === "accept" ? operation.input.coalesceIntoRunId : operation.type === "compact" ? 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);
+    if (duplicateReceipt) {
+      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] : []))
+      };
+    }
+    if (operation.type === "accept") {
+      const inputCollision = await driver.admissions.loadByInputMessageId(transaction, {
+        conversationId,
+        inputMessageId: operation.input.input.id
+      });
+      if (inputCollision) {
+        throw new TypeError("Input message identity is already assigned to an admission");
+      }
+      if (!operation.input.coalesceIntoRunId) {
+        const [runCollision, assistantCollision] = await Promise.all([
+          driver.runs.load(transaction, {
+            conversationId,
+            runId: operation.input.run.id
+          }),
+          driver.runs.loadByAssistantMessageId(transaction, {
+            conversationId,
+            assistantMessageId: operation.input.run.assistantMessageId
+          })
+        ]);
+        if (runCollision || assistantCollision) {
+          throw new TypeError("Queued run identities are already reserved");
+        }
+      }
+    }
+    const reduced = reduceStore(current, operation);
+    if (reduced.outcome !== "applied")
+      return reduced;
+    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);
+    }
+    for (const mutation of reduced.historyMutations ?? []) {
+      await driver.history.apply(transaction, mutation);
+    }
+    return { outcome: "applied", snapshot: reduced.snapshot };
+  });
+  return {
+    loadSnapshot,
+    loadRun,
+    listActiveRuns,
+    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)
+    }),
+    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)
+    }),
+    async scanRecoverable(input) {
+      const parsed = AgentRecoverableScanInputSchema.parse(input);
+      return AgentRecoverablePageSchema.parse(await driver.scanRecoverable(parsed));
+    }
+  };
+}
+function cloneHeadMap(source) {
+  return new Map([...source].map(([key, value]) => [
+    key,
+    AgentRuntimeHeadSchema.parse(structuredClone(value))
+  ]));
+}
+function cloneNestedMap(source, clone) {
+  return new Map([...source].map(([outerKey, values]) => [
+    outerKey,
+    new Map([...values].map(([innerKey, value]) => [innerKey, clone(value)]))
+  ]));
+}
+function cloneHistoryMap(source) {
+  return new Map([...source].map(([key, value]) => [
+    key,
+    value.map((message) => AgentMessageSchema.parse(structuredClone(message)))
+  ]));
+}
+function createMemoryAgentRuntimeStore() {
+  let heads = new Map;
+  let runs = new Map;
+  let admissions = new Map;
+  let histories = new Map;
+  let transactionTail = Promise.resolve();
+  const driver = {
+    async transaction(work) {
+      const previous = transactionTail;
+      const release = Promise.withResolvers();
+      transactionTail = previous.catch(() => {
+        return;
+      }).then(() => release.promise);
+      await previous.catch(() => {
+        return;
+      });
+      const transaction = {
+        heads: cloneHeadMap(heads),
+        runs: cloneNestedMap(runs, (record) => AgentStoredRunSchema.parse(structuredClone(record))),
+        admissions: cloneNestedMap(admissions, (receipt) => AgentAdmissionReceiptSchema.parse(structuredClone(receipt))),
+        histories: cloneHistoryMap(histories)
+      };
+      try {
+        const result = await work(transaction);
+        heads = transaction.heads;
+        runs = transaction.runs;
+        admissions = transaction.admissions;
+        histories = transaction.histories;
+        return result;
+      } finally {
+        release.resolve();
+      }
+    },
+    head: {
+      async load(transaction, conversationId) {
+        const head = transaction.heads.get(conversationId);
+        return head ? AgentRuntimeHeadSchema.parse(structuredClone(head)) : undefined;
+      },
+      async compareAndSwap(transaction, input) {
+        const current = transaction.heads.get(input.conversationId);
+        const actualVersion = current?.version ?? 0;
+        if (actualVersion !== input.expectedVersion) {
+          return { outcome: "conflict", actualVersion };
+        }
+        transaction.heads.set(input.conversationId, AgentRuntimeHeadSchema.parse(structuredClone(input.next)));
+        return { outcome: "applied" };
+      }
+    },
+    runs: {
+      async load(transaction, input) {
+        const record = transaction.runs.get(input.conversationId)?.get(input.runId);
+        return record ? AgentStoredRunSchema.parse(structuredClone(record)) : undefined;
+      },
+      async loadByAssistantMessageId(transaction, input) {
+        const record = [...transaction.runs.get(input.conversationId)?.values() ?? []].find((candidate) => candidate.run.assistantMessageId === input.assistantMessageId);
+        return record ? AgentStoredRunSchema.parse(structuredClone(record)) : undefined;
+      },
+      async loadMany(transaction, input) {
+        const records = transaction.runs.get(input.conversationId);
+        return input.runIds.flatMap((runId) => {
+          const record = records?.get(runId);
+          return record ? [AgentStoredRunSchema.parse(structuredClone(record))] : [];
+        });
+      },
+      async listActive(transaction, conversationId) {
+        return [...transaction.runs.get(conversationId)?.values() ?? []].filter((record) => isActiveRunState(record.run.state)).map((record) => AgentStoredRunSchema.parse(structuredClone(record)));
+      },
+      async save(transaction, rawRecord) {
+        const record = AgentStoredRunSchema.parse(structuredClone(rawRecord));
+        const conversationRuns = transaction.runs.get(record.run.conversationId) ?? new Map;
+        const collision = [...conversationRuns.values()].find((candidate) => candidate.run.id !== record.run.id && candidate.run.assistantMessageId === record.run.assistantMessageId);
+        if (collision)
+          throw new TypeError("Assistant message identity is already reserved");
+        conversationRuns.set(record.run.id, record);
+        transaction.runs.set(record.run.conversationId, conversationRuns);
+      }
+    },
+    admissions: {
+      async load(transaction, input) {
+        const receipt = transaction.admissions.get(input.conversationId)?.get(input.idempotencyKey);
+        return receipt ? AgentAdmissionReceiptSchema.parse(structuredClone(receipt)) : undefined;
+      },
+      async loadByInputMessageId(transaction, input) {
+        const receipt = [
+          ...transaction.admissions.get(input.conversationId)?.values() ?? []
+        ].find((candidate) => candidate.input.id === input.inputMessageId);
+        return receipt ? AgentAdmissionReceiptSchema.parse(structuredClone(receipt)) : undefined;
+      },
+      async create(transaction, rawReceipt) {
+        const receipt = AgentAdmissionReceiptSchema.parse(structuredClone(rawReceipt));
+        const conversationAdmissions = transaction.admissions.get(receipt.conversationId) ?? new Map;
+        if (conversationAdmissions.has(receipt.idempotencyKey) || [...conversationAdmissions.values()].some((candidate) => candidate.input.id === receipt.input.id)) {
+          throw new TypeError("Admission identity is already reserved");
+        }
+        conversationAdmissions.set(receipt.idempotencyKey, receipt);
+        transaction.admissions.set(receipt.conversationId, conversationAdmissions);
+      }
+    },
+    history: {
+      async load(transaction, conversationId) {
+        return (transaction.histories.get(conversationId) ?? []).map((message) => AgentMessageSchema.parse(structuredClone(message)));
+      },
+      async apply(transaction, rawMutation) {
+        const mutation = AgentHistoryMutationSchema.parse(rawMutation);
+        const conversationId = mutation.type === "admit" ? mutation.input.conversationId : mutation.type === "upsert-assistant" ? mutation.message.conversationId : mutation.summary.conversationId;
+        const current = transaction.histories.get(conversationId) ?? [];
+        if (mutation.type === "admit") {
+          transaction.histories.set(conversationId, [...current, mutation.input]);
+          return;
+        }
+        if (mutation.type === "upsert-assistant") {
+          transaction.histories.set(conversationId, replaceMessage(current, mutation.message));
+          return;
+        }
+        const replaced = new Set(mutation.replacedMessageIds);
+        const positions = current.map((message, index) => replaced.has(message.id) ? index : undefined).filter((index) => index !== undefined);
+        const first = positions[0];
+        if (first === undefined)
+          throw new Error("Compaction history range disappeared");
+        transaction.histories.set(conversationId, [
+          ...current.slice(0, first),
+          mutation.summary,
+          ...current.slice(first + positions.length)
+        ]);
+      }
+    },
+    async scanRecoverable(input) {
+      const descriptors = [...runs].flatMap(([conversationId, conversationRuns]) => [...conversationRuns.values()].filter((record) => isActiveRunState(record.run.state)).map((record) => ({ conversationId, run: record.run }))).sort((left, right) => left.conversationId.localeCompare(right.conversationId) || left.run.id.localeCompare(right.run.id));
+      const cursorTuple = input.cursor ? parseRecoverableCursor(input.cursor) : undefined;
+      const start = cursorTuple ? descriptors.findIndex((item) => item.conversationId.localeCompare(cursorTuple[0]) > 0 || item.conversationId === cursorTuple[0] && item.run.id.localeCompare(cursorTuple[1]) > 0) : 0;
+      if (start === -1) {
+        return AgentRecoverablePageSchema.parse({ items: [] });
+      }
+      const items = descriptors.slice(start, start + input.limit);
+      const last = items.at(-1);
+      const hasMore = start + items.length < descriptors.length;
+      return AgentRecoverablePageSchema.parse({
+        items,
+        ...hasMore && last && { nextCursor: recoverableCursor(last) }
+      });
+    }
+  };
+  return createAgentRuntimeStore(driver);
+}
+
+export { isSpeakableAssistantStatus, assistantStatus, AgentStoreConflictSchema, AgentStoreNotFoundSchema, AgentStoreAppliedSchema, AgentStoreDuplicateSchema, AgentStoreMutationResultSchema, AgentRunViewSchema, AcceptInputAndAssignRunSchema, AcquireAgentRunSchema, CheckpointRunAssistantSchema, CommitRunTerminalSchema, RequestRunInterruptSchema, RecoverAgentRunSchema, ReplaceCompactedRangeSchema, AgentRuntimeHeadSchema, AgentStoredRunSchema, AgentAdmissionReceiptSchema, AgentHistoryMutationSchema, AgentRecoverableDescriptorSchema, AgentRecoverablePageSchema, ACTIVE_AGENT_RUN_STATES, createAgentRuntimeStore, createMemoryAgentRuntimeStore };