stitchkit 0.92.0 → 0.94.0

package/dist/index-vk3kq9sb.js

@@ -1,3344 +0,0 @@
-import {
-  messageOf
-} from "./index-p13mwz16.js";
-import {
-  AgentRuntimeEventSchema,
-  agentDurableEventId
-} from "./index-y64k3s0h.js";
-import {
-  advanceToolChronology,
-  assistantStatus,
-  canProjectToolChronology,
-  canonicalAgentJson,
-  createToolChronology,
-  isAssistantHistoryEvidence,
-  isCompleteAgentHistoryTurn
-} from "./index-zwkgfq1s.js";
-import {
-  AgentAssistantPlaceholderSchema,
-  AgentJsonObjectSchema,
-  AgentMessagePartSchema,
-  AgentMessageSchema,
-  AgentProvenanceSchema,
-  AgentProviderResponseSchema,
-  AgentRunOperationSchema,
-  AgentRunSchema,
-  AgentSnapshotSchema,
-  runStateForTerminalReason
-} from "./index-gtj3zc53.js";
-import {
-  createBoundedSinkManager
-} from "./index-wnfk50r0.js";
-import {
-  createLocalStepDurability,
-  createToolDurabilityContext,
-  isAgentToolError
-} from "./index-kw9t5ayn.js";
-import {
-  ToolExecutionControlError,
-  isToolExecutionControlError
-} from "./index-yn8remb1.js";
-import {
-  isRecord,
-  transportResult
-} from "./index-77fekveh.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/admission-lanes.ts
-function createRuntimeAdmissionLanes() {
-  const lanes = new Map;
-  const admit = (runId) => {
-    const admission = { runId, completion: Promise.withResolvers() };
-    admission.completion.promise.catch(() => {
-      return;
-    });
-    return admission;
-  };
-  return {
-    reserve(key, runId) {
-      const existing = lanes.get(key);
-      const lane = existing ?? { acceptanceTail: Promise.resolve() };
-      if (!existing)
-        lanes.set(key, lane);
-      if (!lane.head) {
-        lane.head = admit(runId);
-        return { lane, admission: lane.head, shouldSchedule: true };
-      }
-      if (!lane.pending) {
-        lane.pending = admit(runId);
-        return { lane, admission: lane.pending, shouldSchedule: true };
-      }
-      return { lane, admission: lane.pending, shouldSchedule: false };
-    },
-    settle(key, admission) {
-      const lane = lanes.get(key);
-      if (!lane)
-        return;
-      if (lane.head?.runId === admission.runId) {
-        lane.head = lane.pending;
-        lane.pending = undefined;
-      } else if (lane.pending?.runId === admission.runId) {
-        lane.pending = undefined;
-      }
-      if (!lane.head && !lane.pending)
-        lanes.delete(key);
-    },
-    async waitForAcceptances(lane) {
-      while (true) {
-        const tail = lane.acceptanceTail;
-        await tail.catch(() => {
-          return;
-        });
-        if (tail === lane.acceptanceTail)
-          return;
-      }
-    }
-  };
-}
-
-// src/agent-runtime/injection.ts
-function createAgentInjectionRegistry() {
-  const offered = new Map;
-  return {
-    offer(key, entry) {
-      const existing = offered.get(key);
-      if (!existing) {
-        offered.set(key, [entry]);
-        return;
-      }
-      if (existing.some((candidate) => candidate.input.id === entry.input.id))
-        return;
-      existing.push(entry);
-    },
-    take(key, excludeRunId) {
-      const existing = offered.get(key);
-      if (!existing)
-        return [];
-      const taken = existing.filter((candidate) => candidate.runId !== excludeRunId);
-      const kept = existing.filter((candidate) => candidate.runId === excludeRunId);
-      if (kept.length === 0)
-        offered.delete(key);
-      else
-        offered.set(key, kept);
-      return taken;
-    },
-    withdraw(key, runId) {
-      const existing = offered.get(key);
-      if (!existing)
-        return;
-      const kept = existing.filter((candidate) => candidate.runId !== runId);
-      if (kept.length === 0)
-        offered.delete(key);
-      else
-        offered.set(key, kept);
-    },
-    clear() {
-      offered.clear();
-    }
-  };
-}
-
-// src/agent-runtime/run-execution.ts
-import { createHash } from "node:crypto";
-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/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-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/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/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-execution.ts
-function snapshotForRunPrompt(snapshot, runId) {
-  const runIndex = snapshot.runs.findIndex((candidate) => candidate.id === runId);
-  if (runIndex < 0)
-    throw new AgentRuntimeConflictError("prompt run lookup");
-  const ownedIds = new Set(snapshot.runs.flatMap((candidate) => [
-    ...candidate.inputMessageIds,
-    candidate.assistantMessageId
-  ]));
-  const eligibleIds = new Set(snapshot.runs.slice(0, runIndex + 1).flatMap((candidate) => [...candidate.inputMessageIds, candidate.assistantMessageId]));
-  return AgentSnapshotSchema.parse({
-    ...snapshot,
-    messages: snapshot.messages.filter((message) => !ownedIds.has(message.id) || eligibleIds.has(message.id))
-  });
-}
-var USER_INSTRUCTION_SEED_KEY = "prompt.user-instructions";
-function seededInstructionMessage(input) {
-  return AgentMessageSchema.parse({
-    schemaVersion: 1,
-    id: createHash("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
-  });
-}
-function failureThisRuntimeOwns(error) {
-  if (error instanceof AgentContextOverflowError)
-    return "context_overflow";
-  if (error instanceof AgentRuntimeConflictError)
-    return "storage_conflict";
-  if (isOwnInputRefusal(error))
-    return "runtime_failure";
-  return;
-}
-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);
-}
-function createRunExecutor(dependencies) {
-  const {
-    config,
-    publish,
-    runtimeEpoch,
-    generateId,
-    now,
-    checkpointEveryEvents,
-    maxSteps,
-    idleTimeoutMs,
-    injection
-  } = dependencies;
-  return async function executeRun(input) {
-    injection?.withdraw(input.key, input.acceptedRun.id);
-    const queued = await config.store.loadRun({
-      conversationId: input.acceptedRun.conversationId,
-      runId: input.acceptedRun.id
-    });
-    if (!queued)
-      throw new AgentRuntimeConflictError("run lookup");
-    if (queued.run.terminalReason === "absorbed") {
-      const absorbing = queued.run.absorbedIntoRunId ? await config.store.loadRun({
-        conversationId: queued.run.conversationId,
-        runId: queued.run.absorbedIntoRunId
-      }) : undefined;
-      if (!absorbing?.assistant || !absorbing.run.terminalReason) {
-        throw new AgentRuntimeConflictError("absorbed run resolution");
-      }
-      input.onAcquired?.();
-      return {
-        run: absorbing.run,
-        message: absorbing.assistant,
-        reason: absorbing.run.terminalReason,
-        snapshotVersion: absorbing.snapshotVersion,
-        ...absorbing.run.terminalPolicyName && {
-          policyName: absorbing.run.terminalPolicyName
-        }
-      };
-    }
-    const queuedRun = queued.run;
-    const acquired = appliedSnapshot(await config.store.acquireRun({
-      conversationId: queuedRun.conversationId,
-      runId: queuedRun.id,
-      expectedRevision: queuedRun.revision,
-      ownerId: runtimeEpoch
-    }), "run acquisition");
-    let run = findRun(acquired.runs, input.acceptedRun.id);
-    input.onAcquired?.();
-    await publish({
-      type: "run-state",
-      eventId: agentDurableEventId("run-state", run.id, acquired.version),
-      conversationId: run.conversationId,
-      runId: run.id,
-      snapshotVersion: acquired.version,
-      state: run.state,
-      emittedAt: now().toISOString()
-    });
-    const trace = config.observe?.rootTrace();
-    const runStartedAt = performance.now();
-    config.observe?.emit({
-      schemaVersion: 1,
-      eventId: generateId(),
-      type: "run-started",
-      conversationId: run.conversationId,
-      runId: run.id,
-      traceId: trace?.traceId ?? generateId(),
-      spanId: trace?.spanId ?? generateId(),
-      ...trace?.parentSpanId && { parentSpanId: trace.parentSpanId },
-      state: run.state,
-      queueWaitMs: Math.max(0, now().getTime() - new Date(run.createdAt).getTime()),
-      emittedAt: now().toISOString()
-    });
-    let assistant = AgentMessageSchema.parse({
-      schemaVersion: 1,
-      id: run.assistantMessageId,
-      conversationId: run.conversationId,
-      runId: run.id,
-      role: "assistant",
-      status: "streaming",
-      parts: [],
-      createdAt: now().toISOString(),
-      updatedAt: now().toISOString()
-    });
-    let snapshot = appliedSnapshot(await config.store.checkpointRunAssistant({
-      conversationId: run.conversationId,
-      runId: run.id,
-      expectedRevision: run.revision,
-      ownerId: runtimeEpoch,
-      ...run.fencingToken !== undefined && { fencingToken: run.fencingToken },
-      assistant
-    }), "assistant draft");
-    run = findRun(snapshot.runs, run.id);
-    let observedVersion = snapshot.version;
-    const parts = [];
-    const absorbed = new Map;
-    let eventsSinceCheckpoint = 0;
-    let sequence = 0;
-    const transientSequence = () => {
-      sequence += 1;
-      return sequence;
-    };
-    let terminalReason = "success";
-    let nonModelUsage = input.acceptedRun.usage;
-    let modelUsage;
-    let abandonedUsage;
-    const billedUsage = () => abandonedUsage && modelUsage ? addUsage(abandonedUsage, modelUsage) : abandonedUsage ?? modelUsage;
-    let usage = nonModelUsage;
-    let sawProviderFinish = false;
-    let step = 0;
-    let selectedModel;
-    let internalCause;
-    let providerStreamCleanupFailure;
-    let reasoningPartIndex;
-    let firstOutputAt;
-    let terminalPolicyName;
-    const idleDeadline = createIdleDeadline(input.signal, idleTimeoutMs);
-    const executionSignal = idleDeadline.signal;
-    const serialize = createRunMutationQueue();
-    const operationLifecycle = createAgentRunOperationLifecycle({
-      store: config.store,
-      runtimeEpoch,
-      serialize,
-      currentRun: () => run,
-      acceptSnapshot: (next) => {
-        snapshot = next;
-        observedVersion = next.version;
-        run = findRun(next.runs, run.id);
-      },
-      publish,
-      now
-    });
-    const updateReasoning = (text, metadata) => {
-      const provider = providerEnvelope(metadata);
-      if (reasoningPartIndex === undefined) {
-        reasoningPartIndex = parts.length;
-        parts.push(AgentMessagePartSchema.parse({
-          type: "reasoning",
-          text,
-          ...provider && { provider }
-        }));
-        return;
-      }
-      const current = parts[reasoningPartIndex];
-      if (current?.type !== "reasoning") {
-        throw new AgentRuntimeConflictError("reasoning accumulator");
-      }
-      parts.splice(reasoningPartIndex, 1, AgentMessagePartSchema.parse({
-        ...current,
-        text: current.text + text,
-        ...provider && { provider }
-      }));
-    };
-    const checkpoint = () => serialize(async () => {
-      assistant = AgentMessageSchema.parse({
-        ...assistant,
-        parts,
-        updatedAt: now().toISOString()
-      });
-      snapshot = appliedSnapshot(await config.store.checkpointRunAssistant({
-        conversationId: run.conversationId,
-        runId: run.id,
-        expectedRevision: run.revision,
-        ownerId: runtimeEpoch,
-        ...run.fencingToken !== undefined && { fencingToken: run.fencingToken },
-        assistant,
-        usage: statedUsage(usage)
-      }), "assistant checkpoint");
-      observedVersion = snapshot.version;
-      run = findRun(snapshot.runs, run.id);
-      const checkpointMetrics = {
-        partial: true,
-        durationMs: performance.now() - runStartedAt,
-        usage: statedUsage(usage),
-        ...firstOutputAt !== undefined && { ttftMs: firstOutputAt - runStartedAt }
-      };
-      await publish({
-        type: "assistant-checkpoint",
-        eventId: agentDurableEventId("assistant-checkpoint", run.id, observedVersion),
-        conversationId: run.conversationId,
-        runId: run.id,
-        snapshotVersion: observedVersion,
-        message: assistant,
-        metrics: checkpointMetrics,
-        emittedAt: now().toISOString()
-      });
-    });
-    try {
-      if (config.history?.compact) {
-        await operationLifecycle.startCompaction(generateId());
-        let compacted;
-        try {
-          compacted = await config.history.compact({
-            conversationId: run.conversationId,
-            store: config.store,
-            signal: executionSignal
-          });
-          snapshot = compacted.snapshot;
-          observedVersion = snapshot.version;
-          run = findRun(snapshot.runs, run.id);
-          await operationLifecycle.finish("completed");
-        } catch (error) {
-          const latest = await config.store.loadRun({
-            conversationId: run.conversationId,
-            runId: run.id
-          });
-          if (latest?.run.ownerId === runtimeEpoch) {
-            observedVersion = latest.snapshotVersion;
-            run = latest.run;
-          }
-          await operationLifecycle.finish(executionSignal.aborted ? "cancelled" : "failed");
-          throw error;
-        }
-        if (compacted.usage) {
-          nonModelUsage = addUsage(nonModelUsage, compacted.usage);
-          const billed = billedUsage();
-          usage = billed ? addUsage(nonModelUsage, billed) : nonModelUsage;
-        }
-      }
-      const assertCurrent = async () => {
-        if (executionSignal.aborted)
-          return "run_interrupted";
-        const current = await config.store.loadRun({
-          conversationId: run.conversationId,
-          runId: run.id
-        });
-        const currentRun = current?.run;
-        if (!currentRun || currentRun.ownerId !== runtimeEpoch)
-          return "stale_run";
-        if (currentRun.fencingToken !== run.fencingToken)
-          return "stale_run";
-        if (currentRun.state === "interrupt_requested")
-          return "run_interrupted";
-        if (currentRun.state !== "running")
-          return "stale_run";
-        return;
-      };
-      const toolFenceLifecycle = createAgentToolFenceLifecycle({
-        runId: run.id,
-        assertCurrent,
-        context: () => ({
-          ...run.fencingToken !== undefined && { fencingToken: run.fencingToken }
-        })
-      });
-      let lastPromptTokens = { provenance: "unavailable" };
-      const runtimeContext = {
-        context: input.context,
-        run,
-        signal: executionSignal,
-        toolFenceLifecycle,
-        get contextUsage() {
-          const descriptor = selectedModel?.descriptor;
-          if (!descriptor)
-            return;
-          return { usedTokens: lastPromptTokens, contextWindow: descriptor.contextWindow };
-        }
-      };
-      selectedModel = await config.models.resolve({
-        context: input.context,
-        conversationId: run.conversationId,
-        run,
-        snapshot
-      });
-      let promptSnapshot = snapshotForRunPrompt(snapshot, run.id);
-      const [composedPrompt, tools] = await Promise.all([
-        config.prompt({
-          context: input.context,
-          signal: executionSignal,
-          event: promptSnapshot.runs[0]?.id === run.id ? "session.started" : "turn.started",
-          model: selectedModel,
-          snapshot: promptSnapshot
-        }),
-        config.tools(runtimeContext)
-      ]);
-      let prompt = composedPrompt;
-      let userInstructionsInserted = false;
-      if (prompt.userInstructions && prompt.userInstructions.length > 0) {
-        const seededAt = now().toISOString();
-        const seeded = await config.store.seedConversationInput({
-          conversationId: run.conversationId,
-          seedKey: USER_INSTRUCTION_SEED_KEY,
-          inputs: prompt.userInstructions.map((section, index) => seededInstructionMessage({
-            conversationId: run.conversationId,
-            seedKey: USER_INSTRUCTION_SEED_KEY,
-            index,
-            text: section.text,
-            createdAt: seededAt
-          }))
-        });
-        const seededSnapshot = appliedSnapshot(seeded, "user instruction seed");
-        const previousIds = new Set(snapshot.messages.map((message) => message.id));
-        userInstructionsInserted = seededSnapshot.messages.some((message) => !previousIds.has(message.id) && message.role === "user" && message.runId === undefined);
-        snapshot = seededSnapshot;
-        observedVersion = snapshot.version;
-        run = findRun(snapshot.runs, run.id);
-        promptSnapshot = snapshotForRunPrompt(snapshot, run.id);
-      }
-      if (prompt.finalizeSeed)
-        prompt = { ...prompt, ...prompt.finalizeSeed(userInstructionsInserted) };
-      if (prompt.contextDecision === "oversized") {
-        throw new AgentContextOverflowError;
-      }
-      if (prompt.contextDecision === "requires-compaction") {
-        throw new AgentContextOverflowError("Agent context still exceeds the model budget after compaction");
-      }
-      let carriedSystem = [];
-      let durableSystem = [];
-      if (config.stateSlots && config.stateSlots.length > 0) {
-        const slotValues = await createAgentStateSlotStore({
-          store: config.store,
-          definitions: config.stateSlots
-        }).list(run.conversationId);
-        const renderedSlots = renderAgentStateSlots(slotValues);
-        if (renderedSlots) {
-          durableSystem = [renderedSlots];
-          carriedSystem = durableSystem;
-        }
-      }
-      const projectHistory = async (source) => {
-        if (config.history?.project)
-          return config.history.project(source.messages);
-        const detailed = await projectAgentHistoryDetailed(source.messages, {
-          ...config.history?.resolveFile && { resolveFile: config.history.resolveFile },
-          ...config.history?.unresolvedFile && {
-            unresolvedFile: config.history.unresolvedFile
-          },
-          ...config.history?.interruptedAssistant && {
-            interruptedAssistant: config.history.interruptedAssistant
-          },
-          ...config.history?.evidencePolicy && {
-            evidencePolicy: config.history.evidencePolicy
-          }
-        });
-        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];
-      };
-      const projectInputs = async (source) => {
-        if (config.history?.project)
-          return config.history.project(source);
-        const detailed = await projectAgentHistoryDetailed(source, {
-          ...config.history?.resolveFile && { resolveFile: config.history.resolveFile },
-          ...config.history?.unresolvedFile && {
-            unresolvedFile: config.history.unresolvedFile
-          },
-          ...config.history?.interruptedAssistant && {
-            interruptedAssistant: config.history.interruptedAssistant
-          },
-          ...config.history?.evidencePolicy && {
-            evidencePolicy: config.history.evidencePolicy
-          }
-        });
-        return [...detailed.messages];
-      };
-      const projectedHistory = await projectHistory(promptSnapshot);
-      const history = [...projectedHistory];
-      const withCarriedSystem = (instructions) => {
-        if (carriedSystem.length === 0)
-          return instructions;
-        const composed = typeof instructions === "string" ? [{ role: "system", content: instructions }] : Array.isArray(instructions) ? instructions : [instructions];
-        return [
-          ...composed,
-          ...carriedSystem.map((content) => ({ role: "system", content }))
-        ];
-      };
-      const maxStepCondition = stepCountIs(maxSteps);
-      const stopConditions = [
-        async (options) => {
-          const stopped = await maxStepCondition(options);
-          if (stopped && terminalPolicyName === undefined)
-            terminalPolicyName = "max-steps";
-          return stopped;
-        }
-      ];
-      for (const policy of config.loop?.stopPolicies ?? []) {
-        stopConditions.push(async (options) => {
-          const stopped = await policy.when(options);
-          if (stopped && terminalPolicyName === undefined)
-            terminalPolicyName = policy.name;
-          return stopped;
-        });
-      }
-      let takenThisAttempt = [];
-      const takeInjectedMessages = async () => {
-        const taken = injection?.take(input.key, run.id) ?? [];
-        if (taken.length === 0)
-          return [];
-        takenThisAttempt.push(...taken);
-        const messages = [];
-        for (const entry of taken) {
-          messages.push(...await projectInputs([entry.input]));
-          const ids = absorbed.get(entry.runId) ?? [];
-          ids.push(entry.input.id);
-          absorbed.set(entry.runId, ids);
-        }
-        return messages;
-      };
-      const fallbackModel = selectedModel.model;
-      const requestModelId = selectedModel.descriptor.modelId;
-      let retryAttempt = 1;
-      let instructionsOverride;
-      const knownMessageShas = new Set;
-      {
-        let fromSeq;
-        do {
-          const page = await config.store.readEvents({
-            conversationId: 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);
-      }
-      const recordProviderRequest = async (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 config.store.appendEvent({
-            conversationId: 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 config.store.appendEvent({
-          conversationId: run.conversationId,
-          kind: "provider/request",
-          payload: {
-            runId: run.id,
-            attempt: request.attempt,
-            stepNumber: request.stepNumber,
-            modelId: requestModelId,
-            instructionsSha256,
-            messageShas,
-            bodySha256
-          }
-        });
-      };
-      const recordProviderResponse = async (response) => {
-        const identity = providerResponseIdentity(response.id, selectedModel?.resolveResponseProvider?.({
-          providerMetadata: response.providerMetadata
-        }));
-        await config.store.appendEvent({
-          conversationId: run.conversationId,
-          kind: "provider/response",
-          payload: {
-            runId: run.id,
-            attempt: response.attempt,
-            stepNumber: response.stepNumber,
-            response: identity
-          }
-        });
-        return identity;
-      };
-      for (;; ) {
-        const attemptPartStart = parts.length;
-        let retrying = false;
-        let draining = false;
-        const providerAttempt = retryAttempt;
-        const attemptAbort = new AbortController;
-        const attemptSignal = AbortSignal.any([executionSignal, attemptAbort.signal]);
-        const result = streamAgentTextBoundary({
-          model: fallbackModel,
-          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: run.conversationId,
-                    runId: run.id,
-                    toolName,
-                    toolCallId,
-                    signal
-                  });
-                return createLocalStepDurability({
-                  store: config.store,
-                  conversationId: run.conversationId,
-                  runId: JSON.stringify([run.id, toolName, toolCallId]),
-                  signal
-                });
-              })
-            ]))
-          },
-          instructions: withCarriedSystem(prompt.instructions),
-          messages: 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: input.context
-          },
-          ...config.loop?.toolApprovalSecret && {
-            experimental_toolApprovalSecret: config.loop.toolApprovalSecret
-          },
-          prepareStep: async (options) => {
-            const previousStep = options.steps.at(-1);
-            if (previousStep) {
-              lastPromptTokens = selectedModel?.normalizeUsage?.({
-                usage: previousStep.usage,
-                providerMetadata: previousStep.providerMetadata
-              })?.inputTokens ?? normalizeSdkUsage(previousStep.usage).inputTokens;
-            }
-            const prepared = await config.loop?.prepareStep?.({
-              ...options,
-              ...runtimeContext
-            });
-            const injected = await takeInjectedMessages();
-            const preparedStep = injected.length === 0 ? prepared : {
-              ...prepared,
-              messages: [...prepared?.messages ?? options.messages, ...injected]
-            };
-            const providerMessages = preparedStep?.messages ?? options.messages;
-            const model = await operationLifecycle.prepareModel(preparedStep?.model ?? fallbackModel, options.stepNumber, generateId());
-            const override = preparedStep;
-            if (override?.instructions !== undefined)
-              instructionsOverride = override.instructions;
-            else if (override?.system !== undefined)
-              instructionsOverride = override.system;
-            await recordProviderRequest({
-              stepNumber: options.stepNumber,
-              attempt: providerAttempt,
-              instructions: instructionsOverride ?? withCarriedSystem(prompt.instructions),
-              messages: providerMessages
-            });
-            return { ...preparedStep, model };
-          }
-        });
-        for await (const part of ownedProviderStream({
-          stream: result.stream,
-          abort: () => attemptAbort.abort(new Error("Agent runtime released provider stream")),
-          onCleanupFailure: (error) => {
-            providerStreamCleanupFailure = error;
-          }
-        })) {
-          idleDeadline.touch();
-          if (draining) {
-            if (part.type === "finish-step") {
-              await recordProviderResponse({
-                id: part.response.id,
-                providerMetadata: part.providerMetadata,
-                stepNumber: step,
-                attempt: providerAttempt
-              });
-              const failedStepUsage = selectedModel.normalizeUsage?.({
-                usage: part.usage,
-                providerMetadata: part.providerMetadata
-              }) ?? normalizeSdkUsage(part.usage);
-              abandonedUsage = abandonedUsage ? addUsage(abandonedUsage, failedStepUsage) : failedStepUsage;
-              const billed = billedUsage();
-              usage = nonModelUsage && billed ? addUsage(nonModelUsage, billed) : billed ?? nonModelUsage;
-            }
-            continue;
-          }
-          eventsSinceCheckpoint += 1;
-          if (part.type === "error" && config.loop?.retry && failureThisRuntimeOwns(part.error) === undefined) {
-            const invokedTool = parts.slice(attemptPartStart).some((candidate) => candidate.type === "tool-call");
-            const decision = invokedTool ? { retry: false, delayMs: 0 } : await recordAgentRetryDecision({
-              store: config.store,
-              conversationId: run.conversationId,
-              attempt: retryAttempt,
-              failure: classifyProviderFailure(part.error),
-              policy: config.loop.retry
-            });
-            if (decision.retry) {
-              await operationLifecycle.finish("failed");
-              parts.splice(attemptPartStart);
-              for (const entry of takenThisAttempt) {
-                injection?.offer(input.key, entry);
-                const ids = absorbed.get(entry.runId);
-                if (ids) {
-                  const kept = ids.filter((id) => id !== entry.input.id);
-                  if (kept.length === 0)
-                    absorbed.delete(entry.runId);
-                  else
-                    absorbed.set(entry.runId, kept);
-                }
-              }
-              takenThisAttempt = [];
-              await checkpoint();
-              eventsSinceCheckpoint = 0;
-              if (decision.delayMs > 0) {
-                await delay(decision.delayMs, undefined, { signal: executionSignal });
-              }
-              retryAttempt += 1;
-              await config.store.appendEvent({
-                conversationId: run.conversationId,
-                kind: "retry/started",
-                payload: { attempt: retryAttempt }
-              });
-              retrying = true;
-              draining = true;
-              continue;
-            }
-          }
-          if (firstOutputAt === undefined && (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")) {
-            firstOutputAt = performance.now();
-          }
-          if (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") {
-            await operationLifecycle.firstOutput();
-          }
-          if (part.type === "text-delta") {
-            appendText(parts, part.text);
-            await publish({
-              type: "assistant-delta",
-              conversationId: run.conversationId,
-              runId: run.id,
-              runtimeEpoch,
-              sequence: transientSequence(),
-              textDelta: part.text,
-              emittedAt: now().toISOString()
-            });
-          } else if (part.type === "reasoning-start") {
-            reasoningPartIndex = undefined;
-            updateReasoning("", part.providerMetadata);
-            const provider = providerEnvelope(part.providerMetadata);
-            await publish({
-              type: "reasoning-start",
-              conversationId: run.conversationId,
-              runId: run.id,
-              runtimeEpoch,
-              sequence: transientSequence(),
-              ...provider && { provider },
-              emittedAt: now().toISOString()
-            });
-          } else if (part.type === "reasoning-delta") {
-            updateReasoning(part.text, part.providerMetadata);
-            const provider = providerEnvelope(part.providerMetadata);
-            await publish({
-              type: "reasoning-delta",
-              conversationId: run.conversationId,
-              runId: run.id,
-              runtimeEpoch,
-              sequence: transientSequence(),
-              textDelta: part.text,
-              ...provider && { provider },
-              emittedAt: now().toISOString()
-            });
-          } else if (part.type === "reasoning-end") {
-            updateReasoning("", part.providerMetadata);
-            reasoningPartIndex = undefined;
-            const provider = providerEnvelope(part.providerMetadata);
-            await publish({
-              type: "reasoning-end",
-              conversationId: run.conversationId,
-              runId: run.id,
-              runtimeEpoch,
-              sequence: transientSequence(),
-              ...provider && { provider },
-              emittedAt: now().toISOString()
-            });
-          } else if (part.type === "tool-call") {
-            const provider = providerEnvelope(part.providerMetadata);
-            parts.push(AgentMessagePartSchema.parse({
-              type: "tool-call",
-              callId: part.toolCallId,
-              toolName: part.toolName,
-              input: jsonValue(part.input),
-              ...provider && { provider }
-            }));
-            await publish({
-              type: "tool-status",
-              conversationId: run.conversationId,
-              runId: run.id,
-              runtimeEpoch,
-              sequence: transientSequence(),
-              callId: part.toolCallId,
-              toolName: part.toolName,
-              status: "started",
-              input: jsonValue(part.input),
-              emittedAt: now().toISOString()
-            });
-          } else if (part.type === "tool-result") {
-            parts.push(AgentMessagePartSchema.parse({
-              type: "tool-result",
-              callId: part.toolCallId,
-              toolName: part.toolName,
-              outcome: "success",
-              output: jsonValue(part.output)
-            }));
-            await publish({
-              type: "tool-status",
-              conversationId: run.conversationId,
-              runId: run.id,
-              runtimeEpoch,
-              sequence: transientSequence(),
-              callId: part.toolCallId,
-              toolName: part.toolName,
-              status: "completed",
-              output: jsonValue(part.output),
-              emittedAt: now().toISOString()
-            });
-          } else if (part.type === "tool-error") {
-            internalCause = part.error;
-            if (isToolExecutionControlError(part.error)) {
-              await publish({
-                type: "tool-status",
-                conversationId: run.conversationId,
-                runId: run.id,
-                runtimeEpoch,
-                sequence: transientSequence(),
-                callId: part.toolCallId,
-                toolName: part.toolName,
-                status: "interrupted",
-                emittedAt: now().toISOString()
-              });
-              await checkpoint();
-              throw part.error;
-            }
-            const output = isAgentToolError(part.error) ? jsonValue(part.error.output) : { message: "Tool execution failed" };
-            parts.push(AgentMessagePartSchema.parse({
-              type: "tool-result",
-              callId: part.toolCallId,
-              toolName: part.toolName,
-              outcome: "error",
-              output
-            }));
-            await publish({
-              type: "tool-status",
-              conversationId: run.conversationId,
-              runId: run.id,
-              runtimeEpoch,
-              sequence: transientSequence(),
-              callId: part.toolCallId,
-              toolName: part.toolName,
-              status: "failed",
-              output,
-              emittedAt: now().toISOString()
-            });
-          } else if (part.type === "tool-output-denied") {
-            parts.push(AgentMessagePartSchema.parse({
-              type: "tool-result",
-              callId: part.toolCallId,
-              toolName: part.toolName,
-              outcome: "error",
-              output: { message: "Tool output denied" }
-            }));
-            await publish({
-              type: "tool-status",
-              conversationId: run.conversationId,
-              runId: run.id,
-              runtimeEpoch,
-              sequence: transientSequence(),
-              callId: part.toolCallId,
-              toolName: part.toolName,
-              status: "failed",
-              output: { message: "Tool output denied" },
-              emittedAt: now().toISOString()
-            });
-          } else if (part.type === "source") {
-            parts.push(AgentMessagePartSchema.parse({
-              type: "source",
-              sourceId: part.id,
-              ...part.sourceType === "url" && { url: part.url },
-              ...part.title && { title: part.title }
-            }));
-          } else if (part.type === "file" && config.persistGeneratedFile) {
-            const persisted = await config.persistGeneratedFile(part.file);
-            parts.push(AgentMessagePartSchema.parse({
-              type: "file",
-              mediaType: part.file.mediaType,
-              reference: persisted.reference,
-              ...persisted.filename && { filename: persisted.filename }
-            }));
-          } else if (part.type === "file") {
-            throw new Error("persistGeneratedFile is required for generated file output");
-          } else if (part.type === "reasoning-file" && config.persistGeneratedFile) {
-            const persisted = await config.persistGeneratedFile(part.file);
-            parts.push(AgentMessagePartSchema.parse({
-              type: "file",
-              mediaType: part.file.mediaType,
-              reference: persisted.reference,
-              ...persisted.filename && { filename: persisted.filename }
-            }));
-          } else if (part.type === "reasoning-file") {
-            throw new Error("persistGeneratedFile is required for generated reasoning files");
-          } else if (part.type === "tool-approval-request") {
-            parts.push(AgentMessagePartSchema.parse({
-              type: "tool-approval-request",
-              approvalId: part.approvalId,
-              callId: part.toolCall.toolCallId,
-              ...part.isAutomatic !== undefined && { isAutomatic: part.isAutomatic },
-              ...part.signature && { signature: part.signature }
-            }));
-          } else if (part.type === "tool-approval-response") {
-            parts.push(AgentMessagePartSchema.parse({
-              type: "tool-approval-response",
-              approvalId: part.approvalId,
-              approved: part.approved,
-              ...part.reason && { reason: part.reason }
-            }));
-          } else if (part.type === "custom") {
-            const provider = providerEnvelope(part.providerMetadata);
-            parts.push(AgentMessagePartSchema.parse({
-              type: "provider",
-              envelope: {
-                schemaVersion: 1,
-                provider: "ai-sdk-custom",
-                data: { kind: part.kind, ...provider && { provider: provider.data } }
-              }
-            }));
-          } else if (part.type === "raw") {
-            parts.push(AgentMessagePartSchema.parse({
-              type: "provider",
-              envelope: {
-                schemaVersion: 1,
-                provider: "ai-sdk-raw",
-                data: { value: jsonValue(part.rawValue) }
-              }
-            }));
-          } else if (part.type === "abort") {
-            terminalReason = "interrupted";
-          } else if (part.type === "error") {
-            terminalReason = failureThisRuntimeOwns(part.error) ?? "provider_failure";
-            internalCause = part.error;
-          } else if (part.type === "finish-step") {
-            const response = await recordProviderResponse({
-              id: part.response.id,
-              providerMetadata: part.providerMetadata,
-              stepNumber: step,
-              attempt: providerAttempt
-            });
-            await operationLifecycle.finish(part.finishReason === "error" ? "failed" : "completed");
-            const stepTrace = trace ? config.observe?.rootTrace(trace) : undefined;
-            const stepUsage = selectedModel.normalizeUsage?.({
-              usage: part.usage,
-              providerMetadata: part.providerMetadata
-            }) ?? normalizeSdkUsage(part.usage);
-            lastPromptTokens = stepUsage.inputTokens;
-            modelUsage = addUsage(modelUsage, stepUsage);
-            usage = nonModelUsage ? addUsage(nonModelUsage, billedUsage() ?? modelUsage) : billedUsage();
-            config.observe?.emit({
-              schemaVersion: 1,
-              eventId: generateId(),
-              type: "step-finished",
-              conversationId: run.conversationId,
-              runId: run.id,
-              traceId: stepTrace?.traceId ?? trace?.traceId ?? generateId(),
-              spanId: stepTrace?.spanId ?? generateId(),
-              ...stepTrace?.parentSpanId && { parentSpanId: stepTrace.parentSpanId },
-              state: run.state,
-              modelId: selectedModel.descriptor.modelId,
-              step,
-              usage: stepUsage,
-              response,
-              emittedAt: now().toISOString()
-            });
-            step += 1;
-          } else if (part.type === "finish" && part.finishReason !== "stop") {
-            if (terminalReason === "success") {
-              terminalReason = part.finishReason === "error" ? "provider_failure" : "provider_stop";
-              internalCause ??= { finishReason: part.finishReason };
-            }
-          }
-          if (part.type === "finish") {
-            sawProviderFinish = true;
-            modelUsage = mergeModelTotals(normalizeSdkUsage(part.totalUsage), modelUsage);
-            usage = nonModelUsage ? addUsage(nonModelUsage, billedUsage() ?? modelUsage) : billedUsage();
-          }
-          const structuralBoundary = [
-            "tool-call",
-            "tool-result",
-            "tool-error",
-            "tool-output-denied",
-            "tool-approval-request",
-            "tool-approval-response",
-            "finish-step"
-          ].includes(part.type);
-          if (structuralBoundary || eventsSinceCheckpoint >= checkpointEveryEvents) {
-            await checkpoint();
-            eventsSinceCheckpoint = 0;
-            if (part.type === "finish-step")
-              operationLifecycle.checkpointStep(step - 1);
-          }
-        }
-        if (retrying) {
-          await publish({
-            type: "attempt-reset",
-            conversationId: run.conversationId,
-            runId: run.id,
-            runtimeEpoch,
-            sequence: transientSequence(),
-            attempt: retryAttempt,
-            emittedAt: now().toISOString()
-          });
-          continue;
-        }
-        break;
-      }
-      await operationLifecycle.finish(executionSignal.aborted ? "cancelled" : terminalReason === "provider_failure" ? "failed" : "completed");
-      if (terminalPolicyName !== undefined)
-        terminalReason = "policy_stop";
-      if (executionSignal.aborted)
-        terminalReason = abortTerminalReason(executionSignal);
-      const awaitsApproval = parts.some((part) => part.type === "tool-approval-request");
-      if (!awaitsApproval && config.protocol.acceptTerminal && (terminalReason === "success" || terminalReason === "policy_stop" || terminalReason === "provider_stop")) {
-        const candidate = AgentMessageSchema.parse({
-          ...assistant,
-          status: assistantStatus(terminalReason),
-          parts,
-          updatedAt: now().toISOString()
-        });
-        if (!await config.protocol.acceptTerminal({
-          message: candidate,
-          reason: terminalReason,
-          ...terminalPolicyName && { policyName: terminalPolicyName }
-        })) {
-          terminalReason = "output_rejected";
-          internalCause = new Error("Agent terminal output was rejected by the protocol");
-        }
-      }
-    } catch (error) {
-      operationLifecycle.failStepCheckpoints(error);
-      internalCause = providerStreamCleanupFailure === undefined ? error : new AggregateError([error, providerStreamCleanupFailure], `${error instanceof Error ? error.message : String(error)} (provider stream cleanup also failed: ${providerStreamCleanupFailure instanceof Error ? providerStreamCleanupFailure.message : String(providerStreamCleanupFailure)})`);
-      const latest = await config.store.loadRun({
-        conversationId: run.conversationId,
-        runId: run.id
-      });
-      const latestRun = latest?.run;
-      const durableInterrupt = latestRun?.ownerId === runtimeEpoch && latestRun.state === "interrupt_requested";
-      if (durableInterrupt && latest && latestRun) {
-        observedVersion = latest.snapshotVersion;
-        run = latestRun;
-      }
-      const staleOwner = isToolExecutionControlError(error) && error.reason === "stale_run";
-      if (!staleOwner) {
-        await operationLifecycle.finish(executionSignal.aborted || durableInterrupt ? "cancelled" : "failed");
-      }
-      if (isToolExecutionControlError(error) || executionSignal.aborted || durableInterrupt) {
-        terminalReason = executionSignal.aborted ? abortTerminalReason(executionSignal) : "interrupted";
-        parts.push(AgentMessagePartSchema.parse({
-          type: "control",
-          reason: isToolExecutionControlError(error) && error.reason === "stale_run" ? "stale-run" : "run-interrupted"
-        }));
-      } else if (error instanceof AgentContextOverflowError) {
-        terminalReason = "context_overflow";
-      } else if (error instanceof AgentRuntimeConflictError) {
-        terminalReason = "storage_conflict";
-      } else {
-        terminalReason = failureThisRuntimeOwns(error) ?? (hasProviderOrigin(error) ? "provider_failure" : "runtime_failure");
-      }
-    } finally {
-      idleDeadline.dispose();
-    }
-    assistant = AgentMessageSchema.parse({
-      ...assistant,
-      status: assistantStatus(terminalReason),
-      parts,
-      updatedAt: now().toISOString()
-    });
-    const spent = statedUsage(usage);
-    const emitSpend = (report) => {
-      config.observe?.emit({
-        schemaVersion: 1,
-        eventId: report.eventId,
-        type: "run-terminal",
-        conversationId: run.conversationId,
-        runId: run.id,
-        traceId: trace?.traceId ?? generateId(),
-        spanId: trace?.spanId ?? generateId(),
-        ...trace?.parentSpanId && { parentSpanId: trace.parentSpanId },
-        state: report.state,
-        terminalReason: report.reason,
-        ...selectedModel && { modelId: selectedModel.descriptor.modelId },
-        durationMs: performance.now() - runStartedAt,
-        usage: spent,
-        ...internalCause !== undefined && { internalCause },
-        ...firstOutputAt !== undefined && { ttftMs: firstOutputAt - runStartedAt },
-        emittedAt: now().toISOString()
-      });
-    };
-    const unsettledEventId = (version) => agentDurableEventId("terminal", `${run.id}:${runtimeEpoch}`, version);
-    let terminal;
-    try {
-      terminal = await commitAgentRunTerminal({
-        store: config.store,
-        runtimeEpoch,
-        candidate: {
-          run,
-          assistant,
-          reason: terminalReason,
-          ...terminalPolicyName && { policyName: terminalPolicyName },
-          usage: spent,
-          ...absorbed.size > 0 && runStateForTerminalReason(terminalReason) === "completed" && {
-            absorb: [...absorbed].map(([runId, inputMessageIds]) => ({
-              runId,
-              inputMessageIds
-            }))
-          }
-        },
-        now
-      });
-    } catch (error) {
-      emitSpend({
-        eventId: unsettledEventId(observedVersion),
-        state: run.state,
-        reason: terminalReason
-      });
-      throw error;
-    }
-    observedVersion = terminal.snapshotVersion;
-    run = terminal.run;
-    assistant = terminal.assistant;
-    terminalReason = terminal.reason;
-    terminalPolicyName = terminal.policyName;
-    const terminalMetrics = terminal.committedByCaller ? {
-      partial: !sawProviderFinish,
-      durationMs: performance.now() - runStartedAt,
-      usage: spent,
-      ...firstOutputAt !== undefined && { ttftMs: firstOutputAt - runStartedAt }
-    } : undefined;
-    if (config.children && terminal.committedByCaller && (terminalReason === "interrupted" || terminalReason === "cancelled" || terminalReason === "timeout" || terminalReason === "shutdown")) {
-      try {
-        await config.children.stopChildren(run.conversationId);
-      } catch (error) {
-        internalCause ??= error;
-      }
-    }
-    emitSpend({
-      eventId: terminal.committedByCaller ? agentDurableEventId("terminal", run.id, observedVersion) : unsettledEventId(observedVersion),
-      state: run.state,
-      reason: terminalReason
-    });
-    for (const settled of terminal.absorbed ?? []) {
-      await publish({
-        type: "run-state",
-        eventId: agentDurableEventId("run-state", settled.id, observedVersion),
-        conversationId: settled.conversationId,
-        runId: settled.id,
-        snapshotVersion: observedVersion,
-        state: settled.state,
-        emittedAt: now().toISOString()
-      });
-    }
-    if (terminalMetrics) {
-      await publish({
-        type: "terminal",
-        eventId: agentDurableEventId("terminal", run.id, observedVersion),
-        conversationId: run.conversationId,
-        runId: run.id,
-        snapshotVersion: observedVersion,
-        reason: terminalReason,
-        ...terminalPolicyName && { policyName: terminalPolicyName },
-        message: assistant,
-        metrics: terminalMetrics,
-        emittedAt: now().toISOString()
-      });
-    }
-    return {
-      run,
-      message: assistant,
-      reason: terminalReason,
-      snapshotVersion: observedVersion,
-      ...terminalMetrics && { metrics: terminalMetrics },
-      ...terminalPolicyName && { policyName: terminalPolicyName }
-    };
-  };
-}
-
-// src/agent-runtime/runtime.ts
-function createAgentRuntime(config) {
-  const coordinator = createAgentSessionCoordinator();
-  const tickets = new Map;
-  const generateId = config.generateId ?? (() => crypto.randomUUID());
-  const now = config.now ?? (() => new Date);
-  const runtimeEpoch = generateId();
-  const admissionLanes = createRuntimeAdmissionLanes();
-  const injectionPossible = typeof config.runs?.inputPolicy === "function" || config.runs?.inputPolicy === "inject";
-  const injection = injectionPossible ? createAgentInjectionRegistry() : undefined;
-  const reserveAdmission = admissionLanes.reserve;
-  const settleAdmission = admissionLanes.settle;
-  const waitForAdmissionAcceptances = admissionLanes.waitForAcceptances;
-  const checkpointEveryEvents = config.loop?.checkpointEveryEvents ?? 20;
-  const maxSteps = config.loop?.maxSteps ?? 50;
-  const declaredIdleTimeoutMs = config.loop?.idleTimeoutMs;
-  const idleTimeoutMs = declaredIdleTimeoutMs === null ? undefined : declaredIdleTimeoutMs ?? 60000;
-  if (!Number.isSafeInteger(checkpointEveryEvents) || checkpointEveryEvents < 1) {
-    throw new TypeError("checkpointEveryEvents must be a positive safe integer");
-  }
-  if (!Number.isSafeInteger(maxSteps) || maxSteps < 1) {
-    throw new TypeError("maxSteps must be a positive safe integer");
-  }
-  if (idleTimeoutMs !== undefined && (!Number.isSafeInteger(idleTimeoutMs) || idleTimeoutMs < 1)) {
-    throw new TypeError("idleTimeoutMs must be a positive safe integer");
-  }
-  const policyNames = new Set(["max-steps"]);
-  for (const policy of config.loop?.stopPolicies ?? []) {
-    if (!policy.name || policyNames.has(policy.name)) {
-      throw new TypeError("Agent stop policy names must be non-empty and unique");
-    }
-    policyNames.add(policy.name);
-  }
-  const publish = async (event) => {
-    try {
-      await config.publish?.(event);
-    } catch (error) {
-      try {
-        await config.onPublishError?.({ event, error });
-      } catch {}
-    }
-  };
-  const executeRun = createRunExecutor({
-    config,
-    publish,
-    runtimeEpoch,
-    generateId,
-    now,
-    checkpointEveryEvents,
-    maxSteps,
-    ...idleTimeoutMs !== undefined && { idleTimeoutMs },
-    ...injection && { injection }
-  });
-  let admissionClosed = false;
-  const closedError = () => new Error("[stitchkit] agent runtime is closed and admits no further work");
-  const admissionsInFlight = new Set;
-  const beginAdmission = () => {
-    const handoff = Promise.withResolvers();
-    admissionsInFlight.add(handoff);
-    return () => {
-      if (admissionsInFlight.delete(handoff))
-        handoff.resolve();
-    };
-  };
-  const drainAdmissions = async (budgetMs) => {
-    const pending = [...admissionsInFlight].map((handoff) => handoff.promise);
-    if (pending.length === 0)
-      return 0;
-    let stranded = pending.length;
-    const settled = Promise.all(pending.map((promise) => promise.then(() => {
-      stranded -= 1;
-    })));
-    if (budgetMs === undefined) {
-      await settled;
-      return 0;
-    }
-    let timer;
-    await Promise.race([
-      settled,
-      new Promise((resolve) => {
-        timer = setTimeout(resolve, budgetMs);
-      })
-    ]);
-    if (timer !== undefined)
-      clearTimeout(timer);
-    return stranded;
-  };
-  const refuse = () => {
-    const error = closedError();
-    const accepted = Promise.reject(error);
-    const result = Promise.reject(error);
-    accepted.catch(() => {
-      return;
-    });
-    result.catch(() => {
-      return;
-    });
-    return { accepted, result };
-  };
-  const resume = (rawInput) => {
-    if (admissionClosed)
-      return refuse();
-    const context = config.protocol.parseContext(rawInput.context);
-    const accepted = Promise.withResolvers();
-    const result = Promise.withResolvers();
-    let acquisitionSettled = false;
-    const resolveAcquisition = () => {
-      acquisitionSettled = true;
-      accepted.resolve();
-    };
-    const rejectAcquisition = (error) => {
-      if (!acquisitionSettled)
-        accepted.reject(error);
-    };
-    const handedOff = beginAdmission();
-    (async () => {
-      try {
-        const recovered = await config.store.loadRun({
-          conversationId: rawInput.conversationId,
-          runId: rawInput.runId
-        });
-        if (!recovered)
-          throw new AgentRuntimeConflictError("run lookup");
-        const recoveredRun = recovered.run;
-        if (recoveredRun.state !== "queued") {
-          throw new Error("Only a queued recovered agent run can be resumed");
-        }
-        const ticket = coordinator.submit({
-          key: rawInput.conversationKey ?? rawInput.conversationId,
-          policy: "queue",
-          create: (signal) => ({
-            runId: recoveredRun.id,
-            execute: () => executeRun({
-              acceptedRun: recoveredRun,
-              context,
-              signal,
-              key: rawInput.conversationKey ?? rawInput.conversationId,
-              onAcquired: resolveAcquisition
-            })
-          })
-        });
-        ticket.accepted.catch(() => {
-          return;
-        });
-        ticket.result.then(result.resolve, (error) => {
-          rejectAcquisition(error);
-          result.reject(error);
-        });
-      } catch (error) {
-        rejectAcquisition(error);
-        result.reject(error);
-      } finally {
-        handedOff();
-      }
-    })();
-    return { accepted: accepted.promise, result: result.promise };
-  };
-  return {
-    submit(rawInput) {
-      if (admissionClosed) {
-        const refused = refuse();
-        const admission = Promise.reject(closedError());
-        admission.catch(() => {
-          return;
-        });
-        return { ...refused, admission };
-      }
-      const metadata = rawInput.metadata === undefined ? undefined : config.protocol.parseInputMetadata(rawInput.metadata);
-      const input = {
-        conversationId: rawInput.conversationId,
-        idempotencyKey: rawInput.idempotencyKey,
-        context: rawInput.context,
-        parts: rawInput.parts.map((part) => config.protocol.parsePart(part)),
-        role: rawInput.role ?? "user",
-        ...metadata !== undefined && { metadata }
-      };
-      if (input.role === "tool" && (input.parts.length === 0 || input.parts.some((part) => part.type !== "tool-approval-response"))) {
-        throw new TypeError("Tool-role Agent input only accepts approval responses");
-      }
-      const context = config.protocol.parseContext(input.context);
-      const conversationTickets = tickets.get(input.conversationId);
-      const existingTicket = conversationTickets?.get(input.idempotencyKey);
-      if (existingTicket)
-        return existingTicket;
-      const key = config.runs?.key?.(input) ?? input.conversationId;
-      const policy = typeof config.runs?.inputPolicy === "function" ? config.runs.inputPolicy(input) : config.runs?.inputPolicy ?? "queue";
-      const nowIso = now().toISOString();
-      const inputMessageId = rawInput.recordIds?.inputMessageId ?? generateId();
-      const runId = rawInput.recordIds?.runId ?? generateId();
-      const assistantMessageId = rawInput.recordIds?.assistantMessageId ?? generateId();
-      const userMessage2 = AgentMessageSchema.parse({
-        schemaVersion: 1,
-        id: inputMessageId,
-        conversationId: input.conversationId,
-        role: input.role,
-        status: "committed",
-        parts: input.parts,
-        ...input.metadata && { metadata: input.metadata },
-        createdAt: nowIso,
-        updatedAt: nowIso
-      });
-      const queuedRun = AgentRunSchema.parse({
-        schemaVersion: 1,
-        id: runId,
-        conversationId: input.conversationId,
-        inputMessageIds: [inputMessageId],
-        assistantMessageId,
-        state: "queued",
-        revision: 0,
-        ...policy === "interrupt-next" && { queuePriority: "interrupt-next" },
-        createdAt: nowIso,
-        updatedAt: nowIso
-      });
-      const outerAccepted = Promise.withResolvers();
-      outerAccepted.promise.catch(() => {
-        return;
-      });
-      const outerAdmission = Promise.withResolvers();
-      outerAdmission.promise.catch(() => {
-        return;
-      });
-      const outerResult = Promise.withResolvers();
-      const reservation = config.runs?.coalescePending && policy !== "interrupt-next" ? reserveAdmission(key, runId) : undefined;
-      const previousAcceptance = reservation?.lane.acceptanceTail ?? Promise.resolve();
-      const acceptanceDone = Promise.withResolvers();
-      if (reservation) {
-        reservation.lane.acceptanceTail = previousAcceptance.catch(() => {
-          return;
-        }).then(() => acceptanceDone.promise);
-      }
-      const publicTicket = {
-        accepted: outerAccepted.promise,
-        admission: outerAdmission.promise,
-        result: outerResult.promise
-      };
-      const currentConversationTickets = conversationTickets ?? new Map;
-      currentConversationTickets.set(input.idempotencyKey, publicTicket);
-      if (!conversationTickets)
-        tickets.set(input.conversationId, currentConversationTickets);
-      let offeredRunId;
-      const forgetTicket = () => {
-        if (offeredRunId !== undefined)
-          injection?.withdraw(key, offeredRunId);
-        if (currentConversationTickets.get(input.idempotencyKey) !== publicTicket)
-          return;
-        currentConversationTickets.delete(input.idempotencyKey);
-        if (currentConversationTickets.size === 0)
-          tickets.delete(input.conversationId);
-      };
-      outerResult.promise.then(forgetTicket, forgetTicket);
-      const handedOff = beginAdmission();
-      (async () => {
-        try {
-          await previousAcceptance.catch(() => {
-            return;
-          });
-          await config.models.preflight?.({
-            context,
-            conversationId: input.conversationId
-          });
-          if (admissionClosed)
-            throw closedError();
-          const acceptance = await config.store.acceptInputAndAssignRun({
-            idempotencyKey: input.idempotencyKey,
-            input: userMessage2,
-            run: queuedRun,
-            ...reservation && !reservation.shouldSchedule && {
-              coalesceIntoRunId: reservation.admission.runId
-            }
-          });
-          const acceptedSnapshot = appliedSnapshot(acceptance, "input acceptance");
-          const assignedRunId = acceptance.outcome === "duplicate" ? acceptance.runId : reservation?.admission.runId ?? runId;
-          const acceptedRun = acceptance.outcome === "duplicate" ? acceptance.run : findRun(acceptedSnapshot.runs, assignedRunId);
-          const actualInputMessageId = acceptance.outcome === "duplicate" ? acceptance.inputMessageId : userMessage2.id;
-          const acceptedInput = acceptance.outcome === "duplicate" ? acceptance.input : acceptedSnapshot.messages.find((candidate) => candidate.id === actualInputMessageId);
-          if (!acceptedInput) {
-            throw new AgentRuntimeConflictError("admission input projection");
-          }
-          const assistantPlaceholder = AgentAssistantPlaceholderSchema.parse({
-            schemaVersion: 1,
-            id: acceptedRun.assistantMessageId,
-            conversationId: acceptedRun.conversationId,
-            runId: acceptedRun.id,
-            status: "pending",
-            createdAt: acceptedRun.createdAt,
-            updatedAt: acceptedRun.updatedAt
-          });
-          const acceptedAssistant = acceptance.outcome === "duplicate" ? acceptance.assistant ?? assistantPlaceholder : assistantPlaceholder;
-          const admission = {
-            inputMessageId: acceptedInput.id,
-            runId: acceptedRun.id,
-            assistantMessageId: assistantPlaceholder.id,
-            input: acceptedInput,
-            run: acceptedRun,
-            assistant: acceptedAssistant,
-            snapshotVersion: acceptedSnapshot.version
-          };
-          outerAdmission.resolve(admission);
-          await publish({
-            type: "admission",
-            eventId: agentDurableEventId("admission", acceptedRun.id, acceptedSnapshot.version),
-            conversationId: acceptedRun.conversationId,
-            runId: acceptedRun.id,
-            snapshotVersion: acceptedSnapshot.version,
-            input: acceptedInput,
-            run: acceptedRun,
-            assistant: acceptedAssistant,
-            emittedAt: now().toISOString()
-          });
-          await publish({
-            type: "run-state",
-            eventId: agentDurableEventId("run-state", acceptedRun.id, acceptedSnapshot.version),
-            conversationId: acceptedRun.conversationId,
-            runId: acceptedRun.id,
-            snapshotVersion: acceptedSnapshot.version,
-            state: acceptedRun.state,
-            emittedAt: now().toISOString()
-          });
-          outerAccepted.resolve();
-          if (acceptance.outcome === "duplicate") {
-            if (!acceptedRun.terminalReason) {
-              const error = new Error("Duplicate input is already owned by another runtime execution");
-              outerResult.reject(error);
-              if (reservation?.shouldSchedule) {
-                reservation.admission.completion.reject(error);
-                settleAdmission(key, reservation.admission);
-              }
-              return;
-            }
-            const message = acceptance.assistant;
-            if (!message) {
-              const error = new Error("Duplicate terminal admission has no retained canonical assistant");
-              outerResult.reject(error);
-              if (reservation?.shouldSchedule) {
-                reservation.admission.completion.reject(error);
-                settleAdmission(key, reservation.admission);
-              }
-              return;
-            }
-            outerResult.resolve({
-              run: acceptedRun,
-              message,
-              reason: acceptedRun.terminalReason,
-              snapshotVersion: acceptedSnapshot.version,
-              ...acceptedRun.terminalPolicyName && {
-                policyName: acceptedRun.terminalPolicyName
-              }
-            });
-            if (reservation?.shouldSchedule) {
-              reservation.admission.completion.reject(new Error("Reserved run resolved to a duplicate durable input"));
-              settleAdmission(key, reservation.admission);
-            }
-            return;
-          }
-          if (policy === "inject") {
-            offeredRunId = acceptedRun.id;
-            injection?.offer(key, { runId: acceptedRun.id, input: acceptedInput });
-          }
-          if (reservation && !reservation.shouldSchedule) {
-            reservation.admission.completion.promise.then(outerResult.resolve, outerResult.reject);
-            return;
-          }
-          const ticket = coordinator.submit({
-            key,
-            policy,
-            create: async (signal) => {
-              if (reservation)
-                await waitForAdmissionAcceptances(reservation.lane);
-              return {
-                runId: acceptedRun.id,
-                execute: () => executeRun({ acceptedRun, context, signal, key })
-              };
-            }
-          });
-          ticket.accepted.catch(() => {
-            return;
-          });
-          if (reservation) {
-            ticket.result.then(reservation.admission.completion.resolve, reservation.admission.completion.reject);
-            reservation.admission.completion.promise.then((value) => {
-              settleAdmission(key, reservation.admission);
-              outerResult.resolve(value);
-            }, (error) => {
-              settleAdmission(key, reservation.admission);
-              outerResult.reject(error);
-            });
-          } else {
-            ticket.result.then(outerResult.resolve, outerResult.reject);
-          }
-        } catch (error) {
-          outerAccepted.reject(error);
-          outerAdmission.reject(error);
-          outerResult.reject(error);
-          if (reservation?.shouldSchedule) {
-            reservation.admission.completion.reject(error);
-            settleAdmission(key, reservation.admission);
-          }
-        } finally {
-          acceptanceDone.resolve();
-          handedOff();
-        }
-      })();
-      return publicTicket;
-    },
-    resume,
-    async interrupt(input) {
-      const view = await config.store.loadRun({
-        conversationId: input.conversationId,
-        runId: input.runId
-      });
-      if (!view)
-        throw new AgentRuntimeConflictError("run lookup");
-      const requested = await config.store.requestRunInterrupt({
-        conversationId: input.conversationId,
-        runId: input.runId,
-        expectedRevision: view.run.revision
-      });
-      if (requested.outcome === "applied") {
-        const interruptedRun = findRun(requested.snapshot.runs, input.runId);
-        await publish({
-          type: "run-state",
-          eventId: agentDurableEventId("run-state", interruptedRun.id, requested.snapshot.version),
-          conversationId: interruptedRun.conversationId,
-          runId: interruptedRun.id,
-          snapshotVersion: requested.snapshot.version,
-          state: interruptedRun.state,
-          emittedAt: now().toISOString()
-        });
-        coordinator.stop(input.conversationKey ?? input.conversationId, "user-interrupt");
-      }
-      return requested;
-    },
-    async abandon(input) {
-      if (input.staleOwner !== true) {
-        throw new TypeError("Abandoning a run requires explicit staleOwner evidence");
-      }
-      const releaseAdmission = beginAdmission();
-      try {
-        const abandoned = await 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 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: now().toISOString()
-          });
-        }
-        return abandoned;
-      } finally {
-        releaseAdmission();
-      }
-    },
-    async recover(options) {
-      if (admissionClosed)
-        throw closedError();
-      const pageSize = options.pageSize ?? 100;
-      const maxRuns = options.maxRuns ?? 1000;
-      if (!Number.isSafeInteger(pageSize) || pageSize < 1 || pageSize > 1000) {
-        throw new TypeError("Recovery pageSize must be an integer between 1 and 1000");
-      }
-      if (!Number.isSafeInteger(maxRuns) || maxRuns < 1) {
-        throw new TypeError("Recovery maxRuns must be a positive safe integer");
-      }
-      const recoverable = [];
-      let cursor;
-      while (recoverable.length < maxRuns && !options.signal?.aborted && !admissionClosed) {
-        const page = await config.store.scanRecoverable({
-          ...cursor && { cursor },
-          limit: Math.min(pageSize, maxRuns - recoverable.length)
-        });
-        recoverable.push(...page.items);
-        cursor = page.nextCursor;
-        if (!cursor || page.items.length === 0)
-          break;
-      }
-      const grouped = new Map;
-      for (const item of recoverable) {
-        const items = grouped.get(item.conversationId) ?? [];
-        items.push(item);
-        grouped.set(item.conversationId, items);
-      }
-      const ordered = [];
-      for (const [conversationId, items] of grouped) {
-        const active = await config.store.listActiveRuns(conversationId);
-        const position = new Map(active.map((run, index) => [run.id, index]));
-        ordered.push(...items.sort((left, right) => {
-          const leftPosition = position.get(left.run.id);
-          const rightPosition = position.get(right.run.id);
-          if (leftPosition === undefined && rightPosition === undefined)
-            return 0;
-          if (leftPosition === undefined)
-            return 1;
-          if (rightPosition === undefined)
-            return -1;
-          return leftPosition - rightPosition;
-        }));
-      }
-      const outcomes = [];
-      const scheduledRuns = new Map;
-      for (const item of ordered) {
-        if (options.signal?.aborted)
-          break;
-        if (admissionClosed)
-          break;
-        const releaseAdmission = beginAdmission();
-        try {
-          const active = await config.store.listActiveRuns(item.conversationId);
-          const position = active.findIndex((run) => run.id === item.run.id);
-          const scheduled = scheduledRuns.get(item.conversationId) ?? new Set;
-          const blockedByUnscheduledPredecessor = position > 0 && active.slice(0, position).some((run) => !scheduled.has(run.id));
-          if (blockedByUnscheduledPredecessor) {
-            outcomes.push({
-              conversationId: item.conversationId,
-              runId: item.run.id,
-              outcome: "skipped"
-            });
-            continue;
-          }
-          const decision = await options.decide?.(item) ?? (item.run.state === "queued" ? { action: "resume" } : { action: "skip" });
-          if (admissionClosed)
-            throw closedError();
-          if (decision.action === "skip") {
-            outcomes.push({
-              conversationId: item.conversationId,
-              runId: item.run.id,
-              outcome: "skipped"
-            });
-            continue;
-          }
-          if (decision.action === "abandon") {
-            const abandoned = await config.store.recoverRun({
-              conversationId: item.conversationId,
-              runId: item.run.id,
-              expectedRevision: item.run.revision,
-              action: "abandon"
-            });
-            if (abandoned.outcome !== "applied") {
-              throw new AgentRuntimeConflictError("recovery abandon");
-            }
-            outcomes.push({
-              conversationId: item.conversationId,
-              runId: item.run.id,
-              outcome: "abandoned"
-            });
-            continue;
-          }
-          if (decision.action === "requeue") {
-            const requeued = await config.store.recoverRun({
-              conversationId: item.conversationId,
-              runId: item.run.id,
-              expectedRevision: item.run.revision,
-              action: "requeue",
-              replaySafe: true
-            });
-            if (requeued.outcome !== "applied") {
-              throw new AgentRuntimeConflictError("recovery requeue");
-            }
-          }
-          const context = await options.resolveContext(item);
-          const resumed = resume({
-            conversationId: item.conversationId,
-            runId: item.run.id,
-            context
-          });
-          resumed.result.catch(() => {
-            return;
-          });
-          await resumed.accepted;
-          scheduled.add(item.run.id);
-          scheduledRuns.set(item.conversationId, scheduled);
-          outcomes.push({
-            conversationId: item.conversationId,
-            runId: item.run.id,
-            outcome: decision.action === "requeue" ? "requeued" : "resumed",
-            result: resumed.result
-          });
-        } catch (error) {
-          outcomes.push({
-            conversationId: item.conversationId,
-            runId: item.run.id,
-            outcome: "failed",
-            error
-          });
-        } finally {
-          releaseAdmission();
-        }
-      }
-      return outcomes;
-    },
-    stop: (conversationKey, reason) => coordinator.stop(conversationKey, reason),
-    close: async (options = {}) => {
-      assertCloseBudgets(options);
-      admissionClosed = true;
-      const startedAt = performance.now();
-      injection?.clear();
-      const stranded = await drainAdmissions(options.forceTimeoutMs);
-      const spent = Math.max(0, Math.round(performance.now() - startedAt));
-      const remainingBudget = (value) => value === undefined ? undefined : Math.max(0, value - spent);
-      const grace = remainingBudget(options.gracePeriodMs);
-      const force = remainingBudget(options.forceTimeoutMs);
-      const result = await coordinator.close({
-        ...grace !== undefined && { gracePeriodMs: grace },
-        ...force !== undefined && { forceTimeoutMs: force }
-      });
-      if (stranded === 0)
-        return result;
-      return { settled: false, timedOut: true, remaining: result.remaining + stranded };
-    }
-  };
-}
-
-export { 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 };