stitchkit 0.59.4 → 0.60.1

package/dist/agent-runtime.js

@@ -1,7 +1,7 @@
 import {
   ToolExecutionControlError,
   isToolExecutionControlError
-} from "./index-sa2mbwa7.js";
+} from "./index-wrhf06ak.js";
 import {
   AgentAssistantPlaceholderSchema,
   AgentControlPartSchema,
@@ -34,15 +34,16 @@ import"./index-6djpbnda.js";
 import"./index-cby4ar3v.js";
 import {
   createBoundedSinkManager
-} from "./index-0nc0cddp.js";
-import"./index-7c0gkyvj.js";
-import"./index-ps5pxp3h.js";
+} from "./index-a59da114.js";
+import"./index-tvwcrx2d.js";
+import"./index-wd8g8z6e.js";
 import"./index-6k1937bx.js";
 import {
   childSpan,
   createTraceContext
-} from "./index-y2rb7dwx.js";
+} from "./index-pzyt11ch.js";
 import"./index-smpbdg6k.js";
+import"./index-xxye8j3k.js";
 
 // src/agent-runtime/compaction.ts
 function providerValidTurn(messages) {
@@ -148,6 +149,13 @@ function structuredCompaction(config) {
   };
 }
 // src/agent-runtime/coordinator.ts
+function assertCloseBudgets(options) {
+  for (const [name, value] of Object.entries(options)) {
+    if (value !== undefined && (!Number.isSafeInteger(value) || value < 0)) {
+      throw new TypeError(`${name} must be a non-negative safe integer`);
+    }
+  }
+}
 function createAgentSessionCoordinator() {
   const lanes = new Map;
   let closed = false;
@@ -230,11 +238,7 @@ function createAgentSessionCoordinator() {
       return true;
     },
     async close(options = {}) {
-      for (const [name, value] of Object.entries(options)) {
-        if (value !== undefined && (!Number.isSafeInteger(value) || value < 0)) {
-          throw new TypeError(`${name} must be a non-negative safe integer`);
-        }
-      }
+      assertCloseBudgets(options);
       closed = true;
       const error = new Error("Agent session coordinator is closed");
       for (const lane of lanes.values()) {
@@ -243,21 +247,31 @@ function createAgentSessionCoordinator() {
       }
       const active = [...lanes.values()].map((lane) => lane.active).filter((run) => run !== undefined);
       const settlements = active.map((run) => run.settled);
+      const outstanding = new Set(settlements);
+      for (const settled of settlements) {
+        settled.then(() => {
+          outstanding.delete(settled);
+        });
+      }
       const drain = Promise.all(settlements).then(() => {
         return;
       });
-      if (options.drainTimeoutMs !== undefined) {
-        const drained = await waitWithin(drain, options.drainTimeoutMs);
-        if (drained)
-          return;
+      const finished = () => ({
+        settled: outstanding.size === 0,
+        timedOut: outstanding.size > 0,
+        remaining: outstanding.size
+      });
+      if (options.gracePeriodMs !== undefined && await waitWithin(drain, options.gracePeriodMs)) {
+        return finished();
       }
       for (const run of active)
         run.controller.abort("shutdown");
-      if (options.drainTimeoutMs === undefined)
-        return drain;
-      if (options.forceTimeoutMs === undefined)
-        return;
+      if (options.forceTimeoutMs === undefined) {
+        await drain;
+        return finished();
+      }
       await waitWithin(drain, options.forceTimeoutMs);
+      return finished();
     },
     isRunning(key) {
       return lanes.get(key)?.active !== undefined;
@@ -431,12 +445,16 @@ async function userMessage(message, options) {
       });
       continue;
     }
-    const fallback = options.unresolvedFile ?? "text";
+    const fallback = options.unresolvedFile ?? "omit";
     if (fallback === "error") {
       throw new Error(`No history file resolver configured for ${part.reference}`);
     }
     if (fallback === "text") {
-      content.push({ type: "text", text: `[attachment: ${part.reference}]` });
+      const described = part.filename ?? part.mediaType;
+      content.push({
+        type: "text",
+        text: described ? `[attachment: ${described}]` : "[attachment]"
+      });
     }
   }
   if (content.length === 0)
@@ -693,7 +711,18 @@ function createAgentObservability(config) {
     ...config.onSinkError && { onSinkError: config.onSinkError },
     ...config.onDrop && { onDrop: config.onDrop }
   });
+  const DEDUPLICATION_WINDOW = 1e4;
   const emitted = new Set;
