@mono-agent/agent-runtime 0.20.14 → 0.21.0

package/src/ai/runtime/live-input-events.js

@@ -1,68 +1,102 @@
-// Metadata-only live-input acknowledgement instrumentation.
-//
-// Provider bridges already call message.acknowledge() only after their native
-// steering boundary accepts guidance. Wrapping that callback here creates one
-// adapter-neutral `live_input_applied` event without copying the guidance body
-// into runtime telemetry. A wrapper owns one logical-run dedupe set and is
-// intentionally reused by the fallback router across provider attempts.
+// Metadata-only live-input lifecycle instrumentation and logical-run replay fencing.
+// Stable ids identify one logical delivery across provider retries. The first
+// occurrence owns the body and identity; later same-id occurrences are invalid
+// duplicates unless an exact opaque logical-owner token proves they carry a new
+// callback lease for that first owner. Anonymous input remains legal but is
+// never replayed.
 
 // @ts-check
 
-const LIVE_INPUT_APPLIED_INSTRUMENTED = Symbol("mono-agent.live-input-applied-instrumented");
+const LIVE_INPUT_INSTRUMENTED = Symbol("mono-agent.live-input-instrumented");
+const MAX_DIAGNOSTICS_PER_KIND = 100;
 
 /**
- * @typedef {{body: string, id?: string, receivedAt?: string, acknowledge?: () => void, reject?: (reason?: unknown) => void}} RuntimeLiveInputMessage
- * @typedef {{type: "live_input_applied", inputId: string, receivedAt?: string}} LiveInputAppliedEvent
+ * @typedef {{providerEntryId?: string, providerRunId?: string}} RuntimeLiveInputEvidence
+ * @typedef {{reason: "delivery_uncertain", providerEntryId?: string, providerRunId?: string}} RuntimeLiveInputUncertainty
+ * @typedef {{body: string, id?: string, receivedAt?: string, logicalOwner?: object, accepted?: (evidence?: RuntimeLiveInputEvidence) => unknown, acknowledge?: (evidence?: RuntimeLiveInputEvidence) => unknown, uncertain?: (details: RuntimeLiveInputUncertainty) => unknown, reject?: (reason?: unknown) => unknown}} RuntimeLiveInputMessage
+ * @typedef {{message: RuntimeLiveInputMessage, callbackMessage: RuntimeLiveInputMessage, logicalOwner?: object, inputId: string, receivedAt?: string, phase: "available"|"leased"|"native_accepted"|"consumed"|"uncertain", attempt: number, generation: number}} LiveInputOwner
+ * @typedef {{type: string, [key: string]: unknown}} LiveInputEvent
  */
 
 /**
  * @param {AsyncIterable<RuntimeLiveInputMessage>|undefined} liveInput
- * @param {(event: LiveInputAppliedEvent) => void} onApplied
+ * @param {(event: LiveInputEvent) => void} onEvent
  * @returns {AsyncIterable<RuntimeLiveInputMessage>|undefined}
  */
