stitchkit 0.68.10 → 0.69.0

package/dist/index-3eqrkqhg.js

@@ -0,0 +1,2565 @@
+import {
+  assistantStatus,
+  isAssistantHistoryEvidence,
+  isCompleteAgentHistoryTurn
+} from "./index-es0h4w26.js";
+import {
+  createBoundedSinkManager
+} from "./index-a59da114.js";
+import {
+  ToolExecutionControlError,
+  isToolExecutionControlError
+} from "./index-h8vn1jcr.js";
+import {
+  AgentAssistantPlaceholderSchema,
+  AgentJsonObjectSchema,
+  AgentMessagePartSchema,
+  AgentMessageSchema,
+  AgentProvenanceSchema,
+  AgentProviderEnvelopeSchema,
+  AgentRecordIdSchema,
+  AgentRecordVersionSchema,
+  AgentRunMetricsSchema,
+  AgentRunSchema,
+  AgentRunStateSchema,
+  AgentSnapshotSchema,
+  AgentTerminalReasonSchema,
+  AgentTimestampSchema,
+  runStateForTerminalReason
+} from "./index-x1th9s8c.js";
+import {
+  isRecord,
+  transportResult
+} from "./index-qyrqwr4c.js";
+
+// 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/event-schema.ts
+import { z } from "zod";
+var AgentAdmissionEventSchema = z.object({
+  type: z.literal("admission"),
+  eventId: AgentRecordIdSchema,
+  conversationId: AgentRecordIdSchema,
+  runId: AgentRecordIdSchema,
+  snapshotVersion: AgentRecordVersionSchema,
+  input: AgentMessageSchema,
+  run: AgentRunSchema,
+  assistant: z.union([AgentAssistantPlaceholderSchema, AgentMessageSchema]),
+  emittedAt: AgentTimestampSchema
+});
+var EventIdentitySchema = z.object({
+  conversationId: AgentRecordIdSchema,
+  runId: AgentRecordIdSchema,
+  emittedAt: AgentTimestampSchema
+});
+var AgentTransientDeltaEventSchema = EventIdentitySchema.extend({
+  type: z.literal("assistant-delta"),
+  runtimeEpoch: z.string().min(1),
+  sequence: z.int().nonnegative(),
+  textDelta: z.string()
+});
+var AgentTransientReasoningIdentitySchema = EventIdentitySchema.extend({
+  runtimeEpoch: z.string().min(1),
+  sequence: z.int().nonnegative(),
+  provider: AgentProviderEnvelopeSchema.optional()
+});
+var AgentReasoningStartEventSchema = AgentTransientReasoningIdentitySchema.extend({
+  type: z.literal("reasoning-start")
+});
+var AgentReasoningDeltaEventSchema = AgentTransientReasoningIdentitySchema.extend({
+  type: z.literal("reasoning-delta"),
+  textDelta: z.string()
+});
+var AgentReasoningEndEventSchema = AgentTransientReasoningIdentitySchema.extend({
+  type: z.literal("reasoning-end")
+});
+var AgentCheckpointEventSchema = EventIdentitySchema.extend({
+  type: z.literal("assistant-checkpoint"),
+  eventId: AgentRecordIdSchema,
+  snapshotVersion: AgentRecordVersionSchema,
+  message: AgentMessageSchema,
+  metrics: AgentRunMetricsSchema.optional()
+});
+var AgentRunStateEventSchema = EventIdentitySchema.extend({
+  type: z.literal("run-state"),
+  eventId: AgentRecordIdSchema,
+  snapshotVersion: AgentRecordVersionSchema,
+  state: AgentRunStateSchema
+});
+var AgentToolStatusEventSchema = EventIdentitySchema.extend({
+  type: z.literal("tool-status"),
+  runtimeEpoch: z.string().min(1),
+  sequence: z.int().nonnegative(),
+  callId: AgentRecordIdSchema,
+  toolName: z.string().min(1),
+  status: z.enum(["started", "completed", "failed", "interrupted"]),
+  input: z.json().optional(),
+  output: z.json().optional()
+});
+var AgentTerminalEventSchema = EventIdentitySchema.extend({
+  type: z.literal("terminal"),
+  eventId: AgentRecordIdSchema,
+  snapshotVersion: AgentRecordVersionSchema,
+  reason: AgentTerminalReasonSchema,
+  policyName: z.string().min(1).optional(),
+  message: AgentMessageSchema,
+  metrics: AgentRunMetricsSchema.optional()
+});
+var AgentRuntimeEventSchema = z.discriminatedUnion("type", [
+  AgentAdmissionEventSchema,
+  AgentTransientDeltaEventSchema,
+  AgentReasoningStartEventSchema,
+  AgentReasoningDeltaEventSchema,
+  AgentReasoningEndEventSchema,
+  AgentCheckpointEventSchema,
+  AgentRunStateEventSchema,
+  AgentToolStatusEventSchema,
+  AgentTerminalEventSchema
+]);
+var AgentRuntimeEventCursorSchema = z.object({
+  snapshotVersion: AgentRecordVersionSchema.optional(),
+  durableEventIds: z.array(AgentRecordIdSchema).optional(),
+  runtimeEpoch: z.string().min(1).optional(),
+  sequence: z.int().nonnegative().optional()
+});
+function isDurableEvent(event) {
+  return event.type === "admission" || event.type === "assistant-checkpoint" || event.type === "run-state" || event.type === "terminal";
+}
+function advanceAgentRuntimeEventCursor(rawCursor, event) {
+  const cursor = AgentRuntimeEventCursorSchema.parse(rawCursor);
+  if (isDurableEvent(event)) {
+    const previous = cursor.snapshotVersion;
+    const durableEventIds = previous === event.snapshotVersion ? cursor.durableEventIds ?? [] : [];
+    if (previous !== undefined && event.snapshotVersion < previous || durableEventIds.includes(event.eventId)) {
+      return { status: "duplicate", cursor };
+    }
+    return {
+      status: "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 as modelMessageSchema2 } from "ai";
+
+// src/internal/ai-sdk-typed.ts
+import { modelMessageSchema, streamText } from "ai";
+function streamAgentTextBoundary(options) {
+  return streamText(options);
+}
+function modelMessageWithApprovalSignature(input) {
+  const parsed = modelMessageSchema.parse(input);
+  const rawContent = isRecord(input) ? input.content : undefined;
+  if (parsed.role !== "assistant" || typeof parsed.content === "string" || !Array.isArray(rawContent)) {
+    return parsed;
+  }
+  const content = parsed.content.map((part, index) => {
+    const raw = rawContent[index];
+    if (part.type !== "tool-approval-request" || !isRecord(raw) || typeof raw.signature !== "string") {
+      return part;
+    }
+    return { ...part, signature: raw.signature };
+  });
+  return transportResult({ ...parsed, content });
+}
+
+// src/agent-runtime/history.ts
+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]";
+var FAILURE_NOTE = "[failed: partial evidence from a run that did not complete successfully]";
+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: modelMessageSchema2.parse({ role: "user", content }), rendered };
+}
+function assistantMessages(message, marker) {
+  const rendered = new Set;
+  const messages = [];
+  let role;
+  let content = [];
+  const flush = () => {
+    if (!role || content.length === 0)
+      return;
+    messages.push(modelMessageWithApprovalSignature({ 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 (part.type === "tool-approval-request") {
+      append("assistant", {
+        type: "tool-approval-request",
+        approvalId: part.approvalId,
+        toolCallId: part.callId,
+        ...part.isAutomatic !== undefined && { isAutomatic: part.isAutomatic },
+        ...part.signature && { signature: part.signature }
+      });
+      rendered.add("tool-approval-request");
+    }
+    if (part.type === "tool-approval-response") {
+      append("tool", {
+        type: "tool-approval-response",
+        approvalId: part.approvalId,
+        approved: part.approved,
+        ...part.reason && { reason: part.reason }
+      });
+      rendered.add("tool-approval-response");
+    }
+  }
+  if (marker && (messages.length > 0 || content.length > 0)) {
+    append("assistant", {
+      type: "text",
+      text: marker === "interrupted" ? INTERRUPTION_NOTE : FAILURE_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;
+    }
+    if (part.type === "tool-approval-request") {
+      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" && !isAssistantHistoryEvidence(message.status, options.evidencePolicy)) {
+      decisions.push(decide(message, "omitted", message.status === "superseded" ? "superseded" : "draft-or-failed"));
+      continue;
+    }
+    if (message.status === "streaming" || message.status === "failed" && options.evidencePolicy?.failedAssistant !== "assistant-marked") {
+      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 ? "interrupted" : message.status === "failed" ? "failed" : undefined);
+    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/prompt.ts
+import { z as z2 } from "zod";
+var AgentTokenCountSchema = z2.object({
+  value: z2.int().nonnegative().optional(),
+  provenance: AgentProvenanceSchema.extract([
+    "measured",
+    "computed",
+    "estimated",
+    "unavailable"
+  ])
+});
+function budgetTurns(messages, evidencePolicy) {
+  const turns = [];
+  let current = [];
+  const flush = () => {
+    if (current.length === 0)
+      return;
+    turns.push({
+      messages: current,
+      complete: isCompleteAgentHistoryTurn(current, evidencePolicy),
+      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" || isAssistantHistoryEvidence(message.status, options.evidencePolicy));
+  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" && !isAssistantHistoryEvidence(candidate.status, options.evidencePolicy) ? "removed" : "kept",
+          reason: candidate.role === "assistant" && !isAssistantHistoryEvidence(candidate.status, options.evidencePolicy) ? "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, options.evidencePolicy);
+  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" && !isAssistantHistoryEvidence(message.status, options.evidencePolicy)) {
+      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/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/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
+} from "ai";
+
+// 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/runtime-internals.ts
+import { z as z3 } from "zod";
+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 = z3.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,
+        run,
+        snapshot
+      });
+      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
+          },
+          ...config.history?.evidencePolicy && {
+            evidencePolicy: config.history.evidencePolicy
+          }
+        });
+        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
+          },
+          ...config.history?.evidencePolicy && {
+            evidencePolicy: config.history.evidencePolicy
+          }
+        });
+        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 = streamAgentTextBoundary({
+        model: selectedModel.model,
+        tools,
+        instructions: withCarriedSystem(prompt.instructions),
+        messages: history,
+        abortSignal: executionSignal,
+        maxRetries: 0,
+        stopWhen: stopConditions,
+        repairToolCall: deferredToolRepair(config.loop?.prepareStep),
+        ...config.loop?.toolApproval && {
+          toolApproval: config.loop.toolApproval,
+          runtimeContext: input.context
+        },
+        ...config.loop?.toolApprovalSecret && {
+          experimental_toolApprovalSecret: config.loop.toolApprovalSecret
+        },
+        ...(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") {
+          parts.push(AgentMessagePartSchema.parse({
+            type: "tool-approval-request",
+            approvalId: part.approvalId,
+            callId: part.toolCall.toolCallId,
+            ...part.isAutomatic !== undefined && { isAutomatic: part.isAutomatic },
+            ...part.signature && { signature: part.signature }
+          }));
+        } else if (part.type === "tool-approval-response") {
+          parts.push(AgentMessagePartSchema.parse({
+            type: "tool-approval-response",
+            approvalId: part.approvalId,
+            approved: part.approved,
+            ...part.reason && { reason: part.reason }
+          }));
+        } 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);
+      const awaitsApproval = parts.some((part) => part.type === "tool-approval-request");
+      if (!awaitsApproval && 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)),
+        role: rawInput.role ?? "user",
+        ...metadata !== undefined && { metadata }
+      };
+      if (input.role === "tool" && (input.parts.length === 0 || input.parts.some((part) => part.type !== "tool-approval-response"))) {
+        throw new TypeError("Tool-role Agent input only accepts approval responses");
+      }
+      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: input.role,
+        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 { AgentContextOverflowError, createAgentSessionCoordinator, registerDeferredToolRepair, registerDeferredToolCatalog, deferredToolCatalog, repairedSearchCall, AgentAdmissionEventSchema, AgentTransientDeltaEventSchema, AgentReasoningStartEventSchema, AgentReasoningDeltaEventSchema, AgentReasoningEndEventSchema, AgentCheckpointEventSchema, AgentRunStateEventSchema, AgentToolStatusEventSchema, AgentTerminalEventSchema, AgentRuntimeEventSchema, AgentRuntimeEventCursorSchema, advanceAgentRuntimeEventCursor, agentDurableEventId, createAgentRuntimeEventSink, projectAgentHistoryDetailed, projectAgentHistory, createAgentToolFenceLifecycle, AgentTokenCountSchema, selectAgentHistory, composeAgentPrompt, AgentRuntimeConflictError, createAgentRuntime };