stitchkit 0.68.11 → 0.70.0

package/dist/agent-runtime.js

@@ -1,8 +1,58 @@
+import {
+  AgentAdmissionEventSchema,
+  AgentCheckpointEventSchema,
+  AgentContextOverflowError,
+  AgentReasoningDeltaEventSchema,
+  AgentReasoningEndEventSchema,
+  AgentReasoningStartEventSchema,
+  AgentRunStateEventSchema,
+  AgentRuntimeConflictError,
+  AgentRuntimeEventCursorSchema,
+  AgentRuntimeEventSchema,
+  AgentTerminalEventSchema,
+  AgentTokenCountSchema,
+  AgentToolStatusEventSchema,
+  AgentTransientDeltaEventSchema,
+  advanceAgentRuntimeEventCursor,
+  agentDurableEventId,
+  composeAgentPrompt,
+  createAgentRuntime,
+  createAgentRuntimeEventSink,
+  createAgentSessionCoordinator,
+  createAgentToolFenceLifecycle,
+  deferredToolCatalog,
+  projectAgentHistory,
+  projectAgentHistoryDetailed,
+  registerDeferredToolCatalog,
+  registerDeferredToolRepair,
+  repairedSearchCall,
+  selectAgentHistory
+} from "./index-vy5bjy07.js";
+import {
+  AgentModelCapabilitySchema,
+  AgentModelCatalogEntrySchema,
+  AgentModelCatalogSchema,
+  AgentModelDescriptorSchema,
+  AgentModelMetricSchema,
+  AgentModelPopularitySchema,
+  AgentModelPriceSchema,
+  AgentModelRegistrySnapshotSchema,
+  AgentModelSearchInputSchema,
+  AgentModelSearchResultSchema,
+  AgentModelSelectionSchema,
+  createMemoryAgentModelSelectionStore,
+  defineModelRegistry,
+  searchAgentModelCatalog,
+  validateAgentModelSnapshot
+} from "./index-tg3m2ec5.js";
 import {
   ACTIVE_AGENT_RUN_STATES,
   AcceptInputAndAssignRunSchema,
   AcquireAgentRunSchema,
   AgentAdmissionReceiptSchema,
+  AgentConversationMessagePageSchema,
+  AgentConversationPageSchema,
+  AgentConversationSummarySchema,
   AgentHistoryMutationSchema,
   AgentRecoverableDescriptorSchema,
   AgentRecoverablePageSchema,
@@ -19,26 +69,28 @@ import {
   RecoverAgentRunSchema,
   ReplaceCompactedRangeSchema,
   RequestRunInterruptSchema,
-  assistantStatus,
   createAgentRuntimeStore,
-  createMemoryAgentRuntimeStore,
-  isSpeakableAssistantStatus
-} from "./index-hqza5nde.js";
+  createMemoryAgentRuntimeStore
+} from "./index-hsabxjz0.js";
+import {
+  isAssistantHistoryEvidence,
+  isCompleteAgentHistoryTurn
+} from "./index-es0h4w26.js";
 import {
   createBoundedSinkManager
 } from "./index-a59da114.js";
 import {
   buildToolManifest,
   mountAgent
-} from "./index-bt5179zb.js";
+} from "./index-s8nt8c22.js";
+import"./index-3xnq72rz.js";
+import"./index-vc498pst.js";
 import {
   defineRuntimeTool
-} from "./index-eqqyd9v8.js";
-import {
-  ToolExecutionControlError,
-  isToolExecutionControlError
-} from "./index-y2ctppmg.js";
-import"./index-f24xg2cw.js";
+} from "./index-wwst0td5.js";
+import"./index-7rey2b8s.js";
+import"./index-qzbg46b6.js";
+import"./index-ktsps64f.js";
 import {
   AgentAssistantPlaceholderSchema,
   AgentControlPartSchema,
@@ -64,43 +116,36 @@ import {
   AgentTerminalReasonSchema,
   AgentTextPartSchema,
   AgentTimestampSchema,
+  AgentToolApprovalRequestPartSchema,
+  AgentToolApprovalResponsePartSchema,
   AgentToolCallPartSchema,
   AgentToolResultPartSchema,
   AgentUsageSchema,
   AgentUsageValueSchema,
   runStateForTerminalReason
-} from "./index-ysphyxax.js";
+} from "./index-x1th9s8c.js";
 import"./index-22by16v6.js";
 import"./index-cby4ar3v.js";
 import {
   childSpan,
   createTraceContext
-} from "./index-pgsyp3xh.js";
+} from "./index-bd17ytae.js";
+import"./index-vj3vvpaa.js";
+import"./index-0w9abg87.js";
 import {
   executableAgentRuntimeTools
 } from "./index-qyrqwr4c.js";
-import"./index-0w9abg87.js";
 import"./index-6k1937bx.js";
 
 // src/agent-runtime/compaction.ts
