stitchkit 0.85.1 → 0.86.0

package/dist/{index-jpp7jd1p.js → index-33xckd7h.js}

@@ -1,3 +1,10 @@
+import {
+  messageOf
+} from "./index-p13mwz16.js";
+import {
+  AgentRuntimeEventSchema,
+  agentDurableEventId
+} from "./index-hkm6wysp.js";
 import {
   advanceToolChronology,
   assistantStatus,
@@ -7,12 +14,8 @@ import {
   isCompleteAgentHistoryTurn
 } from "./index-y2s6h5bf.js";
 import {
-  createBoundedSinkManager
-} from "./index-wnfk50r0.js";
-import {
-  AgentRuntimeEventSchema,
-  agentDurableEventId
-} from "./index-4hk633vz.js";
+  canonicalAgentJson
+} from "./index-vfgb58nf.js";
 import {
   AgentAssistantPlaceholderSchema,
   AgentJsonObjectSchema,
@@ -23,19 +26,145 @@ import {
   AgentRunSchema,
   AgentSnapshotSchema,
   runStateForTerminalReason
-} from "./index-x15ss2dx.js";
+} from "./index-p1b1y93x.js";
+import {
+  createBoundedSinkManager
+} from "./index-wnfk50r0.js";
 import {
   isAgentToolError
 } from "./index-3xnq72rz.js";
 import {
   ToolExecutionControlError,
   isToolExecutionControlError
-} from "./index-dggwnnjv.js";
+} from "./index-wn9cb82y.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";
@@ -686,128 +815,232 @@ function composeAgentPrompt(sections) {
   };
 }
 
-// src/agent-runtime/terminal-commit.ts
-class AgentRuntimeConflictError extends Error {
-  constructor(operation) {
-    super(`Agent runtime store conflict during ${operation}`);
-    this.name = "AgentRuntimeConflictError";
+// 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 appliedSnapshot(result, operation) {
-  if (result.outcome === "applied" || result.outcome === "duplicate")
-    return result.snapshot;
-  throw new AgentRuntimeConflictError(operation);
+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 viewOfSnapshot(snapshot, runId, retainedAssistant) {
-  const run = snapshot.runs.find((candidate) => candidate.id === runId);
-  const assistant = snapshot.messages.find((message) => message.id === run?.assistantMessageId) ?? retainedAssistant;
+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 {
-    snapshotVersion: snapshot.version,
-    conversationId: snapshot.conversationId,
-    ...run && { run },
-    ...assistant && { assistant }
+    reason: "unknown",
+    ...status !== undefined && { status },
+    retryable: false,
+    evidence: "none"
   };
 }
-function viewOfRun(view, conversationId) {
-  return {
-    snapshotVersion: view.snapshotVersion,
-    conversationId,
-    run: view.run,
-    ...view.assistant && { assistant: view.assistant }
-  };
+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 canonicalTerminal(view) {
-  const { run, assistant } = view;
-  if (!run?.terminalReason)
+function parseJson(value) {
+  try {
+    return JSON.parse(value);
+  } catch {
     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" })
-  ];
+
+// 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 {
-    ...candidate.usage && { usage: candidate.usage },
-    run,
-    assistant: AgentMessageSchema.parse({
-      ...candidate.assistant,
-      status: assistantStatus(reason),
-      parts,
-      updatedAt: now().toISOString()
-    }),
-    reason
+    name: input.name,
+    version,
+    schema: input.schema,
+    ...input.description && { description: input.description }
   };
 }
-function canRetryTerminal(current, previous, runtimeEpoch) {
-  return (current.state === "running" || current.state === "interrupt_requested") && current.ownerId === runtimeEpoch && current.fencingToken === previous.fencingToken;
+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;
 }
-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 }
+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
     });
-    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 event = await input.store.appendEvent({
+      conversationId: request.conversationId,
+      kind: "state/set",
+      payload
     });
-    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");
+    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;
     }
-    candidate = current.state === "interrupt_requested" ? interruptedCandidate(candidate, current, input.now) : { ...candidate, run: current };
-  }
-  throw new AgentRuntimeConflictError("terminal commit");
+    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() {
@@ -904,6 +1137,8 @@ function createAgentInjectionRegistry() {
 }
 
 // src/agent-runtime/run-execution.ts
+import { createHash } from "node:crypto";
+import { setTimeout as delay } from "node:timers/promises";
 import {
   stepCountIs
 } from "ai";
@@ -934,11 +1169,44 @@ function repairedSearchCall(toolCall, searchName) {
   };
 }
 
