stitchkit 0.93.0 → 0.94.1

package/dist/index-7f68ghdn.js

@@ -0,0 +1,3618 @@
+import {
+  messageOf
+} from "./index-83bdg97s.js";
+import {
+  AgentRuntimeEventSchema,
+  agentDurableEventId
+} from "./index-y64k3s0h.js";
+import {
+  createBoundedSinkManager
+} from "./index-h6eeys1v.js";
+import {
+  advanceToolChronology,
+  assistantStatus,
+  canProjectToolChronology,
+  canonicalAgentJson,
+  createToolChronology,
+  isAssistantHistoryEvidence,
+  isCompleteAgentHistoryTurn
+} from "./index-gxrt5h6v.js";
+import {
+  AgentAssistantPlaceholderSchema,
+  AgentJsonObjectSchema,
+  AgentMessagePartSchema,
+  AgentMessageSchema,
+  AgentProvenanceSchema,
+  AgentProviderResponseSchema,
+  AgentRunOperationSchema,
+  AgentRunSchema,
+  AgentSnapshotSchema,
+  runStateForTerminalReason
+} from "./index-gtj3zc53.js";
+import {
+  createLocalStepDurability,
+  createToolDurabilityContext,
+  isAgentToolError
+} from "./index-79z7m7dt.js";
+import {
+  ToolExecutionControlError,
+  isToolExecutionControlError
+} from "./index-55hkhm67.js";
+import {
+  isRecord,
+  transportResult
+} from "./index-hffjpmq9.js";
+
+// 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/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/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: (bound) => manager.flush(bound),
+    getStatus: () => manager.getStatus(),
+    close: (bound) => manager.close(bound)
+  };
+}
+
+// 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 };
+}
+async function projectAgentHistoryDetailed(messages, options = {}) {
+  const projected = [];
+  const system = [];
+  const decisions = [];
+  const interruptedRule = options.interruptedAssistant ?? "assistant-marked";
+  let observedUser = false;
+  let chronology = createToolChronology();
+  let conversationId;
+  for (const message of messages) {
+    if (message.conversationId !== conversationId) {
+      conversationId = message.conversationId;
+      chronology = createToolChronology();
+      observedUser = false;
+    }
+    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);
+      if (chronology.pending === 0)
+        chronology = createToolChronology();
+      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;
+    }
+    const nextChronology = advanceToolChronology(chronology, message.parts);
+    if (!nextChronology || !canProjectToolChronology(nextChronology)) {
+      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);
+    chronology = nextChronology;
+    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 } from "zod";
+var AgentTokenCountSchema = z.object({
+  value: z.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 event = z.enum(["session.started", "turn.started"]).parse(options.event ?? "turn.started");
+    const rendered = [];
+    let systemTotal = 0;
+    let userTotal = 0;
+    let systemUnavailable = false;
+    let userUnavailable = false;
+    let systemEstimated = false;
+    let userEstimated = false;
+    for (const section of sections) {
+      const role = section.role ?? "system";
+      const text = await section.render({
+        context: options.context,
+        signal: options.signal,
+        event
+      });
+      rendered.push({ name: section.name, stability: section.stability, role, 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 (role === "user") {
+        if (value === undefined)
+          userUnavailable = true;
+        else
+          userTotal += value;
+        if (count.provenance === "estimated")
+          userEstimated = true;
+      } else {
+        if (value === undefined)
+          systemUnavailable = true;
+        else
+          systemTotal += value;
+        if (count.provenance === "estimated")
+          systemEstimated = true;
+      }
+    }
+    const instructionTokens = systemUnavailable ? { provenance: "unavailable" } : { value: systemTotal, provenance: systemEstimated ? "estimated" : "computed" };
+    const userInstructionTokens = userUnavailable ? { provenance: "unavailable" } : { value: userTotal, provenance: userEstimated ? "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.filter((section) => section.role === "system").map((section) => section.text).join(`
+
+`);
+    const userInstructions = rendered.filter((section) => section.role === "user" && section.text.trim().length > 0).map((section) => ({ name: section.name, text: section.text }));
+    return {
+      instructions: options.adaptInstructions ? await options.adaptInstructions(instructionText) : instructionText,
+      sections: rendered,
+      userInstructions,
+      instructionTokens,
+      userInstructionTokens,
+      finalizeSeed: (inserted) => {
+        const seedTokens = inserted ? knownValue(userInstructionTokens) : 0;
+        if (availableHistoryTokens === undefined || seedTokens === undefined)
+          return { contextDecision: "unavailable" };
+        const available = availableHistoryTokens - seedTokens;
+        const history = options.historyTokens ? knownValue(options.historyTokens) : undefined;
+        const decision = history === undefined ? "unavailable" : available < 0 ? "oversized" : history <= available ? "fits" : options.oversizePolicy === "compact" ? "requires-compaction" : "oversized";
+        return { availableHistoryTokens: available, contextDecision: decision };
+      },
+      contextDecision,
+      ...availableHistoryTokens !== undefined && { availableHistoryTokens }
+    };
+  };
+}
+
+// src/agent-runtime/provider-failure.ts
+var BY_STATUS = {
+  402: "insufficient-credits",
+  404: "model-unavailable",
+  408: "timeout",
+  413: "context-overflow",
+  429: "rate-limited"
+};
+var BY_MESSAGE = [
+  [/insufficient|not enough credit|payment required|quota exceeded/i, "insufficient-credits"],
+  [/rate.?limit|too many requests|slow down/i, "rate-limited"],
+  [
+    /no endpoints found|model not found|unknown model|no allowed providers/i,
+    "model-unavailable"
+  ],
+  [/context length|maximum context|too many tokens|prompt is too long/i, "context-overflow"],
+  [/timed? ?out|deadline exceeded|etimedout/i, "timeout"],
+  [/abort|cancell?ed/i, "cancelled"]
+];
+var RETRYABLE = new Set([
+  "rate-limited",
+  "timeout",
+  "insufficient-credits",
+  "stream-cut"
+]);
+
+class AgentProviderStreamCutError extends Error {
+  reason = "stream-cut";
+  constructor(message = "Provider stream ended before a terminal part") {
+    super(message);
+    this.name = "AgentProviderStreamCutError";
+  }
+}
+function statusOf(value) {
+  if (!isRecord(value))
+    return;
+  for (const key of ["statusCode", "status", "code"]) {
+    const candidate = value[key];
+    if (typeof candidate === "number" && candidate >= 400 && candidate < 600)
+      return candidate;
+  }
+  const nested = value.cause ?? value.response ?? value.error;
+  return nested === value ? undefined : statusOf(nested);
+}
+function classifyProviderFailure(error) {
+  if (error instanceof AgentProviderStreamCutError) {
+    return { reason: "stream-cut", retryable: true, evidence: "none" };
+  }
+  const status = statusOf(error);
+  const byStatus = status === undefined ? undefined : BY_STATUS[status];
+  if (byStatus) {
+    return {
+      reason: byStatus,
+      status,
+      retryable: RETRYABLE.has(byStatus),
+      evidence: "status"
+    };
+  }
+  const message = messageOf(error);
+  for (const [pattern, reason] of BY_MESSAGE) {
+    if (pattern.test(message)) {
+      return {
+        reason,
+        ...status !== undefined && { status },
+        retryable: RETRYABLE.has(reason),
+        evidence: "message"
+      };
+    }
+  }
+  return {
+    reason: "unknown",
+    ...status !== undefined && { status },
+    retryable: false,
+    evidence: "none"
+  };
+}
+function isToolResultFailure(output) {
+  const parsed = typeof output === "string" ? parseJson(output) : output;
+  if (!isRecord(parsed))
+    return false;
+  if ("error" in parsed)
+    return true;
+  return isRecord(parsed.value) && "error" in parsed.value;
+}
+function parseJson(value) {
+  try {
+    return JSON.parse(value);
+  } catch {
+    return;
+  }
+}
+
+// src/agent-runtime/retry-policy.ts
+async function recordAgentRetryDecision(input) {
+  const retry = input.failure.retryable && input.attempt < input.policy.maxAttempts;
+  const delayMs = retry ? input.policy.delayMs({ attempt: input.attempt, failure: input.failure }) : 0;
+  if (!Number.isInteger(delayMs) || delayMs < 0) {
+    throw new TypeError("Retry delay must be a non-negative integer");
+  }
+  if (retry) {
+    await input.store.appendEvent({
+      conversationId: input.conversationId,
+      kind: "retry/scheduled",
+      payload: { attempt: input.attempt + 1, delayMs, reason: input.failure.reason }
+    });
+  }
+  return { retry, delayMs };
+}
+
+// src/agent-runtime/state-slots.ts
+import { z as z2 } from "zod";
+function defineStateSlot(input) {
+  if (input.name.length === 0)
+    throw new TypeError("State slot name must not be empty");
+  const version = input.version ?? 1;
+  if (!Number.isInteger(version) || version < 1) {
+    throw new TypeError("State slot version must be a positive integer");
+  }
+  return {
+    name: input.name,
+    version,
+    schema: input.schema,
+    ...input.description && { description: input.description }
+  };
+}
+var StateSetPayloadSchema = z2.object({
+  name: z2.string().min(1),
+  version: z2.int().positive(),
+  value: z2.json(),
+  actor: z2.enum(["agent", "human", "system"])
+}).strict();
+function slotRegistry(definitions) {
+  const result = new Map;
+  for (const definition of definitions) {
+    if (result.has(definition.name))
+      throw new TypeError(`Duplicate state slot: ${definition.name}`);
+    result.set(definition.name, definition);
+  }
+  return result;
+}
+function createAgentStateSlotStore(input) {
+  const definitions = slotRegistry(input.definitions);
+  const set = async (request) => {
+    const definition = definitions.get(request.name);
+    if (!definition)
+      throw new TypeError(`Unknown state slot: ${request.name}`);
+    const value = definition.schema.parse(request.value);
+    const payload = StateSetPayloadSchema.parse({
+      name: definition.name,
+      version: definition.version,
+      value,
+      actor: request.actor
+    });
+    const event = await input.store.appendEvent({
+      conversationId: request.conversationId,
+      kind: "state/set",
+      payload
+    });
+    return {
+      name: definition.name,
+      version: definition.version,
+      value,
+      updatedAt: event.occurredAt,
+      seq: event.seq
+    };
+  };
+  const list = async (conversationId) => {
+    const values = new Map;
+    let cursor = 1;
+    for (;; ) {
+      const page = await input.store.readEvents({
+        conversationId,
+        fromSeq: cursor,
+        limit: 1000
+      });
+      for (const event of page.items) {
+        if (event.kind !== "state/set")
+          continue;
+        const payload = StateSetPayloadSchema.parse(event.payload);
+        const definition = definitions.get(payload.name);
+        if (!definition || definition.version !== payload.version)
+          continue;
+        values.set(payload.name, {
+          name: payload.name,
+          version: payload.version,
+          value: definition.schema.parse(payload.value),
+          updatedAt: event.occurredAt,
+          seq: event.seq
+        });
+      }
+      if (page.nextSeq === undefined)
+        break;
+      cursor = page.nextSeq;
+    }
+    return [...values.values()].sort((left, right) => left.name.localeCompare(right.name));
+  };
+  const get = async (conversationId, name) => (await list(conversationId)).find((value) => value.name === name);
+  return { set, get, list };
+}
+function renderAgentStateSlots(values) {
+  if (values.length === 0)
+    return;
+  return [
+    "Durable conversation state (authoritative; newer than compacted history):",
+    ...values.map((slot) => `${slot.name}: ${JSON.stringify(slot.value)}`)
+  ].join(`
+`);
+}
+var agentGoalStateSlot = defineStateSlot({
+  name: "goal",
+  description: "The durable objective and lifecycle of this conversation.",
+  schema: z2.object({
+    objective: z2.string().min(1),
+    status: z2.enum(["active", "complete", "blocked"])
+  }).strict()
+});
+var agentTodoStateSlot = defineStateSlot({
+  name: "todo",
+  description: "The durable ordered work plan for this conversation.",
+  schema: z2.object({
+    items: z2.array(z2.object({
+      step: z2.string().min(1),
+      status: z2.enum(["pending", "in_progress", "completed"])
+    }).strict())
+  }).strict()
+});
+
+// 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 providerResponseIdentity(id, provider) {
+  return AgentProviderResponseSchema.parse({
+    id,
+    ...typeof provider === "string" && provider.length > 0 ? { provider } : {}
+  });
+}
+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,
+      start: noop,
+      stop: noop,
+      suspend: noop,
+      resume: noop,
+      dispose: noop
+    };
+  }
+  const controller = new AbortController;
+  let timer;
+  let active = false;
+  let suspended = 0;
+  const clear = () => {
+    if (timer !== undefined)
+      clearTimeout(timer);
+    timer = undefined;
+  };
+  const touch = () => {
+    clear();
+    if (!active || suspended > 0 || controller.signal.aborted)
+      return;
+    timer = setTimeout(() => controller.abort("timeout"), timeoutMs);
+  };
+  return {
+    signal: AbortSignal.any([parent, controller.signal]),
+    touch,
+    start() {
+      active = true;
+      touch();
+    },
+    stop() {
+      active = false;
+      clear();
+    },
+    suspend() {
+      suspended += 1;
+      clear();
+    },
+    resume() {
+      suspended = Math.max(0, suspended - 1);
+      touch();
+    },
+    dispose() {
+      active = false;
+      clear();
+    }
+  };
+}
+
+// src/agent-runtime/runtime-control.ts
+async function interruptAgentRun(state, input) {
+  const { store } = state.config;
+  const view = await store.loadRun({
+    conversationId: input.conversationId,
+    runId: input.runId
+  });
+  if (!view)
+    throw new AgentRuntimeConflictError("run lookup");
+  const requested = await 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 state.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: state.now().toISOString()
+    });
+    state.coordinator.stop(input.conversationKey ?? input.conversationId, "user-interrupt");
+  }
+  return requested;
+}
+async function abandonAgentRun(state, input) {
+  if (input.staleOwner !== true) {
+    throw new TypeError("Abandoning a run requires explicit staleOwner evidence");
+  }
+  const releaseAdmission = state.gate.begin();
+  try {
+    const abandoned = await state.config.store.recoverRun({
+      conversationId: input.conversationId,
+      runId: input.runId,
+      expectedRevision: input.expectedRevision,
+      action: "abandon"
+    });
+    if (abandoned.outcome === "applied") {
+      const abandonedRun = findRun(abandoned.snapshot.runs, input.runId);
+      await state.publish({
+        type: "run-state",
+        eventId: agentDurableEventId("run-state", abandonedRun.id, abandoned.snapshot.version),
+        conversationId: abandonedRun.conversationId,
+        runId: abandonedRun.id,
+        snapshotVersion: abandoned.snapshot.version,
+        state: abandonedRun.state,
+        emittedAt: state.now().toISOString()
+      });
+    }
+    return abandoned;
+  } finally {
+    releaseAdmission();
+  }
+}
+async function closeAgentRuntime(state, options) {
+  assertCloseBudgets(options);
+  state.gate.closed = true;
+  const startedAt = performance.now();
+  state.injection?.clear();
+  const stranded = await state.gate.drain(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 state.coordinator.close({
+    ...grace !== undefined && { gracePeriodMs: grace },
+    ...force !== undefined && { forceTimeoutMs: force }
+  });
+  if (stranded === 0)
+    return result;
+  return { settled: false, timedOut: true, remaining: result.remaining + stranded };
+}
+
+// src/agent-runtime/runtime-admission-gate.ts
+var closedError = () => new Error("[stitchkit] agent runtime is closed and admits no further work");
+function refuse() {
+  const error = closedError();
+  const accepted = Promise.reject(error);
+  const result = Promise.reject(error);
+  accepted.catch(() => {
+    return;
+  });
+  result.catch(() => {
+    return;
+  });
+  return { accepted, result };
+}
+function createRuntimeAdmissionGate() {
+  const admissionsInFlight = new Set;
+  const begin = () => {
+    const handoff = Promise.withResolvers();
+    admissionsInFlight.add(handoff);
+    return () => {
+      if (admissionsInFlight.delete(handoff))
+        handoff.resolve();
+    };
+  };
+  const drain = 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;
+  };
+  return { closed: false, begin, drain };
+}
+
+// src/agent-runtime/runtime-recovery.ts
+function resumeAgentRun(state, rawInput) {
+  const { config, coordinator } = state;
+  if (state.gate.closed)
+    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 = state.gate.begin();
+  (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: () => state.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 };
+}
+async function recoverAgentRuns(state, options) {
+  if (state.gate.closed)
+    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 ordered = await collectRecoverable(state, options, pageSize, maxRuns);
+  const outcomes = [];
+  const scheduledRuns = new Map;
+  for (const item of ordered) {
+    if (options.signal?.aborted)
+      break;
+    if (state.gate.closed)
+      break;
+    const releaseAdmission = state.gate.begin();
+    try {
+      outcomes.push(await recoverItem(state, options, item, scheduledRuns));
+    } catch (error) {
+      outcomes.push({
+        conversationId: item.conversationId,
+        runId: item.run.id,
+        outcome: "failed",
+        error
+      });
+    } finally {
+      releaseAdmission();
+    }
+  }
+  return outcomes;
+}
+async function collectRecoverable(state, options, pageSize, maxRuns) {
+  const { store } = state.config;
+  const recoverable = [];
+  let cursor;
+  while (recoverable.length < maxRuns && !options.signal?.aborted && !state.gate.closed) {
+    const page = await 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 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;
+    }));
+  }
+  return ordered;
+}
+async function recoverItem(state, options, item, scheduledRuns) {
+  const { store } = state.config;
+  const active = await 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) {
+    return { conversationId: item.conversationId, runId: item.run.id, outcome: "skipped" };
+  }
+  const decision = await options.decide?.(item) ?? (item.run.state === "queued" ? { action: "resume" } : { action: "skip" });
+  if (state.gate.closed)
+    throw closedError();
+  if (decision.action === "skip") {
+    return { conversationId: item.conversationId, runId: item.run.id, outcome: "skipped" };
+  }
+  if (decision.action === "abandon") {
+    const abandoned = await store.recoverRun({
+      conversationId: item.conversationId,
+      runId: item.run.id,
+      expectedRevision: item.run.revision,
+      action: "abandon"
+    });
+    if (abandoned.outcome !== "applied") {
+      throw new AgentRuntimeConflictError("recovery abandon");
+    }
+    return { conversationId: item.conversationId, runId: item.run.id, outcome: "abandoned" };
+  }
+  if (decision.action === "requeue") {
+    const requeued = await 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 = resumeAgentRun(state, {
+    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);
+  return {
+    conversationId: item.conversationId,
+    runId: item.run.id,
+    outcome: decision.action === "requeue" ? "requeued" : "resumed",
+    result: resumed.result
+  };
+}
+
+// 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-state.ts
+function adoptSnapshot(state, next) {
+  state.snapshot = next;
+  state.observedVersion = next.version;
+  state.run = findRun(next.runs, state.run.id);
+}
+function transientSequence(state) {
+  state.sequence += 1;
+  return state.sequence;
+}
+function billedUsage(state) {
+  return state.abandonedUsage && state.modelUsage ? addUsage(state.abandonedUsage, state.modelUsage) : state.abandonedUsage ?? state.modelUsage;
+}
+function updateReasoning(state, text, metadata) {
+  const { parts } = state;
+  const provider = providerEnvelope(metadata);
+  if (state.reasoningPartIndex === undefined) {
+    state.reasoningPartIndex = parts.length;
+    parts.push(AgentMessagePartSchema.parse({
+      type: "reasoning",
+      text,
+      ...provider && { provider }
+    }));
+    return;
+  }
+  const current = parts[state.reasoningPartIndex];
+  if (current?.type !== "reasoning") {
+    throw new AgentRuntimeConflictError("reasoning accumulator");
+  }
+  parts.splice(state.reasoningPartIndex, 1, AgentMessagePartSchema.parse({
+    ...current,
+    text: current.text + text,
+    ...provider && { provider }
+  }));
+}
+function checkpoint(execution) {
+  const { config, runtimeEpoch, publish, now } = execution.dependencies;
+  const { state } = execution;
+  return execution.serialize(async () => {
+    state.assistant = AgentMessageSchema.parse({
+      ...state.assistant,
+      parts: state.parts,
+      updatedAt: now().toISOString()
+    });
+    const run = state.run;
+    adoptSnapshot(state, appliedSnapshot(await config.store.checkpointRunAssistant({
+      conversationId: run.conversationId,
+      runId: run.id,
+      expectedRevision: run.revision,
+      ownerId: runtimeEpoch,
+      ...run.fencingToken !== undefined && { fencingToken: run.fencingToken },
+      assistant: state.assistant,
+      usage: statedUsage(state.usage)
+    }), "assistant checkpoint"));
+    const checkpointMetrics = {
+      partial: true,
+      durationMs: performance.now() - execution.runStartedAt,
+      usage: statedUsage(state.usage),
+      ...state.firstOutputAt !== undefined && {
+        ttftMs: state.firstOutputAt - execution.runStartedAt
+      }
+    };
+    await publish({
+      type: "assistant-checkpoint",
+      eventId: agentDurableEventId("assistant-checkpoint", state.run.id, state.observedVersion),
+      conversationId: state.run.conversationId,
+      runId: state.run.id,
+      snapshotVersion: state.observedVersion,
+      message: state.assistant,
+      metrics: checkpointMetrics,
+      emittedAt: now().toISOString()
+    });
+  });
+}
+
+// src/agent-runtime/run-mutation-queue.ts
+function createRunMutationQueue() {
+  let tail = Promise.resolve();
+  return (mutation) => {
+    const result = tail.then(mutation, mutation);
+    tail = result.then(() => {
+      return;
+    }, () => {
+      return;
+    });
+    return result;
+  };
+}
+
+// src/agent-runtime/run-operation-lifecycle.ts
+import { wrapLanguageModel } from "ai";
+
+// src/agent-runtime/provider-origin.ts
+import {
+  InvalidToolApprovalError,
+  InvalidToolApprovalSignatureError,
+  ToolCallNotFoundForApprovalError
+} from "ai";
+var providerOrigin = new WeakSet;
+function isOwnInputRefusal(error) {
+  return InvalidToolApprovalSignatureError.isInstance(error) || InvalidToolApprovalError.isInstance(error) || ToolCallNotFoundForApprovalError.isInstance(error);
+}
+function markProviderOrigin(error) {
+  if (typeof error === "object" && error !== null)
+    providerOrigin.add(error);
+  return error;
+}
+function hasProviderOrigin(error) {
+  return typeof error === "object" && error !== null && providerOrigin.has(error);
+}
+
+// src/agent-runtime/run-operation-lifecycle.ts
+function createAgentRunOperationLifecycle(config) {
+  let active;
+  let providerCallId;
+  let checkpointedStep = -1;
+  const checkpointWaiters = new Map;
+  const record = (operation) => config.serialize(async () => {
+    const current = config.currentRun();
+    const snapshot = appliedSnapshot(await config.store.recordRunOperation({
+      conversationId: current.conversationId,
+      runId: current.id,
+      expectedRevision: current.revision,
+      ownerId: config.runtimeEpoch,
+      ...current.fencingToken !== undefined && { fencingToken: current.fencingToken },
+      operation
+    }), "run operation");
+    config.acceptSnapshot(snapshot);
+    const run = findRun(snapshot.runs, current.id);
+    active = operation;
+    await config.publish({
+      type: "run-operation",
+      eventId: agentDurableEventId("run-operation", run.id, snapshot.version),
+      conversationId: run.conversationId,
+      runId: run.id,
+      snapshotVersion: snapshot.version,
+      operation,
+      emittedAt: config.now().toISOString()
+    });
+  });
+  const startModelRequest = async (callId, step) => {
+    await record(AgentRunOperationSchema.parse({
+      operationId: `${callId}:${step}`,
+      kind: "model-request",
+      phase: "started",
+      step,
+      startedAt: config.now().toISOString()
+    }));
+  };
+  return {
+    noteProviderCall(callId) {
+      providerCallId = callId;
+    },
+    async prepareModel(model, step, fallbackCallId) {
+      if (step > checkpointedStep + 1) {
+        const waiter = checkpointWaiters.get(step - 1) ?? Promise.withResolvers();
+        checkpointWaiters.set(step - 1, waiter);
+        await waiter.promise;
+      }
+      if (typeof model === "string") {
+        await startModelRequest(fallbackCallId, step);
+        return model;
+      }
+      return wrapLanguageModel({
+        model,
+        middleware: {
+          specificationVersion: "v4",
+          wrapStream: async ({ doStream }) => {
+            const callId = providerCallId;
+            providerCallId = undefined;
+            if (!callId) {
+              throw new Error("AgentRuntime model call reached the provider without lifecycle identity");
+            }
+            await startModelRequest(callId, step);
+            try {
+              return await doStream();
+            } catch (error) {
+              throw isOwnInputRefusal(error) ? error : markProviderOrigin(error);
+            }
+          }
+        }
+      });
+    },
+    checkpointStep(step) {
+      checkpointedStep = Math.max(checkpointedStep, step);
+      for (const [waitingFor, waiter] of checkpointWaiters) {
+        if (waitingFor > checkpointedStep)
+          continue;
+        checkpointWaiters.delete(waitingFor);
+        waiter.resolve();
+      }
+    },
+    failStepCheckpoints(error) {
+      for (const waiter of checkpointWaiters.values())
+        waiter.reject(error);
+      checkpointWaiters.clear();
+    },
+    startCompaction(operationId) {
+      return record(AgentRunOperationSchema.parse({
+        operationId,
+        kind: "compaction",
+        phase: "started",
+        startedAt: config.now().toISOString()
+      }));
+    },
+    firstOutput() {
+      if (active?.kind !== "model-request" || active.phase !== "started") {
+        return Promise.resolve();
+      }
+      return record(AgentRunOperationSchema.parse({
+        ...active,
+        phase: "first-output",
+        firstOutputAt: config.now().toISOString()
+      }));
+    },
+    finish(phase) {
+      if (!active || ["completed", "failed", "cancelled"].includes(active.phase)) {
+        return Promise.resolve();
+      }
+      return record(AgentRunOperationSchema.parse({
+        ...active,
+        phase,
+        finishedAt: config.now().toISOString()
+      }));
+    }
+  };
+}
+
+// src/agent-runtime/run-acquisition.ts
+async function acquireRun(dependencies, input) {
+  const { config, publish, runtimeEpoch, generateId, now, idleTimeoutMs, injection } = dependencies;
+  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 {
+      kind: "absorbed",
+      result: {
+        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()
+  });
+  const 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()
+  });
+  const 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);
+  const state = {
+    run,
+    snapshot,
+    observedVersion: snapshot.version,
+    assistant,
+    parts: [],
+    absorbed: new Map,
+    eventsSinceCheckpoint: 0,
+    sequence: 0,
+    terminalReason: "success",
+    nonModelUsage: input.acceptedRun.usage,
+    modelUsage: undefined,
+    abandonedUsage: undefined,
+    usage: input.acceptedRun.usage,
+    sawProviderFinish: false,
+    step: 0,
+    selectedModel: undefined,
+    internalCause: undefined,
+    providerStreamCleanupFailure: undefined,
+    reasoningPartIndex: undefined,
+    firstOutputAt: undefined,
+    terminalPolicyName: undefined,
+    lastPromptTokens: { provenance: "unavailable" }
+  };
+  const idleDeadline = createIdleDeadline(input.signal, idleTimeoutMs);
+  const serialize = createRunMutationQueue();
+  const operationLifecycle = createAgentRunOperationLifecycle({
+    store: config.store,
+    runtimeEpoch,
+    serialize,
+    currentRun: () => state.run,
+    acceptSnapshot: (next) => adoptSnapshot(state, next),
+    publish,
+    now
+  });
+  return {
+    kind: "acquired",
+    execution: {
+      dependencies,
+      input,
+      state,
+      trace,
+      runStartedAt,
+      idleDeadline,
+      executionSignal: idleDeadline.signal,
+      serialize,
+      operationLifecycle
+    }
+  };
+}
+
+// src/agent-runtime/run-failure.ts
+function failureThisRuntimeOwns(error) {
+  if (error instanceof AgentContextOverflowError)
+    return "context_overflow";
+  if (error instanceof AgentRuntimeConflictError)
+    return "storage_conflict";
+  if (isOwnInputRefusal(error))
+    return "runtime_failure";
+  return;
+}
+async function classifyRunFailure(execution, error) {
+  const { config, runtimeEpoch } = execution.dependencies;
+  const { state, operationLifecycle, executionSignal } = execution;
+  operationLifecycle.failStepCheckpoints(error);
+  const cleanupFailure = state.providerStreamCleanupFailure;
+  state.internalCause = cleanupFailure === undefined ? error : new AggregateError([error, cleanupFailure], `${error instanceof Error ? error.message : String(error)} (provider stream cleanup also failed: ${cleanupFailure instanceof Error ? cleanupFailure.message : String(cleanupFailure)})`);
+  const latest = await config.store.loadRun({
+    conversationId: state.run.conversationId,
+    runId: state.run.id
+  });
+  const latestRun = latest?.run;
+  const durableInterrupt = latestRun?.ownerId === runtimeEpoch && latestRun.state === "interrupt_requested";
+  if (durableInterrupt && latest && latestRun) {
+    state.observedVersion = latest.snapshotVersion;
+    state.run = latestRun;
+  }
+  const staleOwner = isToolExecutionControlError(error) && error.reason === "stale_run";
+  if (!staleOwner) {
+    await operationLifecycle.finish(executionSignal.aborted || durableInterrupt ? "cancelled" : "failed");
+  }
+  if (isToolExecutionControlError(error) || executionSignal.aborted || durableInterrupt) {
+    state.terminalReason = executionSignal.aborted ? abortTerminalReason(executionSignal) : "interrupted";
+    state.parts.push(AgentMessagePartSchema.parse({
+      type: "control",
+      reason: isToolExecutionControlError(error) && error.reason === "stale_run" ? "stale-run" : "run-interrupted"
+    }));
+  } else if (error instanceof AgentContextOverflowError) {
+    state.terminalReason = "context_overflow";
+  } else if (error instanceof AgentRuntimeConflictError) {
+    state.terminalReason = "storage_conflict";
+  } else {
+    state.terminalReason = failureThisRuntimeOwns(error) ?? (hasProviderOrigin(error) ? "provider_failure" : "runtime_failure");
+  }
+}
+
+// src/agent-runtime/run-model-attempts.ts
+import { setTimeout as delay } from "node:timers/promises";
+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/owned-provider-stream.ts
+var DEFAULT_CLEANUP_TIMEOUT_MS = 1000;
+async function settleCleanup(operation, timeoutMs) {
+  let timeout;
+  const deadline = new Promise((_resolve, reject) => {
+    timeout = setTimeout(() => reject(new Error(`Provider stream cleanup exceeded ${timeoutMs} ms`)), timeoutMs);
+  });
+  try {
+    await Promise.race([operation, deadline]);
+  } finally {
+    if (timeout !== undefined)
+      clearTimeout(timeout);
+  }
+}
+async function* ownedProviderStream(input) {
+  const iterator = input.stream[Symbol.asyncIterator]();
+  let completed = false;
+  try {
+    for (;; ) {
+      const next = await iterator.next();
+      if (next.done) {
+        completed = true;
+        return;
+      }
+      yield next.value;
+    }
+  } finally {
+    if (!completed) {
+      input.abort();
+      const cleanup = iterator.return?.();
+      if (cleanup) {
+        try {
+          await settleCleanup(cleanup, input.cleanupTimeoutMs ?? DEFAULT_CLEANUP_TIMEOUT_MS);
+        } catch (error) {
+          input.onCleanupFailure(error);
+        }
+      }
+    }
+  }
+}
+
+// src/agent-runtime/run-provider-ledger.ts
+import { createHash } from "node:crypto";
+function withoutBinaryParts(message) {
+  const reference = (value) => {
+    if (value instanceof Uint8Array || value instanceof ArrayBuffer) {
+      const bytes = value instanceof ArrayBuffer ? new Uint8Array(value) : value;
+      return {
+        binary: true,
+        sha256: createHash("sha256").update(bytes).digest("hex"),
+        bytes: bytes.byteLength
+      };
+    }
+    if (value instanceof URL)
+      return value.toString();
+    if (Array.isArray(value))
+      return value.map(reference);
+    if (value && typeof value === "object") {
+      return Object.fromEntries(Object.entries(value).map(([key, entry]) => [
+        key,
+        reference(entry)
+      ]));
+    }
+    return value;
+  };
+  return reference(message);
+}
+async function createRunProviderLedger(input) {
+  const { store, state } = input;
+  const requestModelId = input.selectedModel.descriptor.modelId;
+  const knownMessageShas = new Set;
+  {
+    let fromSeq;
+    do {
+      const page = await store.readEvents({
+        conversationId: state.run.conversationId,
+        ...fromSeq && { fromSeq },
+        limit: 1e4
+      });
+      for (const event of page.items) {
+        if (event.kind !== "provider/message")
+          continue;
+        const sha = event.payload?.sha256;
+        if (typeof sha === "string")
+          knownMessageShas.add(sha);
+      }
+      fromSeq = page.nextSeq;
+    } while (fromSeq !== undefined);
+  }
+  return {
+    async recordRequest(request) {
+      const messageShas = [];
+      for (const message of request.messages) {
+        const body = canonicalAgentJson(JSON.parse(JSON.stringify(withoutBinaryParts(message))));
+        const sha256 = createHash("sha256").update(body).digest("hex");
+        messageShas.push(sha256);
+        if (knownMessageShas.has(sha256))
+          continue;
+        await store.appendEvent({
+          conversationId: state.run.conversationId,
+          kind: "provider/message",
+          payload: { sha256, message: JSON.parse(body) }
+        });
+        knownMessageShas.add(sha256);
+      }
+      const instructionsSha256 = createHash("sha256").update(typeof request.instructions === "string" ? request.instructions : canonicalAgentJson(JSON.parse(JSON.stringify(withoutBinaryParts(request.instructions))))).digest("hex");
+      const bodySha256 = createHash("sha256").update(instructionsSha256).update(messageShas.join(",")).digest("hex");
+      await store.appendEvent({
+        conversationId: state.run.conversationId,
+        kind: "provider/request",
+        payload: {
+          runId: state.run.id,
+          attempt: request.attempt,
+          stepNumber: request.stepNumber,
+          modelId: requestModelId,
+          instructionsSha256,
+          messageShas,
+          bodySha256
+        }
+      });
+    },
+    async recordResponse(response) {
+      const identity = providerResponseIdentity(response.id, state.selectedModel?.resolveResponseProvider?.({
+        providerMetadata: response.providerMetadata
+      }));
+      await store.appendEvent({
+        conversationId: state.run.conversationId,
+        kind: "provider/response",
+        payload: {
+          runId: state.run.id,
+          attempt: response.attempt,
+          stepNumber: response.stepNumber,
+          response: identity
+        }
+      });
+      return identity;
+    }
+  };
+}
+
+// src/agent-runtime/run-stream-parts.ts
+function transientHead(execution) {
+  const { state } = execution;
+  return {
+    conversationId: state.run.conversationId,
+    runId: state.run.id,
+    runtimeEpoch: execution.dependencies.runtimeEpoch,
+    sequence: transientSequence(state)
+  };
+}
+function isOutputPart(part) {
+  return part.type === "text-delta" && part.text.length > 0 || part.type === "reasoning-delta" && part.text.length > 0 || part.type === "tool-input-delta" && part.delta.length > 0 || part.type === "tool-call";
+}
+var STRUCTURAL_BOUNDARY_PARTS = [
+  "tool-call",
+  "tool-result",
+  "tool-error",
+  "tool-output-denied",
+  "tool-approval-request",
+  "tool-approval-response",
+  "finish-step"
+];
+async function applyTextPart(execution, part) {
+  const { publish, now } = execution.dependencies;
+  const { state } = execution;
+  if (part.type === "text-delta") {
+    appendText(state.parts, part.text);
+    await publish({
+      type: "assistant-delta",
+      ...transientHead(execution),
+      textDelta: part.text,
+      emittedAt: now().toISOString()
+    });
+  } else if (part.type === "reasoning-start") {
+    state.reasoningPartIndex = undefined;
+    updateReasoning(state, "", part.providerMetadata);
+    const provider = providerEnvelope(part.providerMetadata);
+    await publish({
+      type: "reasoning-start",
+      ...transientHead(execution),
+      ...provider && { provider },
+      emittedAt: now().toISOString()
+    });
+  } else if (part.type === "reasoning-delta") {
+    updateReasoning(state, part.text, part.providerMetadata);
+    const provider = providerEnvelope(part.providerMetadata);
+    await publish({
+      type: "reasoning-delta",
+      ...transientHead(execution),
+      textDelta: part.text,
+      ...provider && { provider },
+      emittedAt: now().toISOString()
+    });
+  } else if (part.type === "reasoning-end") {
+    updateReasoning(state, "", part.providerMetadata);
+    state.reasoningPartIndex = undefined;
+    const provider = providerEnvelope(part.providerMetadata);
+    await publish({
+      type: "reasoning-end",
+      ...transientHead(execution),
+      ...provider && { provider },
+      emittedAt: now().toISOString()
+    });
+  }
+}
+async function applyToolPart(execution, part) {
+  const { publish, now } = execution.dependencies;
+  const { state } = execution;
+  if (part.type === "tool-call") {
+    const provider = providerEnvelope(part.providerMetadata);
+    state.parts.push(AgentMessagePartSchema.parse({
+      type: "tool-call",
+      callId: part.toolCallId,
+      toolName: part.toolName,
+      input: jsonValue(part.input),
+      ...provider && { provider }
+    }));
+    await publish({
+      type: "tool-status",
+      ...transientHead(execution),
+      callId: part.toolCallId,
+      toolName: part.toolName,
+      status: "started",
+      input: jsonValue(part.input),
+      emittedAt: now().toISOString()
+    });
+  } else if (part.type === "tool-result") {
+    state.parts.push(AgentMessagePartSchema.parse({
+      type: "tool-result",
+      callId: part.toolCallId,
+      toolName: part.toolName,
+      outcome: "success",
+      output: jsonValue(part.output)
+    }));
+    await publish({
+      type: "tool-status",
+      ...transientHead(execution),
+      callId: part.toolCallId,
+      toolName: part.toolName,
+      status: "completed",
+      output: jsonValue(part.output),
+      emittedAt: now().toISOString()
+    });
+  } else if (part.type === "tool-error") {
+    state.internalCause = part.error;
+    if (isToolExecutionControlError(part.error)) {
+      await publish({
+        type: "tool-status",
+        ...transientHead(execution),
+        callId: part.toolCallId,
+        toolName: part.toolName,
+        status: "interrupted",
+        emittedAt: now().toISOString()
+      });
+      await checkpoint(execution);
+      throw part.error;
+    }
+    const output = isAgentToolError(part.error) ? jsonValue(part.error.output) : { message: "Tool execution failed" };
+    state.parts.push(AgentMessagePartSchema.parse({
+      type: "tool-result",
+      callId: part.toolCallId,
+      toolName: part.toolName,
+      outcome: "error",
+      output
+    }));
+    await publish({
+      type: "tool-status",
+      ...transientHead(execution),
+      callId: part.toolCallId,
+      toolName: part.toolName,
+      status: "failed",
+      output,
+      emittedAt: now().toISOString()
+    });
+  } else if (part.type === "tool-output-denied") {
+    state.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",
+      ...transientHead(execution),
+      callId: part.toolCallId,
+      toolName: part.toolName,
+      status: "failed",
+      output: { message: "Tool output denied" },
+      emittedAt: now().toISOString()
+    });
+  }
+}
+async function applyRecordedPart(execution, part) {
+  const { config } = execution.dependencies;
+  const { parts } = execution.state;
+  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) }
+      }
+    }));
+  }
+}
+async function applyFinishStep(execution, scope, part) {
+  if (part.type !== "finish-step")
+    return;
+  const { config, generateId, now } = execution.dependencies;
+  const { state, trace } = execution;
+  const response = await scope.ledger.recordResponse({
+    id: part.response.id,
+    providerMetadata: part.providerMetadata,
+    stepNumber: state.step,
+    attempt: scope.providerAttempt
+  });
+  await execution.operationLifecycle.finish(part.finishReason === "error" ? "failed" : "completed");
+  const stepTrace = trace ? config.observe?.rootTrace(trace) : undefined;
+  const stepUsage = scope.selectedModel.normalizeUsage?.({
+    usage: part.usage,
+    providerMetadata: part.providerMetadata
+  }) ?? normalizeSdkUsage(part.usage);
+  state.lastPromptTokens = stepUsage.inputTokens;
+  state.modelUsage = addUsage(state.modelUsage, stepUsage);
+  state.usage = state.nonModelUsage ? addUsage(state.nonModelUsage, billedUsage(state) ?? state.modelUsage) : billedUsage(state);
+  config.observe?.emit({
+    schemaVersion: 1,
+    eventId: generateId(),
+    type: "step-finished",
+    conversationId: state.run.conversationId,
+    runId: state.run.id,
+    traceId: stepTrace?.traceId ?? trace?.traceId ?? generateId(),
+    spanId: stepTrace?.spanId ?? generateId(),
+    ...stepTrace?.parentSpanId && { parentSpanId: stepTrace.parentSpanId },
+    state: state.run.state,
+    modelId: scope.selectedModel.descriptor.modelId,
+    step: state.step,
+    usage: stepUsage,
+    response,
+    emittedAt: now().toISOString()
+  });
+  state.step += 1;
+}
+async function applyStreamPart(execution, scope, part) {
+  const { state } = execution;
+  switch (part.type) {
+    case "text-delta":
+    case "reasoning-start":
+    case "reasoning-delta":
+    case "reasoning-end":
+      await applyTextPart(execution, part);
+      break;
+    case "tool-call":
+    case "tool-result":
+    case "tool-error":
+    case "tool-output-denied":
+      await applyToolPart(execution, part);
+      break;
+    case "source":
+    case "file":
+    case "reasoning-file":
+    case "tool-approval-request":
+    case "tool-approval-response":
+    case "custom":
+    case "raw":
+      await applyRecordedPart(execution, part);
+      break;
+    case "abort":
+      state.terminalReason = "interrupted";
+      break;
+    case "error":
+      state.terminalReason = failureThisRuntimeOwns(part.error) ?? "provider_failure";
+      state.internalCause = part.error;
+      break;
+    case "finish-step":
+      await applyFinishStep(execution, scope, part);
+      break;
+    case "finish":
+      if (part.finishReason !== "stop") {
+        if (state.terminalReason === "success") {
+          state.terminalReason = part.finishReason === "error" ? "provider_failure" : "provider_stop";
+          state.internalCause ??= { finishReason: part.finishReason };
+        }
+      }
+      state.sawProviderFinish = true;
+      state.modelUsage = mergeModelTotals(normalizeSdkUsage(part.totalUsage), state.modelUsage);
+      state.usage = state.nonModelUsage ? addUsage(state.nonModelUsage, billedUsage(state) ?? state.modelUsage) : billedUsage(state);
+      break;
+  }
+}
+
+// src/agent-runtime/run-model-attempts.ts
+function createStopConditions(execution) {
+  const { config, maxSteps } = execution.dependencies;
+  const { state } = execution;
+  const maxStepCondition = stepCountIs(maxSteps);
+  const stopConditions = [
+    async (options) => {
+      const stopped = await maxStepCondition(options);
+      if (stopped && state.terminalPolicyName === undefined)
+        state.terminalPolicyName = "max-steps";
+      return stopped;
+    }
+  ];
+  for (const policy of config.loop?.stopPolicies ?? []) {
+    stopConditions.push(async (options) => {
+      const stopped = await policy.when(options);
+      if (stopped && state.terminalPolicyName === undefined)
+        state.terminalPolicyName = policy.name;
+      return stopped;
+    });
+  }
+  return stopConditions;
+}
+async function takeInjectedMessages(context) {
+  const { execution, turn, loop } = context;
+  const { state } = execution;
+  const taken = execution.dependencies.injection?.take(execution.input.key, state.run.id) ?? [];
+  if (taken.length === 0)
+    return [];
+  loop.takenThisAttempt.push(...taken);
+  const messages = [];
+  for (const entry of taken) {
+    messages.push(...await turn.projection.projectInputs([entry.input]));
+    const ids = state.absorbed.get(entry.runId) ?? [];
+    ids.push(entry.input.id);
+    state.absorbed.set(entry.runId, ids);
+  }
+  return messages;
+}
+async function prepareAttemptStep(context, attempt, options) {
+  const { execution, turn, loop, ledger } = context;
+  const { config, generateId } = execution.dependencies;
+  const { state } = execution;
+  const previousStep = options.steps.at(-1);
+  if (previousStep) {
+    state.lastPromptTokens = state.selectedModel?.normalizeUsage?.({
+      usage: previousStep.usage,
+      providerMetadata: previousStep.providerMetadata
+    })?.inputTokens ?? normalizeSdkUsage(previousStep.usage).inputTokens;
+  }
+  const prepared = await config.loop?.prepareStep?.({
+    ...options,
+    ...turn.runtimeContext
+  });
+  const injected = await takeInjectedMessages(context);
+  const preparedStep = injected.length === 0 ? prepared : {
+    ...prepared,
+    messages: [...prepared?.messages ?? options.messages, ...injected]
+  };
+  const providerMessages = preparedStep?.messages ?? options.messages;
+  const model = await execution.operationLifecycle.prepareModel(preparedStep?.model ?? turn.selectedModel.model, options.stepNumber, generateId());
+  const override = preparedStep;
+  if (override?.instructions !== undefined)
+    loop.instructionsOverride = override.instructions;
+  else if (override?.system !== undefined)
+    loop.instructionsOverride = override.system;
+  await ledger.recordRequest({
+    stepNumber: options.stepNumber,
+    attempt: attempt.providerAttempt,
+    instructions: loop.instructionsOverride ?? turn.projection.withCarriedSystem(turn.prompt.instructions),
+    messages: providerMessages
+  });
+  return { ...preparedStep, model };
+}
+function startAttemptStream(context, attempt, stopConditions) {
+  const { execution, turn } = context;
+  const { config } = execution.dependencies;
+  const { state, idleDeadline, operationLifecycle } = execution;
+  const { tools } = turn;
+  const attemptSignal = AbortSignal.any([
+    execution.executionSignal,
+    attempt.attemptAbort.signal
+  ]);
+  return streamAgentTextBoundary({
+    model: turn.selectedModel.model,
+    tools,
+    ...config.durability && {
+      toolsContext: Object.fromEntries(Object.keys(tools).map((toolName) => [
+        toolName,
+        createToolDurabilityContext((toolCallId, signal) => {
+          const port = config.durability;
+          if (typeof port === "function")
+            return port({
+              store: config.store,
+              conversationId: state.run.conversationId,
+              runId: state.run.id,
+              toolName,
+              toolCallId,
+              signal
+            });
+          return createLocalStepDurability({
+            store: config.store,
+            conversationId: state.run.conversationId,
+            runId: JSON.stringify([state.run.id, toolName, toolCallId]),
+            signal
+          });
+        })
+      ]))
+    },
+    instructions: turn.projection.withCarriedSystem(turn.prompt.instructions),
+    messages: turn.history,
+    abortSignal: attemptSignal,
+    maxRetries: 0,
+    stopWhen: stopConditions,
+    onLanguageModelCallStart: (event) => {
+      idleDeadline.start();
+      operationLifecycle.noteProviderCall(event.callId);
+    },
+    onLanguageModelCallEnd: () => idleDeadline.stop(),
+    onToolExecutionStart: () => idleDeadline.suspend(),
+    onToolExecutionEnd: () => idleDeadline.resume(),
+    repairToolCall: deferredToolRepair(config.loop?.prepareStep),
+    ...config.loop?.toolApproval && {
+      toolApproval: config.loop.toolApproval,
+      runtimeContext: execution.input.context
+    },
+    ...config.loop?.toolApprovalSecret && {
+      experimental_toolApprovalSecret: config.loop.toolApprovalSecret
+    },
+    prepareStep: (options) => prepareAttemptStep(context, attempt, options)
+  });
+}
+async function drainAbandonedPart(context, attempt, part) {
+  if (part.type !== "finish-step")
+    return;
+  const { state } = context.execution;
+  await context.ledger.recordResponse({
+    id: part.response.id,
+    providerMetadata: part.providerMetadata,
+    stepNumber: state.step,
+    attempt: attempt.providerAttempt
+  });
+  const failedStepUsage = context.turn.selectedModel.normalizeUsage?.({
+    usage: part.usage,
+    providerMetadata: part.providerMetadata
+  }) ?? normalizeSdkUsage(part.usage);
+  state.abandonedUsage = state.abandonedUsage ? addUsage(state.abandonedUsage, failedStepUsage) : failedStepUsage;
+  const billed = billedUsage(state);
+  state.usage = state.nonModelUsage && billed ? addUsage(state.nonModelUsage, billed) : billed ?? state.nonModelUsage;
+}
+async function retryAfterProviderError(context, attempt, error) {
+  const { execution, loop } = context;
+  const { config, injection } = execution.dependencies;
+  const { state, executionSignal } = execution;
+  const retry = config.loop?.retry;
+  if (!retry || failureThisRuntimeOwns(error) !== undefined)
+    return false;
+  const invokedTool = state.parts.slice(attempt.attemptPartStart).some((candidate) => candidate.type === "tool-call");
+  const decision = invokedTool ? { retry: false, delayMs: 0 } : await recordAgentRetryDecision({
+    store: config.store,
+    conversationId: state.run.conversationId,
+    attempt: loop.retryAttempt,
+    failure: classifyProviderFailure(error),
+    policy: retry
+  });
+  if (!decision.retry)
+    return false;
+  await execution.operationLifecycle.finish("failed");
+  state.parts.splice(attempt.attemptPartStart);
+  for (const entry of loop.takenThisAttempt) {
+    injection?.offer(execution.input.key, entry);
+    const ids = state.absorbed.get(entry.runId);
+    if (ids) {
+      const kept = ids.filter((id) => id !== entry.input.id);
+      if (kept.length === 0)
+        state.absorbed.delete(entry.runId);
+      else
+        state.absorbed.set(entry.runId, kept);
+    }
+  }
+  loop.takenThisAttempt = [];
+  await checkpoint(execution);
+  state.eventsSinceCheckpoint = 0;
+  if (decision.delayMs > 0) {
+    await delay(decision.delayMs, undefined, { signal: executionSignal });
+  }
+  loop.retryAttempt += 1;
+  await config.store.appendEvent({
+    conversationId: state.run.conversationId,
+    kind: "retry/started",
+    payload: { attempt: loop.retryAttempt }
+  });
+  attempt.retrying = true;
+  attempt.draining = true;
+  return true;
+}
+async function consumeAttempt(context, attempt, stream) {
+  const { execution, turn, ledger } = context;
+  const { checkpointEveryEvents } = execution.dependencies;
+  const { state, idleDeadline, operationLifecycle } = execution;
+  const scope = {
+    selectedModel: turn.selectedModel,
+    ledger,
+    providerAttempt: attempt.providerAttempt
+  };
+  for await (const part of ownedProviderStream({
+    stream,
+    abort: () => attempt.attemptAbort.abort(new Error("Agent runtime released provider stream")),
+    onCleanupFailure: (error) => {
+      state.providerStreamCleanupFailure = error;
+    }
+  })) {
+    idleDeadline.touch();
+    if (attempt.draining) {
+      await drainAbandonedPart(context, attempt, part);
+      continue;
+    }
+    state.eventsSinceCheckpoint += 1;
+    if (part.type === "error" && await retryAfterProviderError(context, attempt, part.error)) {
+      continue;
+    }
+    if (isOutputPart(part)) {
+      if (state.firstOutputAt === undefined)
+        state.firstOutputAt = performance.now();
+      await operationLifecycle.firstOutput();
+    }
+    await applyStreamPart(execution, scope, part);
+    const structuralBoundary = STRUCTURAL_BOUNDARY_PARTS.includes(part.type);
+    if (structuralBoundary || state.eventsSinceCheckpoint >= checkpointEveryEvents) {
+      await checkpoint(execution);
+      state.eventsSinceCheckpoint = 0;
+      if (part.type === "finish-step")
+        operationLifecycle.checkpointStep(state.step - 1);
+    }
+  }
+}
+async function runModelAttempts(execution, turn) {
+  const { config, publish, now } = execution.dependencies;
+  const { state } = execution;
+  const stopConditions = createStopConditions(execution);
+  const loop = {
+    retryAttempt: 1,
+    takenThisAttempt: [],
+    instructionsOverride: undefined
+  };
+  const ledger = await createRunProviderLedger({
+    store: config.store,
+    state,
+    selectedModel: turn.selectedModel
+  });
+  const context = { execution, turn, loop, ledger };
+  for (;; ) {
+    const attempt = {
+      providerAttempt: loop.retryAttempt,
+      attemptPartStart: state.parts.length,
+      retrying: false,
+      draining: false,
+      attemptAbort: new AbortController
+    };
+    const result = startAttemptStream(context, attempt, stopConditions);
+    await consumeAttempt(context, attempt, result.stream);
+    if (!attempt.retrying)
+      break;
+    await publish({
+      type: "attempt-reset",
+      conversationId: state.run.conversationId,
+      runId: state.run.id,
+      runtimeEpoch: execution.dependencies.runtimeEpoch,
+      sequence: transientSequence(state),
+      attempt: loop.retryAttempt,
+      emittedAt: now().toISOString()
+    });
+  }
+}
+
+// src/agent-runtime/run-terminal.ts
+async function settleStreamOutcome(execution) {
+  const { config, now } = execution.dependencies;
+  const { state, executionSignal } = execution;
+  await execution.operationLifecycle.finish(executionSignal.aborted ? "cancelled" : state.terminalReason === "provider_failure" ? "failed" : "completed");
+  if (state.terminalPolicyName !== undefined)
+    state.terminalReason = "policy_stop";
+  if (executionSignal.aborted)
+    state.terminalReason = abortTerminalReason(executionSignal);
+  const awaitsApproval = state.parts.some((part) => part.type === "tool-approval-request");
+  if (!awaitsApproval && config.protocol.acceptTerminal && (state.terminalReason === "success" || state.terminalReason === "policy_stop" || state.terminalReason === "provider_stop")) {
+    const candidate = AgentMessageSchema.parse({
+      ...state.assistant,
+      status: assistantStatus(state.terminalReason),
+      parts: state.parts,
+      updatedAt: now().toISOString()
+    });
+    if (!await config.protocol.acceptTerminal({
+      message: candidate,
+      reason: state.terminalReason,
+      ...state.terminalPolicyName && { policyName: state.terminalPolicyName }
+    })) {
+      state.terminalReason = "output_rejected";
+      state.internalCause = new Error("Agent terminal output was rejected by the protocol");
+    }
+  }
+}
+function emitSpend(execution, report) {
+  const { config, generateId, now } = execution.dependencies;
+  const { state, trace, runStartedAt } = execution;
+  config.observe?.emit({
+    schemaVersion: 1,
+    eventId: report.eventId,
+    type: "run-terminal",
+    conversationId: state.run.conversationId,
+    runId: state.run.id,
+    traceId: trace?.traceId ?? generateId(),
+    spanId: trace?.spanId ?? generateId(),
+    ...trace?.parentSpanId && { parentSpanId: trace.parentSpanId },
+    state: report.state,
+    terminalReason: report.reason,
+    ...state.selectedModel && { modelId: state.selectedModel.descriptor.modelId },
+    durationMs: performance.now() - runStartedAt,
+    usage: report.usage,
+    ...state.internalCause !== undefined && { internalCause: state.internalCause },
+    ...state.firstOutputAt !== undefined && { ttftMs: state.firstOutputAt - runStartedAt },
+    emittedAt: now().toISOString()
+  });
+}
+async function stopChildrenAfterExplicitStop(execution, committedByCaller) {
+  const { config } = execution.dependencies;
+  const { state } = execution;
+  if (config.children && committedByCaller && (state.terminalReason === "interrupted" || state.terminalReason === "cancelled" || state.terminalReason === "timeout" || state.terminalReason === "shutdown")) {
+    try {
+      await config.children.stopChildren(state.run.conversationId);
+    } catch (error) {
+      state.internalCause ??= error;
+    }
+  }
+}
+async function commitRunTerminal(execution) {
+  const { config, publish, runtimeEpoch, now } = execution.dependencies;
+  const { state, runStartedAt } = execution;
+  state.assistant = AgentMessageSchema.parse({
+    ...state.assistant,
+    status: assistantStatus(state.terminalReason),
+    parts: state.parts,
+    updatedAt: now().toISOString()
+  });
+  const spent = statedUsage(state.usage);
+  const unsettledEventId = (version) => agentDurableEventId("terminal", `${state.run.id}:${runtimeEpoch}`, version);
+  let terminal;
+  try {
+    terminal = await commitAgentRunTerminal({
+      store: config.store,
+      runtimeEpoch,
+      candidate: {
+        run: state.run,
+        assistant: state.assistant,
+        reason: state.terminalReason,
+        ...state.terminalPolicyName && { policyName: state.terminalPolicyName },
+        usage: spent,
+        ...state.absorbed.size > 0 && runStateForTerminalReason(state.terminalReason) === "completed" && {
+          absorb: [...state.absorbed].map(([runId, inputMessageIds]) => ({
+            runId,
+            inputMessageIds
+          }))
+        }
+      },
+      now
+    });
+  } catch (error) {
+    emitSpend(execution, {
+      eventId: unsettledEventId(state.observedVersion),
+      state: state.run.state,
+      reason: state.terminalReason,
+      usage: spent
+    });
+    throw error;
+  }
+  state.observedVersion = terminal.snapshotVersion;
+  state.run = terminal.run;
+  state.assistant = terminal.assistant;
+  state.terminalReason = terminal.reason;
+  state.terminalPolicyName = terminal.policyName;
+  const terminalMetrics = terminal.committedByCaller ? {
+    partial: !state.sawProviderFinish,
+    durationMs: performance.now() - runStartedAt,
+    usage: spent,
+    ...state.firstOutputAt !== undefined && {
+      ttftMs: state.firstOutputAt - runStartedAt
+    }
+  } : undefined;
+  await stopChildrenAfterExplicitStop(execution, terminal.committedByCaller);
+  emitSpend(execution, {
+    eventId: terminal.committedByCaller ? agentDurableEventId("terminal", state.run.id, state.observedVersion) : unsettledEventId(state.observedVersion),
+    state: state.run.state,
+    reason: state.terminalReason,
+    usage: spent
+  });
+  for (const settled of terminal.absorbed ?? []) {
+    await publish({
+      type: "run-state",
+      eventId: agentDurableEventId("run-state", settled.id, state.observedVersion),
+      conversationId: settled.conversationId,
+      runId: settled.id,
+      snapshotVersion: state.observedVersion,
+      state: settled.state,
+      emittedAt: now().toISOString()
+    });
+  }
+  if (terminalMetrics) {
+    await publish({
+      type: "terminal",
+      eventId: agentDurableEventId("terminal", state.run.id, state.observedVersion),
+      conversationId: state.run.conversationId,
+      runId: state.run.id,
+      snapshotVersion: state.observedVersion,
+      reason: state.terminalReason,
+      ...state.terminalPolicyName && { policyName: state.terminalPolicyName },
+      message: state.assistant,
+      metrics: terminalMetrics,
+      emittedAt: now().toISOString()
+    });
+  }
+  return {
+    run: state.run,
+    message: state.assistant,
+    reason: state.terminalReason,
+    snapshotVersion: state.observedVersion,
+    ...terminalMetrics && { metrics: terminalMetrics },
+    ...state.terminalPolicyName && { policyName: state.terminalPolicyName }
+  };
+}
+
+// src/agent-runtime/run-prompt-history.ts
+import { createHash as createHash2 } from "node:crypto";
+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))
+  });
+}
+var USER_INSTRUCTION_SEED_KEY = "prompt.user-instructions";
+function seededInstructionMessage(input) {
+  return AgentMessageSchema.parse({
+    schemaVersion: 1,
+    id: createHash2("sha256").update(`${input.conversationId}\x00${input.seedKey}\x00${input.index}`).digest("hex"),
+    conversationId: input.conversationId,
+    role: "user",
+    status: "committed",
+    parts: [{ type: "text", text: input.text }],
+    createdAt: input.createdAt,
+    updatedAt: input.createdAt
+  });
+}
+async function loadDurableSystem(config, conversationId) {
+  if (config.stateSlots && config.stateSlots.length > 0) {
+    const slotValues = await createAgentStateSlotStore({
+      store: config.store,
+      definitions: config.stateSlots
+    }).list(conversationId);
+    const renderedSlots = renderAgentStateSlots(slotValues);
+    if (renderedSlots)
+      return [renderedSlots];
+  }
+  return [];
+}
+function detailedProjection(config, source) {
+  return 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
+    }
+  });
+}
+function createRunHistoryProjection(input) {
+  const { config, durableSystem } = input;
+  let carriedSystem = durableSystem;
+  return {
+    async projectHistory(source) {
+      if (config.history?.project)
+        return config.history.project(source.messages);
+      const detailed = await detailedProjection(config, source.messages);
+      const run = input.currentRun();
+      for (const decision of detailed.decisions) {
+        if (decision.action === "omitted" && run.inputMessageIds.includes(decision.messageId) && source.messages.some((message) => message.id === decision.messageId && message.role === "tool")) {
+          throw new Error(`Invalid approval continuation ${decision.messageId}: ${decision.reason}`);
+        }
+      }
+      carriedSystem = [...durableSystem, ...detailed.system];
+      return [...detailed.messages];
+    },
+    async projectInputs(source) {
+      if (config.history?.project)
+        return config.history.project(source);
+      const detailed = await detailedProjection(config, source);
+      return [...detailed.messages];
+    },
+    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 }))
+      ];
+    }
+  };
+}
+
+// src/agent-runtime/run-turn-preparation.ts
+async function compactHistory(execution) {
+  const { config, runtimeEpoch, generateId } = execution.dependencies;
+  const { state, operationLifecycle, executionSignal } = execution;
+  const compact = config.history?.compact;
+  if (!compact)
+    return;
+  await operationLifecycle.startCompaction(generateId());
+  let compacted;
+  try {
+    compacted = await compact({
+      conversationId: state.run.conversationId,
+      store: config.store,
+      signal: executionSignal
+    });
+    adoptSnapshot(state, compacted.snapshot);
+    await operationLifecycle.finish("completed");
+  } catch (error) {
+    const latest = await config.store.loadRun({
+      conversationId: state.run.conversationId,
+      runId: state.run.id
+    });
+    if (latest?.run.ownerId === runtimeEpoch) {
+      state.observedVersion = latest.snapshotVersion;
+      state.run = latest.run;
+    }
+    await operationLifecycle.finish(executionSignal.aborted ? "cancelled" : "failed");
+    throw error;
+  }
+  if (compacted.usage) {
+    state.nonModelUsage = addUsage(state.nonModelUsage, compacted.usage);
+    const billed = billedUsage(state);
+    state.usage = billed ? addUsage(state.nonModelUsage, billed) : state.nonModelUsage;
+  }
+}
+function createRuntimeContext(execution) {
+  const { runtimeEpoch, config } = execution.dependencies;
+  const { state, executionSignal } = execution;
+  const assertCurrent = async () => {
+    if (executionSignal.aborted)
+      return "run_interrupted";
+    const current = await config.store.loadRun({
+      conversationId: state.run.conversationId,
+      runId: state.run.id
+    });
+    const currentRun = current?.run;
+    if (!currentRun || currentRun.ownerId !== runtimeEpoch)
+      return "stale_run";
+    if (currentRun.fencingToken !== state.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: state.run.id,
+    assertCurrent,
+    context: () => ({
+      ...state.run.fencingToken !== undefined && { fencingToken: state.run.fencingToken }
+    })
+  });
+  return {
+    context: execution.input.context,
+    run: state.run,
+    signal: executionSignal,
+    toolFenceLifecycle,
+    get contextUsage() {
+      const descriptor = state.selectedModel?.descriptor;
+      if (!descriptor)
+        return;
+      return { usedTokens: state.lastPromptTokens, contextWindow: descriptor.contextWindow };
+    }
+  };
+}
+async function seedUserInstructions(execution, prompt) {
+  const { config, now } = execution.dependencies;
+  const { state } = execution;
+  if (!prompt.userInstructions || prompt.userInstructions.length === 0)
+    return;
+  const conversationId = state.run.conversationId;
+  const seededAt = now().toISOString();
+  const seeded = await config.store.seedConversationInput({
+    conversationId,
+    seedKey: USER_INSTRUCTION_SEED_KEY,
+    inputs: prompt.userInstructions.map((section, index) => seededInstructionMessage({
+      conversationId,
+      seedKey: USER_INSTRUCTION_SEED_KEY,
+      index,
+      text: section.text,
+      createdAt: seededAt
+    }))
+  });
+  const seededSnapshot = appliedSnapshot(seeded, "user instruction seed");
+  const previousIds = new Set(state.snapshot.messages.map((message) => message.id));
+  const inserted = seededSnapshot.messages.some((message) => !previousIds.has(message.id) && message.role === "user" && message.runId === undefined);
+  adoptSnapshot(state, seededSnapshot);
+  return inserted;
+}
+async function prepareTurn(execution) {
+  const { config } = execution.dependencies;
+  const { state, executionSignal } = execution;
+  await compactHistory(execution);
+  const runtimeContext = createRuntimeContext(execution);
+  const selectedModel = await config.models.resolve({
+    context: execution.input.context,
+    conversationId: state.run.conversationId,
+    run: state.run,
+    snapshot: state.snapshot
+  });
+  state.selectedModel = selectedModel;
+  let promptSnapshot = snapshotForRunPrompt(state.snapshot, state.run.id);
+  const [composedPrompt, tools] = await Promise.all([
+    config.prompt({
+      context: execution.input.context,
+      signal: executionSignal,
+      event: promptSnapshot.runs[0]?.id === state.run.id ? "session.started" : "turn.started",
+      model: selectedModel,
+      snapshot: promptSnapshot
+    }),
+    config.tools(runtimeContext)
+  ]);
+  let prompt = composedPrompt;
+  const userInstructionsInserted = await seedUserInstructions(execution, prompt);
+  if (userInstructionsInserted !== undefined) {
+    promptSnapshot = snapshotForRunPrompt(state.snapshot, state.run.id);
+  }
+  if (prompt.finalizeSeed)
+    prompt = { ...prompt, ...prompt.finalizeSeed(userInstructionsInserted ?? false) };
+  if (prompt.contextDecision === "oversized") {
+    throw new AgentContextOverflowError;
+  }
+  if (prompt.contextDecision === "requires-compaction") {
+    throw new AgentContextOverflowError("Agent context still exceeds the model budget after compaction");
+  }
+  const projection = createRunHistoryProjection({
+    config,
+    currentRun: () => state.run,
+    durableSystem: await loadDurableSystem(config, state.run.conversationId)
+  });
+  const history = [...await projection.projectHistory(promptSnapshot)];
+  return { selectedModel, runtimeContext, prompt, tools, history, projection };
+}
+
+// src/agent-runtime/run-execution.ts
+function createRunExecutor(dependencies) {
+  return async function executeRun(input) {
+    const acquisition = await acquireRun(dependencies, input);
+    if (acquisition.kind === "absorbed")
+      return acquisition.result;
+    const { execution } = acquisition;
+    try {
+      const turn = await prepareTurn(execution);
+      await runModelAttempts(execution, turn);
+      await settleStreamOutcome(execution);
+    } catch (error) {
+      await classifyRunFailure(execution, error);
+    } finally {
+      execution.idleDeadline.dispose();
+    }
+    return commitRunTerminal(execution);
+  };
+}
+
+// src/agent-runtime/runtime-state.ts
+function resolveLoopLimits(config) {
+  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);
+  }
+  return {
+    checkpointEveryEvents,
+    maxSteps,
+    ...idleTimeoutMs !== undefined && { idleTimeoutMs }
+  };
+}
+function createAgentRuntimeState(config) {
+  const coordinator = createAgentSessionCoordinator();
+  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 { checkpointEveryEvents, maxSteps, idleTimeoutMs } = resolveLoopLimits(config);
+  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 }
+  });
+  return {
+    config,
+    coordinator,
+    tickets: new Map,
+    generateId,
+    now,
+    admissionLanes,
+    gate: createRuntimeAdmissionGate(),
+    ...injection && { injection },
+    publish,
+    executeRun
+  };
+}
+
+// src/agent-runtime/runtime-submit.ts
+function submitAgentInput(state, rawInput) {
+  if (state.gate.closed) {
+    const refused = refuse();
+    const admission = Promise.reject(closedError());
+    admission.catch(() => {
+      return;
+    });
+    return { ...refused, admission };
+  }
+  const input = parseSubmittedInput(state, rawInput);
+  const context = state.config.protocol.parseContext(input.context);
+  const conversationTickets = state.tickets.get(input.conversationId);
+  const existingTicket = conversationTickets?.get(input.idempotencyKey);
+  if (existingTicket)
+    return existingTicket;
+  const submission = createSubmission(state, rawInput, input, context);
+  const publicTicket = registerTicket(state, submission, conversationTickets);
+  const handedOff = state.gate.begin();
+  admitSubmission(state, submission, handedOff);
+  return publicTicket;
+}
+function parseSubmittedInput(state, rawInput) {
+  const { protocol } = state.config;
+  const metadata = rawInput.metadata === undefined ? undefined : protocol.parseInputMetadata(rawInput.metadata);
+  const input = {
+    conversationId: rawInput.conversationId,
+    idempotencyKey: rawInput.idempotencyKey,
+    context: rawInput.context,
+    parts: rawInput.parts.map((part) => 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");
+  }
+  return input;
+}
+function createSubmission(state, rawInput, input, context) {
+  const { config, generateId } = state;
+  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 = state.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();
+  outerAccepted.promise.catch(() => {
+    return;
+  });
+  const outerAdmission = Promise.withResolvers();
+  outerAdmission.promise.catch(() => {
+    return;
+  });
+  const outerResult = Promise.withResolvers();
+  const reservation = config.runs?.coalescePending && policy !== "interrupt-next" ? state.admissionLanes.reserve(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);
+  }
+  return {
+    input,
+    context,
+    key,
+    policy,
+    runId,
+    userMessage: userMessage2,
+    queuedRun,
+    ...reservation && { reservation },
+    previousAcceptance,
+    acceptanceDone,
+    outerAccepted,
+    outerAdmission,
+    outerResult
+  };
+}
+function registerTicket(state, submission, conversationTickets) {
+  const { input, key } = submission;
+  const publicTicket = {
+    accepted: submission.outerAccepted.promise,
+    admission: submission.outerAdmission.promise,
+    result: submission.outerResult.promise
+  };
+  const currentConversationTickets = conversationTickets ?? new Map;
+  currentConversationTickets.set(input.idempotencyKey, publicTicket);
+  if (!conversationTickets) {
+    state.tickets.set(input.conversationId, currentConversationTickets);
+  }
+  const forgetTicket = () => {
+    if (submission.offeredRunId !== undefined) {
+      state.injection?.withdraw(key, submission.offeredRunId);
+    }
+    if (currentConversationTickets.get(input.idempotencyKey) !== publicTicket)
+      return;
+    currentConversationTickets.delete(input.idempotencyKey);
+    if (currentConversationTickets.size === 0)
+      state.tickets.delete(input.conversationId);
+  };
+  submission.outerResult.promise.then(forgetTicket, forgetTicket);
+  return publicTicket;
+}
+async function admitSubmission(state, submission, handedOff) {
+  const { config } = state;
+  const { input, reservation, key } = submission;
+  try {
+    await submission.previousAcceptance.catch(() => {
+      return;
+    });
+    await config.models.preflight?.({
+      context: submission.context,
+      conversationId: input.conversationId
+    });
+    if (state.gate.closed)
+      throw closedError();
+    const acceptance = await config.store.acceptInputAndAssignRun({
+      idempotencyKey: input.idempotencyKey,
+      input: submission.userMessage,
+      run: submission.queuedRun,
+      ...reservation && !reservation.shouldSchedule && {
+        coalesceIntoRunId: reservation.admission.runId
+      }
+    });
+    const admission = projectAdmission(submission, acceptance);
+    submission.outerAdmission.resolve(admission);
+    await publishAdmission(state, admission);
+    submission.outerAccepted.resolve();
+    if (acceptance.outcome === "duplicate") {
+      settleDuplicate(state, submission, admission, acceptance.assistant);
+      return;
+    }
+    if (submission.policy === "inject") {
+      submission.offeredRunId = admission.run.id;
+      state.injection?.offer(key, { runId: admission.run.id, input: admission.input });
+    }
+    if (reservation && !reservation.shouldSchedule) {
+      reservation.admission.completion.promise.then(submission.outerResult.resolve, submission.outerResult.reject);
+      return;
+    }
+    handOffToCoordinator(state, submission, admission.run);
+  } catch (error) {
+    submission.outerAccepted.reject(error);
+    submission.outerAdmission.reject(error);
+    submission.outerResult.reject(error);
+    if (reservation?.shouldSchedule) {
+      reservation.admission.completion.reject(error);
+      state.admissionLanes.settle(key, reservation.admission);
+    }
+  } finally {
+    submission.acceptanceDone.resolve();
+    handedOff();
+  }
+}
+function projectAdmission(submission, acceptance) {
+  const acceptedSnapshot = appliedSnapshot(acceptance, "input acceptance");
+  const assignedRunId = acceptance.outcome === "duplicate" ? acceptance.runId : submission.reservation?.admission.runId ?? submission.runId;
+  const acceptedRun = acceptance.outcome === "duplicate" ? acceptance.run : findRun(acceptedSnapshot.runs, assignedRunId);
+  const actualInputMessageId = acceptance.outcome === "duplicate" ? acceptance.inputMessageId : submission.userMessage.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;
+  return {
+    inputMessageId: acceptedInput.id,
+    runId: acceptedRun.id,
+    assistantMessageId: assistantPlaceholder.id,
+    input: acceptedInput,
+    run: acceptedRun,
+    assistant: acceptedAssistant,
+    snapshotVersion: acceptedSnapshot.version
+  };
+}
+async function publishAdmission(state, admission) {
+  const { run, snapshotVersion } = admission;
+  await state.publish({
+    type: "admission",
+    eventId: agentDurableEventId("admission", run.id, snapshotVersion),
+    conversationId: run.conversationId,
+    runId: run.id,
+    snapshotVersion,
+    input: admission.input,
+    run,
+    assistant: admission.assistant,
+    emittedAt: state.now().toISOString()
+  });
+  await state.publish({
+    type: "run-state",
+    eventId: agentDurableEventId("run-state", run.id, snapshotVersion),
+    conversationId: run.conversationId,
+    runId: run.id,
+    snapshotVersion,
+    state: run.state,
+    emittedAt: state.now().toISOString()
+  });
+}
+function settleDuplicate(state, submission, admission, retainedAssistant) {
+  const { reservation, key, outerResult } = submission;
+  const acceptedRun = admission.run;
+  const refuseDuplicate = (error) => {
+    outerResult.reject(error);
+    if (reservation?.shouldSchedule) {
+      reservation.admission.completion.reject(error);
+      state.admissionLanes.settle(key, reservation.admission);
+    }
+  };
+  if (!acceptedRun.terminalReason) {
+    refuseDuplicate(new Error("Duplicate input is already owned by another runtime execution"));
+    return;
+  }
+  const message = retainedAssistant;
+  if (!message) {
+    refuseDuplicate(new Error("Duplicate terminal admission has no retained canonical assistant"));
+    return;
+  }
+  outerResult.resolve({
+    run: acceptedRun,
+    message,
+    reason: acceptedRun.terminalReason,
+    snapshotVersion: admission.snapshotVersion,
+    ...acceptedRun.terminalPolicyName && {
+      policyName: acceptedRun.terminalPolicyName
+    }
+  });
+  if (reservation?.shouldSchedule) {
+    reservation.admission.completion.reject(new Error("Reserved run resolved to a duplicate durable input"));
+    state.admissionLanes.settle(key, reservation.admission);
+  }
+}
+function handOffToCoordinator(state, submission, acceptedRun) {
+  const { reservation, key, context, outerResult } = submission;
+  const ticket = state.coordinator.submit({
+    key,
+    policy: submission.policy,
+    create: async (signal) => {
+      if (reservation)
+        await state.admissionLanes.waitForAcceptances(reservation.lane);
+      return {
+        runId: acceptedRun.id,
+        execute: () => state.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) => {
+      state.admissionLanes.settle(key, reservation.admission);
+      outerResult.resolve(value);
+    }, (error) => {
+      state.admissionLanes.settle(key, reservation.admission);
+      outerResult.reject(error);
+    });
+  } else {
+    ticket.result.then(outerResult.resolve, outerResult.reject);
+  }
+}
+
+// src/agent-runtime/runtime.ts
+function createAgentRuntime(config) {
+  const state = createAgentRuntimeState(config);
+  return {
+    submit: (rawInput) => submitAgentInput(state, rawInput),
+    resume: (rawInput) => resumeAgentRun(state, rawInput),
+    interrupt: (input) => interruptAgentRun(state, input),
+    abandon: (input) => abandonAgentRun(state, input),
+    recover: (options) => recoverAgentRuns(state, options),
+    stop: (conversationKey, reason) => state.coordinator.stop(conversationKey, reason),
+    close: (options = {}) => closeAgentRuntime(state, options)
+  };
+}
+
+export { AgentRuntimeConflictError, normalizeSdkUsage, AgentContextOverflowError, createAgentSessionCoordinator, registerDeferredToolRepair, registerDeferredToolCatalog, deferredToolCatalog, repairedSearchCall, createAgentRuntimeEventSink, projectAgentHistoryDetailed, projectAgentHistory, createAgentToolFenceLifecycle, AgentTokenCountSchema, selectAgentHistory, composeAgentPrompt, AgentProviderStreamCutError, classifyProviderFailure, isToolResultFailure, recordAgentRetryDecision, defineStateSlot, createAgentStateSlotStore, renderAgentStateSlots, agentGoalStateSlot, agentTodoStateSlot, createAgentRuntime };