-export function instrumentLiveInputAppliedEvents(liveInput, onApplied) {
+export function instrumentLiveInputAppliedEvents(liveInput, onEvent) {
   if (liveInput === undefined || isInstrumented(liveInput)) return liveInput;
 
-  const appliedInputIds = new Set();
+  /** @type {Map<string, LiveInputOwner>} */
+  const owners = new Map();
+  const diagnosticCounts = new Map();
+  let generation = 0;
+
   const instrumented = {
-    [LIVE_INPUT_APPLIED_INSTRUMENTED]: true,
+    [LIVE_INPUT_INSTRUMENTED]: true,
     [Symbol.asyncIterator]() {
+      generation += 1;
+      const iteratorGeneration = generation;
       const iterator = liveInput[Symbol.asyncIterator]();
+      const yieldedIds = new Set();
       let ordinal = 0;
+
       return {
         async next() {
-          const next = await iterator.next();
-          if (next.done === true) return next;
-          ordinal += 1;
-          const message = next.value;
-          const inputId = stableInputId(message?.id, ordinal);
-          const receivedAt = typeof message?.receivedAt === "string" && message.receivedAt.length > 0
-            ? message.receivedAt
-            : undefined;
-          const acknowledge = typeof message?.acknowledge === "function"
-            ? message.acknowledge.bind(message)
-            : undefined;
-          return {
-            done: false,
-            value: {
-              ...message,
-              acknowledge: () => {
-                acknowledge?.();
-                if (appliedInputIds.has(inputId)) return;
-                appliedInputIds.add(inputId);
-                try {
-                  onApplied({
-                    type: "live_input_applied",
-                    inputId,
-                    ...(receivedAt === undefined ? {} : { receivedAt }),
-                  });
-                } catch {
-                  // Telemetry must never turn accepted guidance into a provider
-                  // failure after the native steering call already succeeded.
-                }
-              },
-            },
-          };
+          while (true) {
+            const next = await iterator.next();
+            if (next.done === true) return next;
+            ordinal += 1;
+            const message = next.value;
+            const stableId = normalizedStableId(message?.id);
+
+            if (stableId === undefined) {
+              if (iteratorGeneration > 1) {
+                emitBounded("anonymous_identity", {
+                  type: "live_input_replay_suppressed",
+                  reason: "anonymous_identity",
+                  generation: iteratorGeneration,
+                  ordinal,
+                });
+                continue;
+              }
+              const owner = createOwner(message, `anonymous:${iteratorGeneration}:${ordinal}`, iteratorGeneration);
+              return { done: false, value: lease(owner) };
+            }
+
+            const existing = owners.get(stableId);
+            if (existing === undefined) {
+              const owner = createOwner(message, stableId, iteratorGeneration);
+              owners.set(stableId, owner);
+              yieldedIds.add(stableId);
+              return { done: false, value: lease(owner) };
+            }
+
+            emitBounded("duplicate_id", {
+              type: "live_input_duplicate_suppressed",
+              inputId: stableId,
+              generation: iteratorGeneration,
+            });
+            if (
+              iteratorGeneration > existing.generation
+              && existing.phase === "available"
+              && !yieldedIds.has(stableId)
+            ) {
+              // Suppress the later occurrence itself. It merely reveals that the
+              // first owner is present in this replay generation; replay the
+              // first owner's immutable body and identity.
+              yieldedIds.add(stableId);
+              existing.generation = iteratorGeneration;
+              if (
+                existing.logicalOwner !== undefined
+                && existing.logicalOwner === validLogicalOwner(message?.logicalOwner)
+              ) {
+                // The logical owner remains the first occurrence. This is only
+                // its fresh, independently fenced host callback lease.
+                existing.callbackMessage = message;
+              }
+              return { done: false, value: lease(existing) };
+            }
+          }
         },
         async return(value) {
           return typeof iterator.return === "function"
@@ -76,19 +110,181 @@ export function instrumentLiveInputAppliedEvents(liveInput, onApplied) {
       };
     },
   };
+
   return /** @type {AsyncIterable<RuntimeLiveInputMessage>} */ (instrumented);
+
+  /** @param {RuntimeLiveInputMessage} message @param {string} inputId @param {number} ownerGeneration */
+  function createOwner(message, inputId, ownerGeneration) {
+    const receivedAt = validString(message?.receivedAt);
+    const logicalOwner = validLogicalOwner(message?.logicalOwner);
+    return {
+      message,
+      callbackMessage: message,
+      ...(logicalOwner === undefined ? {} : { logicalOwner }),
+      inputId,
+      ...(receivedAt === undefined ? {} : { receivedAt }),
+      phase: /** @type {const} */ ("available"),
+      attempt: 0,
+      generation: ownerGeneration,
+    };
+  }
+
+  /** @param {LiveInputOwner} owner */
+  function lease(owner) {
+    owner.phase = "leased";
+    owner.attempt += 1;
+    const attempt = owner.attempt;
+    const host = owner.callbackMessage;
+    const base = eventBase(owner);
+
+    /** @type {RuntimeLiveInputMessage} */
+    const wrapped = {
+      ...owner.message,
+      accepted(evidence) {
+        if (!isCurrent(owner, attempt, "leased")) return "ignored";
+        owner.phase = "native_accepted";
+        const disposition = callHost(host.accepted, host, evidence);
+        emit({
+          type: "live_input_native_accepted",
+          ...base,
+          ...safeEvidence(evidence),
+          settlementDisposition: disposition,
+        });
+        return publicDisposition(disposition);
+      },
+      acknowledge(evidence) {
+        if (!isCurrent(owner, attempt, "leased", "native_accepted")) {
+          emit({ type: "live_input_consumed", ...base, ...safeEvidence(evidence), late: true });
+          return "ignored";
+        }
+        owner.phase = "consumed";
+        emit({ type: "live_input_consumed", ...base, ...safeEvidence(evidence) });
+        const disposition = callHost(host.acknowledge, host, evidence);
+        if (disposition === "recorded") {
+          emit({ type: "live_input_applied", ...base, ...safeEvidence(evidence) });
+        } else {
+          emit({
+            type: "live_input_settlement_unconfirmed",
+            ...base,
+            phase: "consumed",
+            settlementDisposition: disposition,
+          });
+        }
+        return publicDisposition(disposition);
+      },
+      uncertain(details) {
+        if (!isCurrent(owner, attempt, "leased", "native_accepted")) return "ignored";
+        owner.phase = "uncertain";
+        const normalized = {
+          reason: /** @type {const} */ ("delivery_uncertain"),
+          ...safeEvidence(details),
+        };
+        const disposition = callHost(host.uncertain, host, normalized);
+        emit({
+          type: "live_input_uncertain",
+          ...base,
+          ...normalized,
+          settlementDisposition: disposition,
+        });
+        return publicDisposition(disposition);
+      },
+      reject(reason) {
+        if (!isCurrent(owner, attempt, "leased", "native_accepted")) return "ignored";
+        if (owner.phase === "native_accepted" && !isNativeQueueRemoved(reason)) {
+          return wrapped.uncertain?.({ reason: "delivery_uncertain" });
+        }
+        const disposition = callHost(host.reject, host, reason);
+        // "ignored" is affirmative host evidence that this attempt no longer
+        // owns settlement (normally because the mailbox already sealed it).
+        // Legacy void and thrown callbacks remain replay-compatible because
+        // native removal still proves the provider did not consume the input.
+        owner.phase = disposition === "ignored" ? "uncertain" : "available";
+        return publicDisposition(disposition);
+      },
+    };
+    return wrapped;
+  }
+
+  /** @param {string} kind @param {LiveInputEvent} event */
+  function emitBounded(kind, event) {
+    const count = diagnosticCounts.get(kind) ?? 0;
+    if (count >= MAX_DIAGNOSTICS_PER_KIND) return;
+    diagnosticCounts.set(kind, count + 1);
+    emit(event);
+  }
+
+  /** @param {LiveInputEvent} event */
+  function emit(event) {
+    try { onEvent(event); } catch { /* telemetry never changes delivery */ }
+  }
+}
+
+/** @param {unknown} callback @param {RuntimeLiveInputMessage} receiver @param {unknown} argument */
+function callHost(callback, receiver, argument) {
+  if (typeof callback !== "function") return "unconfirmed";
+  try {
+    const result = callback.call(receiver, argument);
+    return result === "recorded" || result === "ignored" ? result : "unconfirmed";
+  } catch {
+    return "threw";
+  }
+}
+
+/** @param {string} disposition */
+function publicDisposition(disposition) {
+  return disposition === "recorded" || disposition === "ignored" ? disposition : undefined;
+}
+
+/** @param {LiveInputOwner} owner */
+function eventBase(owner) {
+  return {
+    inputId: owner.inputId,
+    ...(owner.receivedAt === undefined ? {} : { receivedAt: owner.receivedAt }),
+  };
+}
+
+/** @param {LiveInputOwner} owner @param {number} attempt @param  {...string} phases */
+function isCurrent(owner, attempt, ...phases) {
+  return owner.attempt === attempt && phases.includes(owner.phase);
 }
 
 /** @param {unknown} value */
-function isInstrumented(value) {
-  return typeof value === "object"
-    && value !== null
-    && value[LIVE_INPUT_APPLIED_INSTRUMENTED] === true;
+function normalizedStableId(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value : undefined;
 }
 
-/** @param {unknown} value @param {number} ordinal */
-function stableInputId(value, ordinal) {
-  return typeof value === "string" && value.trim().length > 0
+/** @param {unknown} value */
+function validLogicalOwner(value) {
+  return value !== null && (typeof value === "object" || typeof value === "function")
     ? value
-    : `anonymous:${ordinal}`;
+    : undefined;
+}
+
+/** @param {unknown} value */
+function validString(value) {
+  return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+
+/** @param {unknown} value */
+function safeEvidence(value) {
+  if (typeof value !== "object" || value === null) return {};
+  const evidence = /** @type {{providerEntryId?: unknown, providerRunId?: unknown}} */ (value);
+  return {
+    ...(validString(evidence.providerEntryId) === undefined ? {} : { providerEntryId: evidence.providerEntryId }),
+    ...(validString(evidence.providerRunId) === undefined ? {} : { providerRunId: evidence.providerRunId }),
+  };
+}
+
+/** @param {unknown} reason */
+function isNativeQueueRemoved(reason) {
+  return typeof reason === "object"
+    && reason !== null
+    && /** @type {{code?: unknown}} */ (reason).code === "native_queue_removed";
+}
+
+/** @param {unknown} value */
+function isInstrumented(value) {
+  return typeof value === "object"
+    && value !== null
+    && value[LIVE_INPUT_INSTRUMENTED] === true;
 }

package/src/ai/runtime/router.js

@@ -28,6 +28,8 @@
 // Result:
 //   The success run's result, with `failoverHistory` appended describing every
 //   prior attempt: [{ model, failureKind, requestId, retryableSubkind }].
+//   Successful retries/backups withhold providerSessionId: their stateless
+//   answer cannot synchronize the primary provider session.
 //   If every eligible retryable/auth entry in the chain fails, returns the last
 //   result with `failureKind: "provider_unavailable_exhausted"`. Terminal
 //   non-retryable failures are returned as-is with their failover history.
@@ -42,6 +44,7 @@ import { passthroughSandbox } from "../../agent/sandbox-seam.js";
 import { resolveRuntimeBrand } from "../../runtime-brand.js";
 import { createObserverHub } from "../observer.js";
 import { instrumentLiveInputAppliedEvents } from "./live-input-events.js";
+import { createWebSearchRunState } from "../../agent/tools/web-search-state.js";
 
 /**
  * @typedef {import('../types.js').RuntimeModelRef} RuntimeModelRef
@@ -89,14 +92,17 @@ import { instrumentLiveInputAppliedEvents } from "./live-input-events.js";
 
 const ATTEMPT_SCOPED_OPTION_KEYS = ["customProvider", "customModel", "modelCapabilities", "isPrivateProvider"];
 const ROUTER_TOOL_CONTEXT_KEYS = [
-  "workspace", "repoRoot", "ripgrepPath", "qaOutputDir", "sandboxPolicy", "sandboxEngine",
+  "workspace", "repoRoot", "additionalReadRoots", "additionalWriteRoots",
+  "ripgrepPath", "qaOutputDir", "sandboxPolicy", "sandboxEngine",
 ];
 const RESOLVER_PROTECTED_OPTION_KEYS = new Set([
   "model", "effort", "messages", "abortSignal", "onEvent",
-  "sessionId", "providerSessionId", "sessionKeepAlive", "sessionIdleTimeoutMs",
+  "sessionRecovery", "sessionId", "providerSessionId", "providerAttributionSessionId", "sessionKeepAlive", "sessionIdleTimeoutMs",
   "diagnosticsSeed", "systemPromptPrefix", "sandboxPolicy", "sandboxEngine", "sandbox",
   "allowedTools", "disallowedTools", "permissionMode", "mcpServers", "mcpApps", "skills",
-  "outputSchema", "liveInput", "toolEnvironment",
+  "mcpCallNoTotalTimeoutTools",
+  "webSearchState",
+  "outputSchema", "liveInput", "toolEnvironment", "persistArtifact",
 ]);
 
 class ResolverProtectedOptionError extends Error {
@@ -141,6 +147,10 @@ export function createRouterRuntime({ host = {}, chain = [], resolveAttempt, ret
      * @returns {Promise<RuntimeResult>}
      */
     async run(systemPrompt, options = {}) {
+      options = {
+        ...options,
+        webSearchState: createWebSearchRunState(options.webSearchConfig, options.webSearchState),
+      };
       const liveInputHub = options.liveInput === undefined
         ? undefined
         : createObserverHub({
@@ -247,13 +257,12 @@ export function createRouterRuntime({ host = {}, chain = [], resolveAttempt, ret
           }
 
           applyEntryEffort(callOptions, entry.effort);
-          // A provider session belongs to the route AND to the attempt that
-          // created it. The entire chain is stateless whenever a fallback exists,
-          // keeping the full logical run replayable regardless of which route is
-          // attempted. A same-model retry re-sends the whole logical turn, so
-          // resuming the session the failed attempt already appended into would
-          // duplicate the turn or hit session_busy.
-          if (entries.length > 1 || i > 0 || retryIndex > 0 || !entrySupportsSessionResume(entry)) {
+          // Only the primary's first attempt may own a provider session. Retries
+          // replay the logical turn and must not resume a transcript the failed
+          // attempt may have appended to; backup routes never inherit that session.
+          const sessionEligibleAttempt = i === 0 && retryIndex === 0 && entrySupportsSessionResume(entry);
+          if (!sessionEligibleAttempt) {
+            delete callOptions.sessionRecovery;
             delete callOptions.sessionId;
             delete callOptions.providerSessionId;
             delete callOptions.sessionKeepAlive;
@@ -311,6 +320,10 @@ export function createRouterRuntime({ host = {}, chain = [], resolveAttempt, ret
           }
 
           result = normalizeProviderAuthFailure(result);
+          if (!sessionEligibleAttempt) {
+            const { providerSessionRecovery: _receipt, ...unownedResult } = result;
+            result = unownedResult;
+          }
 
           const retryability = retryableProviderFailureInfo({
             errorText: result.error || "",
@@ -333,7 +346,10 @@ export function createRouterRuntime({ host = {}, chain = [], resolveAttempt, ret
                 model: modelKey(entry.model),
               });
             }
-            return { ...result, failoverHistory };
+            // Pi may report the attribution id as its session id even on a
+            // stateless call. Withhold that resumable id so host history cannot
+            // synchronize an untouched or failed primary transcript.
+            return { ...result, ...(sessionEligibleAttempt ? {} : { providerSessionId: undefined }), failoverHistory };
           }
 
           failoverHistory.push({
@@ -428,6 +444,9 @@ export function createRouterRuntime({ host = {}, chain = [], resolveAttempt, ret
       configuredTools = { ...(configuredTools || {}), ...next };
       inner.configureTools?.(next);
     },
+    async recoverSession(receipt, context) {
+      return await inner.recoverSession?.(receipt, context) === true;
+    },
     async syncSession(providerSessionId) {
       return Boolean(await inner.syncSession?.(providerSessionId));
     },

package/src/ai/tool-lifecycle.js

@@ -15,9 +15,9 @@ const HOST_HISTORY_METADATA = Symbol("mono-agent.host-tool-history");
 const HOST_TOOL_LIFECYCLE_METADATA = Symbol("mono-agent.host-tool-lifecycle");
 
 /**
- * @param {{sink?: (event: any) => Promise<any>, onObserve?: (event: any) => void, onEvent?: (event: any) => void, abortSignal?: AbortSignal}} options
+ * @param {{sink?: (event: any) => Promise<any>, onObserve?: (event: any) => void, onLifecycleAdmitted?: (event: any) => void, onEvent?: (event: any) => void, abortSignal?: AbortSignal}} options
  */
-export function createToolLifecycleEventGate({ sink, onObserve, onEvent, abortSignal }) {
+export function createToolLifecycleEventGate({ sink, onObserve, onLifecycleAdmitted, onEvent, abortSignal }) {
   /** @type {Promise<void>} */
   let tail = Promise.resolve();
   let pendingDeliveries = 0;
@@ -25,22 +25,30 @@ export function createToolLifecycleEventGate({ sink, onObserve, onEvent, abortSi
   const timing = new Map();
   /** @type {Map<string, any>} */
   const approvals = new Map();
+  const preparedBlocks = new WeakSet();
 
   const emit = (event) => {
     stripProviderLifecycleMetadata(event);
     try { onObserve?.(event); } catch { /* observer callback semantics remain best-effort */ }
+    observeClassification(event, timing, approvals);
     const requiresPersistence = typeof sink === "function" && eventNeedsPersistence(event);
+    // Admission/classification follows native emission, not delayed storage.
+    const writes = requiresPersistence ? prepareEvent(event, { timing, approvals, abortSignal }, preparedBlocks) : [];
+    for (const write of writes) {
+      try { onLifecycleAdmitted?.(write.lifecycle); } catch { /* observers remain best-effort */ }
+    }
     if (!requiresPersistence && pendingDeliveries === 0) {
-      observeClassification(event, timing, approvals);
       try { onEvent?.(event); } catch { /* host callback semantics remain best-effort */ }
       return;
     }
 
     pendingDeliveries += 1;
     const delivery = tail.then(async () => {
-      observeClassification(event, timing, approvals);
       if (requiresPersistence) {
-        await persistEvent(event, sink, { timing, approvals, abortSignal });
+        for (const write of writes) {
+          const persisted = await safePersist(sink, write.lifecycle);
+          try { write.block.history = historyMetadata(persisted, write.state); } catch { /* still settle every admitted write */ }
+        }
       }
       try { onEvent?.(event); } catch { /* host callback semantics remain best-effort */ }
     }).catch((error) => {
@@ -118,32 +126,34 @@ function observeClassification(event, timing, approvals) {
   }
 }
 
-/** @param {any} event @param {(event:any)=>Promise<any>} sink @param {{timing:Map<string,any>,approvals:Map<string,any>,abortSignal?:AbortSignal}} context */
-async function persistEvent(event, sink, context) {
-  if (!record(event) || (event.type !== "assistant" && event.type !== "user")) return;
+/** @param {any} event @param {{timing:Map<string,any>,approvals:Map<string,any>,abortSignal?:AbortSignal}} context @param {WeakSet<object>} preparedBlocks */
+function prepareEvent(event, context, preparedBlocks) {
+  const writes = [];
+  if (!record(event) || (event.type !== "assistant" && event.type !== "user")) return writes;
   const message = event.message;
-  if (!record(message) || !Array.isArray(message.content)) return;
+  if (!record(message) || !Array.isArray(message.content)) return writes;
   for (const block of message.content) {
     if (!record(block)) continue;
     if (event.type === "assistant" && block.type === "tool_use") {
-      if (hostHistoryMetadata(block.history)) continue;
+      if (hostHistoryMetadata(block.history) || preparedBlocks.has(block)) continue;
       if (typeof block.id !== "string" || typeof block.name !== "string") continue;
-      const persisted = await safePersist(sink, {
+      const lifecycle = {
         phase: "invocation",
         toolCallId: block.id,
         toolName: block.name,
         ...(Object.hasOwn(block, "input") ? { arguments: block.input } : {}),
-      });
-      block.history = historyMetadata(persisted, undefined);
+      };
+      preparedBlocks.add(block);
+      writes.push({ block, lifecycle, state: undefined });
       continue;
     }
     if (event.type === "user" && block.type === "tool_result") {
-      if (hostHistoryMetadata(block.history)) continue;
+      if (hostHistoryMetadata(block.history) || preparedBlocks.has(block)) continue;
       const id = typeof block.tool_use_id === "string" ? block.tool_use_id
         : typeof block.tool_call_id === "string" ? block.tool_call_id : undefined;
       if (id === undefined) continue;
       const classified = classifyGenericResult(block, context.timing.get(id), context.approvals.get(id), context.abortSignal);
-      const persisted = await safePersist(sink, {
+      const lifecycle = {
         phase: "result",
         toolCallId: id,
         ...(typeof block.name === "string" ? { toolName: block.name } : {}),
@@ -153,12 +163,14 @@ async function persistEvent(event, sink, context) {
           ? { executionMs: context.timing.get(id).execution_ms }
           : {}),
         artifacts: artifactPaths(block),
-      });
-      block.history = historyMetadata(persisted, classified.state);
+      };
+      preparedBlocks.add(block);
+      writes.push({ block, lifecycle, state: classified.state });
       context.timing.delete(id);
       context.approvals.delete(id);
     }
   }
+  return writes;
 }
 
 /** @param {any} block @param {any} timing @param {any} approval @param {AbortSignal|undefined} abortSignal */
@@ -219,7 +231,9 @@ export function historyMetadata(persisted, terminalStateValue) {
   const metadata = {
     ...(typeof persisted?.recordId === "string" ? { recordId: persisted.recordId } : {}),
     ...(Number.isFinite(Number(persisted?.sequence)) ? { sequence: Number(persisted.sequence) } : {}),
-    persistence: persisted?.persistence === "persisted" ? "persisted" : "failed",
+    persistence: persisted?.persistence === "persisted" || persisted?.persistence === "deferred"
+      ? persisted.persistence
+      : "failed",
     ...(terminalStateValue === undefined ? {} : { terminalState: terminalStateValue }),
     ...(typeof persisted?.truncated === "boolean" ? { truncated: persisted.truncated } : {}),
     ...(Number.isFinite(Number(persisted?.originalBytes)) ? { originalBytes: Number(persisted.originalBytes) } : {}),