+  const ring = new Array(DEDUPLICATION_WINDOW).fill(undefined);
+  let cursor = 0;
+  const remember = (eventId) => {
+    emitted.add(eventId);
+    const evicted = ring[cursor];
+    ring[cursor] = eventId;
+    cursor = (cursor + 1) % DEDUPLICATION_WINDOW;
+    if (evicted !== undefined)
+      emitted.delete(evicted);
+  };
   return {
     rootTrace(parent) {
       const trace = parent ? childSpan(parent) : createTraceContext();
@@ -703,7 +732,7 @@ function createAgentObservability(config) {
       const parsed = AgentRunEventSchema.parse(rawEvent);
       if ((config.deduplicate ?? true) && emitted.has(parsed.eventId))
         return;
-      emitted.add(parsed.eventId);
+      remember(parsed.eventId);
       manager.submit(() => config.includeInternalCause ? parsed : AgentRunEventSchema.omit({ internalCause: true }).parse(parsed));
     },
     flush: () => manager.flush(),
@@ -893,13 +922,74 @@ function defineAgentProtocol(config) {
     parsePart: (input) => AgentMessageSchema.shape.parts.element.parse(input)
   };
 }
-// src/agent-runtime/runtime.ts
-import {
-  stepCountIs,
-  streamText
-} from "ai";
+// src/agent-runtime/admission-lanes.ts
+function createRuntimeAdmissionLanes() {
+  const lanes = new Map;
+  const admit = (runId) => {
+    const admission = { runId, completion: Promise.withResolvers() };
+    admission.completion.promise.catch(() => {
+      return;
+    });
+    return admission;
+  };
+  return {
+    reserve(key, runId) {
+      const existing = lanes.get(key);
+      const lane = existing ?? { acceptanceTail: Promise.resolve() };
+      if (!existing)
+        lanes.set(key, lane);
+      if (!lane.head) {
+        lane.head = admit(runId);
+        return { lane, admission: lane.head, shouldSchedule: true };
+      }
+      if (!lane.pending) {
+        lane.pending = admit(runId);
+        return { lane, admission: lane.pending, shouldSchedule: true };
+      }
+      return { lane, admission: lane.pending, shouldSchedule: false };
+    },
+    settle(key, admission) {
+      const lane = lanes.get(key);
+      if (!lane)
+        return;
+      if (lane.head?.runId === admission.runId) {
+        lane.head = lane.pending;
+        lane.pending = undefined;
+      } else if (lane.pending?.runId === admission.runId) {
+        lane.pending = undefined;
+      }
+      if (!lane.head && !lane.pending)
+        lanes.delete(key);
+    },
+    async waitForAcceptances(lane) {
+      while (true) {
+        const tail = lane.acceptanceTail;
+        await tail.catch(() => {
+          return;
+        });
+        if (tail === lane.acceptanceTail)
+          return;
+      }
+    }
+  };
+}
+
+// src/agent-runtime/run-execution.ts
+import { stepCountIs, streamText } from "ai";
+
+// src/agent-runtime/runtime-internals.ts
 import { z as z5 } from "zod";
 
+// src/agent-runtime/terminal-status.ts
+function assistantStatus(reason) {
+  if (reason === "success" || reason === "policy_stop")
+    return "completed";
+  if (reason === "interrupted" || reason === "cancelled" || reason === "shutdown") {
+    return "interrupted";
+  }
+  return "failed";
+}
+
 // src/agent-runtime/terminal-commit.ts
 class AgentRuntimeConflictError extends Error {
   constructor(operation) {
@@ -912,20 +1002,12 @@ function appliedSnapshot(result, operation) {
     return result.snapshot;
   throw new AgentRuntimeConflictError(operation);
 }
-function terminalMessageStatus(reason) {
-  if (reason === "success" || reason === "policy_stop")
-    return "completed";
-  if (reason === "interrupted" || reason === "cancelled" || reason === "shutdown") {
-    return "interrupted";
-  }
-  return "failed";
-}
 function canonicalTerminal(snapshot, runId, retainedAssistant) {
   const run = snapshot.runs.find((candidate) => candidate.id === runId);
   if (!run?.terminalReason)
     return;
   const assistant = snapshot.messages.find((message) => message.id === run.assistantMessageId) ?? retainedAssistant;
-  if (snapshot.conversationId !== run.conversationId || !assistant || assistant.id !== run.assistantMessageId || assistant.conversationId !== run.conversationId || assistant.runId !== run.id || assistant.role !== "assistant" || assistant.status !== terminalMessageStatus(run.terminalReason)) {
+  if (snapshot.conversationId !== run.conversationId || !assistant || assistant.id !== run.assistantMessageId || assistant.conversationId !== run.conversationId || assistant.runId !== run.id || assistant.role !== "assistant" || assistant.status !== assistantStatus(run.terminalReason)) {
     throw new AgentRuntimeConflictError("terminal result projection");
   }
   return {
@@ -999,7 +1081,7 @@ async function commitAgentRunTerminal(input) {
   }
 }
 
-// src/agent-runtime/runtime.ts
+// src/agent-runtime/runtime-internals.ts
 function findRun(runs, runId) {
   const run = runs.find((candidate) => candidate.id === runId);
   if (!run)
@@ -1025,14 +1107,6 @@ function appendText(parts, text) {
   }
   parts.push(AgentMessagePartSchema.parse({ type: "text", text }));
 }
-function assistantStatus(reason) {
-  if (reason === "success" || reason === "policy_stop")
-    return "completed";
-  if (reason === "interrupted" || reason === "cancelled" || reason === "shutdown") {
-    return "interrupted";
-  }
-  return "failed";
-}
 function abortTerminalReason(signal) {
   if (signal.reason === "shutdown")
     return "shutdown";
@@ -1074,88 +1148,20 @@ function createIdleDeadline(parent, timeoutMs) {
     }
   };
 }
-function createAgentRuntime(config) {
-  const coordinator = createAgentSessionCoordinator();
-  const tickets = new Map;
-  const generateId = config.generateId ?? (() => crypto.randomUUID());
-  const now = config.now ?? (() => new Date);
-  const runtimeEpoch = generateId();
-  const admissionLanes = new Map;
-  const reserveAdmission = (key, runId) => {
-    const existing = admissionLanes.get(key);
-    const lane = existing ?? { acceptanceTail: Promise.resolve() };
-    if (!existing)
-      admissionLanes.set(key, lane);
-    if (!lane.head) {
-      const admission = { runId, completion: Promise.withResolvers() };
-      admission.completion.promise.catch(() => {
-        return;
-      });
-      lane.head = admission;
-      return { lane, admission, shouldSchedule: true };
-    }
-    if (!lane.pending) {
-      const admission = { runId, completion: Promise.withResolvers() };
-      admission.completion.promise.catch(() => {
-        return;
-      });
-      lane.pending = admission;
-      return { lane, admission, shouldSchedule: true };
-    }
-    return { lane, admission: lane.pending, shouldSchedule: false };
-  };
-  const settleAdmission = (key, admission) => {
-    const lane = admissionLanes.get(key);
-    if (!lane)
-      return;
-    if (lane.head?.runId === admission.runId) {
-      lane.head = lane.pending;
-      lane.pending = undefined;
-    } else if (lane.pending?.runId === admission.runId) {
-      lane.pending = undefined;
-    }
-    if (!lane.head && !lane.pending)
-      admissionLanes.delete(key);
-  };
-  const waitForAdmissionAcceptances = async (lane) => {
-    while (true) {
-      const tail = lane.acceptanceTail;
-      await tail.catch(() => {
-        return;
-      });
-      if (tail === lane.acceptanceTail)
-        return;
-    }
-  };
-  const checkpointEveryEvents = config.loop?.checkpointEveryEvents ?? 20;
-  const maxSteps = config.loop?.maxSteps ?? 50;
-  const idleTimeoutMs = config.loop?.idleTimeoutMs;
-  if (!Number.isSafeInteger(checkpointEveryEvents) || checkpointEveryEvents < 1) {
-    throw new TypeError("checkpointEveryEvents must be a positive safe integer");
-  }
-  if (!Number.isSafeInteger(maxSteps) || maxSteps < 1) {
-    throw new TypeError("maxSteps must be a positive safe integer");
-  }
-  if (idleTimeoutMs !== undefined && (!Number.isSafeInteger(idleTimeoutMs) || idleTimeoutMs < 1)) {
-    throw new TypeError("idleTimeoutMs must be a positive safe integer");
-  }
-  const policyNames = new Set(["max-steps"]);
-  for (const policy of config.loop?.stopPolicies ?? []) {
-    if (!policy.name || policyNames.has(policy.name)) {
-      throw new TypeError("Agent stop policy names must be non-empty and unique");
-    }
-    policyNames.add(policy.name);
-  }
-  const publish = async (event) => {
-    try {
-      await config.publish?.(event);
-    } catch (error) {
-      try {
-        await config.onPublishError?.({ event, error });
-      } catch {}
-    }
-  };
-  const executeRun = async (input) => {
+
+// src/agent-runtime/run-execution.ts
+function createRunExecutor(dependencies) {
+  const {
+    config,
+    publish,
+    runtimeEpoch,
+    generateId,
+    now,
+    checkpointEveryEvents,
+    maxSteps,
+    idleTimeoutMs
+  } = dependencies;
+  return async function executeRun(input) {
     const queuedSnapshot = await config.store.loadSnapshot(input.acceptedRun.conversationId);
     const queuedRun = findRun(queuedSnapshot.runs, input.acceptedRun.id);
     const acquired = appliedSnapshot(await config.store.acquireRun({
@@ -1628,8 +1634,9 @@ function createAgentRuntime(config) {
       } else {
         terminalReason = "provider_failure";
       }
+    } finally {
+      idleDeadline.dispose();
     }
-    idleDeadline.dispose();
     assistant = AgentMessageSchema.parse({
       ...assistant,
       status: assistantStatus(terminalReason),
@@ -1699,10 +1706,110 @@ function createAgentRuntime(config) {
       ...terminalPolicyName && { policyName: terminalPolicyName }
     };
   };
+}
+
+// src/agent-runtime/runtime.ts
+function createAgentRuntime(config) {
+  const coordinator = createAgentSessionCoordinator();
+  const tickets = new Map;
+  const generateId = config.generateId ?? (() => crypto.randomUUID());
+  const now = config.now ?? (() => new Date);
+  const runtimeEpoch = generateId();
+  const admissionLanes = createRuntimeAdmissionLanes();
+  const reserveAdmission = admissionLanes.reserve;
+  const settleAdmission = admissionLanes.settle;
+  const waitForAdmissionAcceptances = admissionLanes.waitForAcceptances;
+  const checkpointEveryEvents = config.loop?.checkpointEveryEvents ?? 20;
+  const maxSteps = config.loop?.maxSteps ?? 50;
+  const idleTimeoutMs = config.loop?.idleTimeoutMs;
+  if (!Number.isSafeInteger(checkpointEveryEvents) || checkpointEveryEvents < 1) {
+    throw new TypeError("checkpointEveryEvents must be a positive safe integer");
+  }
+  if (!Number.isSafeInteger(maxSteps) || maxSteps < 1) {
+    throw new TypeError("maxSteps must be a positive safe integer");
+  }
+  if (idleTimeoutMs !== undefined && (!Number.isSafeInteger(idleTimeoutMs) || idleTimeoutMs < 1)) {
+    throw new TypeError("idleTimeoutMs must be a positive safe integer");
+  }
+  const policyNames = new Set(["max-steps"]);
+  for (const policy of config.loop?.stopPolicies ?? []) {
+    if (!policy.name || policyNames.has(policy.name)) {
+      throw new TypeError("Agent stop policy names must be non-empty and unique");
+    }
+    policyNames.add(policy.name);
+  }
+  const publish = async (event) => {
+    try {
+      await config.publish?.(event);
+    } catch (error) {
+      try {
+        await config.onPublishError?.({ event, error });
+      } catch {}
+    }
+  };
+  const executeRun = createRunExecutor({
+    config,
+    publish,
+    runtimeEpoch,
+    generateId,
+    now,
+    checkpointEveryEvents,
+    maxSteps,
+    ...idleTimeoutMs !== undefined && { idleTimeoutMs }
+  });
+  let admissionClosed = false;
+  const closedError = () => new Error("[stitchkit] agent runtime is closed and admits no further work");
+  const admissionsInFlight = new Set;
+  const beginAdmission = () => {
+    const handoff = Promise.withResolvers();
+    admissionsInFlight.add(handoff);
+    return () => {
+      if (admissionsInFlight.delete(handoff))
+        handoff.resolve();
+    };
+  };
+  const drainAdmissions = async (budgetMs) => {
+    const pending = [...admissionsInFlight].map((handoff) => handoff.promise);
+    if (pending.length === 0)
+      return 0;
+    let stranded = pending.length;
+    const settled = Promise.all(pending.map((promise) => promise.then(() => {
+      stranded -= 1;
+    })));
+    if (budgetMs === undefined) {
+      await settled;
+      return 0;
+    }
+    let timer;
+    await Promise.race([
+      settled,
+      new Promise((resolve) => {
+        timer = setTimeout(resolve, budgetMs);
+      })
+    ]);
+    if (timer !== undefined)
+      clearTimeout(timer);
+    return stranded;
+  };
+  const refuse = () => {
+    const error = closedError();
+    const accepted = Promise.reject(error);
+    const result = Promise.reject(error);
+    accepted.catch(() => {
+      return;
+    });
+    result.catch(() => {
+      return;
+    });
+    return { accepted, result };
+  };
   const resume = (rawInput) => {
+    if (admissionClosed)
+      return refuse();
     const context = config.protocol.parseContext(rawInput.context);
     const accepted = Promise.withResolvers();
     const result = Promise.withResolvers();
+    const handedOff = beginAdmission();
     (async () => {
       try {
         const snapshot = await config.store.loadSnapshot(rawInput.conversationId);
@@ -1719,16 +1826,29 @@ function createAgentRuntime(config) {
             execute: () => executeRun({ acceptedRun: recoveredRun, context, signal })
           })
         });
+        ticket.accepted.catch(() => {
+          return;
+        });
         ticket.result.then(result.resolve, result.reject);
       } catch (error) {
         accepted.reject(error);
         result.reject(error);
+      } finally {
+        handedOff();
       }
     })();
     return { accepted: accepted.promise, result: result.promise };
   };
   return {
     submit(rawInput) {
+      if (admissionClosed) {
+        const refused = refuse();
+        const admission = Promise.reject(closedError());
+        admission.catch(() => {
+          return;
+        });
+        return { ...refused, admission };
+      }
       const metadata = rawInput.metadata === undefined ? undefined : config.protocol.parseInputMetadata(rawInput.metadata);
       const input = {
         conversationId: rawInput.conversationId,
@@ -1801,6 +1921,7 @@ function createAgentRuntime(config) {
           tickets.delete(input.conversationId);
       };
       outerResult.promise.then(forgetTicket, forgetTicket);
+      const handedOff = beginAdmission();
       (async () => {
         try {
           await previousAcceptance.catch(() => {
@@ -1810,6 +1931,8 @@ function createAgentRuntime(config) {
             context,
             conversationId: input.conversationId
           });
+          if (admissionClosed)
+            throw closedError();
           const acceptance = await config.store.acceptInputAndAssignRun({
             idempotencyKey: input.idempotencyKey,
             input: userMessage2,
@@ -1918,6 +2041,9 @@ function createAgentRuntime(config) {
               };
             }
           });
+          ticket.accepted.catch(() => {
+            return;
+          });
           if (reservation) {
             ticket.result.then(reservation.admission.completion.resolve, reservation.admission.completion.reject);
             reservation.admission.completion.promise.then((value) => {
@@ -1940,6 +2066,7 @@ function createAgentRuntime(config) {
           }
         } finally {
           acceptanceDone.resolve();
+          handedOff();
         }
       })();
       return publicTicket;
@@ -1969,9 +2096,8 @@ function createAgentRuntime(config) {
       return requested;
     },
     async recover(options) {
-      if (!config.store.scanRecoverablePage) {
-        throw new Error("The configured agent store does not support bounded recovery scans");
-      }
+      if (admissionClosed)
+        throw closedError();
       const pageSize = options.pageSize ?? 100;
       const maxRuns = options.maxRuns ?? 1000;
       if (!Number.isSafeInteger(pageSize) || pageSize < 1 || pageSize > 1000) {
@@ -1982,14 +2108,17 @@ function createAgentRuntime(config) {
       }
       const outcomes = [];
       let cursor;
-      while (outcomes.length < maxRuns && !options.signal?.aborted) {
-        const page = await config.store.scanRecoverablePage({
+      while (outcomes.length < maxRuns && !options.signal?.aborted && !admissionClosed) {
+        const page = await config.store.scanRecoverable({
           ...cursor && { cursor },
           limit: Math.min(pageSize, maxRuns - outcomes.length)
         });
         for (const item of page.items) {
           if (options.signal?.aborted)
             break;
+          if (admissionClosed)
+            break;
+          const handedOff = beginAdmission();
           try {
             if (item.run.state === "queued") {
               const snapshot = await config.store.loadSnapshot(item.conversationId);
@@ -2004,6 +2133,8 @@ function createAgentRuntime(config) {
               }
             }
             const decision = await options.decide?.(item) ?? (item.run.state === "queued" ? { action: "resume" } : { action: "skip" });
+            if (admissionClosed)
+              throw closedError();
             if (decision.action === "skip") {
               outcomes.push({
                 conversationId: item.conversationId,
@@ -2063,6 +2194,8 @@ function createAgentRuntime(config) {
               outcome: "failed",
               error
             });
+          } finally {
+            handedOff();
           }
         }
         cursor = page.nextCursor;
@@ -2072,7 +2205,23 @@ function createAgentRuntime(config) {
       return outcomes;
     },
     stop: (conversationKey, reason) => coordinator.stop(conversationKey, reason),
-    close: (options) => coordinator.close(options)
+    close: async (options = {}) => {
+      assertCloseBudgets(options);
+      admissionClosed = true;
+      const startedAt = performance.now();
+      const stranded = await drainAdmissions(options.forceTimeoutMs);
+      const spent = Math.max(0, Math.round(performance.now() - startedAt));
+      const remainingBudget = (value) => value === undefined ? undefined : Math.max(0, value - spent);
+      const grace = remainingBudget(options.gracePeriodMs);
+      const force = remainingBudget(options.forceTimeoutMs);
+      const result = await coordinator.close({
+        ...grace !== undefined && { gracePeriodMs: grace },
+        ...force !== undefined && { forceTimeoutMs: force }
+      });
+      if (stranded === 0)
+        return result;
+      return { settled: false, timedOut: true, remaining: result.remaining + stranded };
+    }
   };
 }
 // src/agent-runtime/store.ts
@@ -2202,14 +2351,31 @@ function emptyHead(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 snapshotOf(head, messages, records) {
   validateSnapshot(head, messages, records);
+  const positionOf = historyPositions(messages);
   return AgentSnapshotSchema.parse({
     schemaVersion: 1,
     conversationId: head.conversationId,
     version: head.version,
     messages,
-    runs: records.map((record) => record.run).sort((left, right) => left.createdAt.localeCompare(right.createdAt) || left.id.localeCompare(right.id))
+    runs: records.map((record) => record.run).sort((left, right) => left.createdAt.localeCompare(right.createdAt) || positionOf(left) - positionOf(right) || left.id.localeCompare(right.id))
   });
 }
 function validateSnapshot(head, messages, records) {
@@ -2271,14 +2437,6 @@ function terminalState(reason) {
     return "abandoned";
   return "failed";
 }
-function terminalMessageStatus2(reason) {
-  if (reason === "success" || reason === "policy_stop")
-    return "completed";
-  if (reason === "interrupted" || reason === "cancelled" || reason === "shutdown") {
-    return "interrupted";
-  }
-  return "failed";
-}
 function applied(current, input, effects) {
   return {
     outcome: "applied",
@@ -2439,7 +2597,7 @@ function reduceStore(current, operation) {
   }
   if (operation.type === "terminal" && run) {
     const input = operation.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 !== terminalMessageStatus2(input.reason)) {
+    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);
     }
     const next = AgentRunSchema.parse({
@@ -2645,26 +2803,7 @@ function createAgentRuntimeStore(driver) {
       type: "compact",
       input: ReplaceCompactedRangeSchema.parse(input)
     }),
-    async scanRecoverable() {
-      const snapshots = [];
-      const seenConversationIds = new Set;
-      let cursor;
-      do {
-        const page = AgentRecoverablePageSchema.parse(await driver.scanRecoverable({
-          ...cursor && { cursor },
-          limit: 100
-        }));
-        const conversationIds = [
-          ...new Set(page.items.map((item) => item.conversationId))
-        ].filter((conversationId) => !seenConversationIds.has(conversationId));
-        for (const conversationId of conversationIds)
-          seenConversationIds.add(conversationId);
-        snapshots.push(...await Promise.all(conversationIds.map(loadSnapshot)));
-        cursor = page.nextCursor;
-      } while (cursor !== undefined);
-      return snapshots;
-    },
-    async scanRecoverablePage(input) {
+    async scanRecoverable(input) {
       const parsed = AgentRecoverableScanInputSchema.parse(input);
       return AgentRecoverablePageSchema.parse(await driver.scanRecoverable(parsed));
     }
@@ -2863,6 +3002,7 @@ export {
   AgentRunSchema,
   AgentRunStateEventSchema,
   AgentRunStateSchema,
+  AgentRuntimeConflictError,
   AgentRuntimeEventCursorSchema,
   AgentRuntimeEventSchema,
   AgentRuntimeHeadSchema,