@ai-matrx/chat 0.4.2 → 0.4.8

package/dist/ui/markdown-stream/EnhancedChatMarkdown.js

@@ -0,0 +1,1108 @@
+"use client";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { useState, useEffect, useLayoutEffect, useMemo, useCallback, useRef } from "react";
+import { cn } from "@ai-matrx/design-system";
+import { splitContentIntoBlocksV2 } from "@ai-matrx/rich-content/display/markdown-classification/processors/utils/content-splitter-v2";
+import { renderSettledFromRecord, settledOneShotBlocks } from "@ai-matrx/rich-content/display/chat-markdown/settle-stream-blocks";
+import { expandTextBlocksInList } from "@ai-matrx/rich-content/display/markdown-classification/processors/utils/expand-text-blocks";
+import { reuseUnchangedBlocks } from "@ai-matrx/rich-content/display/chat-markdown/stable-blocks";
+import { useProgressiveMount } from "@ai-matrx/rich-content/display/chat-markdown/progressive-mount";
+import { renderBlockToContentBlock } from "@ai-matrx/rich-content/display/chat-markdown/render-block-to-content-block";
+import { DocumentFootnotes, DocumentNumberingProvider } from "@ai-matrx/rich-content/markdown-core/syntax/elements/DocumentNumbering";
+import { OptionalMarkdownSourceEditProvider } from "@ai-matrx/rich-content/markdown-core/syntax/elements/MarkdownSourceEdit";
+function MaybeSourceEdit({ source, save, children }) {
+  return /* @__PURE__ */ jsx(OptionalMarkdownSourceEditProvider, { source, save, children });
+}
+import { RichCopySplit } from "../../agent-copy/RichCopySplit.js";
+import { ShimmerText } from "../ShimmerText.js";
+import {
+  RunJobWorkingLine,
+  useIsRunJob
+} from "../../agents/components/run/RunJobWorkingLine.js";
+import { GenerationJobCard } from "../../agents/components/run/GenerationJobCard.js";
+import { selectRequestGenerationJob } from "../../agents/redux/execution-system/active-requests/active-requests.selectors.js";
+import { FullScreenMarkdownEditor } from "../../host/app-data-slots.js";
+import { InlineStatusIndicator } from "@ai-matrx/rich-content/display/chat-markdown/internal-handlers/InlineStatusIndicator";
+import { InlineThinkingSlot } from "./internal-handlers/InlineThinkingSlot.js";
+import {
+  selectAccumulatedTextWithCitationMarkers,
+  selectIsReasoningStreaming,
+  selectUnifiedSlotRange,
+  selectAgentCallChildSlots,
+  selectAllRenderBlocks,
+  selectToolLifecycleMap,
+  selectLiveCitationMarkersByBlockId,
+  blockCarriesDataNotText,
+  blockHasSomethingToRender,
+  verbalizedDecisionJsonTextBlockIds
+} from "../../agents/redux/execution-system/active-requests/active-requests.selectors.js";
+import {
+  insertCitationMarkers
+} from "../../agents/redux/execution-system/messages/message-citations.js";
+import {
+  foldAgentWork,
+  SHORT_TEXT_FOLD_MAX
+} from "../../tool-call-visualization/grouping/foldAgentWork.js";
+import { AgentWorkGroup } from "../../tool-call-visualization/components/AgentWorkGroup.js";
+import { holdsADecision, recordHoldsADecision } from "../../tool-call-visualization/components/holdsADecision.js";
+import {
+  EXPERT_WORKING_LABEL,
+  useMachineFramesVisible
+} from "../../agents/components/shared/transcript-audience.js";
+import { getToolDisplayMode } from "../../tool-call-visualization/registry/registry.js";
+import { isCloudBrowserToolName } from "../../tool-call-visualization/renderers/cloud-browser/cloudBrowserRun.js";
+import { collectCloudBrowserRun } from "../../tool-call-visualization/grouping/groupCloudBrowserRuns.js";
+import {
+  selectMessageInterleavedContent,
+  selectMessagesInterleavedRuns
+} from "../../agents/redux/execution-system/messages/messages.selectors.js";
+import { useAppSelector } from "../../store/hooks.js";
+import { ToolCard, ToolBatch } from "./internal-handlers/ToolHandlers.js";
+import { InlineAssistantError } from "./internal-handlers/InlineAssistantError.js";
+import { PlainTextFallback } from "@ai-matrx/rich-content/display/chat-markdown/internal-handlers/PlainTextFallback";
+import { SafeBlockRenderer } from "@ai-matrx/rich-content/display/chat-markdown/internal-handlers/SafeBlockRenderer";
+import { MarkdownStreamingProvider } from "@ai-matrx/rich-content/markdown-core/streaming-context";
+import { useBoundAgentOutputSchema } from "./useBoundAgentOutputSchema.js";
+import { MarkdownErrorBoundary } from "@ai-matrx/rich-content/display/chat-markdown/internal-handlers/MarkdownErrorBoundary";
+import { ErrorAlchemyMenu } from "../../host/ui-slots.js";
+const _EMPTY_SEGMENTS = [];
+const _EMPTY_SLOTS = [];
+const _selectEmptyString = () => "";
+const _selectFalse = () => false;
+const _selectEmptySegments = () => _EMPTY_SEGMENTS;
+const _selectNoRuns = () => null;
+const _selectEmptySlots = () => _EMPTY_SLOTS;
+const _selectEmptyRenderBlocks = () => void 0;
+const _EMPTY_CITATION_MARKERS = {};
+const _selectEmptyCitationMarkers = () => _EMPTY_CITATION_MARKERS;
+const TOOL_BATCH_MIN = 2;
+function groupConsecutiveToolSlots(slots, getBatchKind, isCloudBrowserBridge) {
+  const out = [];
+  let browserRunOrder = 0;
+  for (let i = 0; i < slots.length; ) {
+    const s = slots[i];
+    const batchKind = s.kind === "tool" ? getBatchKind(s.callId) : null;
+    if (s.kind === "tool" && batchKind === "cloud-browser") {
+      const run = collectCloudBrowserRun(slots, i, (candidate) => {
+        if (candidate.kind === "tool" && getBatchKind(candidate.callId) === "cloud-browser") {
+          return "browser";
+        }
+        return isCloudBrowserBridge(candidate) ? "bridge" : "break";
+      });
+      out.push({
+        kind: "tool_batch",
+        callIds: run.browserItems.map(
+          (candidate) => candidate.callId
+        ),
+        seq: s.seq,
+        batchKind,
+        browserRunOrder,
+        browserBreakBefore: browserRunOrder > 0,
+        browserBreakAfter: run.breakAfter
+      });
+      out.push(...run.bridgeItems);
+      browserRunOrder++;
+      i = run.nextIndex;
+      continue;
+    }
+    if (s.kind === "tool" && batchKind) {
+      const callIds = [s.callId];
+      let j = i + 1;
+      while (j < slots.length) {
+        const candidate = slots[j];
+        if (!candidate || candidate.kind !== "tool" || getBatchKind(candidate.callId) !== batchKind) {
+          break;
+        }
+        callIds.push(candidate.callId);
+        j++;
+      }
+      out.push(
+        callIds.length >= TOOL_BATCH_MIN ? { kind: "tool_batch", callIds, seq: s.seq, batchKind } : s
+      );
+      i = j;
+    } else {
+      out.push(s);
+      i++;
+    }
+  }
+  return out;
+}
+function groupConsecutiveDbTools(segments, getBatchKind, isCloudBrowserBridge) {
+  const out = [];
+  let browserRunOrder = 0;
+  for (let i = 0; i < segments.length; ) {
+    const seg = segments[i];
+    const batchKind = seg.type === "db_tool" ? getBatchKind(seg) : null;
+    if (seg.type === "db_tool" && batchKind === "cloud-browser") {
+      const run = collectCloudBrowserRun(segments, i, (candidate) => {
+        if (candidate.type === "db_tool" && getBatchKind(candidate) === "cloud-browser") {
+          return "browser";
+        }
+        return isCloudBrowserBridge(candidate) ? "bridge" : "break";
+      });
+      out.push({
+        type: "db_tool_batch",
+        segments: run.browserItems,
+        key: `db-tool-batch-${seg.callId}`,
+        batchKind,
+        browserRunOrder,
+        browserBreakBefore: browserRunOrder > 0,
+        browserBreakAfter: run.breakAfter
+      });
+      out.push(...run.bridgeItems);
+      browserRunOrder++;
+      i = run.nextIndex;
+      continue;
+    }
+    if (seg.type === "db_tool" && batchKind) {
+      const run = [seg];
+      let j = i + 1;
+      while (j < segments.length) {
+        const candidate = segments[j];
+        if (!candidate || candidate.type !== "db_tool" || getBatchKind(candidate) !== batchKind) {
+          break;
+        }
+        run.push(candidate);
+        j++;
+      }
+      out.push(
+        run.length >= TOOL_BATCH_MIN ? {
+          type: "db_tool_batch",
+          segments: run,
+          key: `db-tool-batch-${run[0].callId}`,
+          batchKind
+        } : seg
+      );
+      i = j;
+    } else {
+      out.push(seg);
+      i++;
+    }
+  }
+  return out;
+}
+function flattenWorkSlots(items) {
+  return items.flatMap(
+    (item) => item.kind === "tool_batch" && item.batchKind === "default" ? item.callIds.map((callId) => ({
+      kind: "tool",
+      callId,
+      seq: item.seq
+    })) : [item]
+  );
+}
+function flattenWorkSegments(items) {
+  return items.flatMap(
+    (item) => item.type === "db_tool_batch" && item.batchKind === "default" ? item.segments : [item]
+  );
+}
+function toolSpan(startedAt, completedAt) {
+  if (!startedAt || !completedAt) return null;
+  const start = Date.parse(startedAt);
+  const end = Date.parse(completedAt);
+  if (!Number.isFinite(start) || !Number.isFinite(end) || end < start) {
+    return null;
+  }
+  return { start, end };
+}
+function mergeSpans(spans) {
+  let start = Infinity;
+  let end = -Infinity;
+  for (const s of spans) {
+    if (!s) continue;
+    if (s.start < start) start = s.start;
+    if (s.end > end) end = s.end;
+  }
+  return end >= start ? { start, end } : null;
+}
+function classifyTextForFold(text) {
+  const trimmed = text?.trim() ?? "";
+  if (trimmed.length === 0) return "shortText";
+  return trimmed.length <= SHORT_TEXT_FOLD_MAX ? "shortText" : "visible";
+}
+const EnhancedChatMarkdownInternal = ({
+  requestId,
+  recordMessageIds,
+  streamSlotStart,
+  streamSlotEnd,
+  agentCallId,
+  turnId,
+  conversationId,
+  content,
+  taskId,
+  className,
+  isStreamActive,
+  onContentChange,
+  analysisData,
+  messageId,
+  allowFullScreenEditor = true,
+  hideCopyButton = true,
+  serverProcessedBlocks,
+  applyLocalEdits = true
+}) => {
+  const [isEditorOpen, setIsEditorOpen] = useState(false);
+  const outputSchema = useBoundAgentOutputSchema(conversationId);
+  const [editedContent, setEditedContent] = useState(null);
+  const [hasError, setHasError] = useState(false);
+  const requestTextSelector = useMemo(
+    () => requestId ? selectAccumulatedTextWithCitationMarkers(requestId) : _selectEmptyString,
+    [requestId]
+  );
+  const requestText = useAppSelector(requestTextSelector);
+  const liveCitationMarkersSelector = useMemo(
+    () => requestId ? selectLiveCitationMarkersByBlockId(requestId) : _selectEmptyCitationMarkers,
+    [requestId]
+  );
+  const liveCitationMarkersByBlockId = useAppSelector(
+    liveCitationMarkersSelector
+  );
+  const isReasoningActive = useAppSelector(
+    requestId ? selectIsReasoningStreaming(requestId) : _selectFalse
+  );
+  const isRunJob = useIsRunJob(requestId);
+  const isVideoJob = useAppSelector(
+    requestId ? selectRequestGenerationJob(requestId) : () => null
+  )?.kind === "video";
+  const unifiedSlotsSelector = useMemo(
+    () => requestId ? agentCallId ? (
+      // One collaboration child's blocks (the card's half of D209).
+      selectAgentCallChildSlots(requestId, agentCallId)
+    ) : selectUnifiedSlotRange(requestId, streamSlotStart, streamSlotEnd) : _selectEmptySlots,
+    [requestId, agentCallId, streamSlotStart, streamSlotEnd]
+  );
+  const unifiedSlots = useAppSelector(unifiedSlotsSelector);
+  const singleRecordContent = useAppSelector(
+    messageId && conversationId ? selectMessageInterleavedContent(conversationId, messageId) : _selectEmptySegments
+  );
+  const recordRunsKey = recordMessageIds && recordMessageIds.length > 1 ? recordMessageIds.join("|") : "";
+  const recordRunsSelector = useMemo(
+    () => recordRunsKey && conversationId ? selectMessagesInterleavedRuns(conversationId, recordRunsKey.split("|")) : _selectNoRuns,
+    [recordRunsKey, conversationId]
+  );
+  const recordRuns = useAppSelector(recordRunsSelector);
+  const messageInterleavedRuns = useMemo(
+    () => recordRuns ?? [singleRecordContent],
+    [recordRuns, singleRecordContent]
+  );
+  const messageInterleavedContent = useMemo(
+    () => messageInterleavedRuns.length === 1 ? messageInterleavedRuns[0] : messageInterleavedRuns.flat(),
+    [messageInterleavedRuns]
+  );
+  const renderBlocksSelector = useMemo(
+    () => requestId ? selectAllRenderBlocks(requestId) : _selectEmptyRenderBlocks,
+    [requestId]
+  );
+  const reduxRenderBlocks = useAppSelector(renderBlocksSelector);
+  const renderBlocksMap = useMemo(() => {
+    if (!reduxRenderBlocks) return {};
+    const map = {};
+    for (const b of reduxRenderBlocks) {
+      map[b.blockId] = b;
+    }
+    return map;
+  }, [reduxRenderBlocks]);
+  const hiddenDecisionJsonTextBlockIds = useMemo(
+    () => verbalizedDecisionJsonTextBlockIds(reduxRenderBlocks),
+    [reduxRenderBlocks]
+  );
+  const hasReduxRenderBlocks = !!(reduxRenderBlocks && reduxRenderBlocks.length > 0);
+  const settledFromRecord = renderSettledFromRecord({
+    isStreamActive: !!isStreamActive,
+    messageId,
+    recordSegmentCount: messageInterleavedContent.length
+  });
+  const resolvedContent = settledFromRecord ? content : requestText || content;
+  const currentContent = editedContent ?? resolvedContent;
+  const hasRequestOrTaskId = requestId || taskId;
+  const hasReceivedNonTextContent = serverProcessedBlocks && serverProcessedBlocks.length > 0 || hasReduxRenderBlocks;
+  const isWaitingForContent = hasRequestOrTaskId && !resolvedContent.trim() && !hasReceivedNonTextContent;
+  const hasUnifiedSpecial = !settledFromRecord && (streamSlotStart !== void 0 || streamSlotEnd !== void 0 || agentCallId !== void 0 || unifiedSlots.some(
+    (s) => s.kind === "tool" || s.kind === "status" || s.kind === "error" || s.kind === "thinking" || s.kind === "render_block" && blockCarriesDataNotText(renderBlocksMap[s.blockId])
+  ));
+  const hasDbInterleavedSpecial = messageInterleavedContent.some(
+    (s) => s.type === "db_tool" || s.type === "thinking"
+  );
+  const toolLifecycleMapSelector = useMemo(
+    () => requestId ? selectToolLifecycleMap(requestId) : () => void 0,
+    [requestId]
+  );
+  const toolLifecycleMap = useAppSelector(toolLifecycleMapSelector);
+  const machineFramesVisible = useMachineFramesVisible();
+  const groupedSlots = useMemo(
+    () => groupConsecutiveToolSlots(
+      unifiedSlots,
+      (callId) => {
+        const toolName = toolLifecycleMap?.[callId]?.toolName ?? null;
+        if (getToolDisplayMode(toolName) !== "auto") return null;
+        return isCloudBrowserToolName(toolName) ? "cloud-browser" : "default";
+      },
+      (slot) => {
+        if (slot.kind === "thinking" || slot.kind === "status") return true;
+        if (slot.kind !== "render_block") return false;
+        const block = renderBlocksMap[slot.blockId];
+        if (!block) return true;
+        return block.type === "text" && classifyTextForFold(block.content) === "shortText";
+      }
+    ),
+    [unifiedSlots, toolLifecycleMap, renderBlocksMap]
+  );
+  const groupedSegmentRuns = useMemo(
+    () => messageInterleavedRuns.map(
+      (run) => groupConsecutiveDbTools(
+        run,
+        (seg) => {
+          const toolName = seg.record?.toolName ?? seg.stubName;
+          if (getToolDisplayMode(toolName) !== "auto") return null;
+          return isCloudBrowserToolName(toolName) ? "cloud-browser" : "default";
+        },
+        (segment) => {
+          if (segment.type === "thinking" || segment.type === "status")
+            return true;
+          return segment.type === "text" && classifyTextForFold(segment.content) === "shortText";
+        }
+      )
+    ),
+    [messageInterleavedRuns]
+  );
+  const groupedSegments = useMemo(
+    () => groupedSegmentRuns.length === 1 ? groupedSegmentRuns[0] : groupedSegmentRuns.flat(),
+    [groupedSegmentRuns]
+  );
+  const isSettled = !isStreamActive;
+  const workGroupedSlots = useMemo(() => {
+    if (!isSettled) return groupedSlots;
+    if (messageId && !settledFromRecord) return groupedSlots;
+    if (!machineFramesVisible) return groupedSlots;
+    return foldAgentWork(groupedSlots, {
+      classify: (slot) => {
+        if (slot.kind === "tool" && holdsADecision(toolLifecycleMap?.[slot.callId])) return "visible";
+        if (slot.kind === "tool_batch" && slot.callIds.some((id) => holdsADecision(toolLifecycleMap?.[id]))) {
+          return "visible";
+        }
+        if (slot.kind === "thinking" || slot.kind === "status" || slot.kind === "tool" || slot.kind === "tool_batch") {
+          return "work";
+        }
+        if (slot.kind === "render_block") {
+          const rb = renderBlocksMap[slot.blockId];
+          if (!rb) return "shortText";
+          if (rb.type === "text") return classifyTextForFold(rb.content);
+        }
+        return "visible";
+      },
+      stepsOf: (slot) => slot.kind === "tool_batch" ? slot.callIds.length : 1,
+      spanOf: (slot) => {
+        const entrySpan = (callId) => {
+          const e = toolLifecycleMap?.[callId];
+          return toolSpan(e?.startedAt, e?.completedAt);
+        };
+        if (slot.kind === "tool") return entrySpan(slot.callId);
+        if (slot.kind === "tool_batch") {
+          return mergeSpans(slot.callIds.map(entrySpan));
+        }
+        return null;
+      }
+    });
+  }, [
+    isSettled,
+    messageId,
+    settledFromRecord,
+    groupedSlots,
+    toolLifecycleMap,
+    renderBlocksMap,
+    machineFramesVisible
+  ]);
+  const workGroupedSegments = useMemo(() => {
+    if (!isSettled) return groupedSegments;
+    if (!machineFramesVisible) return groupedSegments;
+    const dbToolSpan = (seg) => toolSpan(seg.record?.startedAt, seg.record?.completedAt);
+    return groupedSegmentRuns.flatMap((runSegments) => foldAgentWork(runSegments, {
+      classify: (seg) => {
+        if (seg.type === "db_tool" && recordHoldsADecision(seg.record)) return "visible";
+        if (seg.type === "db_tool_batch" && seg.segments.some((one) => recordHoldsADecision(one.record))) {
+          return "visible";
+        }
+        if (seg.type === "thinking" || seg.type === "status" || seg.type === "db_tool" || seg.type === "db_tool_batch") {
+          return "work";
+        }
+        if (seg.type === "text") return classifyTextForFold(seg.content);
+        return "visible";
+      },
+      stepsOf: (seg) => seg.type === "db_tool_batch" ? seg.segments.length : 1,
+      spanOf: (seg) => {
+        if (seg.type === "db_tool") return dbToolSpan(seg);
+        if (seg.type === "db_tool_batch") {
+          return mergeSpans(seg.segments.map(dbToolSpan));
+        }
+        return null;
+      }
+    }));
+  }, [isSettled, groupedSegments, groupedSegmentRuns, machineFramesVisible]);
+  useEffect(() => {
+    if (isStreamActive) {
+      setEditedContent(null);
+    }
+  }, [isStreamActive]);
+  useEffect(() => {
+    if (applyLocalEdits === false) {
+      setEditedContent(null);
+    }
+  }, [applyLocalEdits, resolvedContent]);
+  const useServerBlocks = serverProcessedBlocks && serverProcessedBlocks.length > 0;
+  const { blocks, blockError } = useMemo(() => {
+    if (isWaitingForContent) return { blocks: [], blockError: false };
+    if (!settledFromRecord && hasReduxRenderBlocks && reduxRenderBlocks) {
+      const settled = settledOneShotBlocks({
+        isStreamActive: !!isStreamActive,
+        blockIds: reduxRenderBlocks.map((rb) => rb.blockId),
+        content: currentContent
+      });
+      if (settled) {
+        return { blocks: expandTextBlocksInList(settled), blockError: false };
+      }
+    }
+    if (!settledFromRecord && hasReduxRenderBlocks && reduxRenderBlocks) {
+      const clientBlocks = reduxRenderBlocks.filter(
+        (rb) => blockHasSomethingToRender(rb) && !hiddenDecisionJsonTextBlockIds.has(rb.blockId)
+      ).map(renderBlockToContentBlock);
+      return {
+        blocks: expandTextBlocksInList(clientBlocks),
+        blockError: false
+      };
+    }
+    if (useServerBlocks && serverProcessedBlocks) {
+      const supplementaryBlocks = serverProcessedBlocks.map(
+        (sb) => ({
+          type: sb.type,
+          content: sb.content ?? "",
+          serverData: sb.data ?? void 0,
+          metadata: sb.metadata,
+          language: sb.data?.language,
+          src: sb.data?.src,
+          alt: sb.data?.alt
+        })
+      );
+      const expandedSupplementaryBlocks = expandTextBlocksInList(supplementaryBlocks);
+      if (currentContent.trim()) {
+        try {
+          const textBlocks = splitContentIntoBlocksV2(currentContent);
+          const parsed = Array.isArray(textBlocks) ? textBlocks : [];
+          return {
+            blocks: [
+              ...expandTextBlocksInList(parsed),
+              ...expandedSupplementaryBlocks
+            ],
+            blockError: false
+          };
+        } catch {
+          return {
+            blocks: [
+              { type: "text", content: currentContent },
+              ...expandedSupplementaryBlocks
+            ],
+            blockError: false
+          };
+        }
+      }
+      return { blocks: expandedSupplementaryBlocks, blockError: false };
+    }
+    try {
+      const result = splitContentIntoBlocksV2(currentContent);
+      return {
+        blocks: expandTextBlocksInList(Array.isArray(result) ? result : []),
+        blockError: false
+      };
+    } catch (error) {
+      console.error(
+        "[MarkdownStream] Error splitting content into blocks:",
+        error
+      );
+      return {
+        blocks: [{ type: "text", content: currentContent }],
+        blockError: true
+      };
+    }
+  }, [
+    currentContent,
+    isStreamActive,
+    isWaitingForContent,
+    useServerBlocks,
+    serverProcessedBlocks,
+    hasReduxRenderBlocks,
+    reduxRenderBlocks,
+    hiddenDecisionJsonTextBlockIds,
+    settledFromRecord
+  ]);
+  useEffect(() => {
+    if (blockError) {
+      setHasError(true);
+    }
+  }, [blockError]);
+  const processedBlocks = useMemo(() => {
+    if (isStreamActive) return blocks;
+    const result = [];
+    let i = 0;
+    while (i < blocks.length) {
+      if (blocks[i].type === "reasoning") {
+        const reasoningGroup = [];
+        while (i < blocks.length && blocks[i].type === "reasoning") {
+          reasoningGroup.push(blocks[i].content);
+          i++;
+        }
+        if (reasoningGroup.length > 1) {
+          result.push({
+            type: "consolidated_reasoning",
+            content: reasoningGroup.join("\n---\n"),
+            // Join for fallback
+            metadata: { reasoningTexts: reasoningGroup }
+          });
+        } else {
+          result.push({
+            type: "reasoning",
+            content: reasoningGroup[0]
+          });
+        }
+      } else {
+        result.push(blocks[i]);
+        i++;
+      }
+    }
+    return result;
+  }, [blocks, isStreamActive]);
+  const prevBlocksRef = useRef([]);
+  const slotBlocksRef = useRef(/* @__PURE__ */ new Map());
+  const stableBlocks = useMemo(
+    () => reuseUnchangedBlocks(prevBlocksRef.current, processedBlocks),
+    [processedBlocks]
+  );
+  useLayoutEffect(() => {
+    prevBlocksRef.current = stableBlocks;
+  }, [stableBlocks]);
+  const { shown: mountedBlockCount, sentinel: progressiveSentinel } = useProgressiveMount(stableBlocks.length);
+  const interleavedTextSplits = useMemo(() => {
+    const splits = /* @__PURE__ */ new Map();
+    for (const segment of messageInterleavedContent) {
+      if (segment.type !== "text" || splits.has(segment.content)) continue;
+      try {
+        splits.set(segment.content, splitContentIntoBlocksV2(segment.content));
+      } catch {
+        splits.set(segment.content, [
+          { type: "text", content: segment.content, startLine: 0, endLine: 0 }
+        ]);
+      }
+    }
+    return splits;
+  }, [messageInterleavedContent]);
+  const interleavedTextBlockTotal = hasDbInterleavedSpecial ? messageInterleavedContent.reduce(
+    (sum, segment) => segment.type === "text" ? sum + (interleavedTextSplits.get(segment.content)?.length ?? 0) : sum,
+    0
+  ) : 0;
+  const { shown: interleavedShown, sentinel: interleavedSentinel } = useProgressiveMount(interleavedTextBlockTotal);
+  const lastReasoningBlockIndex = useMemo(() => {
+    for (let i = processedBlocks.length - 1; i >= 0; i--) {
+      if (processedBlocks[i].type === "reasoning") {
+        return i;
+      }
+    }
+    return -1;
+  }, [processedBlocks]);
+  const latestRef = useRef({ currentContent, onContentChange, applyLocalEdits });
+  useLayoutEffect(() => {
+    latestRef.current = { currentContent, onContentChange, applyLocalEdits };
+  });
+  const blockContentChange = useCallback((next) => {
+    const { onContentChange: change, currentContent: prev } = latestRef.current;
+    change?.(next, prev);
+  }, []);
+  const replaceBlockContent = useCallback(
+    (original, replacement, remark) => {
+      const { currentContent: currentContent2, onContentChange: onContentChange2, applyLocalEdits: applyLocalEdits2 } = latestRef.current;
+      try {
+        const idx = currentContent2.indexOf(original);
+        if (idx === -1) {
+          console.warn(
+            // access-errors: ok — console-only diagnostic about an in-memory substring comparison performed here (indexOf === -1), no record read involved
+            "[MarkdownStream] replaceBlockContent: original substring not found in content.",
+            { originalLen: original.length, contentLen: currentContent2.length }
+          );
+          return;
+        }
+        const updatedContent = currentContent2.slice(0, idx) + replacement + currentContent2.slice(idx + original.length);
+        onContentChange2?.(updatedContent, currentContent2, remark);
+        if (applyLocalEdits2 !== false) {
+          setEditedContent(updatedContent);
+        }
+      } catch (error) {
+        console.error("[MarkdownStream] Error in replaceBlockContent:", error);
+      }
+    },
+    []
+  );
+  const handleOpenEditor = useCallback(() => {
+    try {
+      if (isStreamActive) return;
+      setIsEditorOpen(true);
+    } catch (error) {
+      console.error("[MarkdownStream] Error opening editor:", error);
+    }
+  }, [isStreamActive]);
+  const handleCancelEdit = useCallback(() => {
+    try {
+      setIsEditorOpen(false);
+    } catch (error) {
+      console.error("[MarkdownStream] Error canceling edit:", error);
+    }
+  }, []);
+  const handleSaveEdit = useCallback(
+    (newContent) => {
+      try {
+        onContentChange?.(newContent, currentContent);
+        if (applyLocalEdits !== false) {
+          setEditedContent(newContent);
+        }
+        setIsEditorOpen(false);
+      } catch (error) {
+        console.error("[MarkdownStream] Error saving edit:", error);
+      }
+    },
+    [onContentChange, applyLocalEdits, currentContent]
+  );
+  const blockKey = useCallback((block, index) => {
+    if (block.type === "code") {
+      return `code-${index}`;
+    }
+    return `${block.type}-${block.content.slice(0, 100)}-${index}`;
+  }, []);
+  const renderBlock = useCallback(
+    (block, index, isLastReasoning = false) => {
+      try {
+        if (!block || typeof block !== "object") {
+          console.warn("[MarkdownStream] Invalid block at index:", index);
+          return null;
+        }
+        return /* @__PURE__ */ jsx(
+          SafeBlockRenderer,
+          {
+            block,
+            index,
+            isStreamActive,
+            onContentChange: onContentChange ? blockContentChange : void 0,
+            conversationId,
+            messageId,
+            requestId,
+            taskId,
+            isLastReasoningBlock: isLastReasoning,
+            replaceBlockContent,
+            handleOpenEditor,
+            outputSchema
+          },
+          blockKey(block, index)
+        );
+      } catch (error) {
+        console.error(
+          "[MarkdownStream] Error in renderBlock at index:",
+          index,
+          error
+        );
+        return /* @__PURE__ */ jsxs(
+          "div",
+          {
+            className: "py-2 px-1 text-sm text-neutral-600 dark:text-neutral-400 whitespace-pre-wrap break-words border-l-2 border-red-500 bg-red-50 dark:bg-red-950/20",
+            children: [
+              block?.content || "[Render error]",
+              /* @__PURE__ */ jsx(ErrorAlchemyMenu, {})
+            ]
+          },
+          blockKey(block, index)
+        );
+      }
+    },
+    [
+      blockKey,
+      isStreamActive,
+      onContentChange,
+      blockContentChange,
+      conversationId,
+      messageId,
+      requestId,
+      taskId,
+      replaceBlockContent,
+      handleOpenEditor,
+      outputSchema
+    ]
+  );
+  const containerStyles = cn(
+    "pt-1 pb-0 px-0 space-y-4 font-sans text-md antialiased leading-relaxed tracking-wide overflow-x-clip min-w-0 break-words",
+    // The first block starts flush (no top margin) — app/globals.css.
+    "block w-full bg-inherit markdown-flush-start",
+    className
+  );
+  if (hasError) {
+    return /* @__PURE__ */ jsx(
+      PlainTextFallback,
+      {
+        requestId,
+        content: currentContent,
+        className
+      }
+    );
+  }
+  const hasPreTextSegments = isWaitingForContent && requestId && hasUnifiedSpecial;
+  if (isWaitingForContent && !hasPreTextSegments) {
+    try {
+      return /* @__PURE__ */ jsx("div", { className: "mb-1 w-full min-w-0 text-left overflow-x-clip", children: /* @__PURE__ */ jsx("div", { className: containerStyles, children: /* @__PURE__ */ jsx("div", { className: "flex items-center justify-start py-1", children: requestId && isVideoJob ? /* @__PURE__ */ jsx(GenerationJobCard, { requestId }) : requestId && isRunJob ? (
+        // A generation job names itself, its model and its clock —
+        // "Processing…" for a minute reads as a hang.
+        /* @__PURE__ */ jsx(RunJobWorkingLine, { requestId })
+      ) : /* @__PURE__ */ jsx(
+        ShimmerText,
+        {
+          text: isReasoningActive ? "Reasoning\u2026" : "Processing\u2026",
+          className: "text-sm"
+        }
+      ) }) }) });
+    } catch (error) {
+      console.error("[MarkdownStream] Error rendering loading state:", error);
+      return /* @__PURE__ */ jsx(PlainTextFallback, { content: "Loading...", className });
+    }
+  }
+  const stableSlotBlocks = (key, next) => {
+    const prev = slotBlocksRef.current.get(key) ?? [];
+    const stable = reuseUnchangedBlocks(prev, next);
+    slotBlocksRef.current.set(key, stable);
+    return stable;
+  };
+  const renderGroupedSlot = (slot, i) => {
+    if (!requestId) return null;
+    if (slot.kind === "tool_batch") {
+      if (!machineFramesVisible) return null;
+      return /* @__PURE__ */ jsx(
+        ToolBatch,
+        {
+          requestId,
+          callIds: slot.callIds,
+          conversationId: conversationId ?? "",
+          browserRunOrder: slot.browserRunOrder,
+          browserBreakBefore: slot.browserBreakBefore,
+          browserBreakAfter: slot.browserBreakAfter
+        },
+        `tool-batch-${slot.callIds[0]}`
+      );
+    }
+    if (slot.kind === "render_block") {
+      let rb = renderBlocksMap[slot.blockId];
+      if (!rb) return null;
+      if (!blockHasSomethingToRender(rb)) {
+        return null;
+      }
+      if (hiddenDecisionJsonTextBlockIds.has(slot.blockId)) {
+        return null;
+      }
+      if (rb.type === "text" && rb.content) {
+        const liveMarkers = liveCitationMarkersByBlockId[slot.blockId];
+        if (liveMarkers && liveMarkers.length > 0) {
+          rb = {
+            ...rb,
+            content: insertCitationMarkers(rb.content, liveMarkers)
+          };
+        }
+      }
+      if (rb.type === "text" && rb.content?.trim()) {
+        const sub = (() => {
+          try {
+            return splitContentIntoBlocksV2(rb.content);
+          } catch {
+            return null;
+          }
+        })();
+        if (sub && sub.length > 0) {
+          let lastReasoningIdx = -1;
+          for (let j = sub.length - 1; j >= 0; j--) {
+            if (sub[j].type === "reasoning" || sub[j].type === "thinking") {
+              lastReasoningIdx = j;
+              break;
+            }
+          }
+          const isStreamingRb = rb.status === "streaming";
+          return stableSlotBlocks(
+            `slot:${slot.seq}`,
+            sub.map(
+              (b, j) => ({
+                ...b,
+                isStreamingBlock: isStreamingRb && j === lastReasoningIdx
+              })
+            )
+          ).map((b, j) => renderBlock(b, i * 1e3 + j));
+        }
+      }
+      const [block] = stableSlotBlocks(`slotb:${slot.seq}`, [renderBlockToContentBlock(rb)]);
+      return renderBlock(block, i);
+    }
+    if (slot.kind === "tool") {
+      if (!machineFramesVisible) {
+        const entry = toolLifecycleMap?.[slot.callId];
+        const settled = entry?.status === "completed" || entry?.status === "error";
+        return settled ? null : /* @__PURE__ */ jsx(
+          InlineStatusIndicator,
+          {
+            label: EXPERT_WORKING_LABEL
+          },
+          `tool-${slot.callId}`
+        );
+      }
+      return /* @__PURE__ */ jsx(
+        ToolCard,
+        {
+          requestId,
+          callId: slot.callId,
+          conversationId: conversationId ?? ""
+        },
+        `tool-${slot.callId}`
+      );
+    }
+    if (slot.kind === "status") {
+      if (requestId && isVideoJob) {
+        return /* @__PURE__ */ jsx(
+          GenerationJobCard,
+          {
+            requestId,
+            className: "my-2"
+          },
+          `status-${slot.seq}`
+        );
+      }
+      if (requestId && isRunJob) {
+        return /* @__PURE__ */ jsx(
+          RunJobWorkingLine,
+          {
+            requestId,
+            className: "flex items-center py-2"
+          },
+          `status-${slot.seq}`
+        );
+      }
+      return /* @__PURE__ */ jsx(
+        InlineStatusIndicator,
+        {
+          label: machineFramesVisible ? slot.label : EXPERT_WORKING_LABEL
+        },
+        `status-${slot.seq}`
+      );
+    }
+    if (slot.kind === "thinking") {
+      return /* @__PURE__ */ jsx(
+        InlineThinkingSlot,
+        {
+          requestId,
+          chunkStartIndex: slot.chunkStartIndex,
+          chunkEndIndex: slot.chunkEndIndex,
+          renderReasoning: (content2, isStreaming) => renderBlock(
+            {
+              type: "reasoning",
+              content: content2,
+              isStreamingBlock: isStreaming
+            },
+            i
+          )
+        },
+        `thinking-${slot.seq}`
+      );
+    }
+    if (slot.kind === "error") {
+      return /* @__PURE__ */ jsx(InlineAssistantError, { requestId }, `error-${slot.seq}`);
+    }
+    return null;
+  };
+  let interleavedBudget = interleavedShown;
+  const renderGroupedSegment = (segment, segIdx) => {
+    if (interleavedBudget <= 0 && interleavedShown < interleavedTextBlockTotal) return null;
+    if (segment.type === "db_tool_batch") {
+      if (!machineFramesVisible) return null;
+      return /* @__PURE__ */ jsx(
+        ToolBatch,
+        {
+          segments: segment.segments,
+          conversationId: conversationId ?? "",
+          browserRunOrder: segment.browserRunOrder,
+          browserBreakBefore: segment.browserBreakBefore,
+          browserBreakAfter: segment.browserBreakAfter
+        },
+        `tool-batch-${segment.segments[0]?.callId ?? segment.key}`
+      );
+    }
+    if (segment.type === "db_tool") {
+      if (!machineFramesVisible) return null;
+      return /* @__PURE__ */ jsx(
+        ToolCard,
+        {
+          callId: segment.callId,
+          segment,
+          conversationId: conversationId ?? ""
+        },
+        `tool-${segment.callId}`
+      );
+    }
+    if (segment.type === "render_block") {
+      const block = {
+        type: segment.blockType,
+        content: segment.content ?? "",
+        serverData: segment.data ?? void 0,
+        metadata: segment.metadata
+      };
+      return stableSlotBlocks(`segrb:${segIdx}`, expandTextBlocksInList([block])).map(
+        (expandedBlock, blockIdx) => renderBlock(expandedBlock, segIdx * 1e3 + blockIdx)
+      );
+    }
+    if (segment.type === "thinking") {
+      const thinkBlocks = (() => {
+        try {
+          return splitContentIntoBlocksV2(segment.content);
+        } catch {
+          return [
+            {
+              type: "reasoning",
+              content: segment.content,
+              startLine: 0,
+              endLine: 0
+            }
+          ];
+        }
+      })();
+      return stableSlotBlocks(
+        `segthink:${segIdx}`,
+        thinkBlocks.map((block) => ({ ...block, type: "reasoning" }))
+      ).map((block, blockIdx) => renderBlock(block, segIdx * 1e3 + blockIdx));
+    }
+    if (segment.type === "text") {
+      const segBlocks = interleavedTextSplits.get(segment.content) ?? (() => {
+        try {
+          return splitContentIntoBlocksV2(segment.content);
+        } catch {
+          return [
+            {
+              type: "text",
+              content: segment.content,
+              startLine: 0,
+              endLine: 0
+            }
+          ];
+        }
+      })();
+      const visible = segBlocks.slice(0, Math.max(0, interleavedBudget));
+      interleavedBudget -= segBlocks.length;
+      return stableSlotBlocks(`segtext:${segIdx}`, visible).map(
+        (block, blockIdx) => renderBlock(block, segIdx * 1e3 + blockIdx)
+      );
+    }
+    return null;
+  };
+  try {
+    return (
+      // A live stream heals half-arrived markdown in every MarkdownCore leaf
+      // below (links, images, emphasis) — finished messages are untouched.
+      /* @__PURE__ */ jsx(MarkdownStreamingProvider, { value: !!isStreamActive, children: /* @__PURE__ */ jsx(DocumentNumberingProvider, { source: currentContent, children: /* @__PURE__ */ jsx(MaybeSourceEdit, { source: currentContent, save: isStreamActive ? void 0 : onContentChange ? handleSaveEdit : void 0, children: /* @__PURE__ */ jsxs(
+        "div",
+        {
+          className: "mb-1 w-full min-w-0 text-left overflow-x-clip",
+          "data-matrx-doc-root": "",
+          "data-block-count": hasUnifiedSpecial ? void 0 : hasDbInterleavedSpecial ? interleavedTextBlockTotal : stableBlocks.length,
+          "data-blocks-mounted": hasUnifiedSpecial ? void 0 : hasDbInterleavedSpecial ? Math.min(interleavedShown, interleavedTextBlockTotal) : mountedBlockCount,
+          children: [
+            /* @__PURE__ */ jsxs("div", { className: containerStyles, children: [
+              hasUnifiedSpecial && requestId ? workGroupedSlots.map(
+                (slot, i) => slot.kind === "agent_work" ? /* @__PURE__ */ jsx(
+                  AgentWorkGroup,
+                  {
+                    sessionKey: `agent-work:${requestId}:${slot.items[0]?.seq ?? i}`,
+                    order: i,
+                    durationMs: slot.durationMs,
+                    stepCount: slot.stepCount,
+                    conversationId,
+                    children: flattenWorkSlots(slot.items).map(
+                      (s, k) => renderGroupedSlot(s, i * 1e3 + k)
+                    )
+                  },
+                  `agent-work-${slot.items[0]?.seq ?? i}`
+                ) : renderGroupedSlot(slot, i)
+              ) : hasDbInterleavedSpecial ? workGroupedSegments.map(
+                (segment, segIdx) => "kind" in segment && segment.kind === "agent_work" ? /* @__PURE__ */ jsx(
+                  AgentWorkGroup,
+                  {
+                    sessionKey: `agent-work:${messageId ?? conversationId ?? ""}:${segIdx}`,
+                    order: segIdx,
+                    durationMs: segment.durationMs,
+                    stepCount: segment.stepCount,
+                    conversationId,
+                    children: flattenWorkSegments(segment.items).map(
+                      (s, k) => renderGroupedSegment(s, segIdx * 1e3 + k)
+                    )
+                  },
+                  `agent-work-${messageId ?? ""}-${segIdx}`
+                ) : renderGroupedSegment(segment, segIdx)
+              ) : stableBlocks.slice(0, mountedBlockCount).map(
+                (block, index) => renderBlock(
+                  block,
+                  index,
+                  index === lastReasoningBlockIndex
+                )
+              ),
+              !hasUnifiedSpecial && !hasDbInterleavedSpecial && progressiveSentinel,
+              !hasUnifiedSpecial && hasDbInterleavedSpecial && interleavedSentinel,
+              /* @__PURE__ */ jsx(DocumentFootnotes, { render: (markdown) => renderBlock({ type: "text", content: markdown }, 1e6) })
+            ] }),
+            !hideCopyButton && /* @__PURE__ */ jsx(
+              MarkdownErrorBoundary,
+              {
+                fallback: null,
+                onError: (error) => console.error("[MarkdownStream] CopyButton error:", error),
+                children: /* @__PURE__ */ jsx(
+                  RichCopySplit,
+                  {
+                    label: "Content",
+                    human: currentContent,
+                    contentFlavor: "markdown",
+                    stripThinking: true,
+                    size: "xs",
+                    className: "absolute top-1/2 right-1 z-10 -translate-y-1/2"
+                  }
+                )
+              }
+            ),
+            allowFullScreenEditor && /* @__PURE__ */ jsx(
+              MarkdownErrorBoundary,
+              {
+                fallback: null,
+                onError: (error) => console.error("[MarkdownStream] FullScreenEditor error:", error),
+                children: /* @__PURE__ */ jsx(
+                  FullScreenMarkdownEditor,
+                  {
+                    imagePolicy: "inherit",
+                    isOpen: isEditorOpen,
+                    initialContent: currentContent,
+                    onSave: handleSaveEdit,
+                    onCancel: handleCancelEdit,
+                    analysisData,
+                    messageId,
+                    conversationId,
+                    tabs: [
+                      "write",
+                      "matrx_split",
+                      "markdown",
+                      "wysiwyg",
+                      "preview"
+                    ],
+                    initialTab: "matrx_split"
+                  }
+                )
+              }
+            )
+          ]
+        }
+      ) }) }) })
+    );
+  } catch (error) {
+    console.error("[MarkdownStream] Critical error in render:", error);
+    return /* @__PURE__ */ jsx(PlainTextFallback, { content: currentContent, className });
+  }
+};
+export {
+  EnhancedChatMarkdownInternal
+};