stitchkit 0.57.0 → 0.58.0

package/dist/agent-runtime.js

@@ -29,7 +29,7 @@ import {
   AgentToolResultPartSchema,
   AgentUsageSchema,
   AgentUsageValueSchema
-} from "./index-1f4fcj0b.js";
+} from "./index-vtjgx3vv.js";
 import"./index-6djpbnda.js";
 import"./index-cby4ar3v.js";
 import {
@@ -86,54 +86,66 @@ function eligibleForCompaction(messages, keepRecentTurns) {
   const eligibleCount = Math.max(0, completeTurns.length - keepRecentTurns);
   return completeTurns.slice(0, eligibleCount).flatMap((turn) => turn.messages);
 }
-function mutationSnapshot(result, fallback) {
+function mutationSnapshot(result, fallback, attempts) {
   if (result.outcome === "applied" || result.outcome === "duplicate") {
-    return { outcome: "applied", snapshot: result.snapshot };
+    return { outcome: "applied", snapshot: result.snapshot, attempts };
   }
-  return { outcome: result.outcome, snapshot: fallback };
+  return { outcome: result.outcome, snapshot: fallback, attempts };
 }
 function structuredCompaction(config) {
   if (!Number.isSafeInteger(config.keepRecentTurns) || config.keepRecentTurns < 1) {
     throw new TypeError("keepRecentTurns must be a positive safe integer");
   }
+  const maxAttempts = config.maxAttempts ?? 1;
+  if (!Number.isSafeInteger(maxAttempts) || maxAttempts < 1) {
+    throw new TypeError("maxAttempts must be a positive safe integer");
+  }
   return async (input) => {
-    const snapshot = await input.store.loadSnapshot(input.conversationId);
-    if (!await config.threshold(snapshot))
-      return { outcome: "not_needed", snapshot };
-    const eligibleMessages = eligibleForCompaction(snapshot.messages, config.keepRecentTurns);
-    if (eligibleMessages.length === 0)
-      return { outcome: "nothing_eligible", snapshot };
-    const leadingSummary = snapshot.messages[0]?.role === "summary" ? snapshot.messages[0] : undefined;
-    const previousSummary = input.previousSummary ?? (leadingSummary && config.readPreviousSummary ? config.schema.parse(config.readPreviousSummary(leadingSummary)) : undefined);
-    const rawSummary = await config.summarize({
-      conversationId: input.conversationId,
-      snapshot,
-      eligibleMessages,
-      ...previousSummary !== undefined && { previousSummary },
-      signal: input.signal
-    });
-    const summary = config.schema.parse(rawSummary);
-    if (input.signal.aborted)
-      throw input.signal.reason;
-    const summaryMessage = config.createSummaryMessage({
-      conversationId: input.conversationId,
-      summary,
-      compactedMessages: eligibleMessages
-    });
-    if (summaryMessage.role !== "summary" || summaryMessage.status !== "committed") {
-      throw new TypeError("Compaction summary must be one committed summary message");
+    let lastSnapshot = await input.store.loadSnapshot(input.conversationId);
+    for (let attempt = 1;attempt <= maxAttempts; attempt += 1) {
+      const snapshot = attempt === 1 ? lastSnapshot : await input.store.loadSnapshot(input.conversationId);
+      lastSnapshot = snapshot;
+      if (!await config.threshold(snapshot)) {
+        return { outcome: "not_needed", snapshot, attempts: attempt };
+      }
+      const eligibleMessages = eligibleForCompaction(snapshot.messages, config.keepRecentTurns);
+      if (eligibleMessages.length === 0) {
+        return { outcome: "nothing_eligible", snapshot, attempts: attempt };
+      }
+      const leadingSummary = snapshot.messages[0]?.role === "summary" ? snapshot.messages[0] : undefined;
+      const previousSummary = leadingSummary && config.readPreviousSummary ? config.schema.parse(config.readPreviousSummary(leadingSummary)) : attempt === 1 ? input.previousSummary : undefined;
+      const rawSummary = await config.summarize({
+        conversationId: input.conversationId,
+        snapshot,
+        eligibleMessages,
+        ...previousSummary !== undefined && { previousSummary },
+        signal: input.signal
+      });
+      const summary = config.schema.parse(rawSummary);
+      if (input.signal.aborted)
+        throw input.signal.reason;
+      const summaryMessage = config.createSummaryMessage({
+        conversationId: input.conversationId,
+        summary,
+        compactedMessages: eligibleMessages
+      });
+      if (summaryMessage.role !== "summary" || summaryMessage.status !== "committed") {
+        throw new TypeError("Compaction summary must be one committed summary message");
+      }
+      const applied = await input.store.replaceCompactedRange({
+        conversationId: input.conversationId,
+        expectedVersion: snapshot.version,
+        replacedMessageIds: [
+          ...leadingSummary ? [leadingSummary.id] : [],
+          ...eligibleMessages.map((message) => message.id)
+        ],
+        summary: summaryMessage
+      });
+      if (applied.outcome !== "conflict" || attempt === maxAttempts) {
+        return mutationSnapshot(applied, snapshot, attempt);
+      }
     }
-    const previousSummaryMessage = previousSummary !== undefined && leadingSummary ? leadingSummary : undefined;
-    const applied = await input.store.replaceCompactedRange({
-      conversationId: input.conversationId,
-      expectedVersion: snapshot.version,
-      replacedMessageIds: [
-        ...previousSummaryMessage ? [previousSummaryMessage.id] : [],
-        ...eligibleMessages.map((message) => message.id)
-      ],
-      summary: summaryMessage
-    });
-    return mutationSnapshot(applied, snapshot);
+    return { outcome: "conflict", snapshot: lastSnapshot, attempts: maxAttempts };
   };
 }
 // src/agent-runtime/coordinator.ts
@@ -335,6 +347,63 @@ var AgentRuntimeEventSchema = z.discriminatedUnion("type", [
   AgentToolStatusEventSchema,
   AgentTerminalEventSchema
 ]);
+var AgentRuntimeEventCursorSchema = z.object({
+  snapshotVersion: AgentRecordVersionSchema.optional(),
+  durableEventIds: z.array(AgentRecordIdSchema).optional(),
+  runtimeEpoch: z.string().min(1).optional(),
+  sequence: z.int().nonnegative().optional()
+});
+function isDurableEvent(event) {
+  return event.type === "admission" || event.type === "assistant-checkpoint" || event.type === "run-state" || event.type === "terminal";
+}
+function advanceAgentRuntimeEventCursor(rawCursor, event) {
+  const cursor = AgentRuntimeEventCursorSchema.parse(rawCursor);
+  if (isDurableEvent(event)) {
+    const previous = cursor.snapshotVersion;
+    const durableEventIds = previous === event.snapshotVersion ? cursor.durableEventIds ?? [] : [];
+    if (previous !== undefined && event.snapshotVersion < previous || durableEventIds.includes(event.eventId)) {
+      return { status: "duplicate", cursor };
+    }
+    return {
+      status: previous !== undefined && event.snapshotVersion > previous + 1 ? "gap" : "accepted",
+      cursor: {
+        ...cursor,
+        snapshotVersion: event.snapshotVersion,
+        durableEventIds: [...durableEventIds, event.eventId]
+      }
+    };
+  }
+  const previousSequence = cursor.runtimeEpoch === event.runtimeEpoch ? cursor.sequence : undefined;
+  if (previousSequence !== undefined && event.sequence <= previousSequence) {
+    return { status: "duplicate", cursor };
+  }
+  return {
+    status: previousSequence !== undefined && event.sequence > previousSequence + 1 ? "gap" : "accepted",
+    cursor: { ...cursor, runtimeEpoch: event.runtimeEpoch, sequence: event.sequence }
+  };
+}
+function createAgentRuntimeEventSink(config) {
+  const manager = createBoundedSinkManager({
+    write: config.write,
+    ...config.maxPending !== undefined && { maxPending: config.maxPending },
+    ...config.onSinkError && { onSinkError: config.onSinkError },
+    ...config.onDrop && { onDrop: config.onDrop }
+  });
+  return {
+    publish(rawEvent) {
+      const event = AgentRuntimeEventSchema.parse(rawEvent);
+      const projected = config.project?.(event) ?? (config.project ? undefined : event);
+      if (projected)
+        manager.submit(() => AgentRuntimeEventSchema.parse(projected));
+    },
+    flush: () => manager.flush(),
+    getStatus: () => manager.getStatus(),
+    close: () => manager.close()
+  };
+}
+function agentDurableEventId(type, runId, snapshotVersion) {
+  return `${runId}:${type}:${snapshotVersion}`;
+}
 // src/agent-runtime/history.ts
 import { modelMessageSchema } from "ai";
 function providerOptions(envelope) {
@@ -416,26 +485,75 @@ function assistantMessages(message) {
   }
   return messages;
 }
-async function projectAgentHistory(messages, options = {}) {
+function completeToolChronology(message) {
+  const calls = new Set(message.parts.filter((part) => part.type === "tool-call").map((part) => part.callId));
+  const results = new Set(message.parts.filter((part) => part.type === "tool-result").map((part) => part.callId));
+  return [...calls].every((callId) => results.has(callId)) && [...results].every((callId) => calls.has(callId));
+}
+async function projectAgentHistoryDetailed(messages, options = {}) {
   const projected = [];
+  const decisions = [];
+  let observedUser = false;
   for (const message of messages) {
-    if (message.status === "streaming" || message.status === "failed")
+    if (message.status === "streaming" || message.status === "failed") {
+      decisions.push({ messageId: message.id, action: "omitted", reason: "draft-or-failed" });
       continue;
+    }
     if (message.role === "user") {
       const user = await userMessage(message, options);
-      if (user)
+      observedUser = true;
+      if (user) {
         projected.push(user);
+        decisions.push({ messageId: message.id, action: "projected", reason: "projected" });
+      } else {
+        decisions.push({ messageId: message.id, action: "omitted", reason: "empty" });
+      }
       continue;
     }
     if (message.role === "system" || message.role === "summary") {
       const content = textContent(message.parts);
-      if (content)
+      if (content) {
         projected.push(modelMessageSchema.parse({ role: "system", content }));
+        decisions.push({ messageId: message.id, action: "projected", reason: "projected" });
+      } else {
+        decisions.push({ messageId: message.id, action: "omitted", reason: "empty" });
+      }
+      continue;
+    }
+    if (!observedUser && options.leadingAssistant !== "allow") {
+      if (options.leadingAssistant === "error") {
+        throw new Error(`Assistant message ${message.id} precedes the first user message`);
+      }
+      decisions.push({
+        messageId: message.id,
+        action: "omitted",
+        reason: "leading-assistant"
+      });
+      continue;
+    }
+    if (!completeToolChronology(message)) {
+      if (options.incompleteToolTurn === "error") {
+        throw new Error(`Assistant message ${message.id} has incomplete tool chronology`);
+      }
+      decisions.push({
+        messageId: message.id,
+        action: "omitted",
+        reason: "incomplete-tool-turn"
+      });
       continue;
     }
-    projected.push(...assistantMessages(message));
+    const assistant = assistantMessages(message);
+    projected.push(...assistant);
+    decisions.push({
+      messageId: message.id,
+      action: assistant.length > 0 ? "projected" : "omitted",
+      reason: assistant.length > 0 ? "projected" : "empty"
+    });
   }
-  return projected;
+  return { messages: projected, decisions };
+}
+async function projectAgentHistory(messages, options = {}) {
+  return [...(await projectAgentHistoryDetailed(messages, options)).messages];
 }
 // src/agent-runtime/managed-tools.ts
 async function assertFence(config, input) {
@@ -469,7 +587,14 @@ var AgentModelDescriptorSchema = z2.object({
   contextWindow: z2.int().positive(),
   capabilities: z2.array(AgentModelCapabilitySchema),
   observedAt: z2.iso.datetime({ offset: true }).optional(),
-  source: z2.string().min(1).optional()
+  source: z2.string().min(1).optional(),
+  availability: z2.enum(["available", "unavailable"]).optional()
+});
+var AgentModelRegistrySnapshotSchema = z2.object({
+  schemaVersion: z2.literal(1),
+  source: z2.string().min(1),
+  observedAt: z2.iso.datetime({ offset: true }),
+  models: z2.record(z2.string().min(1), AgentModelDescriptorSchema)
 });
 function defineModelRegistry(config) {
   const descriptors = new Map;
@@ -488,15 +613,26 @@ function defineModelRegistry(config) {
     const available = new Set(descriptor(key).capabilities);
     return capabilities.every((capability) => available.has(capability));
   };
+  const preflight = (key, required = []) => {
+    const selected = descriptor(key);
+    if (selected.availability === "unavailable") {
+      throw new Error(`Agent model ${key} is unavailable`);
+    }
+    if (!supports(key, required)) {
+      throw new Error(`Agent model ${key} does not satisfy required capabilities`);
+    }
+    if (!config.providers[selected.provider]) {
+      throw new Error(`Unknown agent model provider: ${selected.provider}`);
+    }
+    return selected;
+  };
   return {
     keys: () => [...descriptors.keys()],
     descriptor,
     supports,
+    preflight,
     resolve(key, required = []) {
-      const selected = descriptor(key);
-      if (!supports(key, required)) {
-        throw new Error(`Agent model ${key} does not satisfy required capabilities`);
-      }
+      const selected = preflight(key, required);
       const provider = config.providers[selected.provider];
       if (!provider)
         throw new Error(`Unknown agent model provider: ${selected.provider}`);
@@ -505,9 +641,29 @@ function defineModelRegistry(config) {
         model: provider.create(selected.modelId),
         ...provider.normalizeUsage && { normalizeUsage: provider.normalizeUsage }
       };
+    },
+    snapshot(input) {
+      return AgentModelRegistrySnapshotSchema.parse({
+        schemaVersion: 1,
+        source: input.source,
+        observedAt: input.observedAt,
+        models: Object.fromEntries(descriptors.entries())
+      });
     }
   };
 }
+function validateAgentModelSnapshot(input, policy) {
+  if (!Number.isSafeInteger(policy.maxAgeMs) || policy.maxAgeMs < 0) {
+    throw new TypeError("maxAgeMs must be a non-negative safe integer");
+  }
+  const snapshot = AgentModelRegistrySnapshotSchema.parse(input);
+  const now = policy.now?.() ?? new Date;
+  const age = now.getTime() - new Date(snapshot.observedAt).getTime();
+  if (age < 0 || age > policy.maxAgeMs) {
+    throw new Error(`Agent model snapshot from ${snapshot.source} is stale`);
+  }
+  return snapshot;
+}
 // src/agent-runtime/observability.ts
 import { z as z3 } from "zod";
 var AgentRunEventSchema = z3.object({
@@ -538,13 +694,18 @@ function createAgentObservability(config) {
     ...config.onSinkError && { onSinkError: config.onSinkError },
     ...config.onDrop && { onDrop: config.onDrop }
   });
+  const emitted = new Set;
   return {
     rootTrace(parent) {
       const trace = parent ? childSpan(parent) : createTraceContext();
       return trace;
     },
     emit(rawEvent) {
-      manager.submit(() => AgentRunEventSchema.parse(rawEvent));
+      const parsed = AgentRunEventSchema.parse(rawEvent);
+      if ((config.deduplicate ?? true) && emitted.has(parsed.eventId))
+        return;
+      emitted.add(parsed.eventId);
+      manager.submit(() => config.includeInternalCause ? parsed : AgentRunEventSchema.omit({ internalCause: true }).parse(parsed));
     },
     flush: () => manager.flush(),
     getStatus: () => manager.getStatus(),
@@ -557,6 +718,110 @@ var AgentTokenCountSchema = z4.object({
   value: z4.int().nonnegative().optional(),
   provenance: z4.enum(["measured", "estimated", "unavailable"])
 });
+function completeTurn(messages) {
+  if (messages[0]?.role !== "user")
+    return false;
+  const assistant = messages.find((message) => message.role === "assistant");
+  if (assistant?.status !== "completed")
+    return false;
+  const calls = new Set(assistant.parts.filter((part) => part.type === "tool-call").map((part) => part.callId));
+  const results = new Set(assistant.parts.filter((part) => part.type === "tool-result").map((part) => part.callId));
+  return [...calls].every((callId) => results.has(callId)) && [...results].every((callId) => calls.has(callId));
+}
+function budgetTurns(messages) {
+  const turns = [];
+  let current = [];
+  const flush = () => {
+    if (current.length === 0)
+      return;
+    turns.push({ messages: current, complete: completeTurn(current), protectedSystem: false });
+    current = [];
+  };
+  for (const message of messages) {
+    if (message.role === "system" || message.role === "summary") {
+      flush();
+      turns.push({ messages: [message], complete: true, protectedSystem: true });
+      continue;
+    }
+    if (message.role === "user")
+      flush();
+    current.push(message);
+  }
+  flush();
+  return turns;
+}
+async function selectAgentHistory(options) {
+  if (!Number.isSafeInteger(options.availableTokens) || options.availableTokens < 0) {
+    throw new TypeError("availableTokens must be a non-negative safe integer");
+  }
+  const keepRecentTurns = options.keepRecentTurns ?? 1;
+  if (!Number.isSafeInteger(keepRecentTurns) || keepRecentTurns < 0) {
+    throw new TypeError("keepRecentTurns must be a non-negative safe integer");
+  }
+  const counts = new Map;
+  let total = 0;
+  let estimated = false;
+  for (const message of options.messages) {
+    const count = AgentTokenCountSchema.parse(await options.estimateMessage(message));
+    counts.set(message.id, count);
+    const value = knownValue(count);
+    if (value === undefined) {
+      return {
+        messages: [...options.messages],
+        decisions: options.messages.map((candidate) => ({
+          messageId: candidate.id,
+          action: "kept",
+          reason: "token-count-unavailable",
+          tokens: counts.get(candidate.id) ?? { provenance: "unavailable" }
+        })),
+        totalTokens: { provenance: "unavailable" },
+        outcome: "unavailable"
+      };
+    }
+    total += value;
+    if (count.provenance === "estimated")
+      estimated = true;
+  }
+  const turns = budgetTurns(options.messages);
+  const completeIndexes = turns.map((turn, index) => ({ turn, index })).filter(({ turn }) => turn.complete && !turn.protectedSystem).map(({ index }) => index);
+  const protectedRecent = new Set(completeIndexes.slice(-keepRecentTurns));
+  const removed = new Set;
+  for (let index = 0;index < turns.length && total > options.availableTokens; index += 1) {
+    const turn = turns[index];
+    if (!turn || turn.protectedSystem || !turn.complete || protectedRecent.has(index))
+      continue;
+    for (const message of turn.messages) {
+      removed.add(message.id);
+      total -= knownValue(counts.get(message.id) ?? { provenance: "unavailable" }) ?? 0;
+    }
+  }
+  const messages = options.messages.filter((message) => !removed.has(message.id));
+  const decisions = options.messages.map((message) => {
+    const turnIndex = turns.findIndex((turn2) => turn2.messages.some((item) => item.id === message.id));
+    const turn = turns[turnIndex];
+    let reason = "within-budget";
+    if (removed.has(message.id))
+      reason = "oldest-eligible-turn";
+    else if (turn?.protectedSystem)
+      reason = "protected-system";
+    else if (turn && !turn.complete)
+      reason = "protected-incomplete-turn";
+    else if (protectedRecent.has(turnIndex))
+      reason = "protected-recent-turn";
+    return {
+      messageId: message.id,
+      action: removed.has(message.id) ? "removed" : "kept",
+      reason,
+      tokens: counts.get(message.id) ?? { provenance: "unavailable" }
+    };
+  });
+  return {
+    messages,
+    decisions,
+    totalTokens: { value: total, provenance: estimated ? "estimated" : "measured" },
+    outcome: total > options.availableTokens ? "oversized" : removed.size > 0 ? "truncated" : "fits"
+  };
+}
 function knownValue(value) {
   return value.provenance === "unavailable" ? undefined : value.value;
 }
@@ -795,7 +1060,11 @@ function createAgentRuntime(config) {
   const publish = async (event) => {
     try {
       await config.publish?.(event);
-    } catch {}
+    } catch (error) {
+      try {
+        await config.onPublishError?.({ event, error });
+      } catch {}
+    }
   };
   const executeRun = async (input) => {
     const queuedSnapshot = await config.store.loadSnapshot(input.acceptedRun.conversationId);
@@ -809,7 +1078,7 @@ function createAgentRuntime(config) {
     let run = findRun(acquired.runs, input.acceptedRun.id);
     await publish({
       type: "run-state",
-      eventId: generateId(),
+      eventId: agentDurableEventId("run-state", run.id, acquired.version),
       conversationId: run.conversationId,
       runId: run.id,
       snapshotVersion: acquired.version,
@@ -847,6 +1116,7 @@ function createAgentRuntime(config) {
       runId: run.id,
       expectedRevision: run.revision,
       ownerId: runtimeEpoch,
+      ...run.fencingToken !== undefined && { fencingToken: run.fencingToken },
       assistant
     }), "assistant draft");
     run = findRun(snapshot.runs, run.id);
@@ -895,6 +1165,7 @@ function createAgentRuntime(config) {
         runId: run.id,
         expectedRevision: run.revision,
         ownerId: runtimeEpoch,
+        ...run.fencingToken !== undefined && { fencingToken: run.fencingToken },
         assistant
       }), "assistant checkpoint");
       run = findRun(snapshot.runs, run.id);
@@ -906,7 +1177,7 @@ function createAgentRuntime(config) {
       };
       await publish({
         type: "assistant-checkpoint",
-        eventId: generateId(),
+        eventId: agentDurableEventId("assistant-checkpoint", run.id, snapshot.version),
         conversationId: run.conversationId,
         runId: run.id,
         snapshotVersion: snapshot.version,
@@ -932,6 +1203,8 @@ function createAgentRuntime(config) {
         const currentRun = current.runs.find((candidate) => candidate.id === run.id);
         if (!currentRun || currentRun.ownerId !== runtimeEpoch)
           return "stale_run";
+        if (currentRun.fencingToken !== run.fencingToken)
+          return "stale_run";
         if (currentRun.state === "interrupt_requested")
           return "run_interrupted";
         if (currentRun.state !== "running")
@@ -940,7 +1213,10 @@ function createAgentRuntime(config) {
       };
       const toolFenceLifecycle = createAgentToolFenceLifecycle({
         runId: run.id,
-        assertCurrent
+        assertCurrent,
+        context: () => ({
+          ...run.fencingToken !== undefined && { fencingToken: run.fencingToken }
+        })
       });
       const runtimeContext = {
         context: input.context,
@@ -1276,6 +1552,7 @@ function createAgentRuntime(config) {
       runId: run.id,
       expectedRevision: run.revision,
       ownerId: runtimeEpoch,
+      ...run.fencingToken !== undefined && { fencingToken: run.fencingToken },
       assistant,
       reason: terminalReason,
       ...terminalPolicyName && { policyName: terminalPolicyName }
@@ -1289,7 +1566,7 @@ function createAgentRuntime(config) {
     };
     config.observe?.emit({
       schemaVersion: 1,
-      eventId: generateId(),
+      eventId: agentDurableEventId("terminal", run.id, snapshot.version),
       type: "run-terminal",
       conversationId: run.conversationId,
       runId: run.id,
@@ -1307,7 +1584,7 @@ function createAgentRuntime(config) {
     });
     await publish({
       type: "terminal",
-      eventId: generateId(),
+      eventId: agentDurableEventId("terminal", run.id, snapshot.version),
       conversationId: run.conversationId,
       runId: run.id,
       snapshotVersion: snapshot.version,
@@ -1433,6 +1710,10 @@ function createAgentRuntime(config) {
           await previousAcceptance.catch(() => {
             return;
           });
+          await config.models.preflight?.({
+            context,
+            conversationId: input.conversationId
+          });
           const acceptance = await config.store.acceptInputAndAssignRun({
             idempotencyKey: input.idempotencyKey,
             input: userMessage2,
@@ -1471,7 +1752,7 @@ function createAgentRuntime(config) {
           outerAdmission.resolve(admission);
           await publish({
             type: "admission",
-            eventId: generateId(),
+            eventId: agentDurableEventId("admission", acceptedRun.id, acceptedSnapshot.version),
             conversationId: acceptedRun.conversationId,
             runId: acceptedRun.id,
             snapshotVersion: acceptedSnapshot.version,
@@ -1482,7 +1763,7 @@ function createAgentRuntime(config) {
           });
           await publish({
             type: "run-state",
-            eventId: generateId(),
+            eventId: agentDurableEventId("run-state", acceptedRun.id, acceptedSnapshot.version),
             conversationId: acceptedRun.conversationId,
             runId: acceptedRun.id,
             snapshotVersion: acceptedSnapshot.version,
@@ -1580,7 +1861,7 @@ function createAgentRuntime(config) {
         const interruptedRun = findRun(requested.snapshot.runs, input.runId);
         await publish({
           type: "run-state",
-          eventId: generateId(),
+          eventId: agentDurableEventId("run-state", interruptedRun.id, requested.snapshot.version),
           conversationId: interruptedRun.conversationId,
           runId: interruptedRun.id,
           snapshotVersion: requested.snapshot.version,
@@ -1741,6 +2022,7 @@ var CheckpointRunAssistantSchema = z6.object({
   runId: AgentRecordIdSchema,
   expectedRevision: AgentRecordVersionSchema,
   ownerId: z6.string().min(1),
+  fencingToken: AgentRecordVersionSchema.optional(),
   assistant: AgentMessageSchema
 });
 var CommitRunTerminalSchema = z6.object({
@@ -1748,6 +2030,7 @@ var CommitRunTerminalSchema = z6.object({
   runId: AgentRecordIdSchema,
   expectedRevision: AgentRecordVersionSchema,
   ownerId: z6.string().min(1),
+  fencingToken: AgentRecordVersionSchema.optional(),
   assistant: AgentMessageSchema,
   reason: AgentTerminalReasonSchema,
   policyName: z6.string().min(1).optional()
@@ -1975,6 +2258,7 @@ function reduceStore(current, currentAdmissions, operation, duplicateInput) {
       ...run,
       state: "running",
       ownerId: operation.input.ownerId,
+      fencingToken: (run.fencingToken ?? 0) + 1,
       revision: run.revision + 1,
       updatedAt: new Date().toISOString()
     });
@@ -1984,7 +2268,7 @@ function reduceStore(current, currentAdmissions, operation, duplicateInput) {
   }
   if (operation.type === "checkpoint" && run) {
     const input = operation.input;
-    if (run.revision !== input.expectedRevision || run.state !== "running" || run.ownerId !== input.ownerId || input.assistant.runId !== run.id || input.assistant.id !== run.assistantMessageId || input.assistant.conversationId !== run.conversationId || input.assistant.role !== "assistant" || input.assistant.status !== "streaming") {
+    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({
@@ -2057,7 +2341,7 @@ function reduceStore(current, currentAdmissions, operation, duplicateInput) {
   }
   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.assistant.runId !== run.id || input.assistant.id !== run.assistantMessageId || input.assistant.conversationId !== run.conversationId || input.assistant.role !== "assistant" || input.assistant.status !== terminalMessageStatus(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 !== terminalMessageStatus(input.reason)) {
       return conflict(run.revision);
     }
     const next = AgentRunSchema.parse({
@@ -2331,6 +2615,7 @@ export {
   AgentMessageStatusSchema,
   AgentModelCapabilitySchema,
   AgentModelDescriptorSchema,
+  AgentModelRegistrySnapshotSchema,
   AgentOpaquePartSchema,
   AgentProviderEnvelopeSchema,
   AgentReasoningDeltaEventSchema,
@@ -2346,6 +2631,7 @@ export {
   AgentRunSchema,
   AgentRunStateEventSchema,
   AgentRunStateSchema,
+  AgentRuntimeEventCursorSchema,
   AgentRuntimeEventSchema,
   AgentSnapshotSchema,
   AgentSourcePartSchema,
@@ -2371,9 +2657,12 @@ export {
   RecoverAgentRunSchema,
   ReplaceCompactedRangeSchema,
   RequestRunInterruptSchema,
+  advanceAgentRuntimeEventCursor,
+  agentDurableEventId,
   composeAgentPrompt,
   createAgentObservability,
   createAgentRuntime,
+  createAgentRuntimeEventSink,
   createAgentRuntimeStore,
   createAgentSessionCoordinator,
   createAgentToolFenceLifecycle,
@@ -2381,5 +2670,8 @@ export {
   defineAgentProtocol,
   defineModelRegistry,
   projectAgentHistory,
-  structuredCompaction
+  projectAgentHistoryDetailed,
+  selectAgentHistory,
+  structuredCompaction,
+  validateAgentModelSnapshot
 };

package/dist/{index-1f4fcj0b.js → index-vtjgx3vv.js}

@@ -121,6 +121,7 @@ var AgentRunSchema = z.object({
   state: AgentRunStateSchema,
   revision: AgentRecordVersionSchema,
   ownerId: z.string().min(1).optional(),
+  fencingToken: AgentRecordVersionSchema.optional(),
   terminalReason: AgentTerminalReasonSchema.optional(),
   terminalPolicyName: z.string().min(1).optional(),
   createdAt: AgentTimestampSchema,