@ai-matrx/chat 0.1.77 → 0.2.1

package/dist/agents/redux/execution-system/thunks/process-stream.js

@@ -0,0 +1,2582 @@
+import {
+  applyServerUsageState,
+  applyUsageRefusal,
+  classifyUsageRefusal
+} from "../../../../host/usage-gate.js";
+import { parseNdjsonStream } from "../../../../host/server/stream-parser.js";
+import { isStreamTransportLost, StreamTransportError } from "@ai-matrx/agents/matrx";
+import { monitorStream } from "@ai-matrx/data/net";
+import { mintClientTempId } from "@ai-matrx/kit/ids";
+import { withPerformedScript } from "../../../speech-script/types.js";
+import {
+  isChunkEvent,
+  isReasoningChunkEvent,
+  isReasoningEvent,
+  isPhaseEvent,
+  isInitEvent,
+  isCompletionEvent,
+  isTypedDataEvent,
+  isToolEventEvent,
+  isWarningEvent,
+  isInfoEvent,
+  isErrorEvent,
+  isEndEvent,
+  isRenderBlockEvent,
+  isHeartbeatEvent,
+  isRecordReservedEvent,
+  isRecordUpdateEvent,
+  isResourceChangedEvent,
+  isProviderRetryEvent,
+  isCxMessageReservation,
+  isCxRequestReservation,
+  isCxToolCallReservation,
+  isContextAnalysisEvent,
+  isStructuredOutputEvent,
+  isContextStateEvent,
+  isContextTrimmedEvent,
+  isInjectionConsumedEvent,
+  isCitationEvent,
+  isControlTokenEvent,
+  isValueStoredEvent,
+  isContextGroomedEvent
+} from "@ai-matrx/agents/generated/stream-events";
+import {
+  appendChunk,
+  appendReasoningChunk,
+  appendDataPayload,
+  appendTimeline,
+  appendRawEvent,
+  markTextStreamStart,
+  closeTextRun,
+  rewindContentToBoundary,
+  markReasoningStreamStart,
+  closeReasoningRun,
+  finalizeAccumulatedReasoning,
+  finalizeClientMetrics,
+  setRequestStatus,
+  recordTransportSeq,
+  setCurrentPhase,
+  trackOperationInit,
+  trackOperationCompletion,
+  addWarning,
+  addInfoEvent,
+  upsertReservation,
+  upsertRenderBlock,
+  upsertToolLifecycle,
+  setCompletion,
+  setProviderRetry,
+  updateExtractedJson,
+  appendCitation
+} from "../active-requests/active-requests.slice.js";
+import { parseNormalizedCitation } from "../messages/message-citations.js";
+import { confirmServerSync } from "../conversations/conversations.slice.js";
+import { receivedFsChange } from "../../../../host/ui-slots.js";
+import {
+  applySkillStreamEvent,
+  isSkillStreamEvent
+} from "../../../../host/ui-slots.js";
+import { invalidateActiveTools } from "../active-tools/active-tools.slice.js";
+import {
+  applyContextState,
+  applyContextTrimmed
+} from "../context-state/context-state.slice.js";
+import {
+  recordBufferSpawned,
+  recordContextInjected,
+  recordMemoryError,
+  recordObserverCompleted,
+  recordReflectorCompleted
+} from "../observational-memory/observational-memory.slice.js";
+import { assertConversationIdMatches } from "../utils/assert-conversation-id.js";
+import {
+  autoBatched,
+  scheduleStreamFlush,
+  unscheduleStreamFlush
+} from "./stream-flush-scheduler.js";
+import {
+  applyAgentWorkingDocDelta,
+  flushPendingDocumentEdgesThunk,
+  reflectAgentMaterializedThunk,
+  syncWorkingDocumentFromAgentThunk
+} from "../instance-working-document/instance-working-document.thunks.js";
+import {
+  applyAgentCanvasItemDelta,
+  syncCanvasItemContextFromAgentThunk
+} from "../instance-context/sync-canvas-item-context.thunk.js";
+import { docKindForContextKey } from "../../../utils/workingDocumentContext.js";
+import { isCanvasItemContextKey } from "../../../utils/canvasItemContext.js";
+import { StreamingJsonTracker } from "@ai-matrx/kit/json-extract";
+import { StreamBlockAccumulator } from "../utils/stream-block-accumulator.js";
+import { deriveAnswerText } from "../active-requests/active-requests.selectors.js";
+import { captureError } from "../../../../host/diagnostics.js";
+import { readReceiptThread, withReceiptHandle } from "../instance-resources/remark-handles.js";
+import { stampPersistedRemarkHandles } from "../message-crud/stamp-remark-handles.thunk.js";
+import {
+  setConversationLabel,
+  reserveMessage,
+  updateMessageRecord,
+  promoteMessageId,
+  addOptimisticUserMessage
+} from "../messages/messages.slice.js";
+import {
+  hasDisplayableMessageContent,
+  refetchSingleMessage
+} from "../message-crud/refetch-single-message.thunk.js";
+import { removeInboxItem } from "../inbox/inbox.slice.js";
+import {
+  selectConversationMessages,
+  selectMessageCount,
+  selectNextMessagePosition
+} from "../messages/messages.selectors.js";
+import { fromImageOutputData } from "@ai-matrx/media/files";
+import { fromPartialImageData } from "@ai-matrx/media/files";
+import { getCapabilitiesForConversation } from "../../../runtime/get-model-capabilities.js";
+import { toast } from "../../../../host/notify.js";
+import { isDirectiveApplyEvent } from "@ai-matrx/agents/envelope";
+import { proposeDirective } from "../../proposed-directives/proposedDirectivesSlice.js";
+function readTransportCursor(event) {
+  if (typeof event !== "object" || event === null || !("stream_seq" in event) || typeof event.stream_seq !== "number" || !Number.isSafeInteger(event.stream_seq) || event.stream_seq <= 0) {
+    return null;
+  }
+  return {
+    streamId: "stream_id" in event && typeof event.stream_id === "string" && event.stream_id.length > 0 ? event.stream_id : null,
+    streamSeq: event.stream_seq
+  };
+}
+function renderBlockToContentType(type) {
+  if (type === "image" || type === "image_output") return "image";
+  if (type === "audio_output") return "audio";
+  if (type === "video_output") return "video";
+  if (type === "document_output") return "document";
+  if (type === "text" || type === "markdown") return "text";
+  return null;
+}
+import {
+  fromMediaBlock,
+  isMediaBlockData
+} from "@ai-matrx/media/files";
+import {
+  upsertUserRequest,
+  patchUserRequest,
+  upsertRequest,
+  upsertToolCall,
+  patchToolCall
+} from "../observability/observability.slice.js";
+import { isInputDraftProtected } from "../instance-user-input/input-draft-protection.js";
+import { clearComposerIfUnsubmitted } from "../instance-user-input/clear-composer.thunk.js";
+import { clearSubmittedResources } from "../instance-resources/instance-resources.slice.js";
+import { selectHasUnsentResources } from "../instance-resources/instance-resources.selectors.js";
+import {
+  clearSubmittedVariableResourcePolicies,
+  resetUserVariableValues,
+  clearSubmittedFirstTurnValues
+} from "../instance-variable-values/instance-variable-values.slice.js";
+import { openOverlay, CHAT_WINDOWS } from "../../../../host/windows.js";
+import { setInstanceStatus } from "../conversations/conversations.slice.js";
+import { patchAgentConversationMetadata } from "../../conversation-list/conversation-list.slice.js";
+import {
+  buildConversationListItemFromExecution,
+  upsertAgentConversationFromExecutionAction
+} from "../../conversation-list/record-conversation-from-execution.js";
+import {
+  patchConversationInScopes,
+  upsertConversationIntoScopes
+} from "../../conversation-history/slice.js";
+import { StreamProfiler } from "../../../../ui/stream-profiler.js";
+import { makePartialKindStalenessGate } from "@ai-matrx/content-ir/wire";
+import { prepareInboundRenderBlock } from "../utils/inbound-render-block.js";
+import { progressDataRenderBlock } from "../../../../host/content-ir-slots.js";
+import { DECISION_ANSWERS_BLOCK_TYPE } from "../../../../utils/content-ir/decision-answers-ids.js";
+import { recordContextReceipt } from "../context-rules/receipt-check.js";
+import { assembleMessageParts } from "../utils/assemble-cx-content-blocks.js";
+import { materializeMessageArtifacts } from "../../../../host/ui-slots.js";
+import { callbackManager } from "../../../../utils/callbackManager.js";
+import { selectWidgetHandleIdFor } from "../instance-ui-state/instance-ui-state.selectors.js";
+import { surfaceDelegatedToolCall } from "./surface-delegated-tool-call.thunk.js";
+import {
+  HandoffRewindTracker,
+  decideAssistantReservation,
+  reservationBelongsToConversation
+} from "../utils/handoff-stream-state.js";
+import { runToolStateEffects } from "../../../../tool-call-visualization/effects/toolStateEffects.js";
+import { noteBrowserActivity } from "../../../../host/ui-slots.js";
+import { adoptCloudBrowserRunFromStream } from "../../../../host/ui-slots.js";
+import { readHumanRequiredSignal } from "../utils/streamHandoffSignal.js";
+const retainedTransportConsumers = /* @__PURE__ */ new Map();
+function hasRetainedTransportConsumer(requestId) {
+  return retainedTransportConsumers.has(requestId);
+}
+function discardRetainedTransportConsumer(requestId) {
+  const retained = retainedTransportConsumers.get(requestId);
+  if (!retained) return;
+  retainedTransportConsumers.delete(requestId);
+  retained.dispose();
+}
+async function processStream({
+  requestId,
+  conversationId,
+  response,
+  submitAt,
+  conversationIdAt,
+  dispatch,
+  getState,
+  submittedVariableResourcePolicies = {},
+  jsonExtraction,
+  onEvent,
+  abortController,
+  heartbeatTimeoutMs,
+  maxLifetimeMs,
+  userMessageClientTempId,
+  forceLocalConversationId = false,
+  skipTranscriptCommit = false,
+  allowTransportResume = false
+}) {
+  const retained = retainedTransportConsumers.get(requestId);
+  if (retained) {
+    const activeRequest = getState().activeRequests.byRequestId[requestId];
+    if (!activeRequest || activeRequest.conversationId !== conversationId) {
+      discardRetainedTransportConsumer(requestId);
+      throw new Error(
+        `Cannot reconnect stream ${requestId}: its active request is missing or belongs to another conversation.`
+      );
+    }
+    if (retained.busy) {
+      throw new Error(
+        `Cannot reconnect stream ${requestId}: another transport reader is already active.`
+      );
+    }
+    return retained.consume(response, abortController, onEvent);
+  }
+  const owningConvId = (wireConvId) => forceLocalConversationId ? conversationId : wireConvId ?? conversationId;
+  let activeAbortController = abortController;
+  let activeOnEvent = onEvent;
+  const jsonTracker = jsonExtraction?.enabled ? new StreamingJsonTracker({
+    maxResults: jsonExtraction.maxResults,
+    fuzzyOnFinalize: jsonExtraction.fuzzyOnFinalize ?? true
+  }) : null;
+  let lastJsonRevision = 0;
+  let cxConversationConfirmed = false;
+  let tokenUsage;
+  let finishReason;
+  let completionStats;
+  const reservedAssistantTurns = [];
+  const reservedUserMessageIds = /* @__PURE__ */ new Set();
+  const persistedConversationIdByUserMessageId = /* @__PURE__ */ new Map();
+  const authoritativeUserMessageRefreshes = [];
+  const refreshUserMessageWithoutBody = (messageId) => {
+    const existing = getState().messages.byConversationId[conversationId]?.byId[messageId];
+    if (hasDisplayableMessageContent(existing?.userContent ?? existing?.content)) {
+      return;
+    }
+    authoritativeUserMessageRefreshes.push(
+      Promise.resolve(
+        dispatch(
+          refetchSingleMessage({
+            conversationId,
+            messageId,
+            persistedConversationId: persistedConversationIdByUserMessageId.get(messageId),
+            waitForReadable: true
+          })
+        )
+      )
+    );
+  };
+  let reservedUserRequestId = null;
+  const inboxTempIdByPosition = /* @__PURE__ */ new Map();
+  const injectionSlotBoundaries = [];
+  const streamRangeForAssistantPosition = (position) => {
+    if (injectionSlotBoundaries.length === 0) {
+      return { start: void 0, end: void 0 };
+    }
+    let start = 0;
+    let end;
+    for (const boundary of injectionSlotBoundaries) {
+      if (position > boundary.position) {
+        start = boundary.timelineIndex;
+      } else {
+        end = boundary.timelineIndex;
+        break;
+      }
+    }
+    return { start, end };
+  };
+  const toolCallIdByProviderCallId = /* @__PURE__ */ new Map();
+  let currentServerIteration = 0;
+  const iterationByProviderCallId = /* @__PURE__ */ new Map();
+  const handoffTracker = new HandoffRewindTracker();
+  const providerAttemptBoundaries = /* @__PURE__ */ new Map();
+  let clientFirstChunkAt = null;
+  let totalEvents = 0;
+  let chunkEvents = 0;
+  let reasoningChunkEvents = 0;
+  let phaseEvents = 0;
+  let initEvents = 0;
+  let completionEvents = 0;
+  let dataEvents = 0;
+  let toolEvents = 0;
+  let renderBlockEvents = 0;
+  let warningEvents = 0;
+  let infoEvents = 0;
+  const contextDeltaAppliedKeys = /* @__PURE__ */ new Set();
+  let recordReservedEvents = 0;
+  let recordUpdateEvents = 0;
+  let resourceChangedEvents = 0;
+  let providerRetryEvents = 0;
+  let otherEvents = 0;
+  let isInTextRun = false;
+  let isInReasoningRun = false;
+  let unknownEvents = 0;
+  StreamProfiler.getInstance().start(requestId);
+  const blockAccumulator = new StreamBlockAccumulator(
+    requestId,
+    upsertRenderBlock
+  );
+  let accumulatorFinalized = false;
+  const finalizeAccumulator = () => {
+    if (accumulatorFinalized) return;
+    accumulatorFinalized = true;
+    dispatchBatch();
+    blockAccumulator.finalize(dispatch);
+  };
+  const gatePartialKindStaleness = makePartialKindStalenessGate();
+  let textBuffer = "";
+  let reasoningBuffer = "";
+  let pendingTransportCursor = null;
+  const batchedDispatch = (action) => dispatch(autoBatched(action));
+  let reasoningLeakReported = false;
+  const runJsonExtraction = (isFinal) => {
+    if (!jsonTracker) return;
+    const req = getState().activeRequests.byRequestId[requestId];
+    const answerText = req ? deriveAnswerText(req) : "";
+    if (!reasoningLeakReported && hasReasoningLeak(answerText)) {
+      reasoningLeakReported = true;
+      captureError({
+        source: "reasoning-leak",
+        message: "Reasoning tag (<thinking>/<reasoning>) leaked into ANSWER text \u2014 the stream block accumulator failed to isolate chain-of-thought. Answer text and JSON extraction may be polluted.",
+        requestId,
+        conversationId,
+        raw: { sample: answerText.slice(0, 500) }
+      });
+    }
+    jsonTracker.setFullText(answerText);
+    const jsonState = isFinal ? jsonTracker.finalize() : jsonTracker.getState();
+    if (isFinal || jsonState.revision !== lastJsonRevision) {
+      lastJsonRevision = jsonState.revision;
+      batchedDispatch(
+        updateExtractedJson({
+          requestId,
+          results: jsonState.results.map(toSnapshot),
+          revision: jsonState.revision,
+          isComplete: isFinal
+        })
+      );
+    }
+  };
+  const dispatchBatch = () => {
+    unscheduleStreamFlush(dispatchBatch);
+    if (pendingTransportCursor !== null) {
+      const cursor = pendingTransportCursor;
+      pendingTransportCursor = null;
+      batchedDispatch(
+        recordTransportSeq({
+          requestId,
+          streamSeq: cursor.streamSeq,
+          streamId: cursor.streamId
+        })
+      );
+    }
+    let flushedAnswerText = false;
+    if (textBuffer.length > 0) {
+      const flushed = textBuffer;
+      batchedDispatch(appendChunk({ requestId, content: flushed }));
+      blockAccumulator.ingest(flushed, batchedDispatch);
+      textBuffer = "";
+      flushedAnswerText = true;
+    }
+    if (reasoningBuffer.length > 0) {
+      batchedDispatch(
+        appendReasoningChunk({ requestId, content: reasoningBuffer })
+      );
+      reasoningBuffer = "";
+    }
+    if (jsonTracker && flushedAnswerText) {
+      runJsonExtraction(false);
+    }
+  };
+  const commitOnAbort = (controller) => controller?.signal.addEventListener("abort", () => dispatchBatch(), {
+    once: true
+  });
+  commitOnAbort(activeAbortController);
+  const scheduleBatchEvent = () => {
+    scheduleStreamFlush(dispatchBatch);
+  };
+  let streamFailure = null;
+  const POST_TERMINAL_GRACE_MS = 3e4;
+  let postTerminalGraceTimer = null;
+  const armPostTerminalGrace = (terminalSignal) => {
+    if (!activeAbortController || postTerminalGraceTimer !== null) return;
+    const terminalTransportController = activeAbortController;
+    postTerminalGraceTimer = setTimeout(() => {
+      console.error(
+        `[stream:${requestId.slice(0, 8)}] server declared the request terminal (${terminalSignal}) but never closed the stream within ${POST_TERMINAL_GRACE_MS}ms \u2014 ending it locally so the client promise settles. SERVER DEFECT: the response was held open after terminal.`,
+        { requestId, conversationId }
+      );
+      captureError({
+        source: "agent-stream-terminal-guard",
+        message: `Stream stayed open ${POST_TERMINAL_GRACE_MS}ms after terminal signal "${terminalSignal}" \u2014 closed locally so the awaited request settles (D130: headless pipeline hung forever on a completed run).`,
+        requestId,
+        conversationId
+      });
+      terminalTransportController.abort("post-terminal-grace");
+    }, POST_TERMINAL_GRACE_MS);
+  };
+  let lastTransportSeq = getState().activeRequests.byRequestId[requestId]?.lastTransportSeq ?? 0;
+  let transportStreamId = getState().activeRequests.byRequestId[requestId]?.transportStreamId ?? null;
+  let retainedEntry;
+  const consume = async (nextResponse, nextAbortController, nextOnEvent) => {
+    if (retainedEntry.busy) {
+      throw new Error(
+        `Cannot consume stream ${requestId}: another transport reader is already active.`
+      );
+    }
+    retainedEntry.busy = true;
+    let handedToRejoin = false;
+    try {
+      activeAbortController = nextAbortController;
+      commitOnAbort(nextAbortController);
+      activeOnEvent = nextOnEvent;
+      const { events: rawEvents } = parseNdjsonStream(nextResponse);
+      const events = nextAbortController ? monitorStream(rawEvents, {
+        heartbeatTimeoutMs,
+        maxLifetimeMs,
+        abortController: nextAbortController
+      }) : rawEvents;
+      streamFailure = null;
+      let sawTerminalEvent = false;
+      try {
+        for await (const event of events) {
+          const transportCursor = readTransportCursor(event);
+          if (transportCursor !== null) {
+            const segmentChanged = transportCursor.streamId !== null && transportStreamId !== null && transportCursor.streamId !== transportStreamId;
+            if (segmentChanged) {
+              blockAccumulator.rewindToBlockCount(
+                getState().activeRequests.byRequestId[requestId]?.renderBlockOrder.length ?? 0
+              );
+              lastTransportSeq = 0;
+            }
+            if (transportCursor.streamId !== null) {
+              transportStreamId = transportCursor.streamId;
+            }
+            if (transportCursor.streamSeq <= lastTransportSeq) {
+              continue;
+            }
+            lastTransportSeq = transportCursor.streamSeq;
+            pendingTransportCursor = {
+              streamSeq: transportCursor.streamSeq,
+              streamId: transportCursor.streamId
+            };
+            scheduleBatchEvent();
+          }
+          totalEvents++;
+          const now = performance.now();
+          if (activeOnEvent) {
+            try {
+              activeOnEvent(event);
+            } catch {
+            }
+          }
+          if (isChunkEvent(event)) {
+            StreamProfiler.getInstance().trackChunk();
+            chunkEvents++;
+            if (clientFirstChunkAt === null) clientFirstChunkAt = now;
+            const text = event.data.text;
+            if (isInReasoningRun) {
+              dispatchBatch();
+              isInReasoningRun = false;
+              dispatch(closeReasoningRun({ requestId, timestamp: now }));
+            }
+            if (!isInTextRun) {
+              isInTextRun = true;
+              dispatch(markTextStreamStart({ requestId, timestamp: now }));
+            }
+            textBuffer += text;
+            scheduleBatchEvent();
+            continue;
+          }
+          if (isReasoningChunkEvent(event)) {
+            reasoningChunkEvents++;
+            const text = event.data.text;
+            if (!isInReasoningRun) {
+              dispatchBatch();
+              blockAccumulator.breakTextBlock(dispatch);
+              isInTextRun = false;
+              isInReasoningRun = true;
+              dispatch(markReasoningStreamStart({ requestId, timestamp: now }));
+            }
+            reasoningBuffer += text;
+            scheduleBatchEvent();
+            continue;
+          }
+          if (isReasoningEvent(event)) {
+            if (event.data.state === "started") {
+              if (!isInReasoningRun) {
+                dispatchBatch();
+                blockAccumulator.breakTextBlock(dispatch);
+                isInTextRun = false;
+                isInReasoningRun = true;
+                dispatch(
+                  markReasoningStreamStart({ requestId, timestamp: now })
+                );
+              }
+            } else {
+              if (isInReasoningRun) {
+                dispatchBatch();
+                isInReasoningRun = false;
+                dispatch(closeReasoningRun({ requestId, timestamp: now }));
+              }
+            }
+            continue;
+          }
+          dispatchBatch();
+          dispatch(
+            appendRawEvent({
+              requestId,
+              event: {
+                idx: totalEvents,
+                timestamp: now,
+                eventType: event.event,
+                data: event.data
+              }
+            })
+          );
+          if (isInTextRun) {
+            isInTextRun = false;
+          }
+          if (isInReasoningRun) {
+            isInReasoningRun = false;
+            const closesReasoningRun = isToolEventEvent(event) || isRenderBlockEvent(event) || isTypedDataEvent(event) || isErrorEvent(event) || isEndEvent(event) || isCompletionEvent(event) || isInitEvent(event) || isProviderRetryEvent(event);
+            if (closesReasoningRun) {
+              dispatch(closeReasoningRun({ requestId, timestamp: now }));
+            }
+          }
+          if (isPhaseEvent(event)) {
+            phaseEvents++;
+            dispatch(setCurrentPhase({ requestId, phase: event.data.phase }));
+            dispatch(
+              appendTimeline({
+                requestId,
+                entry: {
+                  kind: "phase",
+                  seq: 0,
+                  timestamp: now,
+                  data: event.data
+                }
+              })
+            );
+          } else if (isInitEvent(event)) {
+            initEvents++;
+            const d = event.data;
+            if (d.operation === "sub_agent") {
+              handoffTracker.onSubAgentInit(d.operation_id);
+            }
+            dispatch(
+              trackOperationInit({
+                requestId,
+                operationId: d.operation_id,
+                operation: d.operation,
+                parentOperationId: d.parent_operation_id,
+                metadata: d.metadata ?? null,
+                timestamp: now
+              })
+            );
+            dispatch(
+              appendTimeline({
+                requestId,
+                entry: {
+                  kind: "init",
+                  seq: 0,
+                  timestamp: now,
+                  data: d
+                }
+              })
+            );
+          } else if (isCompletionEvent(event)) {
+            completionEvents++;
+            const d = event.data;
+            const result = d.result ?? {};
+            dispatch(
+              trackOperationCompletion({
+                requestId,
+                operationId: d.operation_id,
+                operation: d.operation,
+                status: d.status,
+                result,
+                timestamp: now
+              })
+            );
+            if (d.operation === "sub_agent" && d.status === "failed") {
+              const rewindDecision = handoffTracker.decideOnSubAgentFailure(
+                d.operation_id
+              );
+              if (rewindDecision.action === "rewind") {
+                blockAccumulator.breakTextBlock(dispatch);
+                dispatch(
+                  rewindContentToBoundary({
+                    requestId,
+                    ...rewindDecision.snapshot
+                  })
+                );
+              } else if (rewindDecision.action === "no_boundary") {
+                console.error(
+                  `[stream:${requestId.slice(0, 8)}] sub_agent FAILED completion arrived with no prior tool boundary \u2014 cannot rewind the handoff text. The partial child output stays visible.`,
+                  d
+                );
+              }
+            }
+            if (d.operation === "user_request") {
+              dispatch(setCompletion({ requestId, data: d }));
+              completionStats = result;
+              const totals = completionStats.total_usage?.total;
+              if (totals) {
+                tokenUsage = {
+                  input: totals.input_tokens ?? 0,
+                  output: totals.output_tokens ?? 0,
+                  total: totals.total_tokens ?? 0
+                };
+              }
+              finishReason = completionStats.finish_reason ?? void 0;
+              armPostTerminalGrace(`completion user_request ${d.status}`);
+            }
+            dispatch(
+              appendTimeline({
+                requestId,
+                entry: {
+                  kind: "completion",
+                  seq: 0,
+                  timestamp: now,
+                  data: d
+                }
+              })
+            );
+          } else if (isTypedDataEvent(event)) {
+            dataEvents++;
+            const d = event.data;
+            const dataType = d.type ?? "unknown";
+            let dataRenderBlockId;
+            dispatch(appendDataPayload({ requestId, data: d }));
+            const progressBlock = progressDataRenderBlock(
+              d,
+              totalEvents,
+              renderBlockEvents
+            );
+            if (progressBlock) {
+              blockAccumulator.breakTextBlock(dispatch);
+              dataRenderBlockId = progressBlock.blockId;
+              dispatch(upsertRenderBlock({ requestId, block: progressBlock }));
+            }
+            if (progressBlock) {
+            } else if (isDirectiveApplyEvent(d)) {
+              const receipt = d.kind === "directive_apply.item" ? {
+                directive: d.directive,
+                outcome: d.status,
+                message: d.message,
+                resource_kind: d.resource_kind,
+                resource_ids: d.resource_ids
+              } : d.kind === "directive_apply.failed" ? {
+                directive: d.directive,
+                outcome: "failed",
+                message: d.message,
+                resource_kind: "",
+                resource_ids: []
+              } : d.kind === "directive_apply.blocked" ? {
+                directive: d.directive,
+                outcome: "blocked",
+                message: d.message,
+                resource_kind: "",
+                resource_ids: []
+              } : d.kind === "directive_apply.proposed" ? {
+                directive: d.directive,
+                outcome: "proposed",
+                message: d.message,
+                resource_kind: "",
+                resource_ids: []
+              } : null;
+              const thread = receipt ? d.thread : void 0;
+              if (receipt && thread && typeof thread === "object") {
+                receipt.thread = thread;
+                const link = readReceiptThread(thread);
+                if (link) {
+                  const stamped = withReceiptHandle(selectConversationMessages(conversationId)(getState()), link);
+                  if (stamped) {
+                    dispatch(
+                      updateMessageRecord({
+                        conversationId,
+                        messageId: stamped.messageId,
+                        patch: { content: stamped.content }
+                      })
+                    );
+                  }
+                }
+              }
+              if (receipt) {
+                const blockId = `directive_receipt_${totalEvents}`;
+                dataRenderBlockId = blockId;
+                blockAccumulator.breakTextBlock(dispatch);
+                dispatch(
+                  upsertRenderBlock({
+                    requestId,
+                    block: {
+                      blockId,
+                      blockIndex: renderBlockEvents,
+                      type: "directive_receipt",
+                      status: "complete",
+                      // null for the same Pass-2 leak reason as value_store_stored.
+                      content: null,
+                      // `data` is the wire field; BlockRenderer surfaces it to the
+                      // component as `serverData`. `message` is the SERVER's
+                      // sentence, copied through VERBATIM — the client does not know
+                      // what the ledger or the handler decided.
+                      data: receipt
+                    }
+                  })
+                );
+              }
+              if (d.kind === "directive_apply.completed") {
+                if (d.failed > 0) {
+                  toast.error(d.message);
+                } else {
+                  toast.success(d.message);
+                }
+              } else if (d.kind === "directive_apply.failed") {
+                toast.error(d.message);
+              } else if (d.kind === "directive_apply.proposed") {
+                dispatch(
+                  proposeDirective({
+                    proposalId: d.proposal_id,
+                    conversationId,
+                    directive: d.directive,
+                    directiveClass: d.directive_class,
+                    noun: d.noun,
+                    summary: d.summary,
+                    message: d.message,
+                    itemCount: d.item_count,
+                    shell: d.shell
+                  })
+                );
+              }
+            } else if (isValueStoredEvent(d)) {
+              const blockId = `value_store_stored_${totalEvents}`;
+              dataRenderBlockId = blockId;
+              dispatch(
+                upsertRenderBlock({
+                  requestId,
+                  block: {
+                    blockId,
+                    blockIndex: renderBlockEvents,
+                    type: "value_store_stored",
+                    status: "complete",
+                    // content stays null like every data-event block: a non-empty
+                    // content string leaks into committed message parts via
+                    // assembleMessageParts Pass 2 when the event lands outside a
+                    // text run. The renderer reads `data`; the slot guard
+                    // allowlists this type (DATA_CARD_RENDER_BLOCK_TYPES).
+                    content: null,
+                    // MATRX-EXCEPTION: ValueStoredEvent has no index signature to
+                    // overlap with RenderBlockPayload.data's generated open bag
+                    // (Record<string, unknown> | null) — two-step cast required.
+                    data: d
+                  }
+                })
+              );
+            } else if (isContextGroomedEvent(d)) {
+              const blockId = `context_groomed_${totalEvents}`;
+              dataRenderBlockId = blockId;
+              dispatch(
+                upsertRenderBlock({
+                  requestId,
+                  block: {
+                    blockId,
+                    blockIndex: renderBlockEvents,
+                    type: "context_groomed",
+                    status: "complete",
+                    // null for the same Pass-2 leak reason as value_store_stored.
+                    content: null,
+                    // MATRX-EXCEPTION: same open-bag cast as ValueStoredEvent above.
+                    data: d
+                  }
+                })
+              );
+            } else if (d.type === "conversation_id") {
+              const convData = d;
+              if (!forceLocalConversationId) {
+                assertConversationIdMatches(
+                  conversationId,
+                  convData.conversation_id,
+                  "conversation_id-data-event"
+                );
+              }
+            } else if (d.type === "conversation_labeled") {
+              const labeled = d;
+              dispatch(
+                setConversationLabel({
+                  conversationId,
+                  title: labeled.title,
+                  description: labeled.description ?? null,
+                  keywords: labeled.keywords ?? null
+                })
+              );
+              dispatch(
+                patchAgentConversationMetadata({
+                  conversationId: labeled.conversation_id,
+                  title: labeled.title,
+                  // Omit (not "") when absent — patchConversationMetadata only
+                  // touches fields it receives as !== undefined, so forcing ""
+                  // here would blank out an existing description instead of
+                  // leaving it alone when the server didn't send one.
+                  description: labeled.description
+                })
+              );
+              dispatch(
+                patchConversationInScopes({
+                  conversationId: labeled.conversation_id,
+                  patch: {
+                    title: labeled.title,
+                    ...labeled.description !== void 0 ? { description: labeled.description } : {}
+                  }
+                })
+              );
+            } else if (d.type === "memory_context_injected") {
+              dispatch(
+                recordContextInjected({
+                  conversationId,
+                  requestId,
+                  data: d
+                })
+              );
+            } else if (d.type === "memory_observer_completed") {
+              dispatch(
+                recordObserverCompleted({
+                  conversationId,
+                  requestId,
+                  data: d
+                })
+              );
+            } else if (d.type === "memory_reflector_completed") {
+              dispatch(
+                recordReflectorCompleted({
+                  conversationId,
+                  requestId,
+                  data: d
+                })
+              );
+            } else if (d.type === "memory_buffer_spawned") {
+              dispatch(
+                recordBufferSpawned({
+                  conversationId,
+                  requestId,
+                  data: d
+                })
+              );
+            } else if (d.type === "memory_error") {
+              dispatch(
+                recordMemoryError({
+                  conversationId,
+                  requestId,
+                  data: d
+                })
+              );
+            } else if (d.type === "context_delta") {
+              const cd = d;
+              if (docKindForContextKey(cd.key) === "working") {
+                const applied = dispatch(
+                  applyAgentWorkingDocDelta({ conversationId, delta: cd })
+                );
+                if (applied) {
+                  contextDeltaAppliedKeys.add(cd.key);
+                } else {
+                  contextDeltaAppliedKeys.delete(cd.key);
+                }
+              } else if (isCanvasItemContextKey(cd.key)) {
+                const applied = dispatch(
+                  applyAgentCanvasItemDelta({
+                    conversationId,
+                    key: cd.key,
+                    delta: cd
+                  })
+                );
+                if (applied) {
+                  contextDeltaAppliedKeys.add(cd.key);
+                } else {
+                  contextDeltaAppliedKeys.delete(cd.key);
+                }
+              }
+            } else if (d.type === "context_changed" || d.type === "context_persisted") {
+              const cd = d;
+              if (docKindForContextKey(cd.key) === "working") {
+                const persisted = cd;
+                if (persisted.materialized && persisted.source_id) {
+                  void dispatch(
+                    reflectAgentMaterializedThunk({
+                      conversationId,
+                      documentId: persisted.source_id
+                    })
+                  );
+                } else if (d.type === "context_persisted" || !contextDeltaAppliedKeys.has(cd.key)) {
+                  void dispatch(
+                    syncWorkingDocumentFromAgentThunk({ conversationId })
+                  );
+                }
+              } else if (isCanvasItemContextKey(cd.key)) {
+                if (d.type === "context_persisted" || !contextDeltaAppliedKeys.has(cd.key)) {
+                  void dispatch(
+                    syncCanvasItemContextFromAgentThunk({
+                      conversationId,
+                      artifactId: cd.key
+                    })
+                  );
+                }
+              }
+            } else if (d.type === "context_conflict") {
+              const cd = d;
+              if (docKindForContextKey(cd.key ?? "") === "working") {
+                console.warn(
+                  "[working-document] context_conflict \u2014 a concurrent user edit raced the agent; both versions are in history, reconcile there",
+                  { conversationId, baseVersion: cd.base_version }
+                );
+                void dispatch(
+                  syncWorkingDocumentFromAgentThunk({ conversationId })
+                );
+              } else if (isCanvasItemContextKey(cd.key ?? "")) {
+                console.warn(
+                  "[canvas-item] context_conflict \u2014 concurrent edit raced the agent; both versions are in artifact history",
+                  {
+                    conversationId,
+                    artifactId: cd.key,
+                    baseVersion: cd.base_version
+                  }
+                );
+                void dispatch(
+                  syncCanvasItemContextFromAgentThunk({
+                    conversationId,
+                    artifactId: cd.key
+                  })
+                );
+              }
+            } else if (d.type === "context_persist_failed") {
+              const cd = d;
+              if (docKindForContextKey(cd.key) === "working") {
+                console.error(
+                  "[working-document] backend failed to persist working document",
+                  { conversationId, error: cd.error }
+                );
+              } else if (isCanvasItemContextKey(cd.key)) {
+                console.error(
+                  "[canvas-item] backend failed to persist canvas artifact edit",
+                  { conversationId, artifactId: cd.key, error: cd.error }
+                );
+              }
+            } else if (isMediaBlockData(d)) {
+              const unified = fromMediaBlock(d.block);
+              const isStreamingPartial = unified.status === "streaming";
+              const renderBlockType = unified.kind === "image" ? "image_output" : unified.kind === "audio" ? "audio_output" : unified.kind === "video" ? "video_output" : "media_block";
+              const stableKey = unified.kind === "image" ? "image_block_current" : `media_block_${unified.kind}_current`;
+              dataRenderBlockId = stableKey;
+              dispatch(
+                upsertRenderBlock({
+                  requestId,
+                  block: {
+                    blockId: stableKey,
+                    blockIndex: renderBlockEvents,
+                    type: renderBlockType,
+                    status: isStreamingPartial ? "streaming" : "complete",
+                    content: null,
+                    // MATRX-EXCEPTION: RenderBlockPayload.data is the generated
+                    // OpenAPI contract's open bag (Record<string, unknown> | null
+                    // — genuinely varies per block type). UnifiedMediaBlock has no
+                    // index signature to overlap with Record<string, unknown>, so
+                    // the two-step cast is required, not a shortcut.
+                    // Audio lifts the performed script exactly as the reload path
+                    // does (withPerformedScript) — live and reloaded render alike.
+                    data: unified.kind === "audio" ? withPerformedScript(unified, unified.metadata) : unified
+                  }
+                })
+              );
+              if (unified.kind === "image" && !isStreamingPartial) {
+                dispatch(openOverlay({ overlayId: CHAT_WINDOWS.imagePeekHost }));
+              }
+            } else if (dataType === "audio_stream_chunk" || dataType === "audio_stream_end") {
+              const audioKey = "media_block_audio_current";
+              const endData = d;
+              const haveAudio = Boolean(
+                getState().activeRequests.byRequestId[requestId]?.renderBlocks?.[audioKey]
+              );
+              if (dataType === "audio_stream_end" && !haveAudio && (endData.file_id || endData.url)) {
+                dataRenderBlockId = audioKey;
+                const unified = fromMediaBlock({
+                  kind: "audio",
+                  origin: endData.file_id ? "matrx" : "external",
+                  status: "complete",
+                  file_id: endData.file_id ?? null,
+                  cdn_url: endData.cdn_url ?? (endData.file_id ? endData.url : null) ?? null,
+                  download_url: endData.download_url ?? null,
+                  external_url: endData.file_id ? null : endData.url ?? null,
+                  mime_type: endData.mime_type ?? null,
+                  duration_ms: endData.duration_ms ?? null
+                });
+                dispatch(
+                  upsertRenderBlock({
+                    requestId,
+                    block: {
+                      blockId: audioKey,
+                      blockIndex: renderBlockEvents,
+                      type: "audio_output",
+                      status: "complete",
+                      content: null,
+                      // MATRX-EXCEPTION: same open-bag cast as the media_block
+                      // branch above (UnifiedMediaBlock has no index signature).
+                      data: unified
+                    }
+                  })
+                );
+              }
+            } else if (dataType === "context_receipt") {
+              recordContextReceipt(dispatch, getState, {
+                conversationId,
+                requestId,
+                data: d
+              });
+            } else if (dataType === DECISION_ANSWERS_BLOCK_TYPE) {
+              const blockId = `decision_answers_${totalEvents}`;
+              dataRenderBlockId = blockId;
+              dispatch(
+                upsertRenderBlock({
+                  requestId,
+                  block: {
+                    blockId,
+                    blockIndex: renderBlockEvents,
+                    type: DECISION_ANSWERS_BLOCK_TYPE,
+                    status: "complete",
+                    content: null,
+                    data: {
+                      payload: d
+                    }
+                  }
+                })
+              );
+            } else {
+              const blockType = [
+                "audio_output",
+                "image_output",
+                "video_output",
+                "search_results",
+                "search_error",
+                "function_result",
+                "workflow_step",
+                "categorization_result",
+                "fetch_results",
+                "podcast_complete",
+                "podcast_stage",
+                "scrape_batch_complete",
+                "structured_input_warning",
+                "display_questionnaire"
+              ].includes(dataType) ? dataType : "unknown_data_event";
+              let blockData;
+              if (dataType === "image_output") {
+                const unified = fromImageOutputData(
+                  d,
+                  d.metadata ?? null
+                );
+                blockData = unified;
+              } else if (dataType === "partial_image") {
+                const unified = fromPartialImageData(
+                  d
+                );
+                blockData = unified;
+              } else if (blockType === "unknown_data_event") {
+                blockData = {
+                  ...d,
+                  _dataType: dataType
+                };
+              } else {
+                blockData = d;
+              }
+              const partialKey = dataType === "partial_image" || dataType === "image_output" ? "image_block_current" : void 0;
+              const blockId = partialKey ?? `data_${dataType}_${totalEvents}`;
+              dataRenderBlockId = blockId;
+              const finalBlockType = dataType === "partial_image" ? "image_output" : blockType;
+              dispatch(
+                upsertRenderBlock({
+                  requestId,
+                  block: {
+                    blockId,
+                    blockIndex: renderBlockEvents,
+                    type: finalBlockType,
+                    status: dataType === "partial_image" ? "streaming" : "complete",
+                    content: null,
+                    data: blockData
+                  }
+                })
+              );
+              if (dataType === "image_output") {
+                dispatch(openOverlay({ overlayId: CHAT_WINDOWS.imagePeekHost }));
+              }
+            }
+            dispatch(
+              appendTimeline({
+                requestId,
+                entry: {
+                  kind: "data",
+                  seq: 0,
+                  timestamp: now,
+                  data: d,
+                  ...dataRenderBlockId ? { blockId: dataRenderBlockId } : {}
+                }
+              })
+            );
+          } else if (isToolEventEvent(event)) {
+            toolEvents++;
+            const toolData = event.data;
+            blockAccumulator.breakTextBlock(dispatch);
+            if (!iterationByProviderCallId.has(toolData.call_id)) {
+              iterationByProviderCallId.set(
+                toolData.call_id,
+                Math.max(currentServerIteration, 1)
+              );
+            }
+            if (toolData.event === "tool_delegated") {
+              dispatch(
+                surfaceDelegatedToolCall({
+                  conversationId,
+                  requestId,
+                  userRequestId: reservedUserRequestId ?? void 0,
+                  callId: toolData.call_id,
+                  toolName: toolData.tool_name,
+                  data: toolData.data ?? {},
+                  event: toolData
+                })
+              );
+            } else {
+              const lifecycleStatus = toolData.event.replace(
+                "tool_",
+                ""
+              );
+              dispatch(
+                upsertToolLifecycle({
+                  requestId,
+                  callId: toolData.call_id,
+                  toolName: toolData.tool_name,
+                  status: lifecycleStatus,
+                  message: toolData.message,
+                  data: toolData.data,
+                  event: toolData,
+                  // The agent's call arguments arrive on `tool_started` (and any
+                  // later event that re-sends them) in `data.arguments`. Forward
+                  // them so the Input / Raw tabs show what the agent actually
+                  // passed — previously dropped, leaving arguments permanently {}.
+                  ...toolData.data?.arguments !== void 0 && {
+                    arguments: toolData.data.arguments
+                  },
+                  ...toolData.event === "tool_completed" && {
+                    result: toolData.data?.result
+                  },
+                  ...toolData.event === "tool_result_preview" && {
+                    resultPreview: toolData.data?.preview
+                  },
+                  ...toolData.event === "tool_error" && {
+                    errorType: toolData.data?.error_type,
+                    errorMessage: toolData.message
+                  }
+                })
+              );
+              if (toolData.event === "tool_completed") {
+                const dbId = toolCallIdByProviderCallId.get(toolData.call_id);
+                const rawResult = toolData.data?.result;
+                if (dbId && rawResult != null) {
+                  const outputStr = typeof rawResult === "string" ? rawResult : JSON.stringify(rawResult);
+                  dispatch(
+                    patchToolCall({
+                      id: dbId,
+                      patch: {
+                        status: "completed",
+                        success: true,
+                        output: outputStr,
+                        outputChars: outputStr.length
+                      }
+                    })
+                  );
+                } else if (!dbId && rawResult != null) {
+                  console.warn(
+                    "[process-stream] tool_completed result not stored to observability \u2014 no record id for call_id",
+                    toolData.call_id
+                  );
+                }
+                runToolStateEffects({
+                  toolName: toolData.tool_name,
+                  args: getState().activeRequests.byRequestId[requestId]?.toolLifecycle[toolData.call_id]?.arguments ?? {},
+                  result: rawResult,
+                  dispatch,
+                  getState
+                });
+              }
+            }
+            dispatch(
+              appendTimeline({
+                requestId,
+                entry: {
+                  kind: "tool_event",
+                  seq: 0,
+                  timestamp: now,
+                  data: toolData
+                }
+              })
+            );
+            if ((toolData.event === "tool_started" || toolData.event === "tool_completed") && typeof toolData.tool_name === "string" && (toolData.tool_name.startsWith("cloud_browser") || toolData.tool_name === "credential_login")) {
+              dispatch(noteBrowserActivity(Date.now()));
+            }
+            const handoffSignal = readHumanRequiredSignal(
+              toolData.event,
+              toolData.tool_name,
+              toolData.data?.result
+            );
+            if (handoffSignal) {
+              void dispatch(adoptCloudBrowserRunFromStream(handoffSignal));
+            }
+            if (toolData.event === "tool_started") {
+              const reqAtBoundary = getState().activeRequests.byRequestId[requestId];
+              if (reqAtBoundary) {
+                handoffTracker.onToolStarted(toolData.call_id, {
+                  blockCount: reqAtBoundary.renderBlockOrder.length,
+                  reasoningChunkCount: reqAtBoundary.reasoningChunks.length,
+                  timelineLength: reqAtBoundary.timeline.length
+                });
+              }
+            } else if (toolData.event === "tool_completed" || toolData.event === "tool_error") {
+              handoffTracker.onToolSettled(toolData.call_id);
+            }
+          } else if (isRenderBlockEvent(event)) {
+            renderBlockEvents++;
+            const { block, sanitized: eventBlock } = prepareInboundRenderBlock(
+              event.data,
+              gatePartialKindStaleness
+            );
+            const _caps = getCapabilitiesForConversation(
+              getState(),
+              conversationId
+            );
+            if (_caps) {
+              const _ct = renderBlockToContentType(block.type);
+              if (_ct && !_caps.output.includes(_ct)) {
+                console.warn(
+                  `[process-stream] capability mismatch: model produced ${block.type} but capabilities.output is [${_caps.output.join(", ")}]`,
+                  { requestId, conversationId, blockType: block.type }
+                );
+              }
+            }
+            dispatch(
+              upsertRenderBlock({
+                requestId,
+                block
+              })
+            );
+            dispatch(
+              appendTimeline({
+                requestId,
+                entry: {
+                  kind: "render_block",
+                  seq: 0,
+                  timestamp: now,
+                  // The sanitized block (same reference as event.data unless a
+                  // malformed __ir was stripped) — the timeline must never carry
+                  // an envelope the pipeline rejected.
+                  data: eventBlock
+                }
+              })
+            );
+          } else if (isWarningEvent(event)) {
+            warningEvents++;
+            dispatch(addWarning({ requestId, warning: event.data }));
+            dispatch(
+              appendTimeline({
+                requestId,
+                entry: {
+                  kind: "warning",
+                  seq: 0,
+                  timestamp: now,
+                  data: event.data
+                }
+              })
+            );
+          } else if (isInfoEvent(event)) {
+            infoEvents++;
+            dispatch(addInfoEvent({ requestId, info: event.data }));
+            if (event.data.code === "usage_state") {
+              applyServerUsageState(dispatch, event.data);
+            }
+            dispatch(
+              appendTimeline({
+                requestId,
+                entry: {
+                  kind: "info",
+                  seq: 0,
+                  timestamp: now,
+                  data: event.data
+                }
+              })
+            );
+          } else if (isRecordReservedEvent(event)) {
+            recordReservedEvents++;
+            const d = event.data;
+            dispatch(
+              upsertReservation({
+                requestId,
+                recordId: d.record_id,
+                dbProject: d.db_project,
+                table: d.table,
+                status: "pending",
+                parentRefs: d.parent_refs,
+                metadata: d.metadata
+              })
+            );
+            if (isCxMessageReservation(d)) {
+              if (d.metadata.role !== "tool") {
+                const { position, role } = d.metadata;
+                const owningConversationId = owningConvId(
+                  d.parent_refs.conversation_id
+                );
+                const belongsToConversation = reservationBelongsToConversation(
+                  d.parent_refs.conversation_id,
+                  conversationId,
+                  forceLocalConversationId
+                );
+                if (role === "user" && belongsToConversation) {
+                  reservedUserMessageIds.add(d.record_id);
+                  persistedConversationIdByUserMessageId.set(
+                    d.record_id,
+                    d.parent_refs.conversation_id ?? conversationId
+                  );
+                }
+                if (role === "assistant") {
+                  const decision = decideAssistantReservation(
+                    reservedAssistantTurns,
+                    {
+                      recordId: d.record_id,
+                      position,
+                      handoff: d.metadata.handoff === true,
+                      belongsToConversation
+                    }
+                  );
+                  if (decision.kind === "rebind") {
+                    dispatch(
+                      promoteMessageId({
+                        conversationId: owningConversationId,
+                        oldId: decision.oldMessageId,
+                        newId: d.record_id,
+                        position
+                      })
+                    );
+                  } else if (decision.kind === "track") {
+                    const streamRange = streamRangeForAssistantPosition(position);
+                    dispatch(
+                      reserveMessage({
+                        conversationId: owningConversationId,
+                        messageId: d.record_id,
+                        role,
+                        position,
+                        requestId,
+                        streamSlotStart: streamRange.start
+                      })
+                    );
+                    if (streamRange.end !== void 0) {
+                      dispatch(
+                        updateMessageRecord({
+                          conversationId: owningConversationId,
+                          messageId: d.record_id,
+                          patch: { _streamSlotEnd: streamRange.end }
+                        })
+                      );
+                    }
+                    reservedAssistantTurns.push({
+                      messageId: d.record_id,
+                      position,
+                      iteration: Math.max(currentServerIteration, 1)
+                    });
+                  }
+                } else if (!belongsToConversation) {
+                } else if (role === "user" && inboxTempIdByPosition.has(position)) {
+                  const inboxTempId = inboxTempIdByPosition.get(position);
+                  inboxTempIdByPosition.delete(position);
+                  if (inboxTempId) {
+                    dispatch(
+                      promoteMessageId({
+                        conversationId: owningConversationId,
+                        oldId: inboxTempId,
+                        newId: d.record_id,
+                        position
+                      })
+                    );
+                  }
+                } else if (role === "user" && userMessageClientTempId) {
+                  dispatch(
+                    promoteMessageId({
+                      conversationId: owningConversationId,
+                      oldId: userMessageClientTempId,
+                      newId: d.record_id,
+                      position
+                    })
+                  );
+                } else {
+                  const echoed = d.metadata.user_content;
+                  dispatch(
+                    reserveMessage({
+                      conversationId: owningConversationId,
+                      messageId: d.record_id,
+                      role,
+                      position,
+                      requestId,
+                      ...role === "user" && Array.isArray(echoed) ? { userContent: echoed } : {}
+                    })
+                  );
+                }
+              }
+            } else if (d.table === "user_request") {
+              reservedUserRequestId = d.record_id;
+              const parents = d.parent_refs;
+              const nowIso = (/* @__PURE__ */ new Date()).toISOString();
+              dispatch(
+                clearComposerIfUnsubmitted(conversationId, { via: "persist" })
+              );
+              dispatch(clearSubmittedResources(conversationId));
+              dispatch(
+                upsertUserRequest({
+                  id: d.record_id,
+                  conversationId: owningConvId(parents?.conversation_id),
+                  // Fields unknown at reservation time; server fills them in on
+                  // record_update / completion. Sensible zeros keep selectors safe.
+                  userId: "",
+                  agentId: null,
+                  agentVersionId: null,
+                  status: "pending",
+                  iterations: 0,
+                  finishReason: null,
+                  error: null,
+                  triggerMessagePosition: null,
+                  resultStartPosition: null,
+                  resultEndPosition: null,
+                  totalInputTokens: 0,
+                  totalOutputTokens: 0,
+                  totalCachedTokens: 0,
+                  totalTokens: 0,
+                  totalToolCalls: 0,
+                  totalCost: null,
+                  totalDurationMs: null,
+                  apiDurationMs: null,
+                  toolDurationMs: null,
+                  sourceApp: "",
+                  sourceFeature: "",
+                  metadata: d.metadata ?? {},
+                  createdAt: nowIso,
+                  completedAt: null,
+                  deletedAt: null
+                })
+              );
+            } else if (isCxRequestReservation(d)) {
+              const activeRequest = getState().activeRequests.byRequestId[requestId];
+              if (activeRequest) {
+                providerAttemptBoundaries.set(
+                  owningConvId(d.parent_refs.conversation_id),
+                  {
+                    blockCount: activeRequest.renderBlockOrder.length,
+                    reasoningChunkCount: activeRequest.reasoningChunks.length,
+                    timelineLength: activeRequest.timeline.length
+                  }
+                );
+              }
+              const { iteration } = d.metadata;
+              const { conversation_id, user_request_id } = d.parent_refs;
+              if (typeof iteration === "number" && reservationBelongsToConversation(
+                conversation_id,
+                conversationId,
+                forceLocalConversationId
+              )) {
+                currentServerIteration = iteration;
+              }
+              const nowIso = (/* @__PURE__ */ new Date()).toISOString();
+              dispatch(
+                upsertRequest({
+                  id: d.record_id,
+                  conversationId: owningConvId(conversation_id),
+                  userRequestId: user_request_id,
+                  aiModelId: "",
+                  iteration,
+                  responseId: null,
+                  finishReason: null,
+                  inputTokens: null,
+                  cachedTokens: null,
+                  outputTokens: null,
+                  totalTokens: null,
+                  cost: null,
+                  totalDurationMs: null,
+                  apiDurationMs: null,
+                  toolDurationMs: null,
+                  toolCallsCount: null,
+                  toolCallsDetails: null,
+                  metadata: d.metadata,
+                  createdAt: nowIso,
+                  deletedAt: null
+                })
+              );
+            } else if (isCxToolCallReservation(d)) {
+              const { tool_name, call_id, iteration } = d.metadata;
+              const {
+                conversation_id,
+                user_request_id,
+                call_id: parentCallId
+              } = d.parent_refs;
+              const nowIso = (/* @__PURE__ */ new Date()).toISOString();
+              const providerCallId = call_id ?? parentCallId;
+              if (providerCallId) {
+                toolCallIdByProviderCallId.set(providerCallId, d.record_id);
+              }
+              dispatch(
+                upsertToolCall({
+                  id: d.record_id,
+                  conversationId: owningConvId(conversation_id),
+                  userRequestId: user_request_id,
+                  messageId: null,
+                  userId: "",
+                  callId: call_id ?? parentCallId,
+                  toolName: tool_name,
+                  // Streamed events carry the canonical name; the as-called value is
+                  // backfilled on conversation reload from cx_tool_call.tool_name_as_called.
+                  toolNameAsCalled: null,
+                  toolType: "",
+                  iteration,
+                  status: "pending",
+                  success: false,
+                  isError: null,
+                  errorType: null,
+                  errorMessage: null,
+                  arguments: {},
+                  output: null,
+                  outputChars: 0,
+                  outputPreview: null,
+                  outputType: null,
+                  inputTokens: null,
+                  outputTokens: null,
+                  totalTokens: null,
+                  costUsd: null,
+                  durationMs: 0,
+                  startedAt: nowIso,
+                  completedAt: nowIso,
+                  parentCallId: null,
+                  retryCount: null,
+                  persistKey: null,
+                  filePath: null,
+                  executionEvents: null,
+                  metadata: d.metadata,
+                  createdAt: nowIso,
+                  deletedAt: null
+                })
+              );
+            } else if (d.table === "conversation") {
+              if (!forceLocalConversationId) {
+                assertConversationIdMatches(
+                  conversationId,
+                  d.record_id,
+                  "record_reserved-cx_conversation"
+                );
+                if (!cxConversationConfirmed) {
+                  cxConversationConfirmed = true;
+                  dispatch(confirmServerSync(conversationId));
+                  void dispatch(
+                    flushPendingDocumentEdgesThunk({ conversationId })
+                  );
+                  const syncListCx = upsertAgentConversationFromExecutionAction(
+                    getState(),
+                    conversationId,
+                    conversationId
+                  );
+                  if (syncListCx) dispatch(syncListCx);
+                  const historyRow = buildConversationListItemFromExecution(
+                    getState(),
+                    conversationId,
+                    conversationId
+                  );
+                  if (historyRow) {
+                    dispatch(
+                      upsertConversationIntoScopes({
+                        row: historyRow.row,
+                        agentId: historyRow.canonicalAgentId
+                      })
+                    );
+                  }
+                }
+              }
+            }
+            dispatch(
+              appendTimeline({
+                requestId,
+                entry: {
+                  kind: "record_reserved",
+                  seq: 0,
+                  timestamp: now,
+                  data: d
+                }
+              })
+            );
+          } else if (isRecordUpdateEvent(event)) {
+            recordUpdateEvents++;
+            const d = event.data;
+            dispatch(
+              upsertReservation({
+                requestId,
+                recordId: d.record_id,
+                dbProject: d.db_project,
+                table: d.table,
+                status: d.status,
+                metadata: d.metadata
+              })
+            );
+            if (d.table === "message") {
+              let patch = { status: d.status };
+              if (d.status === "failed" && d.metadata) {
+                patch = {
+                  status: d.status,
+                  metadata: d.metadata
+                };
+                const rawError = d.metadata.error;
+                if (rawError && typeof rawError === "object" && !Array.isArray(rawError) && typeof rawError.message === "string") {
+                  const e = rawError;
+                  patch.error = {
+                    type: typeof e.type === "string" ? e.type : "error",
+                    message: e.message
+                  };
+                }
+              }
+              dispatch(
+                updateMessageRecord({
+                  conversationId,
+                  messageId: d.record_id,
+                  patch
+                })
+              );
+              if (d.status === "completed" && reservedUserMessageIds.delete(d.record_id)) {
+                refreshUserMessageWithoutBody(d.record_id);
+              }
+            } else if (d.table === "user_request") {
+              dispatch(
+                patchUserRequest({
+                  id: d.record_id,
+                  patch: {
+                    status: d.status,
+                    completedAt: d.status === "completed" || d.status === "failed" ? (/* @__PURE__ */ new Date()).toISOString() : null
+                  }
+                })
+              );
+            } else if (d.table === "tool_call") {
+              dispatch(
+                patchToolCall({
+                  id: d.record_id,
+                  patch: {
+                    status: d.status,
+                    completedAt: (/* @__PURE__ */ new Date()).toISOString()
+                  }
+                })
+              );
+            }
+            dispatch(
+              appendTimeline({
+                requestId,
+                entry: {
+                  kind: "record_update",
+                  seq: 0,
+                  timestamp: now,
+                  data: d
+                }
+              })
+            );
+          } else if (isResourceChangedEvent(event)) {
+            resourceChangedEvents++;
+            const d = event.data;
+            if (d.kind === "active_tools") {
+              const added = typeof d.metadata?.added === "number" ? d.metadata.added : 0;
+              const removed = typeof d.metadata?.removed === "number" ? d.metadata.removed : 0;
+              dispatch(
+                invalidateActiveTools({ conversationId, added, removed })
+              );
+            } else if (isSkillStreamEvent(d.kind)) {
+              applySkillStreamEvent(dispatch, {
+                kind: d.kind,
+                action: d.action,
+                resource_id: d.resource_id,
+                metadata: d.metadata ?? {}
+              });
+            } else {
+              dispatch(
+                receivedFsChange({
+                  kind: d.kind,
+                  action: d.action,
+                  resourceId: d.resource_id,
+                  sandboxId: d.sandbox_id ?? null,
+                  userId: d.user_id ?? null,
+                  metadata: d.metadata ?? {},
+                  receivedAt: Date.now(),
+                  requestId,
+                  conversationId
+                })
+              );
+            }
+            dispatch(
+              appendTimeline({
+                requestId,
+                entry: {
+                  kind: "resource_changed",
+                  seq: 0,
+                  timestamp: now,
+                  data: d
+                }
+              })
+            );
+          } else if (isProviderRetryEvent(event)) {
+            providerRetryEvents++;
+            const d = event.data;
+            if (d.discard_partial_output) {
+              const providerAttemptBoundary = providerAttemptBoundaries.get(
+                owningConvId(d.conversation_id)
+              );
+              if (providerAttemptBoundary) {
+                blockAccumulator.rewindToBlockCount(
+                  providerAttemptBoundary.blockCount
+                );
+                dispatch(
+                  rewindContentToBoundary({
+                    requestId,
+                    ...providerAttemptBoundary
+                  })
+                );
+                isInTextRun = false;
+                isInReasoningRun = false;
+                runJsonExtraction(false);
+              } else {
+                captureError({
+                  source: "agent-stream-provider-retry",
+                  message: "Provider requested partial-output discard before a cx_request boundary was observed; content was retained to avoid deleting a prior iteration.",
+                  requestId,
+                  conversationId,
+                  raw: d
+                });
+              }
+            }
+            dispatch(setProviderRetry({ requestId, retry: d }));
+            if (d.state === "suspended") {
+              dispatch(setInstanceStatus({ conversationId, status: "paused" }));
+            } else if (d.state === "cancelled") {
+              dispatch(setRequestStatus({ requestId, status: "cancelled" }));
+              dispatch(
+                setInstanceStatus({ conversationId, status: "cancelled" })
+              );
+            }
+            dispatch(
+              appendTimeline({
+                requestId,
+                entry: {
+                  kind: "provider_retry",
+                  seq: 0,
+                  timestamp: now,
+                  data: d
+                }
+              })
+            );
+          } else if (isErrorEvent(event)) {
+            otherEvents++;
+            dispatch(
+              setRequestStatus({
+                requestId,
+                status: "error",
+                error: event.data
+              })
+            );
+            dispatch(setInstanceStatus({ conversationId, status: "error" }));
+            const streamRefusal = classifyUsageRefusal(null, event.data, getState);
+            if (streamRefusal) {
+              applyUsageRefusal(
+                streamRefusal,
+                dispatch,
+                getState,
+                event.data,
+                event.data.user_message ?? event.data.message
+              );
+            }
+            dispatch(
+              appendTimeline({
+                requestId,
+                entry: {
+                  kind: "error",
+                  seq: 0,
+                  timestamp: now,
+                  data: event.data
+                }
+              })
+            );
+            const errWidgetHandleId = selectWidgetHandleIdFor(
+              getState(),
+              conversationId
+            );
+            if (errWidgetHandleId) {
+              const handle = callbackManager.get(errWidgetHandleId);
+              handle?.onError?.({
+                reason: event.data.error_type ?? "stream_error",
+                message: event.data.user_message ?? event.data.message
+              });
+            }
+            armPostTerminalGrace("fatal error event");
+          } else if (isEndEvent(event)) {
+            sawTerminalEvent = true;
+            otherEvents++;
+            const currentState = getState();
+            const currentRequest = currentState.activeRequests.byRequestId[requestId];
+            if (currentRequest?.status !== "error") {
+              dispatch(setRequestStatus({ requestId, status: "complete" }));
+              const instStatus = currentState.conversations.byConversationId[conversationId]?.status;
+              if (instStatus !== "paused") {
+                dispatch(
+                  setInstanceStatus({ conversationId, status: "complete" })
+                );
+              }
+              const endWidgetHandleId = selectWidgetHandleIdFor(
+                getState(),
+                conversationId
+              );
+              if (endWidgetHandleId) {
+                const handle = callbackManager.get(endWidgetHandleId);
+                if (handle?.onComplete) {
+                  const responseText = currentRequest?.renderBlockOrder.map(
+                    (id) => currentRequest.renderBlocks[id]?.content ?? ""
+                  ).join("\n") || "";
+                  handle.onComplete({
+                    conversationId,
+                    requestId,
+                    responseText
+                  });
+                }
+              }
+            }
+            dispatch(
+              appendTimeline({
+                requestId,
+                entry: {
+                  kind: "end",
+                  seq: 0,
+                  timestamp: now,
+                  data: event.data
+                }
+              })
+            );
+            armPostTerminalGrace("end event");
+          } else if (isHeartbeatEvent(event)) {
+            otherEvents++;
+            dispatch(
+              appendTimeline({
+                requestId,
+                entry: {
+                  kind: "heartbeat",
+                  seq: 0,
+                  timestamp: now,
+                  data: event.data
+                }
+              })
+            );
+          } else if (isContextAnalysisEvent(event)) {
+            otherEvents++;
+            dispatch(
+              appendTimeline({
+                requestId,
+                entry: {
+                  kind: "unknown",
+                  seq: 0,
+                  timestamp: now,
+                  originalEvent: "context_analysis",
+                  rawData: event.data
+                }
+              })
+            );
+          } else if (isStructuredOutputEvent(event)) {
+            otherEvents++;
+            dispatch(
+              appendTimeline({
+                requestId,
+                entry: {
+                  kind: "structured_output",
+                  seq: 0,
+                  timestamp: now,
+                  data: event.data
+                }
+              })
+            );
+          } else if (isContextStateEvent(event)) {
+            otherEvents++;
+            dispatch(applyContextState(event.data));
+          } else if (isContextTrimmedEvent(event)) {
+            otherEvents++;
+            dispatch(applyContextTrimmed(event.data));
+          } else if (isCitationEvent(event)) {
+            otherEvents++;
+            const parsedCitation = parseNormalizedCitation(event.data.citation);
+            if (!parsedCitation) {
+              console.warn(
+                `[stream:${requestId.slice(0, 8)}] Malformed citation event payload \u2014 violates the NormalizedCitation contract; skipped for live render (preserved in rawEvents).`,
+                event.data
+              );
+            } else {
+              const reqSnapshot = getState().activeRequests.byRequestId[requestId];
+              let anchorBlockId = null;
+              let anchorOffset = null;
+              if (reqSnapshot) {
+                for (let i = reqSnapshot.renderBlockOrder.length - 1; i >= 0; i--) {
+                  const candidate = reqSnapshot.renderBlocks[reqSnapshot.renderBlockOrder[i]];
+                  if (candidate && candidate.type === "text") {
+                    anchorBlockId = candidate.blockId;
+                    anchorOffset = (candidate.content ?? "").length;
+                    break;
+                  }
+                }
+              }
+              dispatch(
+                appendCitation({
+                  requestId,
+                  entry: {
+                    providerBlockIndex: event.data.block_index ?? null,
+                    anchorBlockId,
+                    anchorOffset,
+                    citation: parsedCitation
+                  }
+                })
+              );
+            }
+          } else if (isControlTokenEvent(event)) {
+            otherEvents++;
+          } else if (isInjectionConsumedEvent(event)) {
+            otherEvents++;
+            const visiblePositions = (event.data.items ?? []).filter(
+              (item) => item.is_visible_to_user !== false && Boolean(item.text)
+            ).map(
+              (item) => typeof item.position === "number" ? item.position : selectMessageCount(conversationId)(getState())
+            ).sort((a, b) => a - b);
+            if (visiblePositions.length > 0) {
+              blockAccumulator.breakTextBlock(dispatch);
+              const activeRequest = getState().activeRequests.byRequestId[requestId];
+              if (activeRequest?.isTextStreaming) {
+                dispatch(closeTextRun({ requestId, timestamp: now }));
+              }
+              if (activeRequest?.isReasoningStreaming) {
+                dispatch(closeReasoningRun({ requestId, timestamp: now }));
+              }
+              const boundarySlot = getState().activeRequests.byRequestId[requestId]?.timeline.length ?? 0;
+              for (const position of visiblePositions) {
+                injectionSlotBoundaries.push({
+                  position,
+                  timelineIndex: boundarySlot
+                });
+              }
+              injectionSlotBoundaries.sort((a, b) => a.position - b.position);
+              const currentMessages = getState().messages.byConversationId[conversationId]?.byId ?? {};
+              for (const message of Object.values(currentMessages)) {
+                if (message.role === "assistant" && message._streamRequestId === requestId && message._streamSlotEnd === void 0) {
+                  const streamRange = streamRangeForAssistantPosition(
+                    message.position
+                  );
+                  dispatch(
+                    updateMessageRecord({
+                      conversationId,
+                      messageId: message.id,
+                      patch: {
+                        _streamSlotStart: streamRange.start,
+                        ...streamRange.end !== void 0 ? { _streamSlotEnd: streamRange.end } : {}
+                      }
+                    })
+                  );
+                }
+              }
+            }
+            for (const item of event.data.items ?? []) {
+              dispatch(
+                removeInboxItem({
+                  conversationId,
+                  injectionId: item.injection_id
+                })
+              );
+              if (item.is_visible_to_user === false) continue;
+              const text = item.text ?? "";
+              if (!text) continue;
+              const tempId = mintClientTempId("inbox", item.injection_id);
+              const position = typeof item.position === "number" ? item.position : selectNextMessagePosition(conversationId)(getState());
+              inboxTempIdByPosition.set(position, tempId);
+              dispatch(
+                addOptimisticUserMessage({
+                  conversationId,
+                  clientTempId: tempId,
+                  content: [{ type: "text", text }],
+                  position
+                })
+              );
+            }
+          } else {
+            const _exhaustive = event;
+            const unhandled = _exhaustive;
+            unknownEvents++;
+            otherEvents++;
+            console.warn(
+              `[stream:${requestId.slice(0, 8)}] Unrecognized event type: "${unhandled.event}"`,
+              unhandled
+            );
+            dispatch(
+              appendTimeline({
+                requestId,
+                entry: {
+                  kind: "unknown",
+                  seq: 0,
+                  timestamp: now,
+                  originalEvent: String(unhandled.event ?? "undefined"),
+                  rawData: unhandled.data
+                }
+              })
+            );
+          }
+        }
+      } catch (err) {
+        streamFailure = err instanceof Error ? err : new Error(String(err));
+      }
+      if (sawTerminalEvent && streamFailure !== null) {
+        streamFailure = null;
+      }
+      const abortReason = activeAbortController?.signal.reason;
+      const monitorAborted = abortReason === "heartbeat-timeout" || abortReason === "total-timeout";
+      if (streamFailure === null && !sawTerminalEvent && activeAbortController?.signal.aborted && !monitorAborted) {
+        const abortError = new Error("Stream was cancelled.");
+        abortError.name = "AbortError";
+        streamFailure = abortError;
+      }
+      if (streamFailure === null && !sawTerminalEvent) {
+        streamFailure = new StreamTransportError({
+          detail: "NDJSON transport closed before a terminal end event.",
+          requestId
+        });
+      }
+      if (postTerminalGraceTimer !== null) {
+        clearTimeout(postTerminalGraceTimer);
+        postTerminalGraceTimer = null;
+      }
+      if (unknownEvents > 0) {
+        console.warn(
+          `[stream:${requestId.slice(0, 8)}] Stream completed with ${unknownEvents} unrecognized event(s)`
+        );
+      }
+      const recoverableTransportFailure = allowTransportResume && streamFailure !== null && (streamFailure.name === "HeartbeatTimeoutError" || isStreamTransportLost(streamFailure));
+      if (recoverableTransportFailure) {
+        dispatchBatch();
+        handedToRejoin = true;
+        throw streamFailure;
+      }
+      if (streamFailure !== null && persistedConversationIdByUserMessageId.size === 0) {
+        const entry = getState().messages.byConversationId[conversationId];
+        const records = (entry?.orderedIds ?? []).map((id) => entry?.byId[id]);
+        const onlyOptimisticFirstAttempt = records.every(
+          (record) => !record || record.source === "client" && record._clientStatus === "pending"
+        );
+        if (onlyOptimisticFirstAttempt) {
+          dispatch(clearSubmittedFirstTurnValues(conversationId));
+        }
+      }
+      finalizeAccumulator();
+      if (streamFailure === null) {
+        for (const messageId of reservedUserMessageIds) {
+          refreshUserMessageWithoutBody(messageId);
+        }
+        reservedUserMessageIds.clear();
+      }
+      if (authoritativeUserMessageRefreshes.length > 0) {
+        await Promise.allSettled(authoritativeUserMessageRefreshes);
+      }
+      if (streamFailure === null) {
+        void Promise.resolve(dispatch(stampPersistedRemarkHandles({ conversationId }))).catch((error) => {
+          console.error("[process-stream] stamping remark handles failed:", error);
+        });
+      }
+      dispatch(closeTextRun({ requestId, timestamp: performance.now() }));
+      dispatch(closeReasoningRun({ requestId, timestamp: performance.now() }));
+      StreamProfiler.getInstance().stopAndReport("Stream Performance Result", {
+        tokens: tokenUsage,
+        // The wire type allows null durations; the profiler wants number|undefined.
+        timing: completionStats?.timing_stats ? {
+          total_duration: completionStats.timing_stats.total_duration ?? void 0,
+          api_duration: completionStats.timing_stats.api_duration ?? void 0
+        } : void 0
+      });
+      const postLoopState = getState();
+      const postLoopRequest = postLoopState.activeRequests.byRequestId[requestId];
+      if (streamFailure === null && postLoopRequest && postLoopRequest.status !== "complete" && postLoopRequest.status !== "error") {
+        dispatch(setRequestStatus({ requestId, status: "complete" }));
+        const postLoopInstStatus = postLoopState.conversations.byConversationId[conversationId]?.status;
+        if (postLoopInstStatus !== "paused") {
+          dispatch(setInstanceStatus({ conversationId, status: "complete" }));
+        }
+      }
+      const streamEndAt = performance.now();
+      dispatch(finalizeAccumulatedReasoning({ requestId }));
+      runJsonExtraction(true);
+      const finalState = getState();
+      const finalRequest = finalState.activeRequests.byRequestId[requestId];
+      const finalErrorMessage = streamFailure?.message ?? (finalRequest?.status === "error" && finalRequest.error ? finalRequest.error.user_message ?? finalRequest.error.message ?? null : null);
+      const cxContentBlocks = finalRequest ? assembleMessageParts(finalRequest) : [];
+      const assistantBlocks = cxContentBlocks.filter(
+        (b) => b.type !== "tool_result"
+      );
+      const sortedTurns = [...reservedAssistantTurns].sort(
+        (a, b) => a.position - b.position
+      );
+      const materializeTargets = [];
+      const partitionBlocksByIteration = () => {
+        const blocksByIter = /* @__PURE__ */ new Map();
+        const blockIter = new Array(assistantBlocks.length).fill(0);
+        let currentIter = 1;
+        let lastToolCallIndex = -1;
+        for (let i = 0; i < assistantBlocks.length; i++) {
+          const block = assistantBlocks[i];
+          if (block.type !== "tool_call") continue;
+          const tcBlock = block;
+          const callId = tcBlock.call_id ?? tcBlock.id;
+          const uuid = callId ? toolCallIdByProviderCallId.get(callId) : void 0;
+          const tc = uuid ? finalState.observability.toolCalls[uuid] : void 0;
+          const callIteration = tc?.iteration ?? (callId ? iterationByProviderCallId.get(callId) : void 0);
+          if (callIteration) currentIter = callIteration;
+          blockIter[i] = currentIter;
+          lastToolCallIndex = i;
+        }
+        let nextToolIter = lastToolCallIndex >= 0 ? blockIter[lastToolCallIndex] + 1 : 1;
+        for (let i = assistantBlocks.length - 1; i >= 0; i--) {
+          if (assistantBlocks[i].type === "tool_call") {
+            nextToolIter = blockIter[i];
+          } else {
+            blockIter[i] = nextToolIter;
+          }
+        }
+        for (let i = 0; i < assistantBlocks.length; i++) {
+          const iter = blockIter[i];
+          const list = blocksByIter.get(iter) ?? [];
+          list.push(assistantBlocks[i]);
+          blocksByIter.set(iter, list);
+        }
+        return blocksByIter;
+      };
+      const toolCallIterationsOf = (blocksByIter) => {
+        const iters = /* @__PURE__ */ new Set();
+        for (const [iter, blocks] of blocksByIter) {
+          if (blocks.some((b) => b.type === "tool_call")) {
+            iters.add(iter);
+          }
+        }
+        return iters;
+      };
+      const commitIterationToClientTemp = (iter, blocks, position, isLast) => {
+        const tempId = mintClientTempId("assistant", requestId, `iter${iter}`);
+        dispatch(
+          reserveMessage({
+            conversationId,
+            messageId: tempId,
+            role: "assistant",
+            position,
+            // Anchor to the live stream like every server-reserved row: the
+            // turn group collapses all rows sharing a requestId into ONE
+            // stream-driven render — without the anchor, this client-temp row
+            // would render its committed slice ON TOP of that render
+            // (duplicate content after an under-announced multi-iteration run).
+            requestId
+          })
+        );
+        dispatch(
+          updateMessageRecord({
+            conversationId,
+            messageId: tempId,
+            patch: {
+              content: blocks,
+              status: "active",
+              _clientStatus: finalErrorMessage && isLast ? "error" : "complete",
+              position
+            }
+          })
+        );
+      };
+      if (skipTranscriptCommit) {
+        return {
+          conversationId: cxConversationConfirmed ? conversationId : null,
+          completionStats,
+          tokenUsage,
+          finishReason
+        };
+      }
+      if (sortedTurns.length === 1) {
+        const turn = sortedTurns[0];
+        const blocksByIter = partitionBlocksByIteration();
+        const toolCallIters = toolCallIterationsOf(blocksByIter);
+        if (toolCallIters.size > 1) {
+          const sortedIters = [...blocksByIter.keys()].sort((a, b) => a - b);
+          console.error(
+            `[stream:${requestId.slice(0, 8)}] SERVER UNDER-ANNOUNCED assistant reservations: ${toolCallIters.size} iterations carry tool_calls but only 1 assistant cx_message reservation arrived (${turn.messageId}). Committing ONLY iteration ${sortedIters[0]}'s blocks to the reserved row; iterations [${sortedIters.slice(1).join(", ")}] go to client-temp records (server-persisted rows take over on reload). Folding all iterations onto one row would corrupt the persisted tool graph (duplicate tool_use ids \u2192 provider 400 on replay). Backend fix: persist_completed_request must announce record_reserved for every per-iteration assistant row.`
+          );
+          const firstIterBlocks = blocksByIter.get(sortedIters[0]) ?? [];
+          dispatch(
+            updateMessageRecord({
+              conversationId,
+              messageId: turn.messageId,
+              patch: {
+                content: firstIterBlocks,
+                status: "active",
+                _clientStatus: "complete",
+                position: turn.position
+              }
+            })
+          );
+          materializeTargets.push({
+            messageId: turn.messageId,
+            content: firstIterBlocks
+          });
+          for (let i = 1; i < sortedIters.length; i++) {
+            const iter = sortedIters[i];
+            const blocks = blocksByIter.get(iter) ?? [];
+            if (blocks.length === 0) continue;
+            commitIterationToClientTemp(
+              iter,
+              blocks,
+              turn.position + i,
+              i === sortedIters.length - 1
+            );
+          }
+        } else {
+          dispatch(
+            updateMessageRecord({
+              conversationId,
+              messageId: turn.messageId,
+              patch: {
+                content: assistantBlocks,
+                status: "active",
+                _clientStatus: finalErrorMessage ? "error" : "complete",
+                position: turn.position
+              }
+            })
+          );
+          materializeTargets.push({
+            messageId: turn.messageId,
+            content: assistantBlocks
+          });
+        }
+      } else if (sortedTurns.length > 1) {
+        const blocksByIter = partitionBlocksByIteration();
+        const sortedIters = [...blocksByIter.keys()].sort((a, b) => a - b);
+        const contentByTurnIndex = /* @__PURE__ */ new Map();
+        const turnIterationsUsable = sortedTurns.every((t) => t.iteration !== void 0) && new Set(sortedTurns.map((t) => t.iteration)).size === sortedTurns.length;
+        const turnIndexForIteration = (iter, rank) => {
+          if (!turnIterationsUsable) return Math.min(rank, sortedTurns.length - 1);
+          const exact = sortedTurns.findIndex((t) => t.iteration === iter);
+          if (exact >= 0) return exact;
+          let preceding = -1;
+          sortedTurns.forEach((t, idx) => {
+            if (t.iteration !== void 0 && t.iteration <= iter) preceding = idx;
+          });
+          if (preceding >= 0) return preceding;
+          return Math.min(rank, sortedTurns.length - 1);
+        };
+        for (let i = 0; i < sortedIters.length; i++) {
+          const iter = sortedIters[i];
+          const turnIndex = turnIndexForIteration(iter, i);
+          if (turnIterationsUsable ? sortedTurns[turnIndex].iteration !== iter : turnIndex !== i) {
+            console.warn(
+              `[stream:${requestId.slice(0, 8)}] iteration ${iter} has no matching reservation; folding ${blocksByIter.get(iter)?.length ?? 0} block(s) into reserved message ${turnIndex} instead of dropping`
+            );
+          }
+          const list = contentByTurnIndex.get(turnIndex) ?? [];
+          list.push(...blocksByIter.get(iter) ?? []);
+          contentByTurnIndex.set(turnIndex, list);
+        }
+        for (let ti = 0; ti < sortedTurns.length; ti++) {
+          const turn = sortedTurns[ti];
+          const content = contentByTurnIndex.get(ti);
+          if (!content || content.length === 0) continue;
+          dispatch(
+            updateMessageRecord({
+              conversationId,
+              messageId: turn.messageId,
+              patch: {
+                content,
+                status: "active",
+                // Only the FINAL reservation carries the error marker — earlier
+                // iterations completed before the stream died and must render
+                // as the normal turns they are.
+                _clientStatus: finalErrorMessage && ti === sortedTurns.length - 1 ? "error" : "complete",
+                position: turn.position
+              }
+            })
+          );
+          materializeTargets.push({
+            messageId: turn.messageId,
+            content
+          });
+        }
+      } else if (assistantBlocks.length > 0) {
+        const conv = finalState.conversations.byConversationId[conversationId];
+        (conv?.isEphemeral === true ? console.info : console.error)(
+          `[stream:${requestId.slice(0, 8)}] no assistant reservation arrived but ${assistantBlocks.length} content block(s) were produced \u2014 committing to a client-temp message to avoid transcript loss. DIAGNOSIS isEphemeral=${conv?.isEphemeral ?? false} apiEndpointMode=${conv?.apiEndpointMode ?? "agent"} userRequestReserved=${reservedUserRequestId !== null} toolReservations=${toolCallIdByProviderCallId.size} streamError=${!!finalErrorMessage}. ` + (conv?.isEphemeral === true ? `Expected for an ephemeral (incognito) turn: the server reserves no message rows for store:false.` : `isEphemeral=false: the server should have reserved a cx_message(role=assistant) \u2014 a backend reservation gap (userRequestReserved alone proves nothing; the preamble announces it even for store:false).`)
+        );
+        const tempId = mintClientTempId("assistant", requestId);
+        const existingById = finalState.messages.byConversationId[conversationId]?.byId ?? {};
+        const maxPos = Object.values(existingById).reduce(
+          (m, r) => Math.max(m, r.position ?? 0),
+          0
+        );
+        dispatch(
+          reserveMessage({
+            conversationId,
+            messageId: tempId,
+            role: "assistant",
+            position: maxPos + 1,
+            // Same stream anchor every reserved row gets — keeps this rescue
+            // record on the unified-slot render path (and inside the turn
+            // group's one-render-per-requestId collapse).
+            requestId
+          })
+        );
+        dispatch(
+          updateMessageRecord({
+            conversationId,
+            messageId: tempId,
+            patch: {
+              content: assistantBlocks,
+              status: "active",
+              _clientStatus: finalErrorMessage ? "error" : "complete",
+              position: maxPos + 1
+            }
+          })
+        );
+      }
+      if (finalRequest?.toolLifecycle) {
+        for (const [callId, lc] of Object.entries(finalRequest.toolLifecycle)) {
+          let dbId = toolCallIdByProviderCallId.get(callId);
+          if (!dbId) {
+            dbId = mintClientTempId("tool-call", callId);
+            const nowIso = (/* @__PURE__ */ new Date()).toISOString();
+            dispatch(
+              upsertToolCall({
+                id: dbId,
+                conversationId,
+                userRequestId: reservedUserRequestId ?? "",
+                messageId: null,
+                userId: "",
+                callId,
+                toolName: lc.toolName,
+                toolNameAsCalled: null,
+                toolType: "",
+                iteration: iterationByProviderCallId.get(callId) ?? 1,
+                status: "pending",
+                success: false,
+                isError: null,
+                errorType: null,
+                errorMessage: null,
+                arguments: {},
+                output: null,
+                outputChars: 0,
+                outputPreview: null,
+                outputType: null,
+                inputTokens: null,
+                outputTokens: null,
+                totalTokens: null,
+                costUsd: null,
+                durationMs: 0,
+                startedAt: lc.startedAt ?? nowIso,
+                completedAt: lc.completedAt ?? nowIso,
+                parentCallId: null,
+                retryCount: null,
+                persistKey: null,
+                filePath: null,
+                executionEvents: null,
+                metadata: null,
+                createdAt: nowIso,
+                deletedAt: null
+              })
+            );
+          }
+          const startedAt = lc.startedAt ?? null;
+          const completedAt = lc.completedAt ?? null;
+          const durationMs = startedAt && completedAt ? new Date(completedAt).getTime() - new Date(startedAt).getTime() : 0;
+          const outputStr = lc.result !== void 0 && lc.result !== null ? typeof lc.result === "string" ? lc.result : JSON.stringify(lc.result) : null;
+          dispatch(
+            patchToolCall({
+              id: dbId,
+              patch: {
+                status: lc.status,
+                success: lc.status === "completed",
+                isError: lc.status === "error" ? true : null,
+                errorType: lc.errorType ?? null,
+                errorMessage: lc.errorMessage ?? null,
+                arguments: lc.arguments,
+                output: outputStr,
+                outputChars: outputStr?.length ?? 0,
+                outputPreview: lc.resultPreview ?? null,
+                // Carry the streamed event log too, so a persisted (post-prune /
+                // committed) render gets the SAME events live as it would after a
+                // DB reload — renderers that read `events` weren't empty there.
+                executionEvents: lc.events ?? [],
+                durationMs,
+                ...startedAt ? { startedAt } : {},
+                ...completedAt ? { completedAt } : {}
+              }
+            })
+          );
+        }
+      }
+      if (streamFailure === null) {
+        const inputEntry = getState().instanceUserInput.byConversationId[conversationId];
+        const textProtected = inputEntry ? isInputDraftProtected(inputEntry) : false;
+        dispatch(clearComposerIfUnsubmitted(conversationId, { via: "clear" }));
+        dispatch(clearSubmittedResources(conversationId));
+        dispatch(
+          clearSubmittedVariableResourcePolicies({
+            conversationId,
+            submitted: submittedVariableResourcePolicies
+          })
+        );
+        const hasUnsentResources = selectHasUnsentResources(conversationId)(getState());
+        if (!textProtected && !hasUnsentResources) {
+          dispatch(resetUserVariableValues(conversationId));
+        }
+        if (finalErrorMessage === null && materializeTargets.length > 0) {
+          void Promise.all(
+            materializeTargets.map(
+              (target) => materializeMessageArtifacts({
+                messageId: target.messageId,
+                conversationId,
+                content: target.content,
+                getState
+              }).then((res) => {
+                const mirror = res.rewrittenContent ?? res.unpersistedRewrite;
+                if (mirror) {
+                  dispatch(
+                    updateMessageRecord({
+                      conversationId,
+                      messageId: target.messageId,
+                      patch: { content: mirror }
+                    })
+                  );
+                }
+                if (res.unpersistedRewrite) {
+                  console.error(
+                    `[stream:${requestId.slice(0, 8)}] message ${target.messageId} is showing its artifacts, but the stored message still holds the raw blocks \u2014 the next load of this conversation rewrites it (reconcile-on-load). Cause: ${res.errors.join("; ")}`
+                  );
+                } else if (res.errors.length > 0) {
+                  console.error(
+                    `[stream:${requestId.slice(0, 8)}] artifact materialization issues for ${target.messageId}:`,
+                    res.errors
+                  );
+                }
+              }).catch((err) => {
+                console.error(
+                  `[stream:${requestId.slice(0, 8)}] artifact materialization threw for ${target.messageId}:`,
+                  err
+                );
+              })
+            )
+          );
+        }
+      }
+      const renderCompleteAt = performance.now();
+      const internalLatencyMs = conversationIdAt !== null ? conversationIdAt - submitAt : null;
+      const ttftMs = clientFirstChunkAt !== null ? clientFirstChunkAt - submitAt : null;
+      const streamDurationMs = clientFirstChunkAt !== null ? streamEndAt - clientFirstChunkAt : null;
+      const renderDelayMs = renderCompleteAt - streamEndAt;
+      const totalClientDurationMs = renderCompleteAt - submitAt;
+      const completedText = cxContentBlocks.filter(
+        (b) => typeof b === "object" && b !== null && b.type === "text" && typeof b.text === "string"
+      ).map((b) => b.text).join("");
+      const completedReasoning = finalRequest?.accumulatedReasoning ?? "";
+      const encoder = new TextEncoder();
+      const accumulatedTextBytes = encoder.encode(completedText).length;
+      const totalPayloadBytes = accumulatedTextBytes + encoder.encode(completedReasoning).length;
+      const clientMetrics = {
+        submitAt,
+        conversationIdAt,
+        firstChunkAt: clientFirstChunkAt,
+        streamEndAt,
+        renderCompleteAt,
+        internalLatencyMs,
+        ttftMs,
+        streamDurationMs,
+        renderDelayMs,
+        totalClientDurationMs,
+        totalEvents,
+        chunkEvents,
+        reasoningChunkEvents,
+        phaseEvents,
+        initEvents,
+        completionEvents,
+        dataEvents,
+        toolEvents,
+        renderBlockEvents,
+        warningEvents,
+        infoEvents,
+        recordReservedEvents,
+        recordUpdateEvents,
+        resourceChangedEvents,
+        providerRetryEvents,
+        otherEvents,
+        accumulatedTextBytes,
+        totalPayloadBytes
+      };
+      dispatch(finalizeClientMetrics({ requestId, metrics: clientMetrics }));
+      discardRetainedTransportConsumer(requestId);
+      if (streamFailure !== null) {
+        throw streamFailure;
+      }
+      return {
+        conversationId,
+        completionStats,
+        tokenUsage,
+        finishReason
+      };
+    } finally {
+      retainedEntry.busy = false;
+      if (!handedToRejoin) finalizeAccumulator();
+    }
+  };
+  retainedEntry = {
+    consume,
+    busy: false,
+    dispose: () => {
+      if (postTerminalGraceTimer !== null) {
+        clearTimeout(postTerminalGraceTimer);
+        postTerminalGraceTimer = null;
+      }
+      finalizeAccumulator();
+    }
+  };
+  if (allowTransportResume) {
+    retainedTransportConsumers.set(requestId, retainedEntry);
+  }
+  return consume(response, abortController, onEvent);
+}
+function toSnapshot(extracted) {
+  return {
+    value: extracted.value,
+    type: extracted.type,
+    source: extracted.source,
+    isComplete: extracted.isComplete,
+    repairApplied: extracted.repairApplied,
+    warnings: extracted.warnings
+  };
+}
+const REASONING_TAG_MARKER = /<\/?(thinking|think|reasoning)(\s|>|\/)/i;
+function hasReasoningLeak(answerText) {
+  return REASONING_TAG_MARKER.test(answerText);
+}
+export {
+  discardRetainedTransportConsumer,
+  hasRetainedTransportConsumer,
+  processStream
+};