+// 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 z2 } from "zod";
+import { z as z3 } from "zod";
 function findRun(runs, runId) {
   const run = runs.find((candidate) => candidate.id === runId);
   if (!run)
@@ -946,7 +1214,7 @@ function findRun(runs, runId) {
   return run;
 }
 function jsonValue(value) {
-  const parsed = z2.json().safeParse(value);
+  const parsed = z3.json().safeParse(value);
   return parsed.success ? parsed.data : { message: "Non-JSON tool output omitted" };
 }
 function providerEnvelope(value) {
@@ -1084,7 +1352,7 @@ function createAgentRunOperationLifecycle(config) {
   let providerCallId;
   let checkpointedStep = -1;
   const checkpointWaiters = new Map;
-  const record = async (operation) => {
+  const record = (operation) => config.serialize(async () => {
     const current = config.currentRun();
     const snapshot = appliedSnapshot(await config.store.recordRunOperation({
       conversationId: current.conversationId,
@@ -1106,14 +1374,16 @@ function createAgentRunOperationLifecycle(config) {
       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()
+    }));
   };
-  const startModelRequest = (callId, step) => record(AgentRunOperationSchema.parse({
-    operationId: `${callId}:${step}`,
-    kind: "model-request",
-    phase: "started",
-    step,
-    startedAt: config.now().toISOString()
-  }));
   return {
     noteProviderCall(callId) {
       providerCallId = callId;
@@ -1139,7 +1409,11 @@ function createAgentRunOperationLifecycle(config) {
               throw new Error("AgentRuntime model call reached the provider without lifecycle identity");
             }
             await startModelRequest(callId, step);
-            return doStream();
+            try {
+              return await doStream();
+            } catch (error) {
+              throw isOwnInputRefusal(error) ? error : markProviderOrigin(error);
+            }
           }
         }
       });
@@ -1204,6 +1478,39 @@ function snapshotForRunPrompt(snapshot, runId) {
     messages: snapshot.messages.filter((message) => !ownedIds.has(message.id) || eligibleIds.has(message.id))
   });
 }
+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,
@@ -1301,9 +1608,15 @@ function createRunExecutor(dependencies) {
     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;
@@ -1314,9 +1627,11 @@ function createRunExecutor(dependencies) {
     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;
@@ -1347,7 +1662,7 @@ function createRunExecutor(dependencies) {
         ...provider && { provider }
       }));
     };
-    const checkpoint = async () => {
+    const checkpoint = () => serialize(async () => {
       assistant = AgentMessageSchema.parse({
         ...assistant,
         parts,
@@ -1380,7 +1695,7 @@ function createRunExecutor(dependencies) {
         metrics: checkpointMetrics,
         emittedAt: now().toISOString()
       });
-    };
+    });
     try {
       if (config.history?.compact) {
         await operationLifecycle.startCompaction(generateId());
@@ -1409,7 +1724,8 @@ function createRunExecutor(dependencies) {
         }
         if (compacted.usage) {
           nonModelUsage = addUsage(nonModelUsage, compacted.usage);
-          usage = modelUsage ? addUsage(nonModelUsage, modelUsage) : nonModelUsage;
+          const billed = billedUsage();
+          usage = billed ? addUsage(nonModelUsage, billed) : nonModelUsage;
         }
       }
       const assertCurrent = async () => {
@@ -1473,6 +1789,18 @@ function createRunExecutor(dependencies) {
         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);
@@ -1493,7 +1821,7 @@ function createRunExecutor(dependencies) {
             throw new Error(`Invalid approval continuation ${decision.messageId}: ${decision.reason}`);
           }
         }
-        carriedSystem = detailed.system;
+        carriedSystem = [...durableSystem, ...detailed.system];
         return [...detailed.messages];
       };
       const projectInputs = async (source) => {
@@ -1540,10 +1868,12 @@ function createRunExecutor(dependencies) {
           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]));
@@ -1554,324 +1884,456 @@ function createRunExecutor(dependencies) {
         return messages;
       };
       const fallbackModel = selectedModel.model;
-      const result = streamAgentTextBoundary({
-        model: fallbackModel,
-        tools,
-        instructions: withCarriedSystem(prompt.instructions),
-        messages: history,
-        abortSignal: executionSignal,
-        maxRetries: 0,
-        stopWhen: stopConditions,
-        onLanguageModelCallStart: (event) => {
-          operationLifecycle.noteProviderCall(event.callId);
-        },
-        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]
-          };
-          return {
-            ...preparedStep,
-            model: await operationLifecycle.prepareModel(preparedStep?.model ?? fallbackModel, options.stepNumber, generateId())
-          };
-        }
-      });
-      for await (const part of result.stream) {
-        idleDeadline.touch();
-        eventsSinceCheckpoint += 1;
-        sequence += 1;
-        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,
-            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",
+      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,
-            runId: run.id,
-            runtimeEpoch,
-            sequence,
-            ...provider && { provider },
-            emittedAt: now().toISOString()
-          });
-        } else if (part.type === "reasoning-delta") {
-          updateReasoning(part.text, part.providerMetadata);
-          const provider = providerEnvelope(part.providerMetadata);
-          await publish({
-            type: "reasoning-delta",
-            conversationId: run.conversationId,
-            runId: run.id,
-            runtimeEpoch,
-            sequence,
-            textDelta: part.text,
-            ...provider && { provider },
-            emittedAt: now().toISOString()
-          });
-        } else if (part.type === "reasoning-end") {
-          updateReasoning("", part.providerMetadata);
-          reasoningPartIndex = undefined;
-          const provider = providerEnvelope(part.providerMetadata);
-          await publish({
-            type: "reasoning-end",
-            conversationId: run.conversationId,
-            runId: run.id,
-            runtimeEpoch,
-            sequence,
-            ...provider && { provider },
-            emittedAt: now().toISOString()
+            ...fromSeq && { fromSeq },
+            limit: 1e4
           });
-        } 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",
+          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,
-            runId: run.id,
-            runtimeEpoch,
-            sequence,
-            callId: part.toolCallId,
-            toolName: part.toolName,
-            status: "started",
-            input: jsonValue(part.input),
-            emittedAt: now().toISOString()
+            kind: "provider/message",
+            payload: { sha256, message: JSON.parse(body) }
           });
