diff --git a/client/src/components/Chat/Messages/Content/__tests__/animate.test.tsx b/client/src/components/Chat/Messages/Content/__tests__/animate.test.tsx index da4382753d..9fcc54fb2e 100644 --- a/client/src/components/Chat/Messages/Content/__tests__/animate.test.tsx +++ b/client/src/components/Chat/Messages/Content/__tests__/animate.test.tsx @@ -261,4 +261,139 @@ describe('AnimatedText', () => { ); expect(animated).toEqual(['appended', 'tail']); }); + + it('collapses the settled prefix into one text node and only renders the tail per word', () => { + const settle = FADE_DURATION_MS + FADE_STAGGER_MAX_MS + 1; + const base = Array.from({ length: 40 }, (_, i) => `w${i}`).join(' '); + const { container, rerender } = render(); + + setTime(settle); + rerender(); + setTime(settle * 2); + rerender(); + + const [first, ...rest] = Array.from(container.childNodes); + expect(first.nodeType).toBe(Node.TEXT_NODE); + expect(first.textContent).toBe(`${base} `); + expect(rest.length).toBeLessThanOrEqual(2); + const animated = Array.from(container.querySelectorAll('span[data-lc-fade]')).map((span) => + span.textContent?.trim(), + ); + expect(animated).toEqual(['one']); + expect(container.textContent).toBe(`${base} next one`); + }); + + it('keeps the last word out of the settled prefix so it can keep growing', () => { + const settle = FADE_DURATION_MS + FADE_STAGGER_MAX_MS + 1; + const { container, rerender } = render(); + setTime(settle); + rerender(); + setTime(settle * 2); + rerender(); + + expect(container.firstChild?.textContent).toBe('alpha '); + expect(container.childNodes).toHaveLength(2); + expect(container.textContent).toBe('alpha betamax'); + }); + + it.each([ + ['a spaceless CJK run', '我们需要先分析这个问题然后给出答案'.repeat(8), '首先考虑'], + ['an unsegmented run without whitespace', 'x'.repeat(200), 'yyyy'], + ['spaced words', 'word '.repeat(60), 'more '], + ])('only classifies a bounded tail per render for %s', (_label, base, appended) => { + const settle = FADE_DURATION_MS + FADE_STAGGER_MAX_MS + 1; + const { container, rerender } = render(); + setTime(settle); + rerender(); + setTime(settle * 2); + + const execSpy = jest.spyOn(RegExp.prototype, 'exec'); + rerender(); + const classified = execSpy.mock.calls.reduce( + (longest, [input], index) => + execSpy.mock.contexts[index].source === '\\S+\\s*' + ? Math.max(longest, input.length) + : longest, + 0, + ); + execSpy.mockRestore(); + + expect(classified).toBeGreaterThan(0); + expect(classified).toBeLessThanOrEqual(64 + appended.length * 2); + expect(container.textContent).toBe(`${base}${appended}${appended}`); + }); + + it.each([ + ['ZWJ families and combining marks', ['\u{1F468}\u200D\u{1F469}\u200D\u{1F467}', 'e\u0301']], + ['skin-tone modifiers', ['\u{1F44D}\u{1F3FD}', '\u{1F44B}\u{1F3FF}']], + ['regional-indicator flags', ['\u{1F1FA}\u{1F1F8}', '\u{1F1EF}\u{1F1F5}']], + ])('never cuts the settled prefix inside a grapheme cluster: %s', (_label, clusters) => { + const settle = FADE_DURATION_MS + FADE_STAGGER_MAX_MS + 1; + let text = clusters.join('').repeat(40); + const { container, rerender } = render(); + for (let step = 1; step <= 12; step++) { + setTime(settle * step); + text += step % 3 === 0 ? 'x' : clusters[step % clusters.length]; + rerender(); + const first = container.firstChild?.textContent ?? ''; + expect(first.length).toBeGreaterThan(0); + const units = Array.from( + new Intl.Segmenter(undefined, { granularity: 'grapheme' }).segment(text), + ); + expect(units.some((unit) => unit.index === first.length)).toBe(true); + } + expect(container.textContent).toBe(text); + }); + + it('does not cut inside a spaceless run when Intl.Segmenter is unavailable', () => { + const settle = FADE_DURATION_MS + FADE_STAGGER_MAX_MS + 1; + const segmenter = Intl.Segmenter; + const flags = '\u{1F1FA}\u{1F1F8}\u{1F1EF}\u{1F1F5}'; + try { + Object.defineProperty(Intl, 'Segmenter', { value: undefined, configurable: true }); + let Isolated: typeof AnimatedText = AnimatedText; + jest.isolateModules(() => { + jest.doMock('react', () => React); + Isolated = jest.requireActual('../animate').AnimatedText; + }); + let text = `a ${flags.repeat(20)}`; + const { container, rerender } = render(); + for (let step = 1; step <= 6; step++) { + setTime(settle * step); + text += step % 2 === 0 ? 'x' : flags; + rerender(); + const settledLength = container.firstChild?.textContent?.length ?? 0; + expect(settledLength).toBeLessThanOrEqual(2); + } + expect(container.textContent).toBe(text); + } finally { + Object.defineProperty(Intl, 'Segmenter', { value: segmenter, configurable: true }); + } + }); + + it('re-classifies from the start when the text no longer extends the settled prefix', () => { + const settle = FADE_DURATION_MS + FADE_STAGGER_MAX_MS + 1; + const { container, rerender } = render(); + setTime(settle); + rerender(); + setTime(settle * 2); + rerender(); + + expect(container.textContent).toBe('replaced text'); + }); + + it('renders the current characters when a rewrite keeps the probed prefix regions', () => { + const settle = FADE_DURATION_MS + FADE_STAGGER_MAX_MS + 1; + const head = 'h'.repeat(40); + const edge = 'e'.repeat(40); + const original = `${head} ${'a'.repeat(30)} ${edge} tail`; + const rewritten = `${head} ${'b'.repeat(30)} ${edge} tail more`; + const { container, rerender } = render(); + setTime(settle); + rerender(); + setTime(settle * 2); + rerender(); + + expect(container.textContent).toBe(rewritten); + }); }); diff --git a/client/src/components/Chat/Messages/Content/animate.tsx b/client/src/components/Chat/Messages/Content/animate.tsx index c295cf39d9..543deed4d2 100644 --- a/client/src/components/Chat/Messages/Content/animate.tsx +++ b/client/src/components/Chat/Messages/Content/animate.tsx @@ -64,17 +64,28 @@ const SPACELESS_REGEX = /[\u0E00-\u0EFF\u0F00-\u0FFF\u1000-\u109F\u1780-\u17FF\u2E80-\u9FFF\uAC00-\uD7AF\uF900-\uFAFF]/; let wordSegmenter: Intl.Segmenter | null | undefined; +let graphemeSegmenter: Intl.Segmenter | null | undefined; + +function createSegmenter(granularity: 'word' | 'grapheme'): Intl.Segmenter | null { + return typeof Intl !== 'undefined' && typeof Intl.Segmenter === 'function' + ? new Intl.Segmenter(undefined, { granularity }) + : null; +} function getWordSegmenter(): Intl.Segmenter | null { if (wordSegmenter === undefined) { - wordSegmenter = - typeof Intl !== 'undefined' && typeof Intl.Segmenter === 'function' - ? new Intl.Segmenter(undefined, { granularity: 'word' }) - : null; + wordSegmenter = createSegmenter('word'); } return wordSegmenter; } +function getGraphemeSegmenter(): Intl.Segmenter | null { + if (graphemeSegmenter === undefined) { + graphemeSegmenter = createSegmenter('grapheme'); + } + return graphemeSegmenter; +} + function pushSegmentedParts(parts: string[], token: string): void { const segmenter = getWordSegmenter(); if (segmenter == null) { @@ -307,30 +318,110 @@ export function createFadePlugin(hydrated = false): FadePlugin { } const DELAY_VAR = '--lc-delay'; +const WHITESPACE_REGEX = /\s/; +const PREFIX_PROBE_LENGTH = 32; +/** + * Longest trailing run kept unsettled. Bounds per-token work when the last + * word never reaches whitespace (CJK, Thai, unspaced Hangul, URLs). Only + * settled, non-animated text is cut, and it renders as plain text on both + * sides of the cut, so a cut inside a part is invisible. + */ +const MAX_UNSETTLED_LENGTH = 64; +/** + * Moves a cut offset in `tail` back to a grapheme-cluster boundary, so emoji + * modifier, flag, ZWJ and combining sequences stay whole. `tail` starts at the + * committed settled boundary, which is itself a cluster boundary, and is + * bounded by the cap, so segmenting it stays proportional to the unsettled text. + * Without a grapheme segmenter there is no safe cut, so the cap is not applied. + */ +function glyphBoundary(tail: string, index: number): number { + const segmenter = getGraphemeSegmenter(); + if (index <= 0 || segmenter == null) { + return 0; + } + let boundary = 0; + for (const segment of segmenter.segment(tail)) { + if (segment.index > index) { + break; + } + boundary = segment.index; + } + return boundary; +} + +/** Offset of the last whitespace-delimited word, which appended text can still extend. */ +function lastWordStart(value: string): number { + let index = value.length; + while (index > 0 && WHITESPACE_REGEX.test(value[index - 1])) { + index -= 1; + } + while (index > 0 && !WHITESPACE_REGEX.test(value[index - 1])) { + index -= 1; + } + return index; +} + +/** + * Whether `text` still extends the settled `prefix`. Probes only the prefix's + * head and the region at its boundary so the per-token check stays constant + * rather than rescanning the whole accumulated prefix; an append-only stream + * always passes, and a rewrite that shifts or replaces text fails a probe. The + * settled region is always rendered from the current text, so a rewrite that + * slips past the probes can only affect fade timing, never the characters shown. + */ +function extendsPrefix(text: string, prefix: string): boolean { + if (text.length < prefix.length) { + return false; + } + const probe = Math.min(PREFIX_PROBE_LENGTH, prefix.length); + const boundary = prefix.length - probe; + return ( + text.startsWith(prefix.slice(0, probe)) && text.startsWith(prefix.slice(boundary), boundary) + ); +} /** * Plain-text counterpart of the rehype plugin for non-markdown streamed text * (reasoning). Renders words in fade spans keyed by character offset; only * render this while the text is actively streaming and render the raw string - * once settled. + * once settled. Classification is append-only: the leading run of parts that + * finished fading collapses into a single committed text node and is never + * re-split, so each streamed token costs work proportional to the unsettled + * tail rather than the accumulated text. The settled boundary never passes a + * word that is still fading, and stops before the last word (which appended + * text can still extend) unless that word outgrows MAX_UNSETTLED_LENGTH. */ export const AnimatedText = memo(function AnimatedText({ text }: { text: string }) { const stateRef = useRef(null); + const settledRef = useRef(''); if (stateRef.current == null) { stateRef.current = createFadeState(); } const state = stateRef.current; + const settledLength = extendsPrefix(text, settledRef.current) ? settledRef.current.length : 0; + const settled = text.slice(0, settledLength); + const tail = text.slice(settledLength); const suppress = state.firstRun && text.length > FADE_HYDRATION_THRESHOLD; const run = beginRun(state, suppress); - const segments = classifyValue(run, text); + run.count = settledLength; + const segments = classifyValue(run, tail); stageRun(run); + const limit = Math.max( + settledLength + lastWordStart(tail), + settledLength + glyphBoundary(tail, tail.length - MAX_UNSETTLED_LENGTH), + ); + const firstAnimated = segments.find((segment) => segment.animated); + const nextSettledLength = Math.min(limit, firstAnimated?.start ?? limit); + useLayoutEffect(() => { commitRun(state); + settledRef.current = text.slice(0, nextSettledLength); }); return ( <> + {settled} {segments.map((segment) => { if (!segment.animated) { return {segment.value}; diff --git a/e2e/setup/fake-model.js b/e2e/setup/fake-model.js index cabd341e2a..30043194c5 100644 --- a/e2e/setup/fake-model.js +++ b/e2e/setup/fake-model.js @@ -36,6 +36,9 @@ const ASSERT_HISTORY_MARKER = 'E2E_ASSERT_HISTORY:'; const ASSERT_QUOTE_MARKER = 'E2E_ASSERT_QUOTE:'; const REPLY_MARKER = 'E2E_REPLY:'; const THINK_REPLY_MARKER = 'E2E_THINK_REPLY:'; +/** A reasoning part long enough that its settled prefix dwarfs the words still fading in. */ +const LONG_THINK_REPLY_MARKER = 'E2E_LONG_THINK_REPLY:'; +const LONG_THINK_WORDS = 400; const SLOW_THINK_REPLY_MARKER = 'E2E_SLOW_THINK_REPLY:'; const COUNTED_REPLY_MARKER = 'E2E_COUNTED_REPLY:'; const ORDERED_REPLY_MARKER = 'E2E_ORDERED_REPLY:'; @@ -641,6 +644,19 @@ function replyResponses(text) { }; } + const longThinkName = getMarkerValue(text, LONG_THINK_REPLY_MARKER); + if (longThinkName) { + const words = Array.from( + { length: LONG_THINK_WORDS }, + (_, index) => `r${String(index).padStart(3, '0')}`, + ); + return { + responses: [ + `E2E long reasoning ${longThinkName} ${words.join(' ')} end\n\nE2E reply ${longThinkName}`, + ], + }; + } + const countedName = getMarkerValue(text, COUNTED_REPLY_MARKER); if (countedName) { const count = (countedReplies.get(countedName) ?? 0) + 1; diff --git a/e2e/specs/mock/scenarios/long-reasoning-stream.spec.ts b/e2e/specs/mock/scenarios/long-reasoning-stream.spec.ts new file mode 100644 index 0000000000..ff144e2f98 --- /dev/null +++ b/e2e/specs/mock/scenarios/long-reasoning-stream.spec.ts @@ -0,0 +1,58 @@ +import { expect, test } from '@playwright/test'; +import { + MOCK_ENDPOINTS, + NEW_CHAT_PATH, + messagesView, + selectMockEndpoint, + sendMessage, +} from '../helpers'; + +const LONG_THINK_WORDS = 400; +const reasoningWords = Array.from( + { length: LONG_THINK_WORDS }, + (_, index) => `r${String(index).padStart(3, '0')}`, +); +const expectedReasoning = (label: string) => + `E2E long reasoning ${label} ${reasoningWords.join(' ')} end`; + +test.describe('long reasoning stream', () => { + test.beforeEach(async ({ page }) => { + await page.addInitScript(() => { + window.localStorage.setItem('showThinking', 'true'); + window.localStorage.setItem('smoothStreaming', 'true'); + }); + }); + + test('keeps only the newest reasoning words in fade spans and reveals the full text in order @scenario:long-reasoning-stream-settles-prefix-and-shows-full-text', async ({ + page, + }) => { + test.setTimeout(90_000); + const label = `long-think-${Date.now()}`; + await page.goto(NEW_CHAT_PATH, { timeout: 10_000 }); + await selectMockEndpoint(page, MOCK_ENDPOINTS[0]); + + const response = await sendMessage(page, `E2E_LONG_THINK_REPLY:${label}`); + expect(response.ok()).toBeTruthy(); + + const assistantMessage = messagesView(page).locator('.message-render').last(); + const reasoning = assistantMessage.locator('p', { hasText: `E2E long reasoning ${label}` }); + await expect(page.getByRole('button', { name: 'Stop generating' })).toBeVisible({ + timeout: 30_000, + }); + await expect(reasoning).toContainText('r200', { timeout: 30_000 }); + + const midStream = await reasoning.evaluate((node) => ({ + text: node.textContent ?? '', + fading: node.querySelectorAll('span[data-lc-fade]').length, + children: node.childNodes.length, + })); + expect(expectedReasoning(label).startsWith(midStream.text)).toBe(true); + expect(midStream.fading).toBeLessThan(40); + expect(midStream.children).toBeLessThan(60); + + await expect(assistantMessage.getByText(`E2E reply ${label}`)).toBeVisible({ + timeout: 60_000, + }); + await expect(reasoning).toHaveText(expectedReasoning(label)); + }); +});