stitchkit 0.100.2 → 0.101.0

package/dist/{index-f4fx2tza.js → index-zs4ms3th.js}

@@ -1,57 +1,57 @@
 import {
-  messageOf
-} from "./index-83bdg97s.js";
-import {
-  AgentRuntimeEventSchema,
-  agentDurableEventId
-} from "./index-y64k3s0h.js";
+  AgentJsonObjectSchema2,
+  AgentProviderResponseSchema2,
+  AgentMessagePartSchema2,
+  AgentMessageSchema2,
+  AgentAssistantPlaceholderSchema2,
+  AgentRunOperationSchema2,
+  runStateForTerminalReason2,
+  AgentProvenanceSchema2,
+  AgentUsageSchema2,
+  AgentRunSchema2,
+  AgentSnapshotSchema2
+} from "./index-8kzct1d6.js";
 import {
   createBoundedSinkManager
-} from "./index-h6eeys1v.js";
+} from "./index-h97tqqp1.js";
+import {
+  AgentRuntimeEventSchema2,
+  agentDurableEventId2
+} from "./index-mnkk1ffz.js";
 import {
+  ToolExecutionControlError2,
+  isToolExecutionControlError2
+} from "./index-dvwj1f43.js";
+import {
+  createLocalStepDurability2,
+  isAgentToolError2,
+  createToolDurabilityContext
+} from "./index-a9pd417t.js";
+import {
+  canonicalAgentJson2,
+  createToolChronology,
   advanceToolChronology,
-  assistantStatus,
   canProjectToolChronology,
-  canonicalAgentJson,
-  createToolChronology,
-  isAssistantHistoryEvidence,
-  isCompleteAgentHistoryTurn
-} from "./index-cyktc4bp.js";
+  isAssistantHistoryEvidence2,
+  isCompleteAgentHistoryTurn,
+  assistantStatus
+} from "./index-r5hsgkz5.js";
 import {
-  AgentAssistantPlaceholderSchema,
-  AgentJsonObjectSchema,
-  AgentMessagePartSchema,
-  AgentMessageSchema,
-  AgentProvenanceSchema,
-  AgentProviderResponseSchema,
-  AgentRunOperationSchema,
-  AgentRunSchema,
-  AgentSnapshotSchema,
-  AgentUsageSchema,
-  runStateForTerminalReason
-} from "./index-gtj3zc53.js";
+  messageOf
+} from "./index-g149e9pk.js";
 import {
   createMutationQueue
-} from "./index-q3pyb9n0.js";
-import {
-  createLocalStepDurability,
-  createToolDurabilityContext,
-  isAgentToolError
-} from "./index-79z7m7dt.js";
-import {
-  ToolExecutionControlError,
-  isToolExecutionControlError
-} from "./index-8qt2m66q.js";
+} from "./index-sykb5ag7.js";
 import {
   serializeCanonicalJson
-} from "./index-k5hsfc3j.js";
+} from "./index-zsvzhjtk.js";
 import {
   isRecord,
   transportResult
-} from "./index-hffjpmq9.js";
+} from "./index-9jfdm5tg.js";
 
 // src/agent-runtime/terminal-commit.ts