-function providerValidTurn(messages) {
-  if (messages[0]?.role !== "user")
-    return false;
-  const assistant = messages.find((message) => message.role === "assistant");
-  if (!assistant || !isSpeakableAssistantStatus(assistant.status))
-    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 groupProviderTurns(messages) {
+function groupProviderTurns(messages, evidencePolicy) {
   const turns = [];
   let current = [];
   for (const message of messages) {
     if (message.role === "user" && current.length > 0) {
       turns.push({
         messages: current,
-        complete: providerValidTurn(current)
+        complete: isCompleteAgentHistoryTurn(current, evidencePolicy)
       });
       current = [];
     }
@@ -109,14 +154,14 @@ function groupProviderTurns(messages) {
   if (current.length > 0) {
     turns.push({
       messages: current,
-      complete: providerValidTurn(current)
+      complete: isCompleteAgentHistoryTurn(current, evidencePolicy)
     });
   }
   return turns;
 }
-function eligibleForCompaction(messages, keepRecentTurns) {
+function eligibleForCompaction(messages, keepRecentTurns, evidencePolicy) {
   const withoutLeadingSummary = messages[0]?.role === "summary" ? messages.slice(1) : messages;
-  const turns = groupProviderTurns(withoutLeadingSummary);
+  const turns = groupProviderTurns(withoutLeadingSummary, evidencePolicy);
   const firstIncomplete = turns.findIndex((turn) => !turn.complete);
   const completeTurns = firstIncomplete === -1 ? turns : turns.slice(0, firstIncomplete);
   const eligibleCount = Math.max(0, completeTurns.length - keepRecentTurns);
@@ -144,7 +189,7 @@ function structuredCompaction(config) {
       if (!await config.threshold(snapshot)) {
         return { outcome: "not_needed", snapshot, attempts: attempt };
       }
-      const eligibleMessages = eligibleForCompaction(snapshot.messages, config.keepRecentTurns);
+      const eligibleMessages = eligibleForCompaction(snapshot.messages, config.keepRecentTurns, config.evidencePolicy);
       if (eligibleMessages.length === 0) {
         return { outcome: "nothing_eligible", snapshot, attempts: attempt };
       }
@@ -184,155 +229,6 @@ function structuredCompaction(config) {
     return { outcome: "conflict", snapshot: lastSnapshot, attempts: maxAttempts };
   };
 }
-// src/agent-runtime/context-refusal.ts
-class AgentContextOverflowError extends Error {
-  name = "AgentContextOverflowError";
-  constructor(message = "Agent context exceeds the configured model budget", options) {
-    super(message, options);
-  }
-}
-// 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;
-  const waitWithin = async (settled, timeoutMs) => {
-    if (timeoutMs === 0)
-      return false;
-    let timer;
-    const timeout = new Promise((resolve) => {
-      timer = setTimeout(() => resolve(false), timeoutMs);
-    });
-    const completed = settled.then(() => true);
-    const result = await Promise.race([completed, timeout]);
-    if (timer !== undefined)
-      clearTimeout(timer);
-    return result;
-  };
-  const laneFor = (key) => {
-    const existing = lanes.get(key);
-    if (existing)
-      return existing;
-    const created = { queue: [] };
-    lanes.set(key, created);
-    return created;
-  };
-  const startNext = (key, lane) => {
-    if (lane.active)
-      return;
-    const next = lane.queue.shift();
-    if (!next) {
-      lanes.delete(key);
-      return;
-    }
-    next.start();
-  };
-  return {
-    submit(input) {
-      const accepted = Promise.withResolvers();
-      const result = Promise.withResolvers();
-      if (closed) {
-        const error = new Error("Agent session coordinator is closed");
-        accepted.reject(error);
-        result.reject(error);
-        return { accepted: accepted.promise, result: result.promise };
-      }
-      const lane = laneFor(input.key);
-      const pending = {
-        priority: input.policy === "interrupt-next",
-        reject(reason) {
-          accepted.reject(reason);
-          result.reject(reason);
-        },
-        async start() {
-          const controller = new AbortController;
-          const settlement = Promise.withResolvers();
-          lane.active = { controller, settled: settlement.promise };
-          try {
-            const coordinated = await input.create(controller.signal);
-            accepted.resolve();
-            result.resolve(await coordinated.execute());
-          } catch (error) {
-            accepted.reject(error);
-            result.reject(error);
-          } finally {
-            settlement.resolve();
-            lane.active = undefined;
-            startNext(input.key, lane);
-          }
-        }
-      };
-      if (input.policy === "interrupt" || input.policy === "interrupt-next") {
-        lane.active?.controller.abort("user-interrupt");
-      }
-      if (input.policy === "supersede")
-        lane.active?.controller.abort("supersede");
-      if (pending.priority) {
-        const firstOrdinary = lane.queue.findIndex((queued) => !queued.priority);
-        if (firstOrdinary === -1)
-          lane.queue.push(pending);
-        else
-          lane.queue.splice(firstOrdinary, 0, pending);
-      } else {
-        lane.queue.push(pending);
-      }
-      startNext(input.key, lane);
-      return { accepted: accepted.promise, result: result.promise };
-    },
-    stop(key, reason = "user-interrupt") {
-      const lane = lanes.get(key);
-      if (!lane?.active)
-        return false;
-      lane.active.controller.abort(reason);
-      return true;
-    },
-    async close(options = {}) {
-      assertCloseBudgets(options);
-      closed = true;
-      const error = new Error("Agent session coordinator is closed");
-      for (const lane of lanes.values()) {
-        for (const pending of lane.queue.splice(0))
-          pending.reject(error);
-      }
-      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;
-      });
-      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.forceTimeoutMs === undefined) {
-        await drain;
-        return finished();
-      }
-      await waitWithin(drain, options.forceTimeoutMs);
-      return finished();
-    },
-    isRunning(key) {
-      return lanes.get(key)?.active !== undefined;
-    }
-  };
-}
 // src/agent-runtime/deferred-tool-types.ts
 import { z } from "zod";
 var DeferredAgentToolSearchInputSchema = z.object({
@@ -547,32 +443,6 @@ function createDeferredSearchTool(config, runContext, surface) {
   });
 }
 
-// src/agent-runtime/deferred-tools-internal.ts
-var repairs = new WeakMap;
-var catalogs = new WeakMap;
-function registerDeferredToolRepair(prepareStep, repair) {
-  repairs.set(prepareStep, repair);
-}
-function deferredToolRepair(prepareStep) {
-  return prepareStep ? repairs.get(prepareStep) : undefined;
-}
-function registerDeferredToolCatalog(tools, searchName, names) {
-  const search = tools[searchName];
-  if (search && typeof search === "object")
-    catalogs.set(search, names);
-}
-function deferredToolCatalog(tools, searchName) {
-  const search = tools[searchName];
-  return search && typeof search === "object" ? catalogs.get(search) : undefined;
-}
-function repairedSearchCall(toolCall, searchName) {
-  return {
-    ...toolCall,
-    toolName: searchName,
-    input: JSON.stringify({ query: toolCall.toolName, reason: "inactive_call" })
-  };
-}
-
 // src/agent-runtime/deferred-tools.ts
 function configuredSurfaces(config) {
   return "surfaces" in config ? config.surfaces : { default: config };
@@ -717,523 +587,39 @@ function createDeferredAgentToolSurface(config) {
     }
   };
 }
-// src/agent-runtime/event-schema.ts
-import { z as z2 } from "zod";
-var AgentAdmissionEventSchema = z2.object({
-  type: z2.literal("admission"),
-  eventId: AgentRecordIdSchema,
-  conversationId: AgentRecordIdSchema,
-  runId: AgentRecordIdSchema,
-  snapshotVersion: AgentRecordVersionSchema,
-  input: AgentMessageSchema,
-  run: AgentRunSchema,
-  assistant: z2.union([AgentAssistantPlaceholderSchema, AgentMessageSchema]),
-  emittedAt: AgentTimestampSchema
-});
-var EventIdentitySchema = z2.object({
-  conversationId: AgentRecordIdSchema,
-  runId: AgentRecordIdSchema,
-  emittedAt: AgentTimestampSchema
-});
-var AgentTransientDeltaEventSchema = EventIdentitySchema.extend({
-  type: z2.literal("assistant-delta"),
-  runtimeEpoch: z2.string().min(1),
-  sequence: z2.int().nonnegative(),
-  textDelta: z2.string()
-});
-var AgentTransientReasoningIdentitySchema = EventIdentitySchema.extend({
-  runtimeEpoch: z2.string().min(1),
-  sequence: z2.int().nonnegative(),
-  provider: AgentProviderEnvelopeSchema.optional()
-});
-var AgentReasoningStartEventSchema = AgentTransientReasoningIdentitySchema.extend({
-  type: z2.literal("reasoning-start")
-});
-var AgentReasoningDeltaEventSchema = AgentTransientReasoningIdentitySchema.extend({
-  type: z2.literal("reasoning-delta"),
-  textDelta: z2.string()
-});
-var AgentReasoningEndEventSchema = AgentTransientReasoningIdentitySchema.extend({
-  type: z2.literal("reasoning-end")
-});
-var AgentCheckpointEventSchema = EventIdentitySchema.extend({
-  type: z2.literal("assistant-checkpoint"),
-  eventId: AgentRecordIdSchema,
-  snapshotVersion: AgentRecordVersionSchema,
-  message: AgentMessageSchema,
-  metrics: AgentRunMetricsSchema.optional()
-});
-var AgentRunStateEventSchema = EventIdentitySchema.extend({
-  type: z2.literal("run-state"),
-  eventId: AgentRecordIdSchema,
-  snapshotVersion: AgentRecordVersionSchema,
-  state: AgentRunStateSchema
-});
-var AgentToolStatusEventSchema = EventIdentitySchema.extend({
-  type: z2.literal("tool-status"),
-  runtimeEpoch: z2.string().min(1),
-  sequence: z2.int().nonnegative(),
-  callId: AgentRecordIdSchema,
-  toolName: z2.string().min(1),
-  status: z2.enum(["started", "completed", "failed", "interrupted"]),
-  input: z2.json().optional(),
-  output: z2.json().optional()
-});
-var AgentTerminalEventSchema = EventIdentitySchema.extend({
-  type: z2.literal("terminal"),
-  eventId: AgentRecordIdSchema,
-  snapshotVersion: AgentRecordVersionSchema,
-  reason: AgentTerminalReasonSchema,
-  policyName: z2.string().min(1).optional(),
-  message: AgentMessageSchema,
-  metrics: AgentRunMetricsSchema.optional()
-});
-var AgentRuntimeEventSchema = z2.discriminatedUnion("type", [
-  AgentAdmissionEventSchema,
-  AgentTransientDeltaEventSchema,
-  AgentReasoningStartEventSchema,
-  AgentReasoningDeltaEventSchema,
-  AgentReasoningEndEventSchema,
-  AgentCheckpointEventSchema,
-  AgentRunStateEventSchema,
-  AgentToolStatusEventSchema,
-  AgentTerminalEventSchema
-]);
-var AgentRuntimeEventCursorSchema = z2.object({
-  snapshotVersion: AgentRecordVersionSchema.optional(),
-  durableEventIds: z2.array(AgentRecordIdSchema).optional(),
-  runtimeEpoch: z2.string().min(1).optional(),
-  sequence: z2.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: "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 agentDurableEventId(type, runId, snapshotVersion) {
-  return `${runId}:${type}:${snapshotVersion}`;
-}
-
-// src/agent-runtime/events.ts
-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()
-  };
-}
-// src/agent-runtime/history.ts
-import { modelMessageSchema } from "ai";
-function providerOptions(envelope) {
-  if (!envelope)
-    return;
-  return envelope.provider === "ai-sdk" ? envelope.data : { [envelope.provider]: envelope.data };
-}
-function textContent(parts) {
-  return parts.filter((part) => part.type === "text").map((part) => part.text).join(`
-`);
-}
-function unrepresented(parts, rendered) {
-  const missing = new Set;
-  for (const part of parts) {
-    if (!rendered.has(part.type))
-      missing.add(part.type);
-  }
-  return [...missing];
-}
-function decide(message, action, reason, rendered) {
-  if (action === "omitted" || !rendered)
-    return { messageId: message.id, action, reason };
-  const omittedParts = unrepresented(message.parts, rendered);
-  return {
-    messageId: message.id,
-    action,
-    reason,
-    ...omittedParts.length > 0 && { omittedParts }
-  };
-}
-var INTERRUPTION_NOTE = "[interrupted: this turn was cut off before it finished]";
-async function userMessage(message, options) {
-  const rendered = new Set;
-  const text = textContent(message.parts);
-  const content = [];
-  if (text) {
-    content.push({ type: "text", text });
-    rendered.add("text");
-  }
-  for (const part of message.parts) {
-    if (part.type !== "file")
-      continue;
-    if (options.resolveFile) {
-      content.push({
-        type: "file",
-        data: await options.resolveFile(part, message),
-        mediaType: part.mediaType,
-        ...part.filename && { filename: part.filename }
-      });
-      rendered.add("file");
-      continue;
-    }
-    const fallback = options.unresolvedFile ?? "omit";
-    if (fallback === "error") {
-      throw new Error(`No history file resolver configured for ${part.reference}`);
-    }
-    if (fallback === "text") {
-      const described = part.filename ?? part.mediaType;
-      content.push({
-        type: "text",
-        text: described ? `[attachment: ${described}]` : "[attachment]"
-      });
-      rendered.add("file");
-    }
-  }
-  if (content.length === 0)
-    return { rendered };
-  return { message: modelMessageSchema.parse({ role: "user", content }), rendered };
-}
-function assistantMessages(message, interrupted) {
-  const rendered = new Set;
-  const messages = [];
-  let role;
-  let content = [];
-  const flush = () => {
-    if (!role || content.length === 0)
-      return;
-    messages.push(modelMessageSchema.parse({ role, content }));
-    content = [];
-  };
-  const append = (nextRole, part) => {
-    if (role !== nextRole) {
-      flush();
-      role = nextRole;
-    }
-    content.push(part);
-  };
-  for (const part of message.parts) {
-    if (part.type === "text") {
-      append("assistant", { type: "text", text: part.text });
-      rendered.add("text");
-    }
-    if (part.type === "reasoning") {
-      append("assistant", {
-        type: "reasoning",
-        text: part.text,
-        ...part.provider && { providerOptions: providerOptions(part.provider) }
-      });
-      rendered.add("reasoning");
-    }
-    if (part.type === "tool-call") {
-      append("assistant", {
-        type: "tool-call",
-        toolCallId: part.callId,
-        toolName: part.toolName,
-        input: part.input,
-        ...part.provider && { providerOptions: providerOptions(part.provider) }
-      });
-      rendered.add("tool-call");
-    }
-    if (part.type === "tool-result") {
-      const output = part.outcome === "success" ? { type: "json", value: part.output ?? null } : { type: "error-json", value: part.output ?? { message: part.outcome } };
-      append("tool", {
-        type: "tool-result",
-        toolCallId: part.callId,
-        toolName: part.toolName,
-        output
-      });
-      rendered.add("tool-result");
-    }
-  }
-  if (interrupted && (messages.length > 0 || content.length > 0)) {
-    append("assistant", { type: "text", text: INTERRUPTION_NOTE });
-    rendered.add("control");
-  }
-  flush();
-  return { messages, rendered };
-}
-function interruptedSystemNote(message) {
-  const rendered = new Set;
-  const text = textContent(message.parts);
-  if (!text)
-    return { rendered };
-  rendered.add("text");
-  rendered.add("control");
-  return { text: `[interrupted] partial response: ${text}`, rendered };
-}
-function completeToolChronology(message) {
-  const pending = new Set;
-  const completed = new Set;
-  let resultsStarted = false;
-  for (const part of message.parts) {
-    if (part.type === "tool-call") {
-      if (resultsStarted && pending.size > 0)
-        return false;
-      if (pending.size === 0)
-        resultsStarted = false;
-      if (pending.has(part.callId) || completed.has(part.callId))
-        return false;
-      pending.add(part.callId);
-    }
-    if (part.type === "tool-result") {
-      if (!pending.delete(part.callId))
-        return false;
-      completed.add(part.callId);
-      resultsStarted = true;
-    }
-  }
-  return pending.size === 0;
-}
-async function projectAgentHistoryDetailed(messages, options = {}) {
-  const projected = [];
-  const system = [];
-  const decisions = [];
-  const interruptedRule = options.interruptedAssistant ?? "assistant-marked";
-  let observedUser = false;
-  for (const message of messages) {
-    if (message.role === "assistant" && !isSpeakableAssistantStatus(message.status)) {
-      decisions.push(decide(message, "omitted", message.status === "superseded" ? "superseded" : "draft-or-failed"));
-      continue;
-    }
-    if (message.status === "streaming" || message.status === "failed") {
-      decisions.push(decide(message, "omitted", "draft-or-failed"));
-      continue;
-    }
-    if (message.role === "user") {
-      const user = await userMessage(message, options);
-      observedUser = true;
-      if (user.message) {
-        projected.push(user.message);
-        decisions.push(decide(message, "projected", "projected", user.rendered));
-      } else {
-        decisions.push(decide(message, "omitted", "empty"));
-      }
-      continue;
-    }
-    if (message.role === "system" || message.role === "summary") {
-      const content = textContent(message.parts);
-      if (content) {
-        system.push(content);
-        decisions.push(decide(message, "projected", "projected", new Set(["text"])));
-      } else {
-        decisions.push(decide(message, "omitted", "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(decide(message, "omitted", "leading-assistant"));
-      continue;
-    }
-    const interrupted = message.status === "interrupted";
-    if (interrupted && interruptedRule === "omit") {
-      decisions.push(decide(message, "omitted", "interrupted"));
-      continue;
-    }
-    if (interrupted && interruptedRule === "system-note") {
-      const note = interruptedSystemNote(message);
-      if (note.text) {
-        system.push(note.text);
-        decisions.push(decide(message, "projected", "projected", note.rendered));
-      } else {
-        decisions.push(decide(message, "omitted", "empty"));
-      }
-      continue;
-    }
-    if (!completeToolChronology(message)) {
-      if (options.incompleteToolTurn === "error") {
-        throw new Error(`Assistant message ${message.id} has incomplete tool chronology`);
-      }
-      decisions.push(decide(message, "omitted", "incomplete-tool-turn"));
-      continue;
-    }
-    const assistant = assistantMessages(message, interrupted);
-    projected.push(...assistant.messages);
-    decisions.push(assistant.messages.length > 0 ? decide(message, "projected", "projected", assistant.rendered) : decide(message, "omitted", "empty"));
-  }
-  return { messages: projected, decisions, system };
-}
-async function projectAgentHistory(messages, options = {}) {
-  return [...(await projectAgentHistoryDetailed(messages, options)).messages];
-}
-// src/agent-runtime/managed-tools.ts
-async function assertFence(config, input) {
-  const rejected = await config.assertCurrent(input);
-  if (rejected)
-    throw new ToolExecutionControlError(rejected);
-}
-function createAgentToolFenceLifecycle(config) {
-  const callContext = (ctx, endpoint) => ({
-    runId: config.runId,
-    ...config.context?.(ctx, endpoint)
-  });
-  return {
-    async beforeHandle(ctx, endpoint) {
-      await assertFence(config, callContext(ctx, endpoint));
-    },
-    async afterHandle(ctx, result, endpoint) {
-      const current = callContext(ctx, endpoint);
-      await assertFence(config, current);
-      await config.onSettled?.(current);
-      return result;
-    }
-  };
-}
-// src/agent-runtime/models.ts
-import { z as z3 } from "zod";
-var AgentModelCapabilitySchema = z3.enum(["tools", "vision", "reasoning", "files"]);
-var AgentModelDescriptorSchema = z3.object({
-  provider: z3.string().min(1),
-  modelId: z3.string().min(1),
-  contextWindow: z3.int().positive(),
-  capabilities: z3.array(AgentModelCapabilitySchema),
-  observedAt: z3.iso.datetime({ offset: true }).optional(),
-  source: z3.string().min(1).optional(),
-  availability: z3.enum(["available", "unavailable"]).optional()
-});
-var AgentModelRegistrySnapshotSchema = z3.object({
-  schemaVersion: z3.literal(1),
-  source: z3.string().min(1),
-  observedAt: z3.iso.datetime({ offset: true }),
-  models: z3.record(z3.string().min(1), AgentModelDescriptorSchema)
-});
-function defineModelRegistry(config) {
-  const descriptors = new Map;
-  for (const key in config.models) {
-    const declaration = config.models[key];
-    if (declaration)
-      descriptors.set(key, AgentModelDescriptorSchema.parse(declaration));
-  }
-  const descriptor = (key) => {
-    const found = descriptors.get(key);
-    if (!found)
-      throw new Error(`Unknown agent model: ${key}`);
-    return found;
-  };
-  const supports = (key, capabilities) => {
-    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 = preflight(key, required);
-      const provider = config.providers[selected.provider];
-      if (!provider)
-        throw new Error(`Unknown agent model provider: ${selected.provider}`);
-      return {
-        descriptor: selected,
-        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 z4 } from "zod";
-var AgentRunEventBaseSchema = z4.object({
-  schemaVersion: z4.literal(1),
+import { z as z2 } from "zod";
+var AgentRunEventBaseSchema = z2.object({
+  schemaVersion: z2.literal(1),
   eventId: AgentRecordIdSchema,
   conversationId: AgentRecordIdSchema,
   runId: AgentRecordIdSchema,
-  traceId: z4.string().min(1),
-  spanId: z4.string().min(1),
-  parentSpanId: z4.string().min(1).optional(),
+  traceId: z2.string().min(1),
+  spanId: z2.string().min(1),
+  parentSpanId: z2.string().min(1).optional(),
   state: AgentRunStateSchema,
-  modelId: z4.string().min(1).optional(),
-  durationMs: z4.number().nonnegative().optional(),
+  modelId: z2.string().min(1).optional(),
+  durationMs: z2.number().nonnegative().optional(),
   emittedAt: AgentTimestampSchema
 });
 var AgentRunStartedEventSchema = AgentRunEventBaseSchema.extend({
-  type: z4.literal("run-started"),
-  queueWaitMs: z4.number().nonnegative().optional()
+  type: z2.literal("run-started"),
+  queueWaitMs: z2.number().nonnegative().optional()
 });
 var AgentStepFinishedEventSchema = AgentRunEventBaseSchema.extend({
-  type: z4.literal("step-finished"),
-  step: z4.int().nonnegative(),
-  ttftMs: z4.number().nonnegative().optional(),
+  type: z2.literal("step-finished"),
+  step: z2.int().nonnegative(),
+  ttftMs: z2.number().nonnegative().optional(),
   usage: AgentUsageSchema
 });
 var AgentRunTerminalEventSchema = AgentRunEventBaseSchema.extend({
-  type: z4.literal("run-terminal"),
+  type: z2.literal("run-terminal"),
   terminalReason: AgentTerminalReasonSchema,
-  ttftMs: z4.number().nonnegative().optional(),
-  internalCause: z4.unknown().optional(),
+  ttftMs: z2.number().nonnegative().optional(),
+  internalCause: z2.unknown().optional(),
   usage: AgentUsageSchema
 });
-var AgentRunEventSchema = z4.discriminatedUnion("type", [
+var AgentRunEventSchema = z2.discriminatedUnion("type", [
   AgentRunStartedEventSchema,
   AgentStepFinishedEventSchema,
   AgentRunTerminalEventSchema
@@ -1281,196 +667,6 @@ function createAgentObservability(config) {
     close: () => manager.close()
   };
 }
-// src/agent-runtime/prompt.ts
-import { z as z5 } from "zod";
-var AgentTokenCountSchema = z5.object({
-  value: z5.int().nonnegative().optional(),
-  provenance: AgentProvenanceSchema.extract([
-    "measured",
-    "computed",
-    "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 spoken = options.messages.filter((message) => message.role !== "assistant" || isSpeakableAssistantStatus(message.status));
-  const counts = new Map;
-  let total = 0;
-  let estimated = false;
-  for (const message of spoken) {
-    const count = AgentTokenCountSchema.parse(await options.estimateMessage(message));
-    counts.set(message.id, count);
-    const value = knownValue(count);
-    if (value === undefined) {
-      return {
-        messages: [...spoken],
-        decisions: options.messages.map((candidate) => ({
-          messageId: candidate.id,
-          action: candidate.role === "assistant" && !isSpeakableAssistantStatus(candidate.status) ? "removed" : "kept",
-          reason: candidate.role === "assistant" && !isSpeakableAssistantStatus(candidate.status) ? "unspeakable" : "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(spoken);
-  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 = spoken.filter((message) => !removed.has(message.id));
-  const decisions = options.messages.map((message) => {
-    if (message.role === "assistant" && !isSpeakableAssistantStatus(message.status)) {
-      return {
-        messageId: message.id,
-        action: "removed",
-        reason: "unspeakable",
-        tokens: { provenance: "unavailable" }
-      };
-    }
-    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" : "computed" },
-    outcome: total > options.availableTokens ? "oversized" : removed.size > 0 ? "truncated" : "fits"
-  };
-}
-function knownValue(value) {
-  return value.provenance === "unavailable" ? undefined : value.value;
-}
-function composeAgentPrompt(sections) {
-  return async (options) => {
-    const rendered = [];
-    let total = 0;
-    let unavailable = false;
-    let estimated = false;
-    for (const section of sections) {
-      const text = await section.render({ context: options.context, signal: options.signal });
-      rendered.push({ name: section.name, stability: section.stability, text });
-      let count;
-      if (section.estimateTokens) {
-        count = AgentTokenCountSchema.parse(await section.estimateTokens(text));
-      } else if (options.estimateFallback) {
-        count = AgentTokenCountSchema.parse(await options.estimateFallback(text));
-      } else
-        count = { provenance: "unavailable" };
-      const value = knownValue(count);
-      if (value === undefined)
-        unavailable = true;
-      else
-        total += value;
-      if (count.provenance === "estimated")
-        estimated = true;
-    }
-    const instructionTokens = unavailable ? { provenance: "unavailable" } : { value: total, provenance: estimated ? "estimated" : "computed" };
-    let availableHistoryTokens;
-    let contextDecision = "unavailable";
-    if (options.budget) {
-      if (!Number.isSafeInteger(options.budget.contextWindow) || options.budget.contextWindow < 0 || !Number.isSafeInteger(options.budget.reservedOutput) || options.budget.reservedOutput < 0) {
-        throw new TypeError("contextWindow and reservedOutput must be non-negative safe integers");
-      }
-      const reserveValues = [
-        options.budget.reservedOutput,
-        knownValue(AgentTokenCountSchema.parse(options.budget.toolSchemas)),
-        knownValue(AgentTokenCountSchema.parse(options.budget.attachments)),
-        knownValue(AgentTokenCountSchema.parse(options.budget.providerOverhead)),
-        knownValue(instructionTokens)
-      ];
-      if (reserveValues.every((value) => value !== undefined)) {
-        availableHistoryTokens = options.budget.contextWindow - reserveValues.reduce((sum, value) => sum + (value ?? 0), 0);
-        const historyTokens = options.historyTokens ? knownValue(AgentTokenCountSchema.parse(options.historyTokens)) : undefined;
-        if (historyTokens !== undefined) {
-          if (availableHistoryTokens < 0)
-            contextDecision = "oversized";
-          else if (historyTokens <= availableHistoryTokens)
-            contextDecision = "fits";
-          else
-            contextDecision = options.oversizePolicy === "compact" ? "requires-compaction" : "oversized";
-        }
-      }
-    }
-    const instructionText = rendered.map((section) => section.text).join(`
-
-`);
-    return {
-      instructions: options.adaptInstructions ? await options.adaptInstructions(instructionText) : instructionText,
-      sections: rendered,
-      instructionTokens,
-      contextDecision,
-      ...availableHistoryTokens !== undefined && { availableHistoryTokens }
-    };
-  };
-}
 // src/agent-runtime/protocol.ts
 function hasAgentTerminalOutput(input) {
   for (const part of input.message.parts) {
@@ -1498,1690 +694,6 @@ function defineAgentProtocol(config) {
     }
   };
 }
-// 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/injection.ts
-function createAgentInjectionRegistry() {
-  const offered = new Map;
-  return {
-    offer(key, entry) {
-      const existing = offered.get(key);
-      if (!existing) {
-        offered.set(key, [entry]);
-        return;
-      }
-      if (existing.some((candidate) => candidate.input.id === entry.input.id))
-        return;
-      existing.push(entry);
-    },
-    take(key, excludeRunId) {
-      const existing = offered.get(key);
-      if (!existing)
-        return [];
-      const taken = existing.filter((candidate) => candidate.runId !== excludeRunId);
-      const kept = existing.filter((candidate) => candidate.runId === excludeRunId);
-      if (kept.length === 0)
-        offered.delete(key);
-      else
-        offered.set(key, kept);
-      return taken;
-    },
-    withdraw(key, runId) {
-      const existing = offered.get(key);
-      if (!existing)
-        return;
-      const kept = existing.filter((candidate) => candidate.runId !== runId);
-      if (kept.length === 0)
-        offered.delete(key);
-      else
-        offered.set(key, kept);
-    },
-    clear() {
-      offered.clear();
-    }
-  };
-}
-
-// src/agent-runtime/run-execution.ts
-import {
-  stepCountIs,
-  streamText
-} from "ai";
-
-// src/agent-runtime/runtime-internals.ts
-import { z as z6 } from "zod";
-
-// src/agent-runtime/terminal-commit.ts
-class AgentRuntimeConflictError extends Error {
-  constructor(operation) {
-    super(`Agent runtime store conflict during ${operation}`);
-    this.name = "AgentRuntimeConflictError";
-  }
-}
-function appliedSnapshot(result, operation) {
-  if (result.outcome === "applied" || result.outcome === "duplicate")
-    return result.snapshot;
-  throw new AgentRuntimeConflictError(operation);
-}
-function viewOfSnapshot(snapshot, runId, retainedAssistant) {
-  const run = snapshot.runs.find((candidate) => candidate.id === runId);
-  const assistant = snapshot.messages.find((message) => message.id === run?.assistantMessageId) ?? retainedAssistant;
-  return {
-    snapshotVersion: snapshot.version,
-    conversationId: snapshot.conversationId,
-    ...run && { run },
-    ...assistant && { assistant }
-  };
-}
-function viewOfRun(view, conversationId) {
-  return {
-    snapshotVersion: view.snapshotVersion,
-    conversationId,
-    run: view.run,
-    ...view.assistant && { assistant: view.assistant }
-  };
-}
-function canonicalTerminal(view) {
-  const { run, assistant } = view;
-  if (!run?.terminalReason)
-    return;
-  if (view.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 {
-    snapshotVersion: view.snapshotVersion,
-    run,
-    assistant,
-    reason: run.terminalReason,
-    committedByCaller: false,
-    ...run.terminalPolicyName && { policyName: run.terminalPolicyName },
-    ...run.usage && { usage: run.usage }
-  };
-}
-function interruptedCandidate(candidate, run, now) {
-  const reason = candidate.reason === "superseded" ? "superseded" : "interrupted";
-  const hasInterruptControl = candidate.assistant.parts.some((part) => part.type === "control" && part.reason === "run-interrupted");
-  const parts = hasInterruptControl ? candidate.assistant.parts : [
-    ...candidate.assistant.parts,
-    AgentMessagePartSchema.parse({ type: "control", reason: "run-interrupted" })
-  ];
-  return {
-    ...candidate.usage && { usage: candidate.usage },
-    run,
-    assistant: AgentMessageSchema.parse({
-      ...candidate.assistant,
-      status: assistantStatus(reason),
-      parts,
-      updatedAt: now().toISOString()
-    }),
-    reason
-  };
-}
-function canRetryTerminal(current, previous, runtimeEpoch) {
-  return (current.state === "running" || current.state === "interrupt_requested") && current.ownerId === runtimeEpoch && current.fencingToken === previous.fencingToken;
-}
-var TERMINAL_COMMIT_ATTEMPTS = 32;
-async function commitAgentRunTerminal(input) {
-  let candidate = input.candidate;
-  for (let attempt = 0;attempt < TERMINAL_COMMIT_ATTEMPTS; attempt += 1) {
-    const committed = await input.store.commitRunTerminal({
-      conversationId: candidate.run.conversationId,
-      runId: candidate.run.id,
-      expectedRevision: candidate.run.revision,
-      ownerId: input.runtimeEpoch,
-      ...candidate.run.fencingToken !== undefined && {
-        fencingToken: candidate.run.fencingToken
-      },
-      assistant: candidate.assistant,
-      reason: candidate.reason,
-      ...candidate.policyName && { policyName: candidate.policyName },
-      ...candidate.usage && { usage: candidate.usage },
-      ...candidate.absorb?.length && { absorb: candidate.absorb }
-    });
-    if (committed.outcome === "applied") {
-      const terminal2 = canonicalTerminal(viewOfSnapshot(committed.snapshot, candidate.run.id));
-      if (!terminal2)
-        throw new AgentRuntimeConflictError("terminal result projection");
-      const absorbed = committed.snapshot.runs.filter((run) => run.absorbedIntoRunId === candidate.run.id);
-      return {
-        ...terminal2,
-        committedByCaller: true,
-        ...absorbed.length > 0 && { absorbed }
-      };
-    }
-    if (committed.outcome === "duplicate") {
-      const terminal2 = canonicalTerminal(viewOfSnapshot(committed.snapshot, candidate.run.id, committed.assistant));
-      if (!terminal2)
-        throw new AgentRuntimeConflictError("terminal result projection");
-      return terminal2;
-    }
-    if (committed.outcome !== "conflict") {
-      throw new AgentRuntimeConflictError("terminal commit");
-    }
-    const latest = await input.store.loadRun({
-      conversationId: candidate.run.conversationId,
-      runId: candidate.run.id
-    });
-    const terminal = latest ? canonicalTerminal(viewOfRun(latest, candidate.run.conversationId)) : undefined;
-    if (terminal)
-      return terminal;
-    const current = latest?.run;
-    if (!current || !canRetryTerminal(current, candidate.run, input.runtimeEpoch)) {
-      throw new AgentRuntimeConflictError("terminal commit");
-    }
-    candidate = current.state === "interrupt_requested" ? interruptedCandidate(candidate, current, input.now) : { ...candidate, run: current };
-  }
-  throw new AgentRuntimeConflictError("terminal commit");
-}
-
-// src/agent-runtime/runtime-internals.ts
-function findRun(runs, runId) {
-  const run = runs.find((candidate) => candidate.id === runId);
-  if (!run)
-    throw new AgentRuntimeConflictError("run lookup");
-  return run;
-}
-function jsonValue(value) {
-  const parsed = z6.json().safeParse(value);
-  return parsed.success ? parsed.data : { message: "Non-JSON tool output omitted" };
-}
-function providerEnvelope(value) {
-  const parsed = AgentJsonObjectSchema.safeParse(value);
-  if (!parsed.success)
-    return;
-  return { schemaVersion: 1, provider: "ai-sdk", data: parsed.data };
-}
-function appendText(parts, text) {
-  const previous = parts.at(-1);
-  if (previous?.type === "text") {
-    const next = AgentMessagePartSchema.parse({ ...previous, text: previous.text + text });
-    parts.splice(parts.length - 1, 1, next);
-    return;
-  }
-  parts.push(AgentMessagePartSchema.parse({ type: "text", text }));
-}
-function abortTerminalReason(signal) {
-  if (signal.reason === "shutdown")
-    return "shutdown";
-  if (signal.reason === "timeout")
-    return "timeout";
-  if (signal.reason === "supersede")
-    return "superseded";
-  return "interrupted";
-}
-function addUsage(total, step) {
-  const sum = (left, right) => {
-    if (left?.value === undefined && right?.value === undefined) {
-      return { provenance: "unavailable" };
-    }
-    if (left?.value === undefined)
-      return { ...right, provenance: "computed" };
-    if (right?.value === undefined)
-      return { ...left, provenance: "computed" };
-    return { value: left.value + right.value, provenance: "computed" };
-  };
-  const sumCost = (left, right) => {
-    if (left?.value === undefined || right?.value === undefined) {
-      return { provenance: "unavailable" };
-    }
-    if (left.currency !== right.currency)
-      return { provenance: "unavailable" };
-    return {
-      value: left.value + right.value,
-      ...left.currency && { currency: left.currency },
-      provenance: "computed"
-    };
-  };
-  if (!total)
-    return step;
-  const cost = sumCost(total.cost, step.cost);
-  return {
-    inputTokens: sum(total.inputTokens, step.inputTokens),
-    outputTokens: sum(total.outputTokens, step.outputTokens),
-    reasoningTokens: sum(total.reasoningTokens, step.reasoningTokens),
-    cacheReadTokens: sum(total.cacheReadTokens, step.cacheReadTokens),
-    cacheWriteTokens: sum(total.cacheWriteTokens, step.cacheWriteTokens),
-    ...cost && { cost }
-  };
-}
-function mergeModelTotals(sdkTotal, accumulated) {
-  const pick = (total, ours) => total?.value !== undefined ? { value: total.value, provenance: "computed" } : ours ?? { provenance: "unavailable" };
-  return {
-    inputTokens: pick(sdkTotal.inputTokens, accumulated?.inputTokens),
-    outputTokens: pick(sdkTotal.outputTokens, accumulated?.outputTokens),
-    reasoningTokens: pick(sdkTotal.reasoningTokens, accumulated?.reasoningTokens),
-    cacheReadTokens: pick(sdkTotal.cacheReadTokens, accumulated?.cacheReadTokens),
-    cacheWriteTokens: pick(sdkTotal.cacheWriteTokens, accumulated?.cacheWriteTokens),
-    cost: accumulated?.cost ?? { provenance: "unavailable" }
-  };
-}
-function statedUsage(usage) {
-  const stated = (value) => value ?? { provenance: "unavailable" };
-  if (!usage)
-    return unknownUsage();
-  return {
-    inputTokens: stated(usage.inputTokens),
-    outputTokens: stated(usage.outputTokens),
-    reasoningTokens: stated(usage.reasoningTokens),
-    cacheReadTokens: stated(usage.cacheReadTokens),
-    cacheWriteTokens: stated(usage.cacheWriteTokens),
-    cost: stated(usage.cost)
-  };
-}
-function unknownUsage() {
-  const nothing = { provenance: "unavailable" };
-  return {
-    inputTokens: nothing,
-    outputTokens: nothing,
-    reasoningTokens: nothing,
-    cacheReadTokens: nothing,
-    cacheWriteTokens: nothing,
-    cost: nothing
-  };
-}
-function normalizeSdkUsage(value) {
-  const reported = (tokens) => tokens === undefined || !Number.isSafeInteger(tokens) || tokens < 0 ? { provenance: "unavailable" } : { value: tokens, provenance: "provider-reported" };
-  return {
-    inputTokens: reported(value.inputTokens),
-    outputTokens: reported(value.outputTokens),
-    reasoningTokens: reported(value.outputTokenDetails.reasoningTokens),
-    cacheReadTokens: reported(value.inputTokenDetails.cacheReadTokens),
-    cacheWriteTokens: reported(value.inputTokenDetails.cacheWriteTokens)
-  };
-}
-function createIdleDeadline(parent, timeoutMs) {
-  if (timeoutMs === undefined) {
-    const noop = () => {
-      return;
-    };
-    return { signal: parent, touch: noop, dispose: noop };
-  }
-  const controller = new AbortController;
-  let timer;
-  const touch = () => {
-    if (timer !== undefined)
-      clearTimeout(timer);
-    timer = setTimeout(() => controller.abort("timeout"), timeoutMs);
-  };
-  touch();
-  return {
-    signal: AbortSignal.any([parent, controller.signal]),
-    touch,
-    dispose() {
-      if (timer !== undefined)
-        clearTimeout(timer);
-    }
-  };
-}
-
-// src/agent-runtime/run-execution.ts
-function snapshotForRunPrompt(snapshot, runId) {
-  const runIndex = snapshot.runs.findIndex((candidate) => candidate.id === runId);
-  if (runIndex < 0)
-    throw new AgentRuntimeConflictError("prompt run lookup");
-  const ownedIds = new Set(snapshot.runs.flatMap((candidate) => [
-    ...candidate.inputMessageIds,
-    candidate.assistantMessageId
-  ]));
-  const eligibleIds = new Set(snapshot.runs.slice(0, runIndex + 1).flatMap((candidate) => [...candidate.inputMessageIds, candidate.assistantMessageId]));
-  return AgentSnapshotSchema.parse({
-    ...snapshot,
-    messages: snapshot.messages.filter((message) => !ownedIds.has(message.id) || eligibleIds.has(message.id))
-  });
-}
-function createRunExecutor(dependencies) {
-  const {
-    config,
-    publish,
-    runtimeEpoch,
-    generateId,
-    now,
-    checkpointEveryEvents,
-    maxSteps,
-    idleTimeoutMs,
-    injection
-  } = dependencies;
-  return async function executeRun(input) {
-    injection?.withdraw(input.key, input.acceptedRun.id);
-    const queued = await config.store.loadRun({
-      conversationId: input.acceptedRun.conversationId,
-      runId: input.acceptedRun.id
-    });
-    if (!queued)
-      throw new AgentRuntimeConflictError("run lookup");
-    if (queued.run.terminalReason === "absorbed") {
-      const absorbing = queued.run.absorbedIntoRunId ? await config.store.loadRun({
-        conversationId: queued.run.conversationId,
-        runId: queued.run.absorbedIntoRunId
-      }) : undefined;
-      if (!absorbing?.assistant || !absorbing.run.terminalReason) {
-        throw new AgentRuntimeConflictError("absorbed run resolution");
-      }
-      input.onAcquired?.();
-      return {
-        run: absorbing.run,
-        message: absorbing.assistant,
-        reason: absorbing.run.terminalReason,
-        snapshotVersion: absorbing.snapshotVersion,
-        ...absorbing.run.terminalPolicyName && {
-          policyName: absorbing.run.terminalPolicyName
-        }
-      };
-    }
-    const queuedRun = queued.run;
-    const acquired = appliedSnapshot(await config.store.acquireRun({
-      conversationId: queuedRun.conversationId,
-      runId: queuedRun.id,
-      expectedRevision: queuedRun.revision,
-      ownerId: runtimeEpoch
-    }), "run acquisition");
-    let run = findRun(acquired.runs, input.acceptedRun.id);
-    input.onAcquired?.();
-    await publish({
-      type: "run-state",
-      eventId: agentDurableEventId("run-state", run.id, acquired.version),
-      conversationId: run.conversationId,
-      runId: run.id,
-      snapshotVersion: acquired.version,
-      state: run.state,
-      emittedAt: now().toISOString()
-    });
-    const trace = config.observe?.rootTrace();
-    const runStartedAt = performance.now();
-    config.observe?.emit({
-      schemaVersion: 1,
-      eventId: generateId(),
-      type: "run-started",
-      conversationId: run.conversationId,
-      runId: run.id,
-      traceId: trace?.traceId ?? generateId(),
-      spanId: trace?.spanId ?? generateId(),
-      ...trace?.parentSpanId && { parentSpanId: trace.parentSpanId },
-      state: run.state,
-      queueWaitMs: Math.max(0, now().getTime() - new Date(run.createdAt).getTime()),
-      emittedAt: now().toISOString()
-    });
-    let assistant = AgentMessageSchema.parse({
-      schemaVersion: 1,
-      id: run.assistantMessageId,
-      conversationId: run.conversationId,
-      runId: run.id,
-      role: "assistant",
-      status: "streaming",
-      parts: [],
-      createdAt: now().toISOString(),
-      updatedAt: now().toISOString()
-    });
-    let snapshot = appliedSnapshot(await config.store.checkpointRunAssistant({
-      conversationId: run.conversationId,
-      runId: run.id,
-      expectedRevision: run.revision,
-      ownerId: runtimeEpoch,
-      ...run.fencingToken !== undefined && { fencingToken: run.fencingToken },
-      assistant
-    }), "assistant draft");
-    run = findRun(snapshot.runs, run.id);
-    let observedVersion = snapshot.version;
-    const parts = [];
-    const absorbed = new Map;
-    let eventCount = 0;
-    let sequence = 0;
-    let terminalReason = "success";
-    let nonModelUsage = input.acceptedRun.usage;
-    let modelUsage;
-    let usage = nonModelUsage;
-    let sawProviderFinish = false;
-    let step = 0;
-    let selectedModel;
-    let internalCause;
-    let reasoningPartIndex;
-    let firstOutputAt;
-    let terminalPolicyName;
-    const idleDeadline = createIdleDeadline(input.signal, idleTimeoutMs);
-    const executionSignal = idleDeadline.signal;
-    const updateReasoning = (text, metadata) => {
-      const provider = providerEnvelope(metadata);
-      if (reasoningPartIndex === undefined) {
-        reasoningPartIndex = parts.length;
-        parts.push(AgentMessagePartSchema.parse({
-          type: "reasoning",
-          text,
-          ...provider && { provider }
-        }));
-        return;
-      }
-      const current = parts[reasoningPartIndex];
-      if (current?.type !== "reasoning") {
-        throw new AgentRuntimeConflictError("reasoning accumulator");
-      }
-      parts.splice(reasoningPartIndex, 1, AgentMessagePartSchema.parse({
-        ...current,
-        text: current.text + text,
-        ...provider && { provider }
-      }));
-    };
-    const checkpoint = async () => {
-      assistant = AgentMessageSchema.parse({
-        ...assistant,
-        parts,
-        updatedAt: now().toISOString()
-      });
-      snapshot = appliedSnapshot(await config.store.checkpointRunAssistant({
-        conversationId: run.conversationId,
-        runId: run.id,
-        expectedRevision: run.revision,
-        ownerId: runtimeEpoch,
-        ...run.fencingToken !== undefined && { fencingToken: run.fencingToken },
-        assistant,
-        usage: statedUsage(usage)
-      }), "assistant checkpoint");
-      observedVersion = snapshot.version;
-      run = findRun(snapshot.runs, run.id);
-      const checkpointMetrics = {
-        partial: true,
-        durationMs: performance.now() - runStartedAt,
-        usage: statedUsage(usage),
-        ...firstOutputAt !== undefined && { ttftMs: firstOutputAt - runStartedAt }
-      };
-      await publish({
-        type: "assistant-checkpoint",
-        eventId: agentDurableEventId("assistant-checkpoint", run.id, observedVersion),
-        conversationId: run.conversationId,
-        runId: run.id,
-        snapshotVersion: observedVersion,
-        message: assistant,
-        metrics: checkpointMetrics,
-        emittedAt: now().toISOString()
-      });
-    };
-    try {
-      if (config.history?.compact) {
-        const compacted = await config.history.compact({
-          conversationId: run.conversationId,
-          store: config.store,
-          signal: executionSignal
-        });
-        snapshot = compacted.snapshot;
-        observedVersion = snapshot.version;
-        run = findRun(snapshot.runs, run.id);
-        if (compacted.usage) {
-          nonModelUsage = addUsage(nonModelUsage, compacted.usage);
-          usage = modelUsage ? addUsage(nonModelUsage, modelUsage) : nonModelUsage;
-        }
-      }
-      const assertCurrent = async () => {
-        if (executionSignal.aborted)
-          return "run_interrupted";
-        const current = await config.store.loadRun({
-          conversationId: run.conversationId,
-          runId: run.id
-        });
-        const currentRun = current?.run;
-        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")
-          return "stale_run";
-        return;
-      };
-      const toolFenceLifecycle = createAgentToolFenceLifecycle({
-        runId: run.id,
-        assertCurrent,
-        context: () => ({
-          ...run.fencingToken !== undefined && { fencingToken: run.fencingToken }
-        })
-      });
-      const runtimeContext = {
-        context: input.context,
-        run,
-        signal: executionSignal,
-        toolFenceLifecycle
-      };
-      selectedModel = await config.models.resolve({
-        context: input.context,
-        conversationId: run.conversationId
-      });
-      const promptSnapshot = snapshotForRunPrompt(snapshot, run.id);
-      const [prompt, tools] = await Promise.all([
-        config.prompt({
-          context: input.context,
-          signal: executionSignal,
-          model: selectedModel,
-          snapshot: promptSnapshot
-        }),
-        config.tools(runtimeContext)
-      ]);
-      if (prompt.contextDecision === "oversized") {
-        throw new AgentContextOverflowError;
-      }
-      if (prompt.contextDecision === "requires-compaction") {
-        throw new AgentContextOverflowError("Agent context still exceeds the model budget after compaction");
-      }
-      let carriedSystem = [];
-      const projectHistory = async (source) => {
-        if (config.history?.project)
-          return config.history.project(source.messages);
-        const detailed = await projectAgentHistoryDetailed(source.messages, {
-          ...config.history?.resolveFile && { resolveFile: config.history.resolveFile },
-          ...config.history?.unresolvedFile && {
-            unresolvedFile: config.history.unresolvedFile
-          },
-          ...config.history?.interruptedAssistant && {
-            interruptedAssistant: config.history.interruptedAssistant
-          }
-        });
-        carriedSystem = detailed.system;
-        return [...detailed.messages];
-      };
-      const projectInputs = async (source) => {
-        if (config.history?.project)
-          return config.history.project(source);
-        const detailed = await projectAgentHistoryDetailed(source, {
-          ...config.history?.resolveFile && { resolveFile: config.history.resolveFile },
-          ...config.history?.unresolvedFile && {
-            unresolvedFile: config.history.unresolvedFile
-          },
-          ...config.history?.interruptedAssistant && {
-            interruptedAssistant: config.history.interruptedAssistant
-          }
-        });
-        return [...detailed.messages];
-      };
-      const history = await projectHistory(promptSnapshot);
-      const withCarriedSystem = (instructions) => {
-        if (carriedSystem.length === 0)
-          return instructions;
-        const composed = typeof instructions === "string" ? [{ role: "system", content: instructions }] : Array.isArray(instructions) ? instructions : [instructions];
-        return [
-          ...composed,
-          ...carriedSystem.map((content) => ({ role: "system", content }))
-        ];
-      };
-      const maxStepCondition = stepCountIs(maxSteps);
-      const stopConditions = [
-        async (options) => {
-          const stopped = await maxStepCondition(options);
-          if (stopped && terminalPolicyName === undefined)
-            terminalPolicyName = "max-steps";
-          return stopped;
-        }
-      ];
-      for (const policy of config.loop?.stopPolicies ?? []) {
-        stopConditions.push(async (options) => {
-          const stopped = await policy.when(options);
-          if (stopped && terminalPolicyName === undefined)
-            terminalPolicyName = policy.name;
-          return stopped;
-        });
-      }
-      const takeInjectedMessages = async () => {
-        const taken = injection?.take(input.key, run.id) ?? [];
-        if (taken.length === 0)
-          return [];
-        const messages = [];
-        for (const entry of taken) {
-          messages.push(...await projectInputs([entry.input]));
-          const ids = absorbed.get(entry.runId) ?? [];
-          ids.push(entry.input.id);
-          absorbed.set(entry.runId, ids);
-        }
-        return messages;
-      };
-      const result = streamText({
-        model: selectedModel.model,
-        tools,
-        instructions: withCarriedSystem(prompt.instructions),
-        messages: history,
-        abortSignal: executionSignal,
-        maxRetries: 0,
-        stopWhen: stopConditions,
-        repairToolCall: deferredToolRepair(config.loop?.prepareStep),
-        ...(config.loop?.prepareStep || injection) && {
-          prepareStep: async (options) => {
-            const prepared = await config.loop?.prepareStep?.({
-              ...options,
-              ...runtimeContext
-            });
-            const injected = await takeInjectedMessages();
-            if (injected.length === 0)
-              return prepared;
-            const base = prepared?.messages ?? options.messages;
-            return { ...prepared, messages: [...base, ...injected] };
-          }
-        }
-      });
-      for await (const part of result.stream) {
-        idleDeadline.touch();
-        eventCount += 1;
-        sequence += 1;
-        if (firstOutputAt === undefined && ["text-delta", "reasoning-delta", "tool-call", "file", "source"].includes(part.type)) {
-          firstOutputAt = performance.now();
-        }
-        if (part.type === "text-delta") {
-          appendText(parts, part.text);
-          await publish({
-            type: "assistant-delta",
-            conversationId: run.conversationId,
-            runId: run.id,
-            runtimeEpoch,
-            sequence,
-            textDelta: part.text,
-            emittedAt: now().toISOString()
-          });
-        } else if (part.type === "reasoning-start") {
-          reasoningPartIndex = undefined;
-          updateReasoning("", part.providerMetadata);
-          const provider = providerEnvelope(part.providerMetadata);
-          await publish({
-            type: "reasoning-start",
-            conversationId: run.conversationId,
-            runId: run.id,
-            runtimeEpoch,
-            sequence,
-            ...provider && { provider },
-            emittedAt: now().toISOString()
-          });
-        } else if (part.type === "reasoning-delta") {
-          updateReasoning(part.text, part.providerMetadata);
-          const provider = providerEnvelope(part.providerMetadata);
-          await publish({
-            type: "reasoning-delta",
-            conversationId: run.conversationId,
-            runId: run.id,
-            runtimeEpoch,
-            sequence,
-            textDelta: part.text,
-            ...provider && { provider },
-            emittedAt: now().toISOString()
-          });
-        } else if (part.type === "reasoning-end") {
-          updateReasoning("", part.providerMetadata);
-          reasoningPartIndex = undefined;
-          const provider = providerEnvelope(part.providerMetadata);
-          await publish({
-            type: "reasoning-end",
-            conversationId: run.conversationId,
-            runId: run.id,
-            runtimeEpoch,
-            sequence,
-            ...provider && { provider },
-            emittedAt: now().toISOString()
-          });
-        } else if (part.type === "tool-call") {
-          const provider = providerEnvelope(part.providerMetadata);
-          parts.push(AgentMessagePartSchema.parse({
-            type: "tool-call",
-            callId: part.toolCallId,
-            toolName: part.toolName,
-            input: jsonValue(part.input),
-            ...provider && { provider }
-          }));
-          await publish({
-            type: "tool-status",
-            conversationId: run.conversationId,
-            runId: run.id,
-            runtimeEpoch,
-            sequence,
-            callId: part.toolCallId,
-            toolName: part.toolName,
-            status: "started",
-            input: jsonValue(part.input),
-            emittedAt: now().toISOString()
-          });
-        } else if (part.type === "tool-result") {
-          parts.push(AgentMessagePartSchema.parse({
-            type: "tool-result",
-            callId: part.toolCallId,
-            toolName: part.toolName,
-            outcome: "success",
-            output: jsonValue(part.output)
-          }));
-          await publish({
-            type: "tool-status",
-            conversationId: run.conversationId,
-            runId: run.id,
-            runtimeEpoch,
-            sequence,
-            callId: part.toolCallId,
-            toolName: part.toolName,
-            status: "completed",
-            output: jsonValue(part.output),
-            emittedAt: now().toISOString()
-          });
-        } else if (part.type === "tool-error") {
-          internalCause = part.error;
-          if (isToolExecutionControlError(part.error)) {
-            await publish({
-              type: "tool-status",
-              conversationId: run.conversationId,
-              runId: run.id,
-              runtimeEpoch,
-              sequence,
-              callId: part.toolCallId,
-              toolName: part.toolName,
-              status: "interrupted",
-              emittedAt: now().toISOString()
-            });
-            throw part.error;
-          }
-          parts.push(AgentMessagePartSchema.parse({
-            type: "tool-result",
-            callId: part.toolCallId,
-            toolName: part.toolName,
-            outcome: "error",
-            output: { message: "Tool execution failed" }
-          }));
-          await publish({
-            type: "tool-status",
-            conversationId: run.conversationId,
-            runId: run.id,
-            runtimeEpoch,
-            sequence,
-            callId: part.toolCallId,
-            toolName: part.toolName,
-            status: "failed",
-            output: { message: "Tool execution failed" },
-            emittedAt: now().toISOString()
-          });
-        } else if (part.type === "tool-output-denied") {
-          parts.push(AgentMessagePartSchema.parse({
-            type: "tool-result",
-            callId: part.toolCallId,
-            toolName: part.toolName,
-            outcome: "error",
-            output: { message: "Tool output denied" }
-          }));
-          await publish({
-            type: "tool-status",
-            conversationId: run.conversationId,
-            runId: run.id,
-            runtimeEpoch,
-            sequence,
-            callId: part.toolCallId,
-            toolName: part.toolName,
-            status: "failed",
-            output: { message: "Tool output denied" },
-            emittedAt: now().toISOString()
-          });
-        } else if (part.type === "source") {
-          parts.push(AgentMessagePartSchema.parse({
-            type: "source",
-            sourceId: part.id,
-            ...part.sourceType === "url" && { url: part.url },
-            ...part.title && { title: part.title }
-          }));
-        } else if (part.type === "file" && config.persistGeneratedFile) {
-          const persisted = await config.persistGeneratedFile(part.file);
-          parts.push(AgentMessagePartSchema.parse({
-            type: "file",
-            mediaType: part.file.mediaType,
-            reference: persisted.reference,
-            ...persisted.filename && { filename: persisted.filename }
-          }));
-        } else if (part.type === "file") {
-          throw new Error("persistGeneratedFile is required for generated file output");
-        } else if (part.type === "reasoning-file" && config.persistGeneratedFile) {
-          const persisted = await config.persistGeneratedFile(part.file);
-          parts.push(AgentMessagePartSchema.parse({
-            type: "file",
-            mediaType: part.file.mediaType,
-            reference: persisted.reference,
-            ...persisted.filename && { filename: persisted.filename }
-          }));
-        } else if (part.type === "reasoning-file") {
-          throw new Error("persistGeneratedFile is required for generated reasoning files");
-        } else if (part.type === "tool-approval-request" || part.type === "tool-approval-response") {
-          throw new Error("Durable tool approval/resume is outside this runtime version");
-        } else if (part.type === "custom") {
-          const provider = providerEnvelope(part.providerMetadata);
-          parts.push(AgentMessagePartSchema.parse({
-            type: "provider",
-            envelope: {
-              schemaVersion: 1,
-              provider: "ai-sdk-custom",
-              data: { kind: part.kind, ...provider && { provider: provider.data } }
-            }
-          }));
-        } else if (part.type === "raw") {
-          parts.push(AgentMessagePartSchema.parse({
-            type: "provider",
-            envelope: {
-              schemaVersion: 1,
-              provider: "ai-sdk-raw",
-              data: { value: jsonValue(part.rawValue) }
-            }
-          }));
-        } else if (part.type === "abort") {
-          terminalReason = "interrupted";
-        } else if (part.type === "error") {
-          terminalReason = part.error instanceof AgentContextOverflowError ? "context_overflow" : "provider_failure";
-          internalCause = part.error;
-        } else if (part.type === "finish-step") {
-          const stepTrace = trace ? config.observe?.rootTrace(trace) : undefined;
-          const stepUsage = selectedModel.normalizeUsage?.({
-            usage: part.usage,
-            providerMetadata: part.providerMetadata
-          }) ?? normalizeSdkUsage(part.usage);
-          modelUsage = addUsage(modelUsage, stepUsage);
-          usage = nonModelUsage ? addUsage(nonModelUsage, modelUsage) : modelUsage;
-          config.observe?.emit({
-            schemaVersion: 1,
-            eventId: generateId(),
-            type: "step-finished",
-            conversationId: run.conversationId,
-            runId: run.id,
-            traceId: stepTrace?.traceId ?? trace?.traceId ?? generateId(),
-            spanId: stepTrace?.spanId ?? generateId(),
-            ...stepTrace?.parentSpanId && { parentSpanId: stepTrace.parentSpanId },
-            state: run.state,
-            modelId: selectedModel.descriptor.modelId,
-            step,
-            usage: stepUsage,
-            emittedAt: now().toISOString()
-          });
-          step += 1;
-        } else if (part.type === "finish" && part.finishReason !== "stop") {
-          if (terminalReason === "success") {
-            terminalReason = part.finishReason === "error" ? "provider_failure" : "provider_stop";
-            internalCause ??= { finishReason: part.finishReason };
-          }
-        }
-        if (part.type === "finish") {
-          sawProviderFinish = true;
-          modelUsage = mergeModelTotals(normalizeSdkUsage(part.totalUsage), modelUsage);
-          usage = nonModelUsage ? addUsage(nonModelUsage, modelUsage) : modelUsage;
-        }
-        if (eventCount % checkpointEveryEvents === 0)
-          await checkpoint();
-      }
-      if (terminalPolicyName !== undefined)
-        terminalReason = "policy_stop";
-      if (executionSignal.aborted)
-        terminalReason = abortTerminalReason(executionSignal);
-      if (config.protocol.acceptTerminal && (terminalReason === "success" || terminalReason === "policy_stop" || terminalReason === "provider_stop")) {
-        const candidate = AgentMessageSchema.parse({
-          ...assistant,
-          status: assistantStatus(terminalReason),
-          parts,
-          updatedAt: now().toISOString()
-        });
-        if (!await config.protocol.acceptTerminal({
-          message: candidate,
-          reason: terminalReason,
-          ...terminalPolicyName && { policyName: terminalPolicyName }
-        })) {
-          terminalReason = "provider_failure";
-          internalCause = new Error("Agent terminal output was rejected by the protocol");
-        }
-      }
-    } catch (error) {
-      internalCause = error;
-      const latest = await config.store.loadRun({
-        conversationId: run.conversationId,
-        runId: run.id
-      });
-      const latestRun = latest?.run;
-      const durableInterrupt = latestRun?.ownerId === runtimeEpoch && latestRun.state === "interrupt_requested";
-      if (durableInterrupt && latest && latestRun) {
-        observedVersion = latest.snapshotVersion;
-        run = latestRun;
-      }
-      if (isToolExecutionControlError(error) || executionSignal.aborted || durableInterrupt) {
-        terminalReason = executionSignal.aborted ? abortTerminalReason(executionSignal) : "interrupted";
-        parts.push(AgentMessagePartSchema.parse({
-          type: "control",
-          reason: isToolExecutionControlError(error) && error.reason === "stale_run" ? "stale-run" : "run-interrupted"
-        }));
-      } else {
-        terminalReason = error instanceof AgentContextOverflowError ? "context_overflow" : "provider_failure";
-      }
-    } finally {
-      idleDeadline.dispose();
-    }
-    assistant = AgentMessageSchema.parse({
-      ...assistant,
-      status: assistantStatus(terminalReason),
-      parts,
-      updatedAt: now().toISOString()
-    });
-    const spent = statedUsage(usage);
-    const emitSpend = (report) => {
-      config.observe?.emit({
-        schemaVersion: 1,
-        eventId: report.eventId,
-        type: "run-terminal",
-        conversationId: run.conversationId,
-        runId: run.id,
-        traceId: trace?.traceId ?? generateId(),
-        spanId: trace?.spanId ?? generateId(),
-        ...trace?.parentSpanId && { parentSpanId: trace.parentSpanId },
-        state: report.state,
-        terminalReason: report.reason,
-        ...selectedModel && { modelId: selectedModel.descriptor.modelId },
-        durationMs: performance.now() - runStartedAt,
-        usage: spent,
-        ...internalCause !== undefined && { internalCause },
-        ...firstOutputAt !== undefined && { ttftMs: firstOutputAt - runStartedAt },
-        emittedAt: now().toISOString()
-      });
-    };
-    const unsettledEventId = (version) => agentDurableEventId("terminal", `${run.id}:${runtimeEpoch}`, version);
-    let terminal;
-    try {
-      terminal = await commitAgentRunTerminal({
-        store: config.store,
-        runtimeEpoch,
-        candidate: {
-          run,
-          assistant,
-          reason: terminalReason,
-          ...terminalPolicyName && { policyName: terminalPolicyName },
-          usage: spent,
-          ...absorbed.size > 0 && runStateForTerminalReason(terminalReason) === "completed" && {
-            absorb: [...absorbed].map(([runId, inputMessageIds]) => ({
-              runId,
-              inputMessageIds
-            }))
-          }
-        },
-        now
-      });
-    } catch (error) {
-      emitSpend({
-        eventId: unsettledEventId(observedVersion),
-        state: run.state,
-        reason: terminalReason
-      });
-      throw error;
-    }
-    observedVersion = terminal.snapshotVersion;
-    run = terminal.run;
-    assistant = terminal.assistant;
-    terminalReason = terminal.reason;
-    terminalPolicyName = terminal.policyName;
-    const terminalMetrics = terminal.committedByCaller ? {
-      partial: !sawProviderFinish,
-      durationMs: performance.now() - runStartedAt,
-      usage: spent,
-      ...firstOutputAt !== undefined && { ttftMs: firstOutputAt - runStartedAt }
-    } : undefined;
-    emitSpend({
-      eventId: terminal.committedByCaller ? agentDurableEventId("terminal", run.id, observedVersion) : unsettledEventId(observedVersion),
-      state: run.state,
-      reason: terminalReason
-    });
-    for (const settled of terminal.absorbed ?? []) {
-      await publish({
-        type: "run-state",
-        eventId: agentDurableEventId("run-state", settled.id, observedVersion),
-        conversationId: settled.conversationId,
-        runId: settled.id,
-        snapshotVersion: observedVersion,
-        state: settled.state,
-        emittedAt: now().toISOString()
-      });
-    }
-    if (terminalMetrics) {
-      await publish({
-        type: "terminal",
-        eventId: agentDurableEventId("terminal", run.id, observedVersion),
-        conversationId: run.conversationId,
-        runId: run.id,
-        snapshotVersion: observedVersion,
-        reason: terminalReason,
-        ...terminalPolicyName && { policyName: terminalPolicyName },
-        message: assistant,
-        metrics: terminalMetrics,
-        emittedAt: now().toISOString()
-      });
-    }
-    return {
-      run,
-      message: assistant,
-      reason: terminalReason,
-      snapshotVersion: observedVersion,
-      ...terminalMetrics && { metrics: terminalMetrics },
-      ...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 injectionPossible = typeof config.runs?.inputPolicy === "function" || config.runs?.inputPolicy === "inject";
-  const injection = injectionPossible ? createAgentInjectionRegistry() : undefined;
-  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 declaredIdleTimeoutMs = config.loop?.idleTimeoutMs;
-  const idleTimeoutMs = declaredIdleTimeoutMs === null ? undefined : declaredIdleTimeoutMs ?? 60000;
-  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 },
-    ...injection && { injection }
-  });
-  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();
-    let acquisitionSettled = false;
-    const resolveAcquisition = () => {
-      acquisitionSettled = true;
-      accepted.resolve();
-    };
-    const rejectAcquisition = (error) => {
-      if (!acquisitionSettled)
-        accepted.reject(error);
-    };
-    const handedOff = beginAdmission();
-    (async () => {
-      try {
-        const recovered = await config.store.loadRun({
-          conversationId: rawInput.conversationId,
-          runId: rawInput.runId
-        });
-        if (!recovered)
-          throw new AgentRuntimeConflictError("run lookup");
-        const recoveredRun = recovered.run;
-        if (recoveredRun.state !== "queued") {
-          throw new Error("Only a queued recovered agent run can be resumed");
-        }
-        const ticket = coordinator.submit({
-          key: rawInput.conversationKey ?? rawInput.conversationId,
-          policy: "queue",
-          create: (signal) => ({
-            runId: recoveredRun.id,
-            execute: () => executeRun({
-              acceptedRun: recoveredRun,
-              context,
-              signal,
-              key: rawInput.conversationKey ?? rawInput.conversationId,
-              onAcquired: resolveAcquisition
-            })
-          })
-        });
-        ticket.accepted.catch(() => {
-          return;
-        });
-        ticket.result.then(result.resolve, (error) => {
-          rejectAcquisition(error);
-          result.reject(error);
-        });
-      } catch (error) {
-        rejectAcquisition(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,
-        idempotencyKey: rawInput.idempotencyKey,
-        context: rawInput.context,
-        parts: rawInput.parts.map((part) => config.protocol.parsePart(part)),
-        ...metadata !== undefined && { metadata }
-      };
-      const context = config.protocol.parseContext(input.context);
-      const conversationTickets = tickets.get(input.conversationId);
-      const existingTicket = conversationTickets?.get(input.idempotencyKey);
-      if (existingTicket)
-        return existingTicket;
-      const key = config.runs?.key?.(input) ?? input.conversationId;
-      const policy = typeof config.runs?.inputPolicy === "function" ? config.runs.inputPolicy(input) : config.runs?.inputPolicy ?? "queue";
-      const nowIso = now().toISOString();
-      const inputMessageId = rawInput.recordIds?.inputMessageId ?? generateId();
-      const runId = rawInput.recordIds?.runId ?? generateId();
-      const assistantMessageId = rawInput.recordIds?.assistantMessageId ?? generateId();
-      const userMessage2 = AgentMessageSchema.parse({
-        schemaVersion: 1,
-        id: inputMessageId,
-        conversationId: input.conversationId,
-        role: "user",
-        status: "committed",
-        parts: input.parts,
-        ...input.metadata && { metadata: input.metadata },
-        createdAt: nowIso,
-        updatedAt: nowIso
-      });
-      const queuedRun = AgentRunSchema.parse({
-        schemaVersion: 1,
-        id: runId,
-        conversationId: input.conversationId,
-        inputMessageIds: [inputMessageId],
-        assistantMessageId,
-        state: "queued",
-        revision: 0,
-        ...policy === "interrupt-next" && { queuePriority: "interrupt-next" },
-        createdAt: nowIso,
-        updatedAt: nowIso
-      });
-      const outerAccepted = Promise.withResolvers();
-      const outerAdmission = Promise.withResolvers();
-      outerAdmission.promise.catch(() => {
-        return;
-      });
-      const outerResult = Promise.withResolvers();
-      const reservation = config.runs?.coalescePending && policy !== "interrupt-next" ? reserveAdmission(key, runId) : undefined;
-      const previousAcceptance = reservation?.lane.acceptanceTail ?? Promise.resolve();
-      const acceptanceDone = Promise.withResolvers();
-      if (reservation) {
-        reservation.lane.acceptanceTail = previousAcceptance.catch(() => {
-          return;
-        }).then(() => acceptanceDone.promise);
-      }
-      const publicTicket = {
-        accepted: outerAccepted.promise,
-        admission: outerAdmission.promise,
-        result: outerResult.promise
-      };
-      const currentConversationTickets = conversationTickets ?? new Map;
-      currentConversationTickets.set(input.idempotencyKey, publicTicket);
-      if (!conversationTickets)
-        tickets.set(input.conversationId, currentConversationTickets);
-      let offeredRunId;
-      const forgetTicket = () => {
-        if (offeredRunId !== undefined)
-          injection?.withdraw(key, offeredRunId);
-        if (currentConversationTickets.get(input.idempotencyKey) !== publicTicket)
-          return;
-        currentConversationTickets.delete(input.idempotencyKey);
-        if (currentConversationTickets.size === 0)
-          tickets.delete(input.conversationId);
-      };
-      outerResult.promise.then(forgetTicket, forgetTicket);
-      const handedOff = beginAdmission();
-      (async () => {
-        try {
-          await previousAcceptance.catch(() => {
-            return;
-          });
-          await config.models.preflight?.({
-            context,
-            conversationId: input.conversationId
-          });
-          if (admissionClosed)
-            throw closedError();
-          const acceptance = await config.store.acceptInputAndAssignRun({
-            idempotencyKey: input.idempotencyKey,
-            input: userMessage2,
-            run: queuedRun,
-            ...reservation && !reservation.shouldSchedule && {
-              coalesceIntoRunId: reservation.admission.runId
-            }
-          });
-          const acceptedSnapshot = appliedSnapshot(acceptance, "input acceptance");
-          const assignedRunId = acceptance.outcome === "duplicate" ? acceptance.runId : reservation?.admission.runId ?? runId;
-          const acceptedRun = acceptance.outcome === "duplicate" ? acceptance.run : findRun(acceptedSnapshot.runs, assignedRunId);
-          const actualInputMessageId = acceptance.outcome === "duplicate" ? acceptance.inputMessageId : userMessage2.id;
-          const acceptedInput = acceptance.outcome === "duplicate" ? acceptance.input : acceptedSnapshot.messages.find((candidate) => candidate.id === actualInputMessageId);
-          if (!acceptedInput) {
-            throw new AgentRuntimeConflictError("admission input projection");
-          }
-          const assistantPlaceholder = AgentAssistantPlaceholderSchema.parse({
-            schemaVersion: 1,
-            id: acceptedRun.assistantMessageId,
-            conversationId: acceptedRun.conversationId,
-            runId: acceptedRun.id,
-            status: "pending",
-            createdAt: acceptedRun.createdAt,
-            updatedAt: acceptedRun.updatedAt
-          });
-          const acceptedAssistant = acceptance.outcome === "duplicate" ? acceptance.assistant ?? assistantPlaceholder : assistantPlaceholder;
-          const admission = {
-            inputMessageId: acceptedInput.id,
-            runId: acceptedRun.id,
-            assistantMessageId: assistantPlaceholder.id,
-            input: acceptedInput,
-            run: acceptedRun,
-            assistant: acceptedAssistant,
-            snapshotVersion: acceptedSnapshot.version
-          };
-          outerAdmission.resolve(admission);
-          await publish({
-            type: "admission",
-            eventId: agentDurableEventId("admission", acceptedRun.id, acceptedSnapshot.version),
-            conversationId: acceptedRun.conversationId,
-            runId: acceptedRun.id,
-            snapshotVersion: acceptedSnapshot.version,
-            input: acceptedInput,
-            run: acceptedRun,
-            assistant: acceptedAssistant,
-            emittedAt: now().toISOString()
-          });
-          await publish({
-            type: "run-state",
-            eventId: agentDurableEventId("run-state", acceptedRun.id, acceptedSnapshot.version),
-            conversationId: acceptedRun.conversationId,
-            runId: acceptedRun.id,
-            snapshotVersion: acceptedSnapshot.version,
-            state: acceptedRun.state,
-            emittedAt: now().toISOString()
-          });
-          outerAccepted.resolve();
-          if (acceptance.outcome === "duplicate") {
-            if (!acceptedRun.terminalReason) {
-              const error = new Error("Duplicate input is already owned by another runtime execution");
-              outerResult.reject(error);
-              if (reservation?.shouldSchedule) {
-                reservation.admission.completion.reject(error);
-                settleAdmission(key, reservation.admission);
-              }
-              return;
-            }
-            const message = acceptance.assistant;
-            if (!message) {
-              const error = new Error("Duplicate terminal admission has no retained canonical assistant");
-              outerResult.reject(error);
-              if (reservation?.shouldSchedule) {
-                reservation.admission.completion.reject(error);
-                settleAdmission(key, reservation.admission);
-              }
-              return;
-            }
-            outerResult.resolve({
-              run: acceptedRun,
-              message,
-              reason: acceptedRun.terminalReason,
-              snapshotVersion: acceptedSnapshot.version,
-              ...acceptedRun.terminalPolicyName && {
-                policyName: acceptedRun.terminalPolicyName
-              }
-            });
-            if (reservation?.shouldSchedule) {
-              reservation.admission.completion.reject(new Error("Reserved run resolved to a duplicate durable input"));
-              settleAdmission(key, reservation.admission);
-            }
-            return;
-          }
-          if (policy === "inject") {
-            offeredRunId = acceptedRun.id;
-            injection?.offer(key, { runId: acceptedRun.id, input: acceptedInput });
-          }
-          if (reservation && !reservation.shouldSchedule) {
-            reservation.admission.completion.promise.then(outerResult.resolve, outerResult.reject);
-            return;
-          }
-          const ticket = coordinator.submit({
-            key,
-            policy,
-            create: async (signal) => {
-              if (reservation)
-                await waitForAdmissionAcceptances(reservation.lane);
-              return {
-                runId: acceptedRun.id,
-                execute: () => executeRun({ acceptedRun, context, signal, key })
-              };
-            }
-          });
-          ticket.accepted.catch(() => {
-            return;
-          });
-          if (reservation) {
-            ticket.result.then(reservation.admission.completion.resolve, reservation.admission.completion.reject);
-            reservation.admission.completion.promise.then((value) => {
-              settleAdmission(key, reservation.admission);
-              outerResult.resolve(value);
-            }, (error) => {
-              settleAdmission(key, reservation.admission);
-              outerResult.reject(error);
-            });
-          } else {
-            ticket.result.then(outerResult.resolve, outerResult.reject);
-          }
-        } catch (error) {
-          outerAccepted.reject(error);
-          outerAdmission.reject(error);
-          outerResult.reject(error);
-          if (reservation?.shouldSchedule) {
-            reservation.admission.completion.reject(error);
-            settleAdmission(key, reservation.admission);
-          }
-        } finally {
-          acceptanceDone.resolve();
-          handedOff();
-        }
-      })();
-      return publicTicket;
-    },
-    resume,
-    async interrupt(input) {
-      const view = await config.store.loadRun({
-        conversationId: input.conversationId,
-        runId: input.runId
-      });
-      if (!view)
-        throw new AgentRuntimeConflictError("run lookup");
-      const requested = await config.store.requestRunInterrupt({
-        conversationId: input.conversationId,
-        runId: input.runId,
-        expectedRevision: view.run.revision
-      });
-      if (requested.outcome === "applied") {
-        const interruptedRun = findRun(requested.snapshot.runs, input.runId);
-        await publish({
-          type: "run-state",
-          eventId: agentDurableEventId("run-state", interruptedRun.id, requested.snapshot.version),
-          conversationId: interruptedRun.conversationId,
-          runId: interruptedRun.id,
-          snapshotVersion: requested.snapshot.version,
-          state: interruptedRun.state,
-          emittedAt: now().toISOString()
-        });
-        coordinator.stop(input.conversationKey ?? input.conversationId, "user-interrupt");
-      }
-      return requested;
-    },
-    async recover(options) {
-      if (admissionClosed)
-        throw closedError();
-      const pageSize = options.pageSize ?? 100;
-      const maxRuns = options.maxRuns ?? 1000;
-      if (!Number.isSafeInteger(pageSize) || pageSize < 1 || pageSize > 1000) {
-        throw new TypeError("Recovery pageSize must be an integer between 1 and 1000");
-      }
-      if (!Number.isSafeInteger(maxRuns) || maxRuns < 1) {
-        throw new TypeError("Recovery maxRuns must be a positive safe integer");
-      }
-      const recoverable = [];
-      let cursor;
-      while (recoverable.length < maxRuns && !options.signal?.aborted && !admissionClosed) {
-        const page = await config.store.scanRecoverable({
-          ...cursor && { cursor },
-          limit: Math.min(pageSize, maxRuns - recoverable.length)
-        });
-        recoverable.push(...page.items);
-        cursor = page.nextCursor;
-        if (!cursor || page.items.length === 0)
-          break;
-      }
-      const grouped = new Map;
-      for (const item of recoverable) {
-        const items = grouped.get(item.conversationId) ?? [];
-        items.push(item);
-        grouped.set(item.conversationId, items);
-      }
-      const ordered = [];
-      for (const [conversationId, items] of grouped) {
-        const active = await config.store.listActiveRuns(conversationId);
-        const position = new Map(active.map((run, index) => [run.id, index]));
-        ordered.push(...items.sort((left, right) => {
-          const leftPosition = position.get(left.run.id);
-          const rightPosition = position.get(right.run.id);
-          if (leftPosition === undefined && rightPosition === undefined)
-            return 0;
-          if (leftPosition === undefined)
-            return 1;
-          if (rightPosition === undefined)
-            return -1;
-          return leftPosition - rightPosition;
-        }));
-      }
-      const outcomes = [];
-      const scheduledRuns = new Map;
-      for (const item of ordered) {
-        if (options.signal?.aborted)
-          break;
-        if (admissionClosed)
-          break;
-        const releaseAdmission = beginAdmission();
-        try {
-          const active = await config.store.listActiveRuns(item.conversationId);
-          const position = active.findIndex((run) => run.id === item.run.id);
-          const scheduled = scheduledRuns.get(item.conversationId) ?? new Set;
-          const blockedByUnscheduledPredecessor = position > 0 && active.slice(0, position).some((run) => !scheduled.has(run.id));
-          if (blockedByUnscheduledPredecessor) {
-            outcomes.push({
-              conversationId: item.conversationId,
-              runId: item.run.id,
-              outcome: "skipped"
-            });
-            continue;
-          }
-          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,
-              runId: item.run.id,
-              outcome: "skipped"
-            });
-            continue;
-          }
-          if (decision.action === "abandon") {
-            const abandoned = await config.store.recoverRun({
-              conversationId: item.conversationId,
-              runId: item.run.id,
-              expectedRevision: item.run.revision,
-              action: "abandon"
-            });
-            if (abandoned.outcome !== "applied") {
-              throw new AgentRuntimeConflictError("recovery abandon");
-            }
-            outcomes.push({
-              conversationId: item.conversationId,
-              runId: item.run.id,
-              outcome: "abandoned"
-            });
-            continue;
-          }
-          if (decision.action === "requeue") {
-            const requeued = await config.store.recoverRun({
-              conversationId: item.conversationId,
-              runId: item.run.id,
-              expectedRevision: item.run.revision,
-              action: "requeue",
-              replaySafe: true
-            });
-            if (requeued.outcome !== "applied") {
-              throw new AgentRuntimeConflictError("recovery requeue");
-            }
-          }
-          const context = await options.resolveContext(item);
-          const resumed = resume({
-            conversationId: item.conversationId,
-            runId: item.run.id,
-            context
-          });
-          resumed.result.catch(() => {
-            return;
-          });
-          await resumed.accepted;
-          scheduled.add(item.run.id);
-          scheduledRuns.set(item.conversationId, scheduled);
-          outcomes.push({
-            conversationId: item.conversationId,
-            runId: item.run.id,
-            outcome: decision.action === "requeue" ? "requeued" : "resumed",
-            result: resumed.result
-          });
-        } catch (error) {
-          outcomes.push({
-            conversationId: item.conversationId,
-            runId: item.run.id,
-            outcome: "failed",
-            error
-          });
-        } finally {
-          releaseAdmission();
-        }
-      }
-      return outcomes;
-    },
-    stop: (conversationKey, reason) => coordinator.stop(conversationKey, reason),
-    close: async (options = {}) => {
-      assertCloseBudgets(options);
-      admissionClosed = true;
-      const startedAt = performance.now();
-      injection?.clear();
-      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 };
-    }
-  };
-}
 export {
   ACTIVE_AGENT_RUN_STATES,
   AcceptInputAndAssignRunSchema,
@@ -3192,6 +704,9 @@ export {
   AgentCheckpointEventSchema,
   AgentContextOverflowError,
   AgentControlPartSchema,
+  AgentConversationMessagePageSchema,
+  AgentConversationPageSchema,
+  AgentConversationSummarySchema,
   AgentCostValueSchema,
   AgentFilePartSchema,
   AgentHistoryMutationSchema,
@@ -3201,8 +716,16 @@ export {
   AgentMessageSchema,
   AgentMessageStatusSchema,
   AgentModelCapabilitySchema,
+  AgentModelCatalogEntrySchema,
+  AgentModelCatalogSchema,
   AgentModelDescriptorSchema,
+  AgentModelMetricSchema,
+  AgentModelPopularitySchema,
+  AgentModelPriceSchema,
   AgentModelRegistrySnapshotSchema,
+  AgentModelSearchInputSchema,
+  AgentModelSearchResultSchema,
+  AgentModelSelectionSchema,
   AgentOpaquePartSchema,
   AgentProvenanceSchema,
   AgentProviderEnvelopeSchema,
@@ -3241,6 +764,8 @@ export {
   AgentTextPartSchema,
   AgentTimestampSchema,
   AgentTokenCountSchema,
+  AgentToolApprovalRequestPartSchema,
+  AgentToolApprovalResponsePartSchema,
   AgentToolCallPartSchema,
   AgentToolResultPartSchema,
   AgentToolStatusEventSchema,
@@ -3265,13 +790,16 @@ export {
   createAgentSessionCoordinator,
   createAgentToolFenceLifecycle,
   createDeferredAgentToolSurface,
+  createMemoryAgentModelSelectionStore,
   createMemoryAgentRuntimeStore,
   defineAgentProtocol,
   defineModelRegistry,
   hasAgentTerminalOutput,
+  isAssistantHistoryEvidence,
   projectAgentHistory,
   projectAgentHistoryDetailed,
   runStateForTerminalReason,
+  searchAgentModelCatalog,
   selectAgentHistory,
   structuredCompaction,
   validateAgentModelSnapshot