-        } 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,
+          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,
-            runtimeEpoch,
-            sequence,
-            callId: part.toolCallId,
-            toolName: part.toolName,
-            status: "completed",
-            output: jsonValue(part.output),
-            emittedAt: now().toISOString()
-          });
-        } else if (part.type === "tool-error") {
-          internalCause = part.error;
-          if (isToolExecutionControlError(part.error)) {
+            attempt: request.attempt,
+            stepNumber: request.stepNumber,
+            modelId: requestModelId,
+            instructionsSha256,
+            messageShas,
+            bodySha256
+          }
+        });
+      };
+      for (;; ) {
+        const attemptPartStart = parts.length;
+        let retrying = false;
+        let draining = false;
+        const result = streamAgentTextBoundary({
+          model: fallbackModel,
+          tools,
+          instructions: withCarriedSystem(prompt.instructions),
+          messages: history,
+          abortSignal: executionSignal,
+          maxRetries: 0,
+          stopWhen: stopConditions,
+          onLanguageModelCallStart: (event) => {
+            operationLifecycle.noteProviderCall(event.callId);
+          },
+          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: retryAttempt,
+              instructions: instructionsOverride ?? withCarriedSystem(prompt.instructions),
+              messages: providerMessages
+            });
+            return { ...preparedStep, model };
+          }
+        });
+        for await (const part of result.stream) {
+          idleDeadline.touch();
+          if (draining) {
+            if (part.type === "finish-step") {
+              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,
+              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,
-              status: "interrupted",
+              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") {
+            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,
               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();
-            throw part.error;
+            eventsSinceCheckpoint = 0;
+            if (part.type === "finish-step")
+              operationLifecycle.checkpointStep(step - 1);
           }
-          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,
-            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" }
-          }));
+        }
+        if (retrying) {
           await publish({
-            type: "tool-status",
+            type: "attempt-reset",
             conversationId: run.conversationId,
             runId: run.id,
             runtimeEpoch,
-            sequence,
-            callId: part.toolCallId,
-            toolName: part.toolName,
-            status: "failed",
-            output: { message: "Tool output denied" },
+            sequence: transientSequence(),
+            attempt: retryAttempt,
             emittedAt: now().toISOString()
           });
-        } else if (part.type === "source") {
-          parts.push(AgentMessagePartSchema.parse({
-            type: "source",
-            sourceId: part.id,
-            ...part.sourceType === "url" && { url: part.url },
-            ...part.title && { title: part.title }
-          }));
-        } else if (part.type === "file" && config.persistGeneratedFile) {
-          const persisted = await config.persistGeneratedFile(part.file);
-          parts.push(AgentMessagePartSchema.parse({
-            type: "file",
-            mediaType: part.file.mediaType,
-            reference: persisted.reference,
-            ...persisted.filename && { filename: persisted.filename }
-          }));
-        } else if (part.type === "file") {
-          throw new Error("persistGeneratedFile is required for generated file output");
-        } else if (part.type === "reasoning-file" && config.persistGeneratedFile) {
-          const persisted = await config.persistGeneratedFile(part.file);
-          parts.push(AgentMessagePartSchema.parse({
-            type: "file",
-            mediaType: part.file.mediaType,
-            reference: persisted.reference,
-            ...persisted.filename && { filename: persisted.filename }
-          }));
-        } else if (part.type === "reasoning-file") {
-          throw new Error("persistGeneratedFile is required for generated reasoning files");
-        } else if (part.type === "tool-approval-request") {
-          parts.push(AgentMessagePartSchema.parse({
-            type: "tool-approval-request",
-            approvalId: part.approvalId,
-            callId: part.toolCall.toolCallId,
-            ...part.isAutomatic !== undefined && { isAutomatic: part.isAutomatic },
-            ...part.signature && { signature: part.signature }
-          }));
-        } else if (part.type === "tool-approval-response") {
-          parts.push(AgentMessagePartSchema.parse({
-            type: "tool-approval-response",
-            approvalId: part.approvalId,
-            approved: part.approved,
-            ...part.reason && { reason: part.reason }
-          }));
-        } else if (part.type === "custom") {
-          const provider = providerEnvelope(part.providerMetadata);
-          parts.push(AgentMessagePartSchema.parse({
-            type: "provider",
-            envelope: {
-              schemaVersion: 1,
-              provider: "ai-sdk-custom",
-              data: { kind: part.kind, ...provider && { provider: provider.data } }
-            }
-          }));
-        } else if (part.type === "raw") {
-          parts.push(AgentMessagePartSchema.parse({
-            type: "provider",
-            envelope: {
-              schemaVersion: 1,
-              provider: "ai-sdk-raw",
-              data: { value: jsonValue(part.rawValue) }
-            }
-          }));
-        } else if (part.type === "abort") {
-          terminalReason = "interrupted";
-        } else if (part.type === "error") {
-          terminalReason = part.error instanceof AgentContextOverflowError ? "context_overflow" : "provider_failure";
-          internalCause = part.error;
-        } else if (part.type === "finish-step") {
-          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, modelUsage) : modelUsage;
-          config.observe?.emit({
-            schemaVersion: 1,
-            eventId: generateId(),
-            type: "step-finished",
-            conversationId: run.conversationId,
-            runId: run.id,
-            traceId: stepTrace?.traceId ?? trace?.traceId ?? generateId(),
-            spanId: stepTrace?.spanId ?? generateId(),
-            ...stepTrace?.parentSpanId && { parentSpanId: stepTrace.parentSpanId },
-            state: run.state,
-            modelId: selectedModel.descriptor.modelId,
-            step,
-            usage: stepUsage,
-            emittedAt: now().toISOString()
-          });
-          step += 1;
-        } else if (part.type === "finish" && part.finishReason !== "stop") {
-          if (terminalReason === "success") {
-            terminalReason = part.finishReason === "error" ? "provider_failure" : "provider_stop";
-            internalCause ??= { finishReason: part.finishReason };
-          }
-        }
-        if (part.type === "finish") {
-          sawProviderFinish = true;
-          modelUsage = mergeModelTotals(normalizeSdkUsage(part.totalUsage), modelUsage);
-          usage = nonModelUsage ? addUsage(nonModelUsage, modelUsage) : modelUsage;
-        }
-        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);
+          continue;
         }
