Skip to content

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

⚡ perf: Preserve Message References in the Content Handler (#16072)

Marco Beretta2db8d91745fc
diff --git a/client/src/hooks/SSE/__tests__/useContentHandler.spec.tsx b/client/src/hooks/SSE/__tests__/useContentHandler.spec.tsx
new file mode 100644
index 0000000000..f749ef9ef9
--- /dev/null
+++ b/client/src/hooks/SSE/__tests__/useContentHandler.spec.tsx
@@ -0,0 +1,169 @@
+import { renderHook, act } from '@testing-library/react';
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
+import type { EventSubmission, TMessage } from 'librechat-data-provider';
+import type { ReactNode } from 'react';
+import useContentHandler from '../useContentHandler';
+
+const wrapper = ({ children }: { children: ReactNode }) => (
+ <QueryClientProvider client={new QueryClient()}>{children}</QueryClientProvider>
+);
+
+describe('useContentHandler message reconciliation', () => {
+ it('keeps order and first existing response while reusing same-thread messages', () => {
+ const userMessage = {
+ messageId: 'user-1',
+ thread_id: 'thread-1',
+ conversationId: 'conversation-1',
+ isCreatedByUser: true,
+ } as TMessage;
+ const lastUserMessage = {
+ messageId: 'user-2',
+ thread_id: 'thread-1',
+ conversationId: 'conversation-1',
+ isCreatedByUser: true,
+ } as TMessage;
+ const firstExistingResponse = {
+ messageId: 'response-1',
+ thread_id: 'thread-1',
+ conversationId: 'conversation-1',
+ sender: 'first-existing-copy',
+ content: [{ type: 'text', text: { value: 'stale' } }],
+ } as TMessage;
+ const laterExistingResponse = {
+ ...firstExistingResponse,
+ sender: 'later-existing-copy',
+ } as TMessage;
+ const differentThreadMessage = {
+ messageId: 'other-1',
+ thread_id: 'thread-0',
+ conversationId: 'conversation-1',
+ isCreatedByUser: false,
+ content: [],
+ } as unknown as TMessage;
+ let messages = [
+ userMessage,
+ firstExistingResponse,
+ differentThreadMessage,
+ lastUserMessage,
+ laterExistingResponse,
+ ];
+ const setMessages = jest.fn((nextMessages: TMessage[]) => {
+ messages = nextMessages;
+ });
+ const submission = {
+ initialResponse: {
+ messageId: 'response-1',
+ conversationId: 'conversation-1',
+ content: [],
+ },
+ } as unknown as EventSubmission;
+ const { result } = renderHook(
+ () => useContentHandler({ setMessages, getMessages: () => messages }),
+ { wrapper },
+ );
+
+ act(() => {
+ result.current.contentHandler({
+ data: {
+ type: 'text',
+ text: 'streamed',
+ messageId: 'response-1',
+ thread_id: 'thread-1',
+ conversationId: 'conversation-1',
+ index: 0,
+ } as never,
+ submission,
+ });
+ });
+
+ const output = setMessages.mock.calls[0][0];
+ expect(output.map((message) => message.messageId)).toEqual([
+ 'user-1',
+ 'other-1',
+ 'user-2',
+ 'response-1',
+ ]);
+ expect(output[0]).toBe(userMessage);
+ expect(output[2]).toBe(lastUserMessage);
+ expect(output[1]).not.toBe(differentThreadMessage);
+ expect(output[1]).toMatchObject({ thread_id: 'thread-1' });
+ expect(output[3]).toMatchObject({
+ sender: 'first-existing-copy',
+ parentMessageId: 'user-2',
+ messageId: 'response-1',
+ thread_id: 'thread-1',
+ content: [{ type: 'text', text: { value: 'streamed' } }],
+ });
+ });
+ it('preserves thread IDs when a content event omits thread_id', () => {
+ const userMessage = {
+ messageId: 'user-1',
+ thread_id: 'thread-1',
+ conversationId: 'conversation-1',
+ isCreatedByUser: true,
+ } as TMessage;
+ const existingResponse = {
+ messageId: 'response-1',
+ conversationId: 'conversation-1',
+ parentMessageId: '',
+ isCreatedByUser: false,
+ sender: 'Assistant',
+ text: '',
+ content: [],
+ } as TMessage;
+ const laterMessageFromAnotherThread = {
+ messageId: 'other-1',
+ thread_id: 'thread-0',
+ conversationId: 'conversation-1',
+ isCreatedByUser: true,
+ content: [],
+ } as unknown as TMessage;
+ const untaggedMessage = {
+ messageId: 'legacy-1',
+ conversationId: 'conversation-1',
+ isCreatedByUser: true,
+ content: [],
+ } as unknown as TMessage;
+ let messages = [userMessage, existingResponse, laterMessageFromAnotherThread, untaggedMessage];
+ const setMessages = jest.fn((nextMessages: TMessage[]) => {
+ messages = nextMessages;
+ });
+ const submission = {
+ initialResponse: {
+ messageId: 'response-1',
+ conversationId: 'conversation-1',
+ thread_id: 'thread-1',
+ content: [],
+ },
+ } as unknown as EventSubmission;
+ const { result } = renderHook(
+ () => useContentHandler({ setMessages, getMessages: () => messages }),
+ { wrapper },
+ );
+
+ act(() => {
+ result.current.contentHandler({
+ data: {
+ type: 'text',
+ text: 'streamed without thread metadata',
+ messageId: 'response-1',
+ conversationId: 'conversation-1',
+ index: 0,
+ } as never,
+ submission,
+ });
+ });
+
+ const output = setMessages.mock.calls[0][0];
+ expect(output).toHaveLength(4);
+ expect(output[0]).toBe(userMessage);
+ expect(output[1]).toBe(laterMessageFromAnotherThread);
+ expect(output[2]).toBe(untaggedMessage);
+ expect(output[3]).toMatchObject({
+ messageId: 'response-1',
+ parentMessageId: 'legacy-1',
+ thread_id: 'thread-1',
+ content: [{ type: 'text', text: { value: 'streamed without thread metadata' } }],
+ });
+ });
+});
diff --git a/client/src/hooks/SSE/useContentHandler.ts b/client/src/hooks/SSE/useContentHandler.ts
index 458c304be4..78840fbd38 100644
--- a/client/src/hooks/SSE/useContentHandler.ts
+++ b/client/src/hooks/SSE/useContentHandler.ts
@@ -36,26 +36,33 @@ export default function useContentHandler({ setMessages, getMessages }: TUseCont
const handler = useCallback(
({ data, submission }: TContentHandler) => {
const { type, messageId, thread_id, conversationId, index } = data;
-
- const _messages = getMessages();
- const messages =
- _messages?.filter((m) => m.messageId !== messageId).map((msg) => ({ ...msg, thread_id })) ??
- [];
+ const _messages = getMessages() ?? [];
+ const messages: TMessage[] = [];
+ let existingMessage: TMessage | undefined;
+ for (const msg of _messages) {
+ if (msg.messageId === messageId) {
+ existingMessage ??= msg;
+ continue;
+ }
+ messages.push(
+ thread_id == null || msg.thread_id === thread_id ? msg : { ...msg, thread_id },
+ );
+ }
const userMessage = messages[messages.length - 1] as TMessage | undefined;
const { initialResponse } = submission;
let response = messageMap.get(messageId);
if (!response) {
- // Check if message already exists in current messages (e.g., after sync)
- // Use that as base instead of stale initialResponse
- const existingMessage = _messages?.find((m) => m.messageId === messageId);
+ const responseBase = existingMessage ?? (initialResponse as TMessage);
+ const responseThreadId =
+ thread_id ?? responseBase.thread_id ?? (initialResponse as TMessage).thread_id;
response = {
- ...(existingMessage ?? (initialResponse as TMessage)),
+ ...responseBase,
parentMessageId: userMessage?.messageId ?? '',
conversationId,
messageId,
- thread_id,
+ ...(responseThreadId != null ? { thread_id: responseThreadId } : {}),
};
messageMap.set(messageId, response);
}
diff --git a/e2e/specs/mock/scenarios/content-handler-message-refs.spec.ts b/e2e/specs/mock/scenarios/content-handler-message-refs.spec.ts
new file mode 100644
index 0000000000..4ed363e59d
--- /dev/null
+++ b/e2e/specs/mock/scenarios/content-handler-message-refs.spec.ts
@@ -0,0 +1,55 @@
+import { expect, test } from '@playwright/test';
+
+import {
+ MOCK_ENDPOINTS,
+ NEW_CHAT_PATH,
+ messagesView,
+ replyPrompt,
+ replyText,
+ selectMockEndpoint,
+ sendMessageAndWaitForCompletion,
+} from '../helpers';
+
+const ORDERED_PIECE_COUNT = 64;
+
+const orderedReplyPieces = Array.from(
+ { length: ORDERED_PIECE_COUNT },
+ (_, index) => `piece-${String(index).padStart(3, '0')}`,
+);
+
+test.describe('content handler message reconciliation', () => {
+ test('keeps streamed replies ordered and visible after a follow-up turn and reload @scenario:streamed-replies-render-in-order-and-survive-reload', async ({
+ page,
+ }) => {
+ test.setTimeout(60_000);
+ const label = `content-handler-${Date.now()}`;
+ const orderedPrompt = `E2E_ORDERED_REPLY:${label}`;
+ const orderedReply = `E2E ordered reply ${label} ${orderedReplyPieces.join(' ')}`;
+
+ await page.goto(NEW_CHAT_PATH, { timeout: 10_000 });
+ await selectMockEndpoint(page, MOCK_ENDPOINTS[0]);
+
+ const firstResponse = await sendMessageAndWaitForCompletion(page, orderedPrompt);
+ expect(firstResponse.ok()).toBeTruthy();
+ const messageRows = messagesView(page).locator('.message-render');
+ await expect(messageRows.last().locator('.message-content')).toHaveText(orderedReply, {
+ timeout: 30_000,
+ });
+
+ const secondResponse = await sendMessageAndWaitForCompletion(page, replyPrompt(label));
+ expect(secondResponse.ok()).toBeTruthy();
+ await expect(messageRows.last().locator('.message-content')).toHaveText(replyText(label), {
+ timeout: 30_000,
+ });
+ await expect(messageRows).toHaveCount(4);
+
+ await page.reload({ timeout: 10_000 });
+ await expect(messageRows).toHaveCount(4, { timeout: 30_000 });
+ await expect(messageRows.nth(1).locator('.message-content')).toHaveText(orderedReply, {
+ timeout: 30_000,
+ });
+ await expect(messageRows.last().locator('.message-content')).toHaveText(replyText(label), {
+ timeout: 30_000,
+ });
+ });
+});