-class AgentRuntimeConflictError extends Error {
+class AgentRuntimeConflictError2 extends Error {
   constructor(operation) {
     super(`Agent runtime store conflict during ${operation}`);
     this.name = "AgentRuntimeConflictError";
@@ -60,7 +60,7 @@ class AgentRuntimeConflictError extends Error {
 function appliedSnapshot(result, operation) {
   if (result.outcome === "applied" || result.outcome === "duplicate")
     return result.snapshot;
-  throw new AgentRuntimeConflictError(operation);
+  throw new AgentRuntimeConflictError2(operation);
 }
 function viewOfSnapshot(snapshot, runId, retainedAssistant) {
   const run = snapshot.runs.find((candidate) => candidate.id === runId);
@@ -85,7 +85,7 @@ function canonicalTerminal(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");
+    throw new AgentRuntimeConflictError2("terminal result projection");
   }
   return {
     snapshotVersion: view.snapshotVersion,
@@ -102,12 +102,12 @@ function interruptedCandidate(candidate, run, now) {
   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" })
+    AgentMessagePartSchema2.parse({ type: "control", reason: "run-interrupted" })
   ];
   return {
     ...candidate.usage && { usage: candidate.usage },
     run,
-    assistant: AgentMessageSchema.parse({
+    assistant: AgentMessageSchema2.parse({
       ...candidate.assistant,
       status: assistantStatus(reason),
       parts,
@@ -138,24 +138,24 @@ async function commitAgentRunTerminal(input) {
       ...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 terminal = canonicalTerminal(viewOfSnapshot(committed.snapshot, candidate.run.id));
+      if (!terminal)
+        throw new AgentRuntimeConflictError2("terminal result projection");
       const absorbed = committed.snapshot.runs.filter((run) => run.absorbedIntoRunId === candidate.run.id);
       return {
-        ...terminal2,
+        ...terminal,
         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;
+      const terminal = canonicalTerminal(viewOfSnapshot(committed.snapshot, candidate.run.id, committed.assistant));
+      if (!terminal)
+        throw new AgentRuntimeConflictError2("terminal result projection");
+      return terminal;
     }
     if (committed.outcome !== "conflict") {
-      throw new AgentRuntimeConflictError("terminal commit");
+      throw new AgentRuntimeConflictError2("terminal commit");
     }
     const latest = await input.store.loadRun({
       conversationId: candidate.run.conversationId,
@@ -166,15 +166,15 @@ async function commitAgentRunTerminal(input) {
       return terminal;
     const current = latest?.run;
     if (!current || !canRetryTerminal(current, candidate.run, input.runtimeEpoch)) {
-      throw new AgentRuntimeConflictError("terminal commit");
+      throw new AgentRuntimeConflictError2("terminal commit");
     }
     candidate = current.state === "interrupt_requested" ? interruptedCandidate(candidate, current, input.now) : { ...candidate, run: current };
   }
-  throw new AgentRuntimeConflictError("terminal commit");
+  throw new AgentRuntimeConflictError2("terminal commit");
 }
 
 // src/agent-runtime/context-refusal.ts
-class AgentContextOverflowError extends Error {
+class AgentContextOverflowError2 extends Error {
   name = "AgentContextOverflowError";
   constructor(message = "Agent context exceeds the configured model budget", options) {
     super(message, options);
@@ -189,7 +189,7 @@ function assertCloseBudgets(options) {
     }
   }
 }
-function createAgentSessionCoordinator() {
+function createAgentSessionCoordinator2() {
   const lanes = new Map;
   let closed = false;
   const waitWithin = async (settled, timeoutMs) => {
@@ -325,7 +325,7 @@ function createAgentSessionCoordinator() {
 }
 
 // src/agent-runtime/events.ts
-function createAgentRuntimeEventSink(config) {
+function createAgentRuntimeEventSink2(config) {
   const manager = createBoundedSinkManager({
     write: config.write,
     ...config.maxPending !== undefined && { maxPending: config.maxPending },
@@ -334,10 +334,10 @@ function createAgentRuntimeEventSink(config) {
   });
   return {
     publish(rawEvent) {
-      const event = AgentRuntimeEventSchema.parse(rawEvent);
+      const event = AgentRuntimeEventSchema2.parse(rawEvent);
       const projected = config.project?.(event) ?? (config.project ? undefined : event);
       if (projected)
-        manager.submit(() => AgentRuntimeEventSchema.parse(projected));
+        manager.submit(() => AgentRuntimeEventSchema2.parse(projected));
     },
     flush: (bound) => manager.flush(bound),
     getStatus: () => manager.getStatus(),
@@ -528,7 +528,7 @@ function interruptedSystemNote(message) {
   rendered.add("control");
   return { text: `[interrupted] partial response: ${text}`, rendered };
 }
-async function projectAgentHistoryDetailed(messages, options = {}) {
+async function projectAgentHistoryDetailed2(messages, options = {}) {
   const projected = [];
   const system = [];
   const decisions = [];
@@ -542,7 +542,7 @@ async function projectAgentHistoryDetailed(messages, options = {}) {
       chronology = createToolChronology();
       observedUser = false;
     }
-    if (message.role === "assistant" && !isAssistantHistoryEvidence(message.status, options.evidencePolicy)) {
+    if (message.role === "assistant" && !isAssistantHistoryEvidence2(message.status, options.evidencePolicy)) {
       decisions.push(decide(message, "omitted", message.status === "superseded" ? "superseded" : "draft-or-failed"));
       continue;
     }
@@ -610,15 +610,15 @@ async function projectAgentHistoryDetailed(messages, options = {}) {
   }
   return { messages: projected, decisions, system };
 }
-async function projectAgentHistory(messages, options = {}) {
-  return [...(await projectAgentHistoryDetailed(messages, options)).messages];
+async function projectAgentHistory2(messages, options = {}) {
+  return [...(await projectAgentHistoryDetailed2(messages, options)).messages];
 }
 
 // src/agent-runtime/invocation-schema.ts
 import { z } from "zod";
 var Id = z.string().min(1).max(512);
 var Hash = z.string().regex(/^[a-f0-9]{64}$/);
-var ModelInvocationTraceSchema = z.object({
+var ModelInvocationTraceSchema2 = z.object({
   operationId: Id,
   purpose: Id,
   project: Id,
@@ -627,10 +627,10 @@ var ModelInvocationTraceSchema = z.object({
   case: Id.optional(),
   profile: Id.optional()
 }).strict();
-var CompletionInvocationInputSchema = z.object({
+var CompletionInvocationInputSchema2 = z.object({
   conversationId: Id,
   idempotencyKey: Id,
-  trace: ModelInvocationTraceSchema,
+  trace: ModelInvocationTraceSchema2,
   prompt: z.string().min(1),
   models: z.array(Id).min(1).max(8),
   settings: z.object({
@@ -661,7 +661,7 @@ var Base = z.object({
 var InvocationStartedSchema = Base.extend({
   type: z.literal("invocation/started"),
   mode: z.enum(["completion", "agent"]),
-  trace: ModelInvocationTraceSchema,
+  trace: ModelInvocationTraceSchema2,
   caller: InvocationCallerSchema,
   executingProcess: InvocationProcessSchema,
   fingerprint: Hash,
@@ -688,7 +688,7 @@ var InvocationResponseSchema = Attempt.extend({
   type: z.literal("provider/response"),
   status: z.enum(["succeeded", "failed", "cancelled"]),
   effective: Identity,
-  usage: AgentUsageSchema,
+  usage: AgentUsageSchema2,
   artifactId: Id,
   payloadSha256: Hash
 }).strict();
@@ -697,7 +697,7 @@ var InvocationFinishedSchema = Base.extend({
   failure: z.object({ artifactId: Id, payloadSha256: Hash }).strict().optional(),
   status: z.enum(["succeeded", "failed", "cancelled"])
 }).strict();
-var ModelInvocationRecordSchema = z.discriminatedUnion("type", [
+var ModelInvocationRecordSchema2 = z.discriminatedUnion("type", [
   InvocationStartedSchema,
   InvocationRequestSchema,
   InvocationResponseSchema,
@@ -859,7 +859,7 @@ 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");
+    throw new AgentRuntimeConflictError2("run lookup");
   return run;
 }
 function jsonValue(value) {
@@ -867,13 +867,13 @@ function jsonValue(value) {
   return parsed.success ? parsed.data : { message: "Non-JSON tool output omitted" };
 }
 function providerEnvelope(value) {
-  const parsed = AgentJsonObjectSchema.safeParse(value);
+  const parsed = AgentJsonObjectSchema2.safeParse(value);
   if (!parsed.success)
     return;
   return { schemaVersion: 1, provider: "ai-sdk", data: parsed.data };
 }
 function providerResponseIdentity(id, provider) {
-  return AgentProviderResponseSchema.parse({
+  return AgentProviderResponseSchema2.parse({
     id,
     ...typeof provider === "string" && provider.length > 0 ? { provider } : {}
   });
@@ -881,11 +881,11 @@ function providerResponseIdentity(id, provider) {
 function appendText(parts, text) {
   const previous = parts.at(-1);
   if (previous?.type === "text") {
-    const next = AgentMessagePartSchema.parse({ ...previous, text: previous.text + text });
+    const next = AgentMessagePartSchema2.parse({ ...previous, text: previous.text + text });
     parts.splice(parts.length - 1, 1, next);
     return;
   }
-  parts.push(AgentMessagePartSchema.parse({ type: "text", text }));
+  parts.push(AgentMessagePartSchema2.parse({ type: "text", text }));
 }
 function abortTerminalReason(signal) {
   if (signal.reason === "shutdown")
@@ -1038,7 +1038,7 @@ function createIdleDeadline(parent, timeoutMs) {
 
 // src/agent-runtime/invocation-attempt.ts
 var currentAttempt = new AsyncLocalStorage;
-function currentModelInvocationAttempt() {
+function currentModelInvocationAttempt2() {
   const value = currentAttempt.getStore();
   return value && { ...value };
 }
@@ -1274,7 +1274,7 @@ async function readInvocationRecords(store, input) {
         {
           seq: event.seq,
           occurredAt: event.occurredAt,
-          record: ModelInvocationRecordSchema.parse(event.payload)
+          record: ModelInvocationRecordSchema2.parse(event.payload)
         }
       ];
     }),
@@ -1341,7 +1341,7 @@ async function generateWithFallback(models, writer, input, abortSignal) {
   }
   throw new Error("No completion model attempt available");
 }
-function createModelInvocationLedger(config) {
+function createModelInvocationLedger2(config) {
   const { store } = config;
   const appendOnce = store.appendEventOnce?.bind(store);
   if (!appendOnce)
@@ -1350,7 +1350,7 @@ function createModelInvocationLedger(config) {
   const payloads = createInvocationPayloads(store, config.payloadKey, maxPayloadBytes);
   const authorize = async (input) => InvocationCallerSchema.parse(await config.authorize(input));
   const start = async (input) => {
-    const trace = ModelInvocationTraceSchema.parse(input.trace);
+    const trace = ModelInvocationTraceSchema2.parse(input.trace);
     const caller = await authorize({
       context: input.context,
       conversationId: input.conversationId,
@@ -1390,7 +1390,7 @@ function createModelInvocationLedger(config) {
       onAttempt: config.onAttempt,
       receiptErrors: [],
       async append(record) {
-        const parsed = ModelInvocationRecordSchema.parse(record);
+        const parsed = ModelInvocationRecordSchema2.parse(record);
         await store.appendEvent({
           conversationId: input.conversationId,
           kind: parsed.type,
@@ -1408,7 +1408,7 @@ function createModelInvocationLedger(config) {
   });
   const ledger = {
     async complete(rawInput, context, signal) {
-      const input = CompletionInvocationInputSchema.parse(rawInput);
+      const input = CompletionInvocationInputSchema2.parse(rawInput);
       const { writer, duplicate } = await start({
         conversationId: input.conversationId,
         key: `completion:${input.idempotencyKey}`,
@@ -1436,8 +1436,8 @@ function createModelInvocationLedger(config) {
           });
         } catch (receiptError) {
           writer.receiptErrors.push(receiptError);
-          await finish(writer, status).catch((error2) => {
-            writer.receiptErrors.push(error2);
+          await finish(writer, status).catch((error) => {
+            writer.receiptErrors.push(error);
           });
         }
         return withReceipt({ invocationId, outcome: status }, writer);
@@ -1494,9 +1494,9 @@ function createModelInvocationLedger(config) {
 async function assertFence(config, input) {
   const rejected = await config.assertCurrent(input);
   if (rejected)
-    throw new ToolExecutionControlError(rejected);
+    throw new ToolExecutionControlError2(rejected);
 }
-function createAgentToolFenceLifecycle(config) {
+function createAgentToolFenceLifecycle2(config) {
   const callContext = (ctx, endpoint) => ({
     runId: config.runId,
     ...config.context?.(ctx, endpoint)
@@ -1516,9 +1516,9 @@ function createAgentToolFenceLifecycle(config) {
 
 // src/agent-runtime/prompt.ts
 import { z as z6 } from "zod";
-var AgentTokenCountSchema = z6.object({
+var AgentTokenCountSchema2 = z6.object({
   value: z6.int().nonnegative().optional(),
-  provenance: AgentProvenanceSchema.extract([
+  provenance: AgentProvenanceSchema2.extract([
     "measured",
     "computed",
     "estimated",
@@ -1551,7 +1551,7 @@ function budgetTurns(messages, evidencePolicy) {
   flush();
   return turns;
 }
-async function selectAgentHistory(options) {
+async function selectAgentHistory2(options) {
   if (!Number.isSafeInteger(options.availableTokens) || options.availableTokens < 0) {
     throw new TypeError("availableTokens must be a non-negative safe integer");
   }
@@ -1559,12 +1559,12 @@ async function selectAgentHistory(options) {
   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 spoken = options.messages.filter((message) => message.role !== "assistant" || isAssistantHistoryEvidence2(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));
+    const count = AgentTokenCountSchema2.parse(await options.estimateMessage(message));
     counts.set(message.id, count);
     const value = knownValue(count);
     if (value === undefined) {
@@ -1572,8 +1572,8 @@ async function selectAgentHistory(options) {
         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",
+          action: candidate.role === "assistant" && !isAssistantHistoryEvidence2(candidate.status, options.evidencePolicy) ? "removed" : "kept",
+          reason: candidate.role === "assistant" && !isAssistantHistoryEvidence2(candidate.status, options.evidencePolicy) ? "unspeakable" : "token-count-unavailable",
           tokens: counts.get(candidate.id) ?? { provenance: "unavailable" }
         })),
         totalTokens: { provenance: "unavailable" },
@@ -1599,7 +1599,7 @@ async function selectAgentHistory(options) {
   }
   const messages = spoken.filter((message) => !removed.has(message.id));
   const decisions = options.messages.map((message) => {
-    if (message.role === "assistant" && !isAssistantHistoryEvidence(message.status, options.evidencePolicy)) {
+    if (message.role === "assistant" && !isAssistantHistoryEvidence2(message.status, options.evidencePolicy)) {
       return {
         messageId: message.id,
         action: "removed",
@@ -1607,7 +1607,7 @@ async function selectAgentHistory(options) {
         tokens: { provenance: "unavailable" }
       };
     }
-    const turnIndex = turns.findIndex((turn2) => turn2.messages.some((item) => item.id === message.id));
+    const turnIndex = turns.findIndex((turn) => turn.messages.some((item) => item.id === message.id));
     const turn = turns[turnIndex];
     let reason = "within-budget";
     if (removed.has(message.id))
@@ -1635,7 +1635,7 @@ async function selectAgentHistory(options) {
 function knownValue(value) {
   return value.provenance === "unavailable" ? undefined : value.value;
 }
-function composeAgentPrompt(sections) {
+function composeAgentPrompt2(sections) {
   return async (options) => {
     const event = z6.enum(["session.started", "turn.started"]).parse(options.event ?? "turn.started");
     const rendered = [];
@@ -1655,9 +1655,9 @@ function composeAgentPrompt(sections) {
       rendered.push({ name: section.name, stability: section.stability, role, text });
       let count;
       if (section.estimateTokens) {
-        count = AgentTokenCountSchema.parse(await section.estimateTokens(text));
+        count = AgentTokenCountSchema2.parse(await section.estimateTokens(text));
       } else if (options.estimateFallback) {
-        count = AgentTokenCountSchema.parse(await options.estimateFallback(text));
+        count = AgentTokenCountSchema2.parse(await options.estimateFallback(text));
       } else
         count = { provenance: "unavailable" };
       const value = knownValue(count);
@@ -1687,14 +1687,14 @@ function composeAgentPrompt(sections) {
       }
       const reserveValues = [
         options.budget.reservedOutput,
-        knownValue(AgentTokenCountSchema.parse(options.budget.toolSchemas)),
-        knownValue(AgentTokenCountSchema.parse(options.budget.attachments)),
-        knownValue(AgentTokenCountSchema.parse(options.budget.providerOverhead)),
+        knownValue(AgentTokenCountSchema2.parse(options.budget.toolSchemas)),
+        knownValue(AgentTokenCountSchema2.parse(options.budget.attachments)),
+        knownValue(AgentTokenCountSchema2.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;
+        const historyTokens = options.historyTokens ? knownValue(AgentTokenCountSchema2.parse(options.historyTokens)) : undefined;
         if (historyTokens !== undefined) {
           if (availableHistoryTokens < 0)
             contextDecision = "oversized";
@@ -1756,7 +1756,7 @@ var RETRYABLE = new Set([
   "stream-cut"
 ]);
 
-class AgentProviderStreamCutError extends Error {
+class AgentProviderStreamCutError2 extends Error {
   reason = "stream-cut";
   constructor(message = "Provider stream ended before a terminal part") {
     super(message);
@@ -1774,8 +1774,8 @@ function statusOf(value) {
   const nested = value.cause ?? value.response ?? value.error;
   return nested === value ? undefined : statusOf(nested);
 }
-function classifyProviderFailure(error) {
-  if (error instanceof AgentProviderStreamCutError) {
+function classifyProviderFailure2(error) {
+  if (error instanceof AgentProviderStreamCutError2) {
     return { reason: "stream-cut", retryable: true, evidence: "none" };
   }
   const status = statusOf(error);
@@ -1806,7 +1806,7 @@ function classifyProviderFailure(error) {
     evidence: "none"
   };
 }
-function isToolResultFailure(output) {
+function isToolResultFailure2(output) {
   const parsed = typeof output === "string" ? parseJson(output) : output;
   if (!isRecord(parsed))
     return false;
@@ -1823,7 +1823,7 @@ function parseJson(value) {
 }
 
 // src/agent-runtime/retry-policy.ts
-async function recordAgentRetryDecision(input) {
+async function recordAgentRetryDecision2(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) {
@@ -1841,7 +1841,7 @@ async function recordAgentRetryDecision(input) {
 
 // src/agent-runtime/state-slots.ts
 import { z as z7 } from "zod";
-function defineStateSlot(input) {
+function defineStateSlot2(input) {
   if (input.name.length === 0)
     throw new TypeError("State slot name must not be empty");
   const version = input.version ?? 1;
@@ -1870,7 +1870,7 @@ function slotRegistry(definitions) {
   }
   return result;
 }
-function createAgentStateSlotStore(input) {
+function createAgentStateSlotStore2(input) {
   const definitions = slotRegistry(input.definitions);
   const set = async (request) => {
     const definition = definitions.get(request.name);
@@ -1929,7 +1929,7 @@ function createAgentStateSlotStore(input) {
   const get = async (conversationId, name) => (await list(conversationId)).find((value) => value.name === name);
   return { set, get, list };
 }
-function renderAgentStateSlots(values) {
+function renderAgentStateSlots2(values) {
   if (values.length === 0)
     return;
   return [
@@ -1938,7 +1938,7 @@ function renderAgentStateSlots(values) {
   ].join(`
 `);
 }
-var agentGoalStateSlot = defineStateSlot({
+var agentGoalStateSlot2 = defineStateSlot2({
   name: "goal",
   description: "The durable objective and lifecycle of this conversation.",
   schema: z7.object({
@@ -1946,7 +1946,7 @@ var agentGoalStateSlot = defineStateSlot({
     status: z7.enum(["active", "complete", "blocked"])
   }).strict()
 });
-var agentTodoStateSlot = defineStateSlot({
+var agentTodoStateSlot2 = defineStateSlot2({
   name: "todo",
   description: "The durable ordered work plan for this conversation.",
   schema: z7.object({
@@ -1965,7 +1965,7 @@ async function interruptAgentRun(state, input) {
     runId: input.runId
   });
   if (!view)
-    throw new AgentRuntimeConflictError("run lookup");
+    throw new AgentRuntimeConflictError2("run lookup");
   const requested = await store.requestRunInterrupt({
     conversationId: input.conversationId,
     runId: input.runId,
@@ -1975,7 +1975,7 @@ async function interruptAgentRun(state, input) {
     const interruptedRun = findRun(requested.snapshot.runs, input.runId);
     await state.publish({
       type: "run-state",
-      eventId: agentDurableEventId("run-state", interruptedRun.id, requested.snapshot.version),
+      eventId: agentDurableEventId2("run-state", interruptedRun.id, requested.snapshot.version),
       conversationId: interruptedRun.conversationId,
       runId: interruptedRun.id,
       snapshotVersion: requested.snapshot.version,
@@ -2002,7 +2002,7 @@ async function abandonAgentRun(state, input) {
       const abandonedRun = findRun(abandoned.snapshot.runs, input.runId);
       await state.publish({
         type: "run-state",
-        eventId: agentDurableEventId("run-state", abandonedRun.id, abandoned.snapshot.version),
+        eventId: agentDurableEventId2("run-state", abandonedRun.id, abandoned.snapshot.version),
         conversationId: abandonedRun.conversationId,
         runId: abandonedRun.id,
         snapshotVersion: abandoned.snapshot.version,
@@ -2109,7 +2109,7 @@ function resumeAgentRun(state, rawInput) {
         runId: rawInput.runId
       });
       if (!recovered)
-        throw new AgentRuntimeConflictError("run lookup");
+        throw new AgentRuntimeConflictError2("run lookup");
       const recoveredRun = recovered.run;
       if (recoveredRun.state !== "queued") {
         throw new Error("Only a queued recovered agent run can be resumed");
@@ -2240,7 +2240,7 @@ async function recoverItem(state, options, item, scheduledRuns) {
       action: "abandon"
     });
     if (abandoned.outcome !== "applied") {
-      throw new AgentRuntimeConflictError("recovery abandon");
+      throw new AgentRuntimeConflictError2("recovery abandon");
     }
     return { conversationId: item.conversationId, runId: item.run.id, outcome: "abandoned" };
   }
@@ -2253,7 +2253,7 @@ async function recoverItem(state, options, item, scheduledRuns) {
       replaySafe: true
     });
     if (requeued.outcome !== "applied") {
-      throw new AgentRuntimeConflictError("recovery requeue");
+      throw new AgentRuntimeConflictError2("recovery requeue");
     }
   }
   const context = await options.resolveContext(item);
@@ -2388,7 +2388,7 @@ function updateReasoning(state, text, metadata) {
   const provider = providerEnvelope(metadata);
   if (state.reasoningPartIndex === undefined) {
     state.reasoningPartIndex = parts.length;
-    parts.push(AgentMessagePartSchema.parse({
+    parts.push(AgentMessagePartSchema2.parse({
       type: "reasoning",
       text,
       ...provider && { provider }
@@ -2397,9 +2397,9 @@ function updateReasoning(state, text, metadata) {
   }
   const current = parts[state.reasoningPartIndex];
   if (current?.type !== "reasoning") {
-    throw new AgentRuntimeConflictError("reasoning accumulator");
+    throw new AgentRuntimeConflictError2("reasoning accumulator");
   }
-  parts.splice(state.reasoningPartIndex, 1, AgentMessagePartSchema.parse({
+  parts.splice(state.reasoningPartIndex, 1, AgentMessagePartSchema2.parse({
     ...current,
     text: current.text + text,
     ...provider && { provider }
@@ -2409,7 +2409,7 @@ function checkpoint(execution) {
   const { config, runtimeEpoch, publish, now } = execution.dependencies;
   const { state } = execution;
   return execution.serialize(async () => {
-    state.assistant = AgentMessageSchema.parse({
+    state.assistant = AgentMessageSchema2.parse({
       ...state.assistant,
       parts: state.parts,
       updatedAt: now().toISOString()
@@ -2434,7 +2434,7 @@ function checkpoint(execution) {
     };
     await publish({
       type: "assistant-checkpoint",
-      eventId: agentDurableEventId("assistant-checkpoint", state.run.id, state.observedVersion),
+      eventId: agentDurableEventId2("assistant-checkpoint", state.run.id, state.observedVersion),
       conversationId: state.run.conversationId,
       runId: state.run.id,
       snapshotVersion: state.observedVersion,
@@ -2467,7 +2467,7 @@ function createAgentRunOperationLifecycle(config) {
     active = operation;
     await config.publish({
       type: "run-operation",
-      eventId: agentDurableEventId("run-operation", run.id, snapshot.version),
+      eventId: agentDurableEventId2("run-operation", run.id, snapshot.version),
       conversationId: run.conversationId,
       runId: run.id,
       snapshotVersion: snapshot.version,
@@ -2476,7 +2476,7 @@ function createAgentRunOperationLifecycle(config) {
     });
   });
   const startModelRequest = async (callId, step) => {
-    await record(AgentRunOperationSchema.parse({
+    await record(AgentRunOperationSchema2.parse({
       operationId: `${callId}:${step}`,
       kind: "model-request",
       phase: "started",
@@ -2534,7 +2534,7 @@ function createAgentRunOperationLifecycle(config) {
       checkpointWaiters.clear();
     },
     startCompaction(operationId) {
-      return record(AgentRunOperationSchema.parse({
+      return record(AgentRunOperationSchema2.parse({
         operationId,
         kind: "compaction",
         phase: "started",
@@ -2545,7 +2545,7 @@ function createAgentRunOperationLifecycle(config) {
       if (active?.kind !== "model-request" || active.phase !== "started") {
         return Promise.resolve();
       }
-      return record(AgentRunOperationSchema.parse({
+      return record(AgentRunOperationSchema2.parse({
         ...active,
         phase: "first-output",
         firstOutputAt: config.now().toISOString()
@@ -2555,7 +2555,7 @@ function createAgentRunOperationLifecycle(config) {
       if (!active || ["completed", "failed", "cancelled"].includes(active.phase)) {
         return Promise.resolve();
       }
-      return record(AgentRunOperationSchema.parse({
+      return record(AgentRunOperationSchema2.parse({
         ...active,
         phase,
         finishedAt: config.now().toISOString()
@@ -2573,14 +2573,14 @@ async function acquireRun(dependencies, input) {
     runId: input.acceptedRun.id
   });
   if (!queued)
-    throw new AgentRuntimeConflictError("run lookup");
+    throw new AgentRuntimeConflictError2("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");
+      throw new AgentRuntimeConflictError2("absorbed run resolution");
     }
     input.onAcquired?.();
     return {
@@ -2607,7 +2607,7 @@ async function acquireRun(dependencies, input) {
   input.onAcquired?.();
   await publish({
     type: "run-state",
-    eventId: agentDurableEventId("run-state", run.id, acquired.version),
+    eventId: agentDurableEventId2("run-state", run.id, acquired.version),
     conversationId: run.conversationId,
     runId: run.id,
     snapshotVersion: acquired.version,
@@ -2629,7 +2629,7 @@ async function acquireRun(dependencies, input) {
     queueWaitMs: Math.max(0, now().getTime() - new Date(run.createdAt).getTime()),
     emittedAt: now().toISOString()
   });
-  const assistant = AgentMessageSchema.parse({
+  const assistant = AgentMessageSchema2.parse({
     schemaVersion: 1,
     id: run.assistantMessageId,
     conversationId: run.conversationId,
@@ -2704,9 +2704,9 @@ async function acquireRun(dependencies, input) {
 function failureThisRuntimeOwns(error) {
   if (error instanceof InvocationReceiptError)
     return "runtime_failure";
-  if (error instanceof AgentContextOverflowError)
+  if (error instanceof AgentContextOverflowError2)
     return "context_overflow";
-  if (error instanceof AgentRuntimeConflictError)
+  if (error instanceof AgentRuntimeConflictError2)
     return "storage_conflict";
   if (isOwnInputRefusal(error))
     return "runtime_failure";
@@ -2728,19 +2728,19 @@ async function classifyRunFailure(execution, error) {
     state.observedVersion = latest.snapshotVersion;
     state.run = latestRun;
   }
-  const staleOwner = isToolExecutionControlError(error) && error.reason === "stale_run";
+  const staleOwner = isToolExecutionControlError2(error) && error.reason === "stale_run";
   if (!staleOwner) {
     await operationLifecycle.finish(executionSignal.aborted || durableInterrupt ? "cancelled" : "failed");
   }
-  if (isToolExecutionControlError(error) || executionSignal.aborted || durableInterrupt) {
+  if (isToolExecutionControlError2(error) || executionSignal.aborted || durableInterrupt) {
     state.terminalReason = executionSignal.aborted ? abortTerminalReason(executionSignal) : "interrupted";
-    state.parts.push(AgentMessagePartSchema.parse({
+    state.parts.push(AgentMessagePartSchema2.parse({
       type: "control",
-      reason: isToolExecutionControlError(error) && error.reason === "stale_run" ? "stale-run" : "run-interrupted"
+      reason: isToolExecutionControlError2(error) && error.reason === "stale_run" ? "stale-run" : "run-interrupted"
     }));
-  } else if (error instanceof AgentContextOverflowError) {
+  } else if (error instanceof AgentContextOverflowError2) {
     state.terminalReason = "context_overflow";
-  } else if (error instanceof AgentRuntimeConflictError) {
+  } else if (error instanceof AgentRuntimeConflictError2) {
     state.terminalReason = "storage_conflict";
   } else {
     state.terminalReason = failureThisRuntimeOwns(error) ?? (hasProviderOrigin(error) ? "provider_failure" : "runtime_failure");
@@ -2882,7 +2882,7 @@ async function createRunProviderLedger(input) {
     async recordRequest(request) {
       const messageShas = [];
       for (const message of request.messages) {
-        const body = canonicalAgentJson(JSON.parse(JSON.stringify(withoutBinaryParts(message))));
+        const body = canonicalAgentJson2(JSON.parse(JSON.stringify(withoutBinaryParts(message))));
         const sha256 = createHash3("sha256").update(body).digest("hex");
         messageShas.push(sha256);
         if (knownMessageShas.has(sha256))
@@ -2894,7 +2894,7 @@ async function createRunProviderLedger(input) {
         });
         knownMessageShas.add(sha256);
       }
-      const instructionsSha256 = createHash3("sha256").update(typeof request.instructions === "string" ? request.instructions : canonicalAgentJson(JSON.parse(JSON.stringify(withoutBinaryParts(request.instructions))))).digest("hex");
+      const instructionsSha256 = createHash3("sha256").update(typeof request.instructions === "string" ? request.instructions : canonicalAgentJson2(JSON.parse(JSON.stringify(withoutBinaryParts(request.instructions))))).digest("hex");
       const bodySha256 = createHash3("sha256").update(instructionsSha256).update(messageShas.join(",")).digest("hex");
       await store.appendEvent({
         conversationId: state.run.conversationId,
@@ -2999,7 +2999,7 @@ async function applyToolPart(execution, part) {
   const { state } = execution;
   if (part.type === "tool-call") {
     const provider = providerEnvelope(part.providerMetadata);
-    state.parts.push(AgentMessagePartSchema.parse({
+    state.parts.push(AgentMessagePartSchema2.parse({
       type: "tool-call",
       callId: part.toolCallId,
       toolName: part.toolName,
@@ -3016,7 +3016,7 @@ async function applyToolPart(execution, part) {
       emittedAt: now().toISOString()
     });
   } else if (part.type === "tool-result") {
-    state.parts.push(AgentMessagePartSchema.parse({
+    state.parts.push(AgentMessagePartSchema2.parse({
       type: "tool-result",
       callId: part.toolCallId,
       toolName: part.toolName,
@@ -3034,7 +3034,7 @@ async function applyToolPart(execution, part) {
     });
   } else if (part.type === "tool-error") {
     state.internalCause = part.error;
-    if (isToolExecutionControlError(part.error)) {
+    if (isToolExecutionControlError2(part.error)) {
       await publish({
         type: "tool-status",
         ...transientHead(execution),
@@ -3046,8 +3046,8 @@ async function applyToolPart(execution, part) {
       await checkpoint(execution);
       throw part.error;
     }
-    const output = isAgentToolError(part.error) ? jsonValue(part.error.output) : { message: "Tool execution failed" };
-    state.parts.push(AgentMessagePartSchema.parse({
+    const output = isAgentToolError2(part.error) ? jsonValue(part.error.output) : { message: "Tool execution failed" };
+    state.parts.push(AgentMessagePartSchema2.parse({
       type: "tool-result",
       callId: part.toolCallId,
       toolName: part.toolName,
@@ -3064,7 +3064,7 @@ async function applyToolPart(execution, part) {
       emittedAt: now().toISOString()
     });
   } else if (part.type === "tool-output-denied") {
-    state.parts.push(AgentMessagePartSchema.parse({
+    state.parts.push(AgentMessagePartSchema2.parse({
       type: "tool-result",
       callId: part.toolCallId,
       toolName: part.toolName,
@@ -3086,7 +3086,7 @@ async function applyRecordedPart(execution, part) {
   const { config } = execution.dependencies;
   const { parts } = execution.state;
   if (part.type === "source") {
-    parts.push(AgentMessagePartSchema.parse({
+    parts.push(AgentMessagePartSchema2.parse({
       type: "source",
       sourceId: part.id,
       ...part.sourceType === "url" && { url: part.url },
@@ -3094,7 +3094,7 @@ async function applyRecordedPart(execution, part) {
     }));
   } else if (part.type === "file" && config.persistGeneratedFile) {
     const persisted = await config.persistGeneratedFile(part.file);
-    parts.push(AgentMessagePartSchema.parse({
+    parts.push(AgentMessagePartSchema2.parse({
       type: "file",
       mediaType: part.file.mediaType,
       reference: persisted.reference,
@@ -3104,7 +3104,7 @@ async function applyRecordedPart(execution, part) {
     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({
+    parts.push(AgentMessagePartSchema2.parse({
       type: "file",
       mediaType: part.file.mediaType,
       reference: persisted.reference,
@@ -3113,7 +3113,7 @@ async function applyRecordedPart(execution, part) {
   } 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({
+    parts.push(AgentMessagePartSchema2.parse({
       type: "tool-approval-request",
       approvalId: part.approvalId,
       callId: part.toolCall.toolCallId,
@@ -3121,7 +3121,7 @@ async function applyRecordedPart(execution, part) {
       ...part.signature && { signature: part.signature }
     }));
   } else if (part.type === "tool-approval-response") {
-    parts.push(AgentMessagePartSchema.parse({
+    parts.push(AgentMessagePartSchema2.parse({
       type: "tool-approval-response",
       approvalId: part.approvalId,
       approved: part.approved,
@@ -3129,7 +3129,7 @@ async function applyRecordedPart(execution, part) {
     }));
   } else if (part.type === "custom") {
     const provider = providerEnvelope(part.providerMetadata);
-    parts.push(AgentMessagePartSchema.parse({
+    parts.push(AgentMessagePartSchema2.parse({
       type: "provider",
       envelope: {
         schemaVersion: 1,
@@ -3138,7 +3138,7 @@ async function applyRecordedPart(execution, part) {
       }
     }));
   } else if (part.type === "raw") {
-    parts.push(AgentMessagePartSchema.parse({
+    parts.push(AgentMessagePartSchema2.parse({
       type: "provider",
       envelope: {
         schemaVersion: 1,
@@ -3334,7 +3334,7 @@ function startAttemptStream(context, attempt, stopConditions) {
               toolCallId,
               signal
             });
-          return createLocalStepDurability({
+          return createLocalStepDurability2({
             store: config.store,
             conversationId: state.run.conversationId,
             runId: JSON.stringify([state.run.id, toolName, toolCallId]),
@@ -3392,11 +3392,11 @@ async function retryAfterProviderError(context, attempt, error) {
   if (!retry || failureThisRuntimeOwns(error) !== undefined)
     return false;
   const invokedTool = state.parts.slice(attempt.attemptPartStart).some((candidate) => candidate.type === "tool-call");
-  const decision = invokedTool ? { retry: false, delayMs: 0 } : await recordAgentRetryDecision({
+  const decision = invokedTool ? { retry: false, delayMs: 0 } : await recordAgentRetryDecision2({
     store: config.store,
     conversationId: state.run.conversationId,
     attempt: loop.retryAttempt,
-    failure: classifyProviderFailure(error),
+    failure: classifyProviderFailure2(error),
     policy: retry
   });
   if (!decision.retry)
@@ -3521,7 +3521,7 @@ async function settleStreamOutcome(execution) {
     state.terminalReason = abortTerminalReason(executionSignal);
   const awaitsApproval = state.parts.some((part) => part.type === "tool-approval-request");
   if (!awaitsApproval && config.protocol.acceptTerminal && (state.terminalReason === "success" || state.terminalReason === "policy_stop" || state.terminalReason === "provider_stop")) {
-    const candidate = AgentMessageSchema.parse({
+    const candidate = AgentMessageSchema2.parse({
       ...state.assistant,
       status: assistantStatus(state.terminalReason),
       parts: state.parts,
@@ -3573,14 +3573,14 @@ async function stopChildrenAfterExplicitStop(execution, committedByCaller) {
 async function commitRunTerminal(execution) {
   const { config, publish, runtimeEpoch, now } = execution.dependencies;
   const { state, runStartedAt } = execution;
-  state.assistant = AgentMessageSchema.parse({
+  state.assistant = AgentMessageSchema2.parse({
     ...state.assistant,
     status: assistantStatus(state.terminalReason),
     parts: state.parts,
     updatedAt: now().toISOString()
   });
   const spent = statedUsage(state.usage);
-  const unsettledEventId = (version) => agentDurableEventId("terminal", `${state.run.id}:${runtimeEpoch}`, version);
+  const unsettledEventId = (version) => agentDurableEventId2("terminal", `${state.run.id}:${runtimeEpoch}`, version);
   let terminal;
   try {
     terminal = await commitAgentRunTerminal({
@@ -3592,7 +3592,7 @@ async function commitRunTerminal(execution) {
         reason: state.terminalReason,
         ...state.terminalPolicyName && { policyName: state.terminalPolicyName },
         usage: spent,
-        ...state.absorbed.size > 0 && runStateForTerminalReason(state.terminalReason) === "completed" && {
+        ...state.absorbed.size > 0 && runStateForTerminalReason2(state.terminalReason) === "completed" && {
           absorb: [...state.absorbed].map(([runId, inputMessageIds]) => ({
             runId,
             inputMessageIds
@@ -3625,7 +3625,7 @@ async function commitRunTerminal(execution) {
   } : undefined;
   await stopChildrenAfterExplicitStop(execution, terminal.committedByCaller);
   emitSpend(execution, {
-    eventId: terminal.committedByCaller ? agentDurableEventId("terminal", state.run.id, state.observedVersion) : unsettledEventId(state.observedVersion),
+    eventId: terminal.committedByCaller ? agentDurableEventId2("terminal", state.run.id, state.observedVersion) : unsettledEventId(state.observedVersion),
     state: state.run.state,
     reason: state.terminalReason,
     usage: spent
@@ -3633,7 +3633,7 @@ async function commitRunTerminal(execution) {
   for (const settled of terminal.absorbed ?? []) {
     await publish({
       type: "run-state",
-      eventId: agentDurableEventId("run-state", settled.id, state.observedVersion),
+      eventId: agentDurableEventId2("run-state", settled.id, state.observedVersion),
       conversationId: settled.conversationId,
       runId: settled.id,
       snapshotVersion: state.observedVersion,
@@ -3644,7 +3644,7 @@ async function commitRunTerminal(execution) {
   if (terminalMetrics) {
     await publish({
       type: "terminal",
-      eventId: agentDurableEventId("terminal", state.run.id, state.observedVersion),
+      eventId: agentDurableEventId2("terminal", state.run.id, state.observedVersion),
       conversationId: state.run.conversationId,
       runId: state.run.id,
       snapshotVersion: state.observedVersion,
@@ -3670,20 +3670,20 @@ import { createHash as createHash4 } from "node:crypto";
 function snapshotForRunPrompt(snapshot, runId) {
   const runIndex = snapshot.runs.findIndex((candidate) => candidate.id === runId);
   if (runIndex < 0)
-    throw new AgentRuntimeConflictError("prompt run lookup");
+    throw new AgentRuntimeConflictError2("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({
+  return AgentSnapshotSchema2.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({
+  return AgentMessageSchema2.parse({
     schemaVersion: 1,
     id: createHash4("sha256").update(`${input.conversationId}\x00${input.seedKey}\x00${input.index}`).digest("hex"),
     conversationId: input.conversationId,
@@ -3696,18 +3696,18 @@ function seededInstructionMessage(input) {
 }
 async function loadDurableSystem(config, conversationId) {
   if (config.stateSlots && config.stateSlots.length > 0) {
-    const slotValues = await createAgentStateSlotStore({
+    const slotValues = await createAgentStateSlotStore2({
       store: config.store,
       definitions: config.stateSlots
     }).list(conversationId);
-    const renderedSlots = renderAgentStateSlots(slotValues);
+    const renderedSlots = renderAgentStateSlots2(slotValues);
     if (renderedSlots)
       return [renderedSlots];
   }
   return [];
 }
 function detailedProjection(config, source) {
-  return projectAgentHistoryDetailed(source, {
+  return projectAgentHistoryDetailed2(source, {
     ...config.history?.resolveFile && { resolveFile: config.history.resolveFile },
     ...config.history?.unresolvedFile && {
       unresolvedFile: config.history.unresolvedFile
@@ -3811,7 +3811,7 @@ function createRuntimeContext(execution) {
       return "stale_run";
     return;
   };
-  const toolFenceLifecycle = createAgentToolFenceLifecycle({
+  const toolFenceLifecycle = createAgentToolFenceLifecycle2({
     runId: state.run.id,
     assertCurrent,
     context: () => ({
@@ -3886,10 +3886,10 @@ async function prepareTurn(execution) {
   if (prompt.finalizeSeed)
     prompt = { ...prompt, ...prompt.finalizeSeed(userInstructionsInserted ?? false) };
   if (prompt.contextDecision === "oversized") {
-    throw new AgentContextOverflowError;
+    throw new AgentContextOverflowError2;
   }
   if (prompt.contextDecision === "requires-compaction") {
-    throw new AgentContextOverflowError("Agent context still exceeds the model budget after compaction");
+    throw new AgentContextOverflowError2("Agent context still exceeds the model budget after compaction");
   }
   const projection = createRunHistoryProjection({
     config,
@@ -3960,7 +3960,7 @@ function resolveLoopLimits(config) {
   };
 }
 function createAgentRuntimeState(config) {
-  const coordinator = createAgentSessionCoordinator();
+  const coordinator = createAgentSessionCoordinator2();
   const generateId = config.generateId ?? (() => crypto.randomUUID());
   const now = config.now ?? (() => new Date);
   const runtimeEpoch = generateId();
@@ -4048,7 +4048,7 @@ function createSubmission(state, rawInput, input, context) {
   const inputMessageId = rawInput.recordIds?.inputMessageId ?? generateId();
   const runId = rawInput.recordIds?.runId ?? generateId();
   const assistantMessageId = rawInput.recordIds?.assistantMessageId ?? generateId();
-  const userMessage2 = AgentMessageSchema.parse({
+  const userMessage = AgentMessageSchema2.parse({
     schemaVersion: 1,
     id: inputMessageId,
     conversationId: input.conversationId,
@@ -4059,7 +4059,7 @@ function createSubmission(state, rawInput, input, context) {
     createdAt: nowIso,
     updatedAt: nowIso
   });
-  const queuedRun = AgentRunSchema.parse({
+  const queuedRun = AgentRunSchema2.parse({
     schemaVersion: 1,
     id: runId,
     conversationId: input.conversationId,
@@ -4094,7 +4094,7 @@ function createSubmission(state, rawInput, input, context) {
     key,
     policy,
     runId,
-    userMessage: userMessage2,
+    userMessage,
     queuedRun,
     ...reservation && { reservation },
     previousAcceptance,
@@ -4187,9 +4187,9 @@ function projectAdmission(submission, acceptance) {
   const actualInputMessageId = acceptance.outcome === "duplicate" ? acceptance.inputMessageId : submission.userMessage.id;
   const acceptedInput = acceptance.outcome === "duplicate" ? acceptance.input : acceptedSnapshot.messages.find((candidate) => candidate.id === actualInputMessageId);
   if (!acceptedInput) {
-    throw new AgentRuntimeConflictError("admission input projection");
+    throw new AgentRuntimeConflictError2("admission input projection");
   }
-  const assistantPlaceholder = AgentAssistantPlaceholderSchema.parse({
+  const assistantPlaceholder = AgentAssistantPlaceholderSchema2.parse({
     schemaVersion: 1,
     id: acceptedRun.assistantMessageId,
     conversationId: acceptedRun.conversationId,
@@ -4213,7 +4213,7 @@ async function publishAdmission(state, admission) {
   const { run, snapshotVersion } = admission;
   await state.publish({
     type: "admission",
-    eventId: agentDurableEventId("admission", run.id, snapshotVersion),
+    eventId: agentDurableEventId2("admission", run.id, snapshotVersion),
     conversationId: run.conversationId,
     runId: run.id,
     snapshotVersion,
@@ -4224,7 +4224,7 @@ async function publishAdmission(state, admission) {
   });
   await state.publish({
     type: "run-state",
-    eventId: agentDurableEventId("run-state", run.id, snapshotVersion),
+    eventId: agentDurableEventId2("run-state", run.id, snapshotVersion),
     conversationId: run.conversationId,
     runId: run.id,
     snapshotVersion,
@@ -4297,7 +4297,7 @@ function handOffToCoordinator(state, submission, acceptedRun) {
 }
 
 // src/agent-runtime/runtime.ts
-function createAgentRuntime(config) {
+function createAgentRuntime2(config) {
   const state = createAgentRuntimeState(config);
   return {
     submit: (rawInput) => submitAgentInput(state, rawInput),
@@ -4310,4 +4310,4 @@ function createAgentRuntime(config) {
   };
 }
 
-export { AgentRuntimeConflictError, normalizeSdkUsage, AgentContextOverflowError, createAgentSessionCoordinator, registerDeferredToolRepair, registerDeferredToolCatalog, deferredToolCatalog, repairedSearchCall, createAgentRuntimeEventSink, projectAgentHistoryDetailed, projectAgentHistory, ModelInvocationTraceSchema, CompletionInvocationInputSchema, ModelInvocationRecordSchema, currentModelInvocationAttempt, createModelInvocationLedger, createAgentToolFenceLifecycle, AgentTokenCountSchema, selectAgentHistory, composeAgentPrompt, AgentProviderStreamCutError, classifyProviderFailure, isToolResultFailure, recordAgentRetryDecision, defineStateSlot, createAgentStateSlotStore, renderAgentStateSlots, agentGoalStateSlot, agentTodoStateSlot, createAgentRuntime };
+export { AgentRuntimeConflictError2, normalizeSdkUsage, AgentContextOverflowError2, createAgentSessionCoordinator2, registerDeferredToolRepair, registerDeferredToolCatalog, deferredToolCatalog, repairedSearchCall, createAgentRuntimeEventSink2, projectAgentHistoryDetailed2, projectAgentHistory2, ModelInvocationTraceSchema2, CompletionInvocationInputSchema2, ModelInvocationRecordSchema2, currentModelInvocationAttempt2, createModelInvocationLedger2, createAgentToolFenceLifecycle2, AgentTokenCountSchema2, selectAgentHistory2, composeAgentPrompt2, AgentProviderStreamCutError2, classifyProviderFailure2, isToolResultFailure2, recordAgentRetryDecision2, defineStateSlot2, createAgentStateSlotStore2, renderAgentStateSlots2, agentGoalStateSlot2, agentTodoStateSlot2, createAgentRuntime2 };