+        break;
       }
       await operationLifecycle.finish(executionSignal.aborted ? "cancelled" : terminalReason === "provider_failure" ? "failed" : "completed");
       if (terminalPolicyName !== undefined)
@@ -1891,7 +2353,7 @@ function createRunExecutor(dependencies) {
           reason: terminalReason,
           ...terminalPolicyName && { policyName: terminalPolicyName }
         })) {
-          terminalReason = "provider_failure";
+          terminalReason = "output_rejected";
           internalCause = new Error("Agent terminal output was rejected by the protocol");
         }
       }
@@ -1918,8 +2380,12 @@ function createRunExecutor(dependencies) {
           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 = error instanceof AgentContextOverflowError ? "context_overflow" : "provider_failure";
+        terminalReason = failureThisRuntimeOwns(error) ?? (hasProviderOrigin(error) ? "provider_failure" : "runtime_failure");
       }
     } finally {
       idleDeadline.dispose();
@@ -1991,6 +2457,13 @@ function createRunExecutor(dependencies) {
       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,
@@ -2623,4 +3096,4 @@ function createAgentRuntime(config) {
   };
 }
 
-export { AgentContextOverflowError, createAgentSessionCoordinator, registerDeferredToolRepair, registerDeferredToolCatalog, deferredToolCatalog, repairedSearchCall, createAgentRuntimeEventSink, projectAgentHistoryDetailed, projectAgentHistory, createAgentToolFenceLifecycle, AgentTokenCountSchema, selectAgentHistory, composeAgentPrompt, AgentRuntimeConflictError, createAgentRuntime };
+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 };