Enhanced ChatGPT Clone: Features Agents, MCP, Skills, DeepSeek, Anthropic, AWS, OpenAI, Responses API, Azure, Groq, o1, GPT-5, Mistral, OpenRouter, Vertex AI, Gemini, Artifacts, AI model switching, message search, Code Interpreter, langchain, DALL-E-3, OpenAPI Actions, Functions, Secure Multi-User Auth, Presets, open-source for self-hosting. Active
TypeScript aianthropicartifactsawsazurechatgptchatgpt-cloneclaudeclonedeepseekgeminigooglegpt-5librechatmcpo1openairesponses-apivisionwebui
🪶 perf: Cut the Mount Cost of Finished Agent Messages (#16057)
Danny Avila79d1cbbafcb6
diff --git a/client/src/Providers/AuthorContext.tsx b/client/src/Providers/AuthorContext.tsxnew file mode 100644index 0000000000..e8cec93446--- /dev/null+++ b/client/src/Providers/AuthorContext.tsx@@ -0,0 +1,17 @@+import { createContext, useContext } from 'react';+import type { ReactNode } from 'react';++/** The author a message restates wherever its content resumes after a steer. */+export type TMessageAuthor = {+ icon: ReactNode;+ label: string;+};++/**+ * Carries the message author to the headers inside its content. The author can+ * resolve after the message paints, when an agent's name and avatar arrive with the+ * agents list, and a context change reaches only the headers that read it rather+ * than every part of the message.+ */+export const AuthorContext = createContext<TMessageAuthor | null>(null);+export const useAuthorContext = () => useContext(AuthorContext);diff --git a/client/src/Providers/index.ts b/client/src/Providers/index.tsindex 76aad5b456..3e499921fc 100644--- a/client/src/Providers/index.ts+++ b/client/src/Providers/index.ts@@ -10,6 +10,7 @@ export * from './EditorContext';export * from './ChatFormContext';export * from './BookmarkContext';export * from './MessageContext';+export * from './AuthorContext';export * from './AssistantsContext';export * from './AgentsContext';export * from './AssistantsMapContext';diff --git a/client/src/components/Chat/Messages/Content/Markdown.tsx b/client/src/components/Chat/Messages/Content/Markdown.tsxindex 24b3cc2624..222c3d0a0d 100644--- a/client/src/components/Chat/Messages/Content/Markdown.tsx+++ b/client/src/components/Chat/Messages/Content/Markdown.tsx@@ -19,7 +19,8 @@ const Markdown = memo(function Markdown({ content = '', isLatestMessage }: TContconst LaTeXParsing = useRecoilValue<boolean>(store.LaTeXParsing);const isInitializing = content === '';- const animate = smoothStreaming && isLatestMessage && isSubmitting;+ const streaming = isLatestMessage && isSubmitting;+ const animate = smoothStreaming && streaming;// Hydration signal for the fade: substantial content already present at the// render where `animate` flips on means resumed/switched-to/follow-up@@ -52,6 +53,7 @@ const Markdown = memo(function Markdown({ content = '', isLatestMessage }: TCont<MarkdownErrorBoundary content={content} codeExecution={true}><MarkdownBlockscontent={content}+ streaming={streaming}remarkPlugins={getRemarkPlugins(LaTeXParsing)}rehypePlugins={getRehypePlugins()}components={getMarkdownComponents()}diff --git a/client/src/components/Chat/Messages/Content/MarkdownBlocks.bench.tsx b/client/src/components/Chat/Messages/Content/MarkdownBlocks.bench.tsxindex 6dc10e8dd6..e982f0b558 100644--- a/client/src/components/Chat/Messages/Content/MarkdownBlocks.bench.tsx+++ b/client/src/components/Chat/Messages/Content/MarkdownBlocks.bench.tsx@@ -5,13 +5,15 @@ import { render } from '@testing-library/react';import { getRemarkPlugins, getRehypePlugins, getMarkdownComponents } from './markdownConfig';import { ArtifactProvider, CodeBlockProvider, MessageContext } from '~/Providers';import CodeBlock from '~/components/Messages/Content/CodeBlock';+import MarkdownBlocks from './MarkdownBlocks';import Markdown from './Markdown';/**- * Streaming render benchmark comparing the previous whole-message renderer- * (one ReactMarkdown re-parsing everything per token) against the per-block- * memoized renderer. This file lives outside `__tests__/` and is named- * `.bench.tsx` so the default jest run skips it; execute it explicitly with:+ * Render benchmark comparing the previous whole-message renderer (one+ * ReactMarkdown re-parsing everything per token) against the per-block memoized+ * renderer, both while a message streams and when a finished message mounts.+ * This file lives outside `__tests__/` and is named `.bench.tsx` so the default+ * jest run skips it; execute it explicitly with:** node node_modules/jest/bin/jest.js --runInBand --coverage=false \* --testMatch '**\/MarkdownBlocks.bench.tsx'@@ -83,8 +85,20 @@ const OldMarkdown = ({ content }: { content: string }) => (</ArtifactProvider>);+/** The per-block renderer a streaming message uses, without the fade. */const NewMarkdown = ({ content }: { content: string }) => (- <Markdown content={content} isLatestMessage={true} />+ <MarkdownBlocks+ content={content}+ streaming={true}+ remarkPlugins={getRemarkPlugins()}+ rehypePlugins={getRehypePlugins()}+ components={getMarkdownComponents()}+ />+);++/** A finished message as a conversation opens with it. */+const SettledMarkdown = ({ content }: { content: string }) => (+ <Markdown content={content} isLatestMessage={false} />);const streamingContext = {@@ -186,4 +200,53 @@ describe('Markdown streaming benchmark (OLD whole-message vs NEW per-block)', ()// Memoization should cut total code-block renders by a wide margin.expect(newRenders).toBeLessThan(oldRenders * 0.5);});++ it('reports mount cost for a message that was already finished', () => {+ const iterations = 5;+ const rows = [12, 40].map((sections) => {+ const prefixes = [buildMessage(sections)];+ measure(OldMarkdown, prefixes);+ measure(NewMarkdown, prefixes);+ measure(SettledMarkdown, prefixes);++ const old: Array<{ totalMs: number; codeBlockRenders: number }> = [];+ const perBlock: Array<{ totalMs: number; codeBlockRenders: number }> = [];+ const settled: Array<{ totalMs: number; codeBlockRenders: number }> = [];+ for (let i = 0; i < iterations; i += 1) {+ old.push(measure(OldMarkdown, prefixes));+ perBlock.push(measure(NewMarkdown, prefixes));+ settled.push(measure(SettledMarkdown, prefixes));+ }+ const minMs = (rs: Array<{ totalMs: number }>) => Math.min(...rs.map((r) => r.totalMs));+ return {+ chars: prefixes[0].length,+ oldMs: minMs(old),+ perBlockMs: minMs(perBlock),+ settledMs: minMs(settled),+ oldRenders: old[0].codeBlockRenders,+ settledRenders: settled[0].codeBlockRenders,+ };+ });++ console.log(+ [+ '',+ '================ Markdown finished-message mount benchmark ================',+ `min of ${iterations} mounts, summed Profiler actualDuration; jsdom`,+ ...rows.map(+ (r) =>+ ` ${r.chars} chars: OLD ${r.oldMs.toFixed(1)} ms | PER-BLOCK ${r.perBlockMs.toFixed(1)} ms | ` ++ `SETTLED ${r.settledMs.toFixed(1)} ms (${(r.perBlockMs / r.settledMs).toFixed(2)}x faster than per-block)`,+ ),+ '==========================================================================',+ '',+ ].join('\n'),+ );++ // A finished message mounts through the whole-message pipeline: every code+ // block renders exactly once, as it did before per-block rendering existed.+ for (const r of rows) {+ expect(r.settledRenders).toBe(r.oldRenders);+ }+ });});diff --git a/client/src/components/Chat/Messages/Content/MarkdownBlocks.tsx b/client/src/components/Chat/Messages/Content/MarkdownBlocks.tsxindex d5b76f3ae6..256bc9cc75 100644--- a/client/src/components/Chat/Messages/Content/MarkdownBlocks.tsx+++ b/client/src/components/Chat/Messages/Content/MarkdownBlocks.tsx@@ -1,4 +1,4 @@-import React, { memo, useMemo, useLayoutEffect } from 'react';+import React, { memo, useMemo, useState, useLayoutEffect } from 'react';import ReactMarkdown from 'react-markdown';import type { PluggableList } from 'unified';import type { ElementType } from 'react';@@ -86,46 +86,103 @@ MarkdownBlock.displayName = 'MarkdownBlock';type MarkdownBlocksProps = SharedProps & {content: string;+ /** Whether this message is the one generating right now. */+ streaming: boolean;+};++type BlockEntry = {+ /**+ * Code and artifact blocks capture their index in a ref when they mount, so a+ * block has to remount whenever an index it holds could shift, and must not+ * remount otherwise.+ */+ key: string;+ raw: string;+ codeBaseIndex: number;+ artifactBaseIndex: number;+ mermaidBaseIndex: number;+};++/**+ * Each top-level block, seeded with the code, artifact and Mermaid indices of the+ * blocks before it. The key carries those bases, so an in-place edit that inserts+ * a block before existing code or artifacts remounts the blocks it shifted, while+ * append-only streaming keeps completed blocks mounted.+ */+const toBlockEntries = (content: string): BlockEntry[] => {+ let codeBaseIndex = 0;+ let artifactBaseIndex = 0;+ let mermaidBaseIndex = 0;+ return splitMarkdownIntoBlocks(content).map((block, index) => {+ const entry = {+ key: `${index}-${codeBaseIndex}-${artifactBaseIndex}-${mermaidBaseIndex}`,+ raw: block.raw,+ codeBaseIndex,+ artifactBaseIndex,+ mermaidBaseIndex,+ };+ codeBaseIndex += block.codeBlockCount;+ artifactBaseIndex += block.artifactCount;+ mermaidBaseIndex += block.mermaidCount;+ return entry;+ });};/**- * Splits a message into top-level blocks and renders each independently so- * that, during streaming, only the last block re-parses while earlier blocks- * (tables, code, etc.) stay memoized. Each block's executable code and artifact- * indices are preserved in document order via per-block providers seeded with- * prefix-summed base indices.+ * The whole message as one block, which numbers its code and artifacts from zero+ * itself. It only ever renders the message exactly as it mounted, so no index it+ * assigns can go stale and its key never has to change.+ */+const toWholeMessage = (content: string): BlockEntry[] =>+ content+ ? [{ key: 'whole', raw: content, codeBaseIndex: 0, artifactBaseIndex: 0, mermaidBaseIndex: 0 }]+ : [];++/**+ * Renders a message's markdown.+ *+ * While the message streams, each top-level block renders and memoizes on its+ * own, so only the last, still-growing block re-parses on each token. Each+ * block's executable code and artifact indices stay in document order through+ * per-block providers seeded with prefix-summed base indices.+ *+ * A message that mounts finished renders as one pipeline instead, for as long as+ * it stays exactly as it mounted. Splitting it would buy memoization nothing+ * uses, at the price of a whole extra parse to find block boundaries and one+ * pipeline per block, which is most of the cost of opening a long conversation.+ *+ * Once the message generates or its content changes, it moves to the split for+ * good. Code and artifact blocks capture their index at mount, and per block only+ * the blocks a change touches re-render, so finishing an answer never remounts its+ * blocks and neither do repeated edits such as artifact saves. The move itself+ * remounts the message once.*/const MarkdownBlocks = memo(function MarkdownBlocks({content,+ streaming,remarkPlugins,rehypePlugins,components,animate,hydrated,}: MarkdownBlocksProps) {- const blocks = useMemo(() => {- let codeBaseIndex = 0;- let artifactBaseIndex = 0;- let mermaidBaseIndex = 0;- return splitMarkdownIntoBlocks(content).map((block) => {- const entry = { raw: block.raw, codeBaseIndex, artifactBaseIndex, mermaidBaseIndex };- codeBaseIndex += block.codeBlockCount;- artifactBaseIndex += block.artifactCount;- mermaidBaseIndex += block.mermaidCount;- return entry;- });- }, [content]);+ const [mountedContent] = useState(content);+ const [hasChanged, setHasChanged] = useState(streaming);+ const changing = streaming || content !== mountedContent;+ if (changing && !hasChanged) {+ setHasChanged(true);+ }+ const perBlock = hasChanged || changing;+ const blocks = useMemo(+ () => (perBlock ? toBlockEntries(content) : toWholeMessage(content)),+ [content, perBlock],+ );return (<>- {blocks.map((block, index) => (- // Key includes the base indices so that an in-place edit which inserts a- // block before existing code/artifact blocks (shifting their base) forces- // a remount, refreshing the index each code/artifact block captures in a- // ref. During append-only streaming these stay constant, so completed- // blocks keep a stable key and are not remounted.+ {blocks.map((block) => (<MarkdownBlock- key={`${index}-${block.codeBaseIndex}-${block.artifactBaseIndex}-${block.mermaidBaseIndex}`}+ key={block.key}content={block.raw}codeBaseIndex={block.codeBaseIndex}artifactBaseIndex={block.artifactBaseIndex}diff --git a/client/src/components/Chat/Messages/Content/Parts/ResumeAuthorHeader.tsx b/client/src/components/Chat/Messages/Content/Parts/ResumeAuthorHeader.tsxnew file mode 100644index 0000000000..297319b99f--- /dev/null+++ b/client/src/components/Chat/Messages/Content/Parts/ResumeAuthorHeader.tsx@@ -0,0 +1,22 @@+import { memo } from 'react';+import { useAuthorContext } from '~/Providers';+import AuthorHeader from './AuthorHeader';++/**+ * Restates the message author where content resumes after a steer, reading the+ * author from `AuthorContext`.+ *+ * A header element built from the author changes identity when the author+ * resolves, and handing that element to the memoized parts tree re-rendered every+ * part of the message. Rendered through this component, the element a caller hands+ * down never changes, and an author update re-renders only the headers on screen.+ */+const ResumeAuthorHeader = memo(function ResumeAuthorHeader() {+ const author = useAuthorContext();+ if (author == null) {+ return null;+ }+ return <AuthorHeader icon={author.icon} label={author.label} />;+});++export default ResumeAuthorHeader;diff --git a/client/src/components/Chat/Messages/Content/Parts/index.ts b/client/src/components/Chat/Messages/Content/Parts/index.tsindex 229db2fe36..56ef2380ee 100644--- a/client/src/components/Chat/Messages/Content/Parts/index.ts+++ b/client/src/components/Chat/Messages/Content/Parts/index.ts@@ -18,3 +18,4 @@ export { default as PtcToolTrace } from './PtcToolTrace';export { default as SubagentCall } from './SubagentCall';export { default as SteerPart } from './SteerPart';export { default as AuthorHeader } from './AuthorHeader';+export { default as ResumeAuthorHeader } from './ResumeAuthorHeader';diff --git a/client/src/components/Chat/Messages/Content/__tests__/MarkdownBlocks.artifacts.test.tsx b/client/src/components/Chat/Messages/Content/__tests__/MarkdownBlocks.artifacts.test.tsxindex f055d6e46a..65437ef434 100644--- a/client/src/components/Chat/Messages/Content/__tests__/MarkdownBlocks.artifacts.test.tsx+++ b/client/src/components/Chat/Messages/Content/__tests__/MarkdownBlocks.artifacts.test.tsx@@ -67,10 +67,41 @@ const readArtifacts = async () =>id: el.getAttribute('data-id'),}));-describe('MarkdownBlocks artifact-index parity (e2e)', () => {+/** The latest message of a conversation, generating while `submitting` holds. */+const liveView = (content: string, submitting: boolean) => (+ <MemoryRouter>+ <RecoilRoot>+ <MessageContext.Provider+ value={{+ messageId: 'm1',+ isExpanded: true,+ isSubmitting: submitting,+ isLatestMessage: true,+ }}+ >+ <Markdown content={content} isLatestMessage={true} />+ </MessageContext.Provider>+ </RecoilRoot>+ </MemoryRouter>+);++/**+ * A finished message renders through one pipeline; one that streamed in this view+ * renders per block. Every parity case has to hold on both paths.+ */+const renderMessage = (content: string, streamed: boolean) => {+ const rendered = render(liveView(content, streamed));+ rendered.rerender(liveView(content, false));+ return rendered;+};++describe.each([+ ['a finished', false],+ ['a streamed', true],+])('MarkdownBlocks artifact-index parity (e2e) in %s message', (_label, streamed) => {it('assigns document-order indices to multiple artifacts', async () => {const content = `${artifact('a', 'A')}\n\n${artifact('b', 'B')}`;- render(wrap(<Markdown content={content} isLatestMessage={false} />));+ renderMessage(content, streamed);expect(await readArtifacts()).toEqual([{ idx: '0', id: 'a' },@@ -85,7 +116,7 @@ describe('MarkdownBlocks artifact-index parity (e2e)', () => {const oldIdx = await readArtifacts();unmount();- render(wrap(<Markdown content={content} isLatestMessage={false} />));+ renderMessage(content, streamed);const newIdx = await readArtifacts();expect(newIdx).toEqual(oldIdx);@@ -95,16 +126,20 @@ describe('MarkdownBlocks artifact-index parity (e2e)', () => {]);});+ /**+ * A finished message moves to per-block rendering on its first edit, and per+ * block the base-aware keys remount the blocks whose index shifted.+ */it('refreshes artifact indices when an in-place edit inserts an artifact before another', async () => {const before = `Intro.\n\n${artifact('b', 'B')}`;const after = `${artifact('a', 'A')}\n\n${artifact('b', 'B')}`;- const { rerender } = render(wrap(<Markdown content={before} isLatestMessage={false} />));+ const { rerender } = renderMessage(before, streamed);expect(await readArtifacts()).toEqual([{ idx: '0', id: 'b' }]);- rerender(wrap(<Markdown content={after} isLatestMessage={false} />));- // 'b' was index 0; inserting 'a' before it shifts its base to 1. Without the- // base-aware block key its ref-cached index would stay 0 (duplicating 'a').+ rerender(liveView(after, false));+ // 'b' was index 0; inserting 'a' before it shifts it to 1. Without a remount+ // its ref-cached index would stay 0 (duplicating 'a').expect(await readArtifacts()).toEqual([{ idx: '0', id: 'a' },{ idx: '1', id: 'b' },@@ -115,7 +150,7 @@ describe('MarkdownBlocks artifact-index parity (e2e)', () => {// `:artifact{}` (text directive) renders as literal text, not an Artifact, so// the following real artifact must still be index 0.const content = `See :artifact{identifier="x"} inline.\n\n${artifact('a', 'A')}`;- render(wrap(<Markdown content={content} isLatestMessage={false} />));+ renderMessage(content, streamed);expect(await readArtifacts()).toEqual([{ idx: '0', id: 'a' }]);});@@ -141,7 +176,7 @@ describe('MarkdownBlocks artifact-index parity (e2e)', () => {':::',].join('\n');- render(wrap(<Markdown content={content} isLatestMessage={false} />));+ renderMessage(content, streamed);const [artifactNode] = await screen.findAllByTestId('art');expect(artifactNode.getAttribute('data-content')).toBe(`${markdown}\n`);diff --git a/client/src/components/Chat/Messages/Content/__tests__/MarkdownBlocks.test.tsx b/client/src/components/Chat/Messages/Content/__tests__/MarkdownBlocks.test.tsxindex 835b24ee8a..9be9d069b7 100644--- a/client/src/components/Chat/Messages/Content/__tests__/MarkdownBlocks.test.tsx+++ b/client/src/components/Chat/Messages/Content/__tests__/MarkdownBlocks.test.tsx@@ -2,10 +2,11 @@ import React from 'react';import { RecoilRoot } from 'recoil';import ReactMarkdown from 'react-markdown';import { MemoryRouter } from 'react-router-dom';-import { render, screen } from '@testing-library/react';+import { render, screen, within } from '@testing-library/react';import { QueryClient, QueryClientProvider } from '@tanstack/react-query';import { getRemarkPlugins, getRehypePlugins, getMarkdownComponents } from '../markdownConfig';-import { ArtifactProvider, CodeBlockProvider } from '~/Providers';+import { MessageContext, ArtifactProvider, CodeBlockProvider } from '~/Providers';+import { splitMarkdownIntoBlocks } from '../splitMarkdown';import Markdown from '../Markdown';/**@@ -13,10 +14,14 @@ import Markdown from '../Markdown';* router the same way it has one in the app — without it the diagram throws into its* error boundary and the assertions compare two fallbacks instead of two renderers.*/+const queryClient = new QueryClient();+const TestProviders = ({ children }: { children: React.ReactNode }) => (- <MemoryRouter>- <RecoilRoot>{children}</RecoilRoot>- </MemoryRouter>+ <QueryClientProvider client={queryClient}>+ <MemoryRouter>+ <RecoilRoot>{children}</RecoilRoot>+ </MemoryRouter>+ </QueryClientProvider>);/**@@ -31,18 +36,48 @@ jest.mock('~/components/Messages/Content/Mermaid', () => ({MermaidErrorBoundary: ({ children }: { children: React.ReactNode }) => <>{children}</>,}));+const mockCodeBlockMounts = { count: 0 };+/*** Stub CodeBlock so we can read the blockIndex each executable code block* receives, while still exercising the real `code` override's skip/single-line- * decision (which decides whether a CodeBlock renders at all).+ * decision (which decides whether a CodeBlock renders at all). It also counts+ * mounts, which is how a remount of an already-rendered block shows up.*/jest.mock('~/components/Messages/Content/CodeBlock', () => ({__esModule: true,- default: ({ lang, blockIndex }: { lang?: string; blockIndex?: number }) => (- <div data-testid="cb" data-block-index={String(blockIndex)} data-lang={String(lang)} />- ),+ default: function MockCodeBlock({+ lang,+ blockIndex,+ codeChildren,+ }: {+ lang?: string;+ blockIndex?: number;+ codeChildren?: React.ReactNode;+ }) {+ const { useEffect } = jest.requireActual<typeof import('react')>('react');+ useEffect(() => {+ mockCodeBlockMounts.count += 1;+ }, []);+ return (+ <div+ data-testid="cb"+ data-block-index={String(blockIndex)}+ data-lang={String(lang)}+ data-code={String(codeChildren)}+ />+ );+ },}));+/** The real splitter, observed: whether a render paid for the block-boundary parse. */+jest.mock('../splitMarkdown', () => {+ const actual = jest.requireActual<typeof import('../splitMarkdown')>('../splitMarkdown');+ return { ...actual, splitMarkdownIntoBlocks: jest.fn(actual.splitMarkdownIntoBlocks) };+});++const splitSpy = jest.mocked(splitMarkdownIntoBlocks);+/** The previous whole-message renderer: a single ReactMarkdown under one set of providers. */const OldMarkdown = ({ content }: { content: string }) => (<ArtifactProvider>@@ -60,6 +95,29 @@ const OldMarkdown = ({ content }: { content: string }) => (</ArtifactProvider>);+/** The latest message of a conversation, generating while `submitting` holds. */+const LiveMarkdown = ({ content, submitting }: { content: string; submitting: boolean }) => (+ <MessageContext.Provider+ value={{+ messageId: 'live',+ isExpanded: false,+ isSubmitting: submitting,+ isLatestMessage: true,+ }}+ >+ <Markdown content={content} isLatestMessage={true} />+ </MessageContext.Provider>+);++const StreamingMarkdown = ({ content }: { content: string }) => (+ <LiveMarkdown content={content} submitting={true} />+);++/** A message the conversation opened with, already finished. */+const SettledMarkdown = ({ content }: { content: string }) => (+ <Markdown content={content} isLatestMessage={false} />+);+/*** The whole-message renderer emits whitespace-only text nodes ("\n") between* top-level block elements; the per-block renderer parses each block in@@ -95,6 +153,22 @@ const streamThrough = (return container;};+/** Streams a message line by line as the latest one, then finishes it. */+const streamAndFinish = (content: string) => {+ const view = (value: string, submitting: boolean) => (+ <TestProviders>+ <LiveMarkdown content={value} submitting={submitting} />+ </TestProviders>+ );+ const lines = content.split('\n');+ const rendered = render(view(lines[0], true));+ for (let i = 2; i <= lines.length; i += 1) {+ rendered.rerender(view(lines.slice(0, i).join('\n'), true));+ }+ rendered.rerender(view(content, false));+ return rendered;+};+const MIXED = ['Intro paragraph.','',@@ -135,9 +209,10 @@ const EXPECTED = [{ idx: '3', lang: 'ts' },];-const NewMarkdown = ({ content }: { content: string }) => (- <Markdown content={content} isLatestMessage={false} />-);+beforeEach(() => {+ splitSpy.mockClear();+ mockCodeBlockMounts.count = 0;+});describe('MarkdownBlocks code-block index parity', () => {it('assigns document-order indices on a direct render (matches whole-message renderer)', () => {@@ -148,7 +223,7 @@ describe('MarkdownBlocks code-block index parity', () => {);const { container: newC } = render(<TestProviders>- <Markdown content={MIXED} isLatestMessage={false} />+ <SettledMarkdown content={MIXED} /></TestProviders>,);@@ -158,47 +233,166 @@ describe('MarkdownBlocks code-block index parity', () => {it('keeps indices correct across a simulated stream (no drift under memoization)', () => {const oldC = streamThrough(OldMarkdown, MIXED);- const newC = streamThrough(NewMarkdown, MIXED);+ const newC = streamThrough(StreamingMarkdown, MIXED);expect(indicesIn(oldC)).toEqual(EXPECTED);expect(indicesIn(newC)).toEqual(EXPECTED);});it('streamed indices match a fresh direct render (stable for stored execution results)', () => {- const streamed = streamThrough(NewMarkdown, MIXED);+ const streamed = streamThrough(StreamingMarkdown, MIXED);const { container: fresh } = render(<TestProviders>- <Markdown content={MIXED} isLatestMessage={false} />+ <SettledMarkdown content={MIXED} /></TestProviders>,);expect(indicesIn(streamed)).toEqual(indicesIn(fresh));});- it('refreshes indices when an in-place edit inserts a code block before existing ones', () => {- const before = 'intro\n\n```js\na\n```';- const after = '```py\nx\n```\n\n```js\na\n```';- const { container, rerender } = render(+ /**+ * Code blocks capture their index when they mount. A finished message moves to+ * per-block rendering on its first edit, and per block the base-aware keys+ * remount the blocks an edit shifted. The fixture turns a Mermaid fence, which+ * takes no code index, into an executable one, so the js block keeps a stale+ * index unless it really remounts.+ */+ it.each([+ ['a finished', false],+ ['a streamed', true],+ ])(+ 'refreshes indices when an in-place edit to %s message inserts a code block before existing ones',+ (_label, streamedFirst) => {+ const before = '```mermaid\ngraph TD\n```\n\n```js\na\n```';+ const after = '```py\nx\n```\n\n```js\na\n```';+ const view = (content: string, submitting: boolean) => (+ <TestProviders>+ <LiveMarkdown content={content} submitting={submitting} />+ </TestProviders>+ );+ const { container, rerender } = render(view(before, streamedFirst));+ rerender(view(before, false));+ expect(indicesIn(container)).toEqual([{ idx: '0', lang: 'js' }]);++ rerender(view(after, false));+ // The js block's index shifted 0 -> 1; without forcing a remount its ref-cached+ // index would stay 0 (duplicating py). It must become 1.+ expect(indicesIn(container)).toEqual([+ { idx: '0', lang: 'py' },+ { idx: '1', lang: 'js' },+ ]);+ },+ );+});++describe('MarkdownBlocks finished and streamed messages', () => {+ const PROSE = '# H\n\nPara with `code`.\n\n| x | y |\n| - | - |\n| 1 | 2 |\n\n- a\n- b';++ it('renders a finished message through one pipeline, without the block-boundary parse', () => {+ const { container: oldC } = render(<TestProviders>- <Markdown content={before} isLatestMessage={false} />+ <OldMarkdown content={PROSE} />+ </TestProviders>,+ );+ const { container: settledC } = render(+ <TestProviders>+ <SettledMarkdown content={PROSE} /></TestProviders>,);- expect(indicesIn(container)).toEqual([{ idx: '0', lang: 'js' }]);- rerender(+ expect(splitSpy).not.toHaveBeenCalled();+ // One pipeline reproduces the whole-message renderer exactly, down to the+ // whitespace between blocks that separately parsed blocks cannot carry.+ expect(settledC.innerHTML).toBe(oldC.innerHTML);+ });++ it('splits the message that is generating, so only its last block re-parses', () => {+ render(<TestProviders>- <Markdown content={after} isLatestMessage={false} />+ <StreamingMarkdown content={PROSE} /></TestProviders>,);- // The js block's base shifted 0 -> 1; without forcing a remount its ref-cached- // index would stay 0 (duplicating py). It must become 1.- expect(indicesIn(container)).toEqual([- { idx: '0', lang: 'py' },- { idx: '1', lang: 'js' },- ]);++ expect(splitSpy).toHaveBeenCalledWith(PROSE);+ });++ it('keeps a streamed message split once it finishes, so no block remounts', () => {+ const view = (content: string, submitting: boolean) => (+ <TestProviders>+ <LiveMarkdown content={content} submitting={submitting} />+ </TestProviders>+ );+ const lines = MIXED.split('\n');+ const { container, rerender } = render(view(lines[0], true));+ for (let i = 2; i <= lines.length; i += 1) {+ rerender(view(lines.slice(0, i).join('\n'), true));+ }+ const mountsWhileStreaming = mockCodeBlockMounts.count;+ splitSpy.mockClear();++ rerender(view(MIXED, false));++ expect(mockCodeBlockMounts.count).toBe(mountsWhileStreaming);+ expect(splitSpy).not.toHaveBeenCalled();+ expect(indicesIn(container)).toEqual(EXPECTED);+ });++ /**+ * Moving to per-block rendering remounts the message once, since the two paths+ * build different trees; it happens as generation starts, so the fade baseline+ * is set on the blocks it mounts. After that the message never remounts again.+ */+ it('moves a finished message to per-block rendering once when it starts generating again', () => {+ const view = (content: string, submitting: boolean) => (+ <TestProviders>+ <LiveMarkdown content={content} submitting={submitting} />+ </TestProviders>+ );+ const opening = MIXED.split('\n').slice(0, 12).join('\n');+ const { container, rerender } = render(view(opening, false));+ expect(splitSpy).not.toHaveBeenCalled();+ const mountsAtOpen = mockCodeBlockMounts.count;++ rerender(view(opening, true));+ expect(splitSpy).toHaveBeenCalledWith(opening);+ expect(mockCodeBlockMounts.count).toBe(mountsAtOpen * 2);++ // A generation that stops before producing anything must not move it back.+ rerender(view(opening, false));+ expect(mockCodeBlockMounts.count).toBe(mountsAtOpen * 2);++ const mountsOnceSplit = mockCodeBlockMounts.count;+ rerender(view(MIXED, true));+ rerender(view(MIXED, false));+ expect(indicesIn(container)).toEqual(EXPECTED);+ expect(mockCodeBlockMounts.count - mountsOnceSplit).toBe(EXPECTED.length - mountsAtOpen);+ });++ /**+ * An artifact editor saves the message it lives in every few hundred+ * milliseconds while the user types. Only the first save may remount the+ * message; after it, a save re-renders just the block it touched.+ */+ it('moves a finished message to per-block rendering on its first edit, and edits in place after it', () => {+ const view = (content: string) => (+ <TestProviders>+ <SettledMarkdown content={content} />+ </TestProviders>+ );+ const { container, rerender } = render(view(MIXED));+ expect(splitSpy).not.toHaveBeenCalled();+ const mountsAtOpen = mockCodeBlockMounts.count;++ rerender(view(MIXED.replace('Intro paragraph.', 'Intro paragraph, edited.')));+ expect(mockCodeBlockMounts.count).toBe(mountsAtOpen * 2);++ rerender(view(MIXED.replace('Intro paragraph.', 'Intro paragraph, edited twice.')));+ rerender(view(MIXED.replace('Some `inline` code here.', 'Some edited `inline` code.')));+ expect(mockCodeBlockMounts.count).toBe(mountsAtOpen * 2);+ expect(indicesIn(container)).toEqual(EXPECTED);});});-describe('MarkdownBlocks DOM equivalence (non-code blocks)', () => {+describe('MarkdownBlocks DOM equivalence', () => {const cases: Array<[string, string]> = [['paragraphs', 'First paragraph.\n\nSecond paragraph.'],['gfm table', ['| a | b |', '| - | - |', '| 1 | 2 |', '| 3 | 4 |'].join('\n')],@@ -208,6 +402,37 @@ describe('MarkdownBlocks DOM equivalence (non-code blocks)', () => {['blockquote', '> quoted line one\n> quoted line two'],['inline code', 'Use the `useMemo` hook for memoization.'],['mixed', '# H\n\nPara with `code`.\n\n| x | y |\n| - | - |\n| 1 | 2 |\n\n- a\n- b'],+ /* A fence indented too little to belong to item 10 is a top-level block whose+ * indentation the whole-message parse strips from every code line. */+ [+ 'fence indented under a two-digit list item',+ [+ '9. Build:',+ '',+ ' make',+ '',+ '10. Run the tests:',+ '',+ ' ```python',+ ' def test():',+ ' assert True',+ ' ```',+ ].join('\n'),+ ],+ [+ 'list indented by two spaces',+ [+ ' - Step one',+ '',+ ' Note: run this',+ '',+ ' - Step two',+ '',+ ' ```python',+ ' print(1)',+ ' ```',+ ].join('\n'),+ ],];it.each(cases)('renders identical DOM to the whole-message renderer: %s', (_label, content) => {@@ -216,12 +441,14 @@ describe('MarkdownBlocks DOM equivalence (non-code blocks)', () => {<OldMarkdown content={content} /></TestProviders>,);- const { container: newC } = render(+ const { container: settledC } = render(<TestProviders>- <Markdown content={content} isLatestMessage={false} />+ <SettledMarkdown content={content} /></TestProviders>,);- expect(normalizeHtml(newC.innerHTML)).toBe(normalizeHtml(oldC.innerHTML));+ const { container: streamedC } = streamAndFinish(content);+ expect(normalizeHtml(settledC.innerHTML)).toBe(normalizeHtml(oldC.innerHTML));+ expect(normalizeHtml(streamedC.innerHTML)).toBe(normalizeHtml(oldC.innerHTML));});});@@ -238,27 +465,48 @@ describe('MarkdownBlocks rendering smoke', () => {it('renders executable code blocks for a multi-code message', () => {render(<TestProviders>- <Markdown content={MIXED} isLatestMessage={false} />+ <SettledMarkdown content={MIXED} /></TestProviders>,);expect(screen.getAllByTestId('cb')).toHaveLength(4);});});-describe('MarkdownBlocks document-level definitions', () => {+/**+ * Constructs that need the whole document render as one block on both paths: a+ * finished message always does, and the splitter falls back to it for a message+ * that streamed.+ */+describe.each([+ ['a finished', false],+ ['a streamed', true],+])('MarkdownBlocks document-level constructs in %s message', (_label, streamed) => {+ const renderMessage = (content: string) =>+ streamed+ ? streamAndFinish(content)+ : render(+ <TestProviders>+ <SettledMarkdown content={content} />+ </TestProviders>,+ );+it('resolves a reference-style link whose definition is in a separate block', () => {- const queryClient = new QueryClient();const content = 'See [docs][d] for details.\n\n[d]: https://example.com/docs';- render(- <QueryClientProvider client={queryClient}>- <TestProviders>- <Markdown content={content} isLatestMessage={false} />- </TestProviders>- </QueryClientProvider>,- );- expect(screen.getByRole('link', { name: 'docs' })).toHaveAttribute(+ const { container } = renderMessage(content);+ expect(within(container).getByRole('link', { name: 'docs' })).toHaveAttribute('href','https://example.com/docs',);});++ it('keeps the separator between adjacent raw HTML blocks', () => {+ const content = '<div>one</div>\n\n<div>two</div>';+ const { container: oldC } = render(+ <TestProviders>+ <OldMarkdown content={content} />+ </TestProviders>,+ );+ const { container } = renderMessage(content);+ expect(container.innerHTML).toBe(oldC.innerHTML);+ });});diff --git a/client/src/components/Chat/Messages/Content/__tests__/MermaidBlockIds.test.tsx b/client/src/components/Chat/Messages/Content/__tests__/MermaidBlockIds.test.tsxindex 9d31ba34e0..829a8d8577 100644--- a/client/src/components/Chat/Messages/Content/__tests__/MermaidBlockIds.test.tsx+++ b/client/src/components/Chat/Messages/Content/__tests__/MermaidBlockIds.test.tsx@@ -25,59 +25,102 @@ jest.mock('~/components/Messages/Content/CodeBlock', () => ({),}));-const renderMarkdown = (content: string) =>- render(- <MarkdownBlocks- content={content}- remarkPlugins={getRemarkPlugins()}- rehypePlugins={getRehypePlugins()}- components={getMarkdownComponents()}- />,- );+const view = (content: string, streaming: boolean) => (+ <MarkdownBlocks+ content={content}+ streaming={streaming}+ remarkPlugins={getRemarkPlugins()}+ rehypePlugins={getRehypePlugins()}+ components={getMarkdownComponents()}+ />+);++const renderMarkdown = (content: string, streaming: boolean) => render(view(content, streaming));const mermaidIds = () =>screen.getAllByTestId('mermaid').map((element) => element.getAttribute('data-mermaid-id'));describe('Mermaid block ids', () => {- it('gives each Mermaid fence in a message a distinct id', () => {- renderMarkdown(- ['```mermaid', 'graph TD', 'A-->B', '```', '', '```mermaid', 'graph TD', 'C-->D', '```'].join(- '\n',- ),- );+ /** A finished message renders as one pipeline and a streaming one per block; both number alike. */+ describe.each([+ ['a finished', false],+ ['a streaming', true],+ ])('in %s message', (_label, streaming) => {+ it('gives each Mermaid fence in a message a distinct id', () => {+ renderMarkdown(+ [+ '```mermaid',+ 'graph TD',+ 'A-->B',+ '```',+ '',+ '```mermaid',+ 'graph TD',+ 'C-->D',+ '```',+ ].join('\n'),+ streaming,+ );- const ids = mermaidIds();- expect(ids).toHaveLength(2);- expect(new Set(ids).size).toBe(2);- });+ const ids = mermaidIds();+ expect(ids).toHaveLength(2);+ expect(new Set(ids).size).toBe(2);+ });- it('keeps Mermaid ids distinct across intervening executable code blocks', () => {- renderMarkdown(- [- '```mermaid',- 'graph TD',- 'A-->B',- '```',- '',- '```python',- 'print("hi")',- '```',- '',- '```mermaid',- 'graph TD',- 'C-->D',- '```',- '',- '```mermaid',- 'graph TD',- 'E-->F',- '```',- ].join('\n'),- );+ it('keeps Mermaid ids distinct across intervening executable code blocks', () => {+ renderMarkdown(+ [+ '```mermaid',+ 'graph TD',+ 'A-->B',+ '```',+ '',+ '```python',+ 'print("hi")',+ '```',+ '',+ '```mermaid',+ 'graph TD',+ 'C-->D',+ '```',+ '',+ '```mermaid',+ 'graph TD',+ 'E-->F',+ '```',+ ].join('\n'),+ streaming,+ );++ const ids = mermaidIds();+ expect(ids).toHaveLength(3);+ expect(new Set(ids).size).toBe(3);+ });++ it('does not let a Mermaid fence disturb executable code block indices', () => {+ renderMarkdown(+ [+ '```python',+ 'print("first")',+ '```',+ '',+ '```mermaid',+ 'graph TD',+ 'A-->B',+ '```',+ '',+ '```python',+ 'print("second")',+ '```',+ ].join('\n'),+ streaming,+ );- const ids = mermaidIds();- expect(ids).toHaveLength(3);- expect(new Set(ids).size).toBe(3);+ const indices = screen+ .getAllByTestId('code-block')+ .map((element) => element.getAttribute('data-block-index'));+ expect(indices).toEqual(['0', '1']);+ });});/**@@ -102,46 +145,13 @@ describe('Mermaid block ids', () => {].join('\n');const listStillGrowing = [listWithTwo, '', '- step three'].join('\n');- const { rerender } = renderMarkdown(listWithOne);+ const { rerender } = renderMarkdown(listWithOne, true);expect(mermaidIds()).toEqual(['mermaid-0']);- const view = (content: string) => (- <MarkdownBlocks- content={content}- remarkPlugins={getRemarkPlugins()}- rehypePlugins={getRehypePlugins()}- components={getMarkdownComponents()}- />- );-- rerender(view(listWithTwo));+ rerender(view(listWithTwo, true));expect(mermaidIds()).toEqual(['mermaid-0', 'mermaid-1']);- rerender(view(listStillGrowing));+ rerender(view(listStillGrowing, true));expect(mermaidIds()).toEqual(['mermaid-0', 'mermaid-1']);});-- it('does not let a Mermaid fence disturb executable code block indices', () => {- renderMarkdown(- [- '```python',- 'print("first")',- '```',- '',- '```mermaid',- 'graph TD',- 'A-->B',- '```',- '',- '```python',- 'print("second")',- '```',- ].join('\n'),- );-- const indices = screen- .getAllByTestId('code-block')- .map((element) => element.getAttribute('data-block-index'));- expect(indices).toEqual(['0', '1']);- });});diff --git a/client/src/components/Chat/Messages/Content/__tests__/splitMarkdown.test.ts b/client/src/components/Chat/Messages/Content/__tests__/splitMarkdown.test.tsindex 100a984f47..5aed247c15 100644--- a/client/src/components/Chat/Messages/Content/__tests__/splitMarkdown.test.ts+++ b/client/src/components/Chat/Messages/Content/__tests__/splitMarkdown.test.ts@@ -39,6 +39,12 @@ describe('splitMarkdownIntoBlocks', () => {expect(raws(content)).toEqual(['Lead.', artifact, 'Tail.']);});+ it("keeps a top-level block's indentation, which decides how it parses", () => {+ const fence = [' ```python', ' def test():', ' assert True', ' ```'].join('\n');+ const content = ['9. Build:', '', ' make', '', '10. Run the tests:', '', fence].join('\n');+ expect(raws(content)).toEqual([content.slice(0, content.indexOf('\n\n ```')), fence]);+ });+it('keeps a list as one block (does not split items)', () => {const list = '- one\n- two\n- three';expect(raws(list)).toEqual([list]);diff --git a/client/src/components/Chat/Messages/Content/splitMarkdown.ts b/client/src/components/Chat/Messages/Content/splitMarkdown.tsindex 21f8e75b67..2fc3d6d0f6 100644--- a/client/src/components/Chat/Messages/Content/splitMarkdown.ts+++ b/client/src/components/Chat/Messages/Content/splitMarkdown.ts@@ -101,6 +101,18 @@ const parseToMdast = (content: string): MdastNode =>mdastExtensions: [gfmFromMarkdown(), directiveFromMarkdown(), mathFromMarkdown()],}) as MdastNode;+/**+ * Where the line holding a top-level block begins, when only indentation precedes+ * the block on it. mdast starts a node after its indentation, but that indentation+ * carries meaning: it is stripped from an indented fence's code lines, and it+ * decides which list item a later indented line belongs to. A block parsed on its+ * own has to keep it to parse the way it does inside the whole message.+ */+const lineStartOf = (content: string, offset: number): number => {+ const lineStart = content.lastIndexOf('\n', offset - 1) + 1;+ return /^[ \t]*$/.test(content.slice(lineStart, offset)) ? lineStart : offset;+};+/*** Split a markdown string into its top-level blocks, returning the exact source* slice for each block plus the index counts it consumes. Completed blocks@@ -149,7 +161,7 @@ export function splitMarkdownIntoBlocks(content: string): MarkdownBlock[] {const counts = { code: 0, artifact: 0, mermaid: 0 };countWithin(node, counts);blocks.push({- raw: content.slice(start, end),+ raw: content.slice(lineStartOf(content, start), end),codeBlockCount: counts.code,artifactCount: counts.artifact,mermaidCount: counts.mermaid,diff --git a/client/src/components/Chat/Messages/MessageParts.tsx b/client/src/components/Chat/Messages/MessageParts.tsxindex eaacbc8d88..64c1b9d1f4 100644--- a/client/src/components/Chat/Messages/MessageParts.tsx+++ b/client/src/components/Chat/Messages/MessageParts.tsx@@ -10,7 +10,7 @@ import {getHeaderPrefixForScreenReader,} from '~/utils';import { useLocalize, useAttachments, useMessageHelpers, useContentMetadata } from '~/hooks';-import AuthorHeader from '~/components/Chat/Messages/Content/Parts/AuthorHeader';+import ResumeAuthorHeader from '~/components/Chat/Messages/Content/Parts/ResumeAuthorHeader';import { ErrorSourceProvider } from '~/components/Messages/Content/Error/source';import { getHeaderHoverLabel } from '~/components/Chat/Messages/ui/HeaderLabel';import { revealOnRowHoverClasses, messageFooterClasses } from './styles';@@ -20,10 +20,17 @@ import { showThinkingAtom } from '~/store/showThinking';import Elapsed, { shouldShowElapsed } from './Elapsed';import ContentParts from './Content/ContentParts';import SiblingSwitch from './SiblingSwitch';+import { AuthorContext } from '~/Providers';import HoverButtons from './HoverButtons';import SubRow from './SubRow';import store from '~/store';+/**+ * The one header every assistant message hands its parts. It reads the author from+ * `AuthorContext`, so the author resolving after paint cannot break the parts' memo.+ */+const RESUME_AUTHOR_HEADER = <ResumeAuthorHeader />;+function MessageParts(props: TMessageProps) {const localize = useLocalize();const { message, siblingIdx, siblingCount, setSiblingIdx } = props;@@ -86,15 +93,12 @@ function MessageParts(props: TMessageProps) {],);- const authorHeader = useMemo(- () =>- isCreatedByUser === true ? undefined : (- <AuthorHeader- icon={<MessageIcon iconData={iconData} assistant={assistant} agent={agent} />}- label={name}- />- ),- [isCreatedByUser, iconData, assistant, agent, name],+ const author = useMemo(+ () => ({+ icon: <MessageIcon iconData={iconData} assistant={assistant} agent={agent} />,+ label: name,+ }),+ [iconData, assistant, agent, name],);const { hasParallelContent } = useContentMetadata(message);@@ -112,8 +116,8 @@ function MessageParts(props: TMessageProps) {<div className="m-auto justify-center px-4 py-3 sm:px-0"><MessageRowid={messageId ?? ''}- icon={<MessageIcon iconData={iconData} assistant={assistant} agent={agent} />}- label={name}+ icon={author.icon}+ label={author.label}hoverLabel={getHeaderHoverLabel(hasConfiguredSender,agent?.model,@@ -169,26 +173,28 @@ function MessageParts(props: TMessageProps) {</SubRow>}>- <ErrorSourceProvider message={message}>- <ContentParts- edit={edit}- isLast={isLast}- enterEdit={enterEdit}- siblingIdx={siblingIdx}- attachments={attachments}- isSubmitting={isSubmitting}- searchResults={searchResults}- manualSkills={message.manualSkills}- messageId={message.messageId}- authorHeader={authorHeader}- setSiblingIdx={setSiblingIdx}- isCreatedByUser={message.isCreatedByUser}- conversationId={conversation?.conversationId}- showThinking={showThinking}- isLatestMessage={messageId === latestMessageId}- content={message.content as Array<TMessageContentParts | undefined>}- />- </ErrorSourceProvider>+ <AuthorContext.Provider value={author}>+ <ErrorSourceProvider message={message}>+ <ContentParts+ edit={edit}+ isLast={isLast}+ enterEdit={enterEdit}+ siblingIdx={siblingIdx}+ attachments={attachments}+ isSubmitting={isSubmitting}+ searchResults={searchResults}+ manualSkills={message.manualSkills}+ messageId={message.messageId}+ authorHeader={isCreatedByUser === true ? undefined : RESUME_AUTHOR_HEADER}+ setSiblingIdx={setSiblingIdx}+ isCreatedByUser={message.isCreatedByUser}+ conversationId={conversation?.conversationId}+ showThinking={showThinking}+ isLatestMessage={messageId === latestMessageId}+ content={message.content as Array<TMessageContentParts | undefined>}+ />+ </ErrorSourceProvider>+ </AuthorContext.Provider></MessageRow></div></div>diff --git a/client/src/components/Messages/ContentRender.tsx b/client/src/components/Messages/ContentRender.tsxindex c3b954583d..e2dba90a29 100644--- a/client/src/components/Messages/ContentRender.tsx+++ b/client/src/components/Messages/ContentRender.tsx@@ -12,8 +12,8 @@ import {} from '~/utils';import { revealOnRowHoverClasses, messageFooterClasses } from '~/components/Chat/Messages/styles';import { useLocalize, useAttachments, useMessageActions, useContentMetadata } from '~/hooks';+import ResumeAuthorHeader from '~/components/Chat/Messages/Content/Parts/ResumeAuthorHeader';import ToolCallLimitNotice from '~/components/Chat/Messages/Content/ToolCallLimitNotice';-import AuthorHeader from '~/components/Chat/Messages/Content/Parts/AuthorHeader';import { ErrorSourceProvider } from '~/components/Messages/Content/Error/source';import Elapsed, { shouldShowElapsed } from '~/components/Chat/Messages/Elapsed';import { getHeaderHoverLabel } from '~/components/Chat/Messages/ui/HeaderLabel';@@ -24,8 +24,15 @@ import MessageRow from '~/components/Chat/Messages/ui/MessageRow';import MessageIcon from '~/components/Chat/Messages/MessageIcon';import { showThinkingAtom } from '~/store/showThinking';import SubRow from '~/components/Chat/Messages/SubRow';+import { AuthorContext } from '~/Providers';import store from '~/store';+/**+ * The one header every assistant message hands its parts. It reads the author from+ * `AuthorContext`, so the author resolving after paint cannot break the parts' memo.+ */+const RESUME_AUTHOR_HEADER = <ResumeAuthorHeader />;+type ContentRenderProps = {message?: TMessage;/**@@ -138,15 +145,12 @@ const ContentRender = memo(function ContentRender({],);- const authorHeader = useMemo(- () =>- msg?.isCreatedByUser === true ? undefined : (- <AuthorHeader- icon={<MessageIcon iconData={iconData} assistant={assistant} agent={agent} />}- label={messageLabel ?? ''}- />- ),- [msg?.isCreatedByUser, iconData, assistant, agent, messageLabel],+ const author = useMemo(+ () => ({+ icon: <MessageIcon iconData={iconData} assistant={assistant} agent={agent} />,+ label: messageLabel ?? '',+ }),+ [iconData, assistant, agent, messageLabel],);const { hasParallelContent } = useContentMetadata(msg);@@ -158,8 +162,8 @@ const ContentRender = memo(function ContentRender({return (<MessageRowid={msg.messageId}- icon={<MessageIcon iconData={iconData} assistant={assistant} agent={agent} />}- label={messageLabel ?? ''}+ icon={author.icon}+ label={author.label}hoverLabel={getHeaderHoverLabel(hasConfiguredSender,agent?.model,@@ -214,27 +218,29 @@ const ContentRender = memo(function ContentRender({</SubRow>}>- <ErrorSourceProvider message={msg}>- <ContentParts- edit={edit}- isLast={isLast}- enterEdit={enterEdit}- siblingIdx={siblingIdx}- messageId={msg.messageId}- attachments={attachments}- searchResults={searchResults}- manualSkills={msg.manualSkills}- authorHeader={authorHeader}- setSiblingIdx={setSiblingIdx}- isLatestMessage={isLatestMessage}- isSubmitting={isSubmitting}- isCreatedByUser={msg.isCreatedByUser}- createdAt={msg.createdAt ?? msg.clientTimestamp}- showThinking={showThinking}- conversationId={conversation?.conversationId}- content={msg.content as Array<TMessageContentParts | undefined>}- />- </ErrorSourceProvider>+ <AuthorContext.Provider value={author}>+ <ErrorSourceProvider message={msg}>+ <ContentParts+ edit={edit}+ isLast={isLast}+ enterEdit={enterEdit}+ siblingIdx={siblingIdx}+ messageId={msg.messageId}+ attachments={attachments}+ searchResults={searchResults}+ manualSkills={msg.manualSkills}+ authorHeader={msg.isCreatedByUser === true ? undefined : RESUME_AUTHOR_HEADER}+ setSiblingIdx={setSiblingIdx}+ isLatestMessage={isLatestMessage}+ isSubmitting={isSubmitting}+ isCreatedByUser={msg.isCreatedByUser}+ createdAt={msg.createdAt ?? msg.clientTimestamp}+ showThinking={showThinking}+ conversationId={conversation?.conversationId}+ content={msg.content as Array<TMessageContentParts | undefined>}+ />+ </ErrorSourceProvider>+ </AuthorContext.Provider>{/** A turn that ran out of agent steps is incomplete, not broken. Rendered* here rather than inside `ContentParts` because it is a message-level* outcome, and `ContentParts` also serves surfaces (subagent panels,diff --git a/client/src/components/Messages/__tests__/ContentRender.test.tsx b/client/src/components/Messages/__tests__/ContentRender.test.tsxnew file mode 100644index 0000000000..2af2d9351b--- /dev/null+++ b/client/src/components/Messages/__tests__/ContentRender.test.tsx@@ -0,0 +1,170 @@+import React from 'react';+import { RecoilRoot } from 'recoil';+import { render, screen, within } from '@testing-library/react';+import type { Agent, TConversation, TMessage } from 'librechat-data-provider';+import type { TMessageChatContext } from '~/common';+import ContentRender from '../ContentRender';++const mockRenders = { parts: 0 };++/**+ * Memoized like the real parts tree with its default comparator, and rendering the+ * resume header it is handed where a steer would place it.+ */+jest.mock('~/components/Chat/Messages/Content/ContentParts', () => {+ const { memo } = jest.requireActual<typeof import('react')>('react');+ return {+ __esModule: true,+ default: memo(function MockContentParts({ authorHeader }: { authorHeader?: React.ReactNode }) {+ mockRenders.parts += 1;+ return <div data-testid="parts">{authorHeader}</div>;+ }),+ };+});++jest.mock('~/components/Chat/Messages/MessageIcon', () => ({+ __esModule: true,+ default: ({ agent }: { agent?: { name?: string } }) => (+ <span data-testid="message-icon" data-agent={agent?.name ?? ''} />+ ),+}));++jest.mock('~/components/Chat/Messages/HoverButtons', () => ({+ __esModule: true,+ default: () => null,+}));++jest.mock('~/components/Chat/Messages/ui/MessageTimestamp', () => ({+ __esModule: true,+ default: () => null,+}));++/**+ * Stands in for the agents map: `useMessageActions` reads it through context, so the+ * agents list landing re-renders the memoized row without any new props.+ */+const mockAgentContext = React.createContext<Agent | undefined>(undefined);+const mockActions = {+ enterEdit: jest.fn(),+ handleContinue: jest.fn(),+ handleFeedback: jest.fn(),+ copyToClipboard: jest.fn(),+ getCanCopy: jest.fn(() => true),+ regenerateMessage: jest.fn(),+};++jest.mock('~/hooks', () => ({+ useLocalize: () => (key: string) => key,+ useAttachments: () => ({ attachments: undefined, searchResults: undefined }),+ useContentMetadata: () => ({ hasParallelContent: false }),+ useMessageActions: ({+ message,+ chatContext,+ }: {+ message?: TMessage;+ chatContext: TMessageChatContext;+ }) => {+ const { useContext } = jest.requireActual<typeof import('react')>('react');+ const agent = useContext(mockAgentContext);+ return {+ ...mockActions,+ edit: false,+ index: chatContext.index,+ agent,+ assistant: undefined,+ conversation: chatContext.conversation,+ messageLabel: agent?.name ?? message?.sender,+ latestMessageId: chatContext.latestMessageId,+ latestMessageDepth: chatContext.latestMessageDepth,+ hasConfiguredSender: false,+ };+ },+}));++const conversation = {+ conversationId: 'convo-1',+ endpoint: 'agents',+ agent_id: 'agent_lia',+} as TConversation;++const chatContext: TMessageChatContext = {+ ask: jest.fn(),+ index: 0,+ regenerate: jest.fn(),+ conversation,+ latestMessageId: 'user-1',+ latestMessageDepth: 1,+ handleContinue: jest.fn(),+ feedbackEnabled: false,+ isSubmitting: false,+};++const assistantMessage = {+ messageId: 'assistant-1',+ parentMessageId: 'user-1',+ conversationId: conversation.conversationId,+ sender: 'agent_lia',+ isCreatedByUser: false,+ text: '',+ content: [{ type: 'text', text: 'Done.' }],+ createdAt: '2026-09-17T00:00:00.000Z',+} as TMessage;++const lia = { id: 'agent_lia', name: 'Lia' } as Agent;+const setSiblingIdx = jest.fn();+const setCurrentEditId = jest.fn();++/** Renders one row with no agent resolved yet, and lets the test land the agents list. */+const renderRow = (message: TMessage) => {+ const view = (agent?: Agent) => (+ <RecoilRoot>+ <mockAgentContext.Provider value={agent}>+ <ContentRender+ message={message}+ chatContext={chatContext}+ siblingIdx={0}+ siblingCount={1}+ setSiblingIdx={setSiblingIdx}+ currentEditId={null}+ setCurrentEditId={setCurrentEditId}+ />+ </mockAgentContext.Provider>+ </RecoilRoot>+ );+ const result = render(view());+ return { ...result, resolveAgent: (agent: Agent) => result.rerender(view(agent)) };+};++describe('ContentRender resume author header', () => {+ beforeEach(() => {+ mockRenders.parts = 0;+ });++ it('keeps the parts tree from re-rendering when the agent resolves after paint', () => {+ const { resolveAgent } = renderRow(assistantMessage);+ const partsRendersAtPaint = mockRenders.parts;++ resolveAgent(lia);++ // The row itself did re-render: its own header now names the agent.+ expect(screen.getAllByTestId('message-icon')[0]).toHaveAttribute('data-agent', 'Lia');+ expect(mockRenders.parts).toBe(partsRendersAtPaint);+ });++ it('still restates the resolved author inside the message', () => {+ const { resolveAgent } = renderRow(assistantMessage);+ const parts = screen.getByTestId('parts');+ expect(within(parts).getByRole('heading', { level: 2 })).toHaveTextContent('agent_lia');++ resolveAgent(lia);++ expect(within(parts).getByRole('heading', { level: 2 })).toHaveTextContent('Lia');+ expect(within(parts).getByTestId('message-icon')).toHaveAttribute('data-agent', 'Lia');+ });++ it('hands a user message no resume header', () => {+ renderRow({ ...assistantMessage, messageId: 'user-2', isCreatedByUser: true });++ expect(screen.getByTestId('parts')).toBeEmptyDOMElement();+ });+});