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
🔌 refactor: Drive useSSE Through the ChatTransport (#16336)
Marco Beretta4fb238d5fec6
diff --git a/client/src/hooks/SSE/__tests__/frames.spec.ts b/client/src/hooks/SSE/__tests__/frames.spec.tsnew file mode 100644index 0000000000..10df6de5dd--- /dev/null+++ b/client/src/hooks/SSE/__tests__/frames.spec.ts@@ -0,0 +1,86 @@+import {+ StepEvents,+ UsageEvents,+ SteerEvents,+ ContentTypes,+ ApprovalEvents,+ ActivityLabelEvents,+ ReasoningLabelEvents,+} from 'librechat-data-provider';+import type { ChatFrame } from 'librechat-data-provider';+import { normalizeFrame } from '../transport';++/** Frames arrive as parsed JSON; the fixtures only carry the keys under test. */+const frame = (value: object) => value as ChatFrame;++describe('normalizeFrame', () => {+ it('tags the control frames by their keys', () => {+ const created = frame({ created: true, message: { messageId: 'user-1' }, streamId: 's-1' });+ const sync = frame({ sync: true, requestMessage: { messageId: 'user-1' } });+ const final = frame({ final: true, responseMessage: { messageId: 'response-1' } });++ expect(normalizeFrame(created)).toEqual({ type: 'created', data: created });+ expect(normalizeFrame(sync)).toEqual({ type: 'sync', data: sync });+ expect(normalizeFrame(final)).toEqual({ type: 'final', data: final });+ });++ it('keeps a reconcile frame final and leaves the decision to the consumer', () => {+ const reconcile = frame({ final: true, reconcile: true, terminalStatus: 'error' });+ expect(normalizeFrame(reconcile)).toEqual({ type: 'final', data: reconcile });+ });++ it('checks keys in the order the stream hooks always have', () => {+ const finalWithEvent = frame({ final: true, event: StepEvents.ON_RUN_STEP });+ const createdWithSync = frame({ created: true, sync: true, message: {} });+ const eventWithType = frame({ event: 'title', type: ContentTypes.TEXT });++ expect(normalizeFrame(finalWithEvent)?.type).toBe('final');+ expect(normalizeFrame(createdWithSync)?.type).toBe('created');+ expect(normalizeFrame(eventWithType)?.type).toBe('title');+ });++ it('unwraps the named side channels to their payload', () => {+ const cases: Array<[string, string]> = [+ ['attachment', 'attachment'],+ [UsageEvents.ON_CONTEXT_USAGE, 'context_usage'],+ [UsageEvents.ON_TOKEN_USAGE, 'token_usage'],+ [ApprovalEvents.ON_PENDING_ACTION, 'pending_action'],+ [SteerEvents.ON_STEER_APPLIED, 'steer_applied'],+ [SteerEvents.ON_STEER_UPDATED, 'steer_updated'],+ [ActivityLabelEvents.ON_ACTIVITY_LABEL, 'activity_label'],+ [ReasoningLabelEvents.ON_REASONING_LABEL, 'reasoning_label'],+ [ReasoningLabelEvents.ON_REASONING_LABEL_ATTEMPT, 'reasoning_label_attempt'],+ ];++ for (const [event, type] of cases) {+ const data = { marker: event };+ expect(normalizeFrame(frame({ event, data }))).toEqual({ type, data });+ }+ });++ it('keeps the whole frame for titles, which the title handler reads as-is', () => {+ const title = frame({ event: 'title', data: { conversationId: 'c-1', title: 'Hello' } });+ expect(normalizeFrame(title)).toEqual({ type: 'title', data: title });+ });++ it('treats any other event as a step, including ones the client does not name yet', () => {+ const delta = frame({ event: StepEvents.ON_MESSAGE_DELTA, data: { id: 'step-1' } });+ const unknown = frame({ event: 'on_future_event', data: {} });++ expect(normalizeFrame(delta)).toEqual({ type: 'step', data: delta });+ expect(normalizeFrame(unknown)).toEqual({ type: 'step', data: unknown });+ });++ it('tags legacy content-part and cumulative-text frames', () => {+ const content = frame({ type: ContentTypes.TEXT, text: 'Hi', index: 0, messageId: 'r-1' });+ const text = frame({ message: true, text: 'Hi there', messageId: 'r-1' });++ expect(normalizeFrame(content)).toEqual({ type: 'content', data: content });+ expect(normalizeFrame(text)).toEqual({ type: 'text', data: text });+ });++ it('returns undefined for a frame with none of the keys', () => {+ expect(normalizeFrame(frame({}))).toBeUndefined();+ expect(normalizeFrame(frame({ final: null, created: null }))).toBeUndefined();+ });+});diff --git a/client/src/hooks/SSE/__tests__/sse.spec.ts b/client/src/hooks/SSE/__tests__/sse.spec.tsnew file mode 100644index 0000000000..665545f298--- /dev/null+++ b/client/src/hooks/SSE/__tests__/sse.spec.ts@@ -0,0 +1,262 @@+import { request } from 'librechat-data-provider';+import type { ChatEvent, TPayload } from 'librechat-data-provider';+import { createSSETransport } from '../transport';++/**+ * Drives the real `sse.js` module through a fake XHR, so the transport is+ * tested against the library's actual framing and lifecycle.+ */+type XHRListener = (event: { currentTarget: FakeXHR }) => void;++class FakeXHR {+ static HEADERS_RECEIVED = 2;+ status = 200;+ readyState = 0;+ response = '';+ responseText = '';+ withCredentials = false;+ headers: Record<string, string> = {};+ body: string | null = null;+ private readonly listeners: Record<string, XHRListener[]> = {};++ addEventListener(type: string, listener: XHRListener) {+ (this.listeners[type] ??= []).push(listener);+ }++ open() {}+ setRequestHeader(key: string, value: string) {+ this.headers[key] = value;+ }++ send(body: string | null) {+ this.body = body;+ }++ getAllResponseHeaders() {+ return 'content-type: text/event-stream\r\n';+ }++ abort() {+ this.emit('abort');+ }++ emit(type: string) {+ for (const listener of this.listeners[type] ?? []) {+ listener({ currentTarget: this });+ }+ }++ receiveHeaders() {+ this.readyState = FakeXHR.HEADERS_RECEIVED;+ this.emit('readystatechange');+ }++ write(chunk: string) {+ this.responseText += chunk;+ this.response = this.responseText;+ this.emit('progress');+ }+}++const message = (data: object | string) =>+ `event: message\ndata: ${typeof data === 'string' ? data : JSON.stringify(data)}\n\n`;++const turn = {+ server: '/api/assistants/v2/chat',+ payload: { text: 'Hello', conversationId: null, isContinued: false } as TPayload,+};++describe('createSSETransport', () => {+ const OriginalXHR = global.XMLHttpRequest;+ let xhrs: FakeXHR[];+ let events: ChatEvent[];+ let controller: AbortController;++ const current = () => xhrs[xhrs.length - 1];+ const send = (token = 'token-1') =>+ createSSETransport({ token }).send(turn, {+ signal: controller.signal,+ onEvent: (event) => events.push(event),+ });++ beforeEach(() => {+ xhrs = [];+ events = [];+ controller = new AbortController();+ const FakeConstructor = jest.fn(() => {+ const xhr = new FakeXHR();+ xhrs.push(xhr);+ return xhr;+ });+ global.XMLHttpRequest = Object.assign(FakeConstructor, {+ HEADERS_RECEIVED: FakeXHR.HEADERS_RECEIVED,+ }) as unknown as typeof XMLHttpRequest;+ });++ afterEach(() => {+ global.XMLHttpRequest = OriginalXHR;+ jest.restoreAllMocks();+ });++ it('posts the payload with the bearer token', () => {+ send();++ expect(current().body).toBe(JSON.stringify(turn.payload));+ expect(current().headers).toEqual({+ 'Content-Type': 'application/json',+ Authorization: 'Bearer token-1',+ });+ });++ it('emits open, then created, sync and final frames in wire order', () => {+ send();+ current().receiveHeaders();+ current().write(+ message({ created: true, message: { messageId: 'user-1' } }) ++ message({ sync: true, responseMessage: { messageId: 'response-1' } }) ++ message({ final: true, responseMessage: { messageId: 'response-1' } }),+ );++ expect(events.map((event) => event.type)).toEqual(['open', 'created', 'sync', 'final']);+ expect(events[1]).toEqual({+ type: 'created',+ data: { created: true, message: { messageId: 'user-1' } },+ });+ });++ it('normalizes the named attachment event and the in-band attachment frame alike', () => {+ const attachment = { file_id: 'file-1', filename: 'a.png', type: 'image/png' };+ send();+ current().write(+ `event: attachment\ndata: ${JSON.stringify(attachment)}\n\n` ++ message({ event: 'attachment', data: attachment }),+ );++ expect(events).toEqual([+ { type: 'attachment', data: attachment },+ { type: 'attachment', data: attachment },+ ]);+ });++ it('skips a malformed frame and keeps dispatching the frames behind it', () => {+ const consoleError = jest.spyOn(console, 'error').mockImplementation(() => undefined);+ send();+ current().write(+ message('{"created": tru') + message({ final: true, responseMessage: { text: 'done' } }),+ );++ expect(events).toEqual([+ { type: 'final', data: { final: true, responseMessage: { text: 'done' } } },+ ]);+ expect(consoleError).toHaveBeenCalledTimes(1);+ });++ it('emits the parsed body of a server error event', () => {+ send();+ current().write(`event: error\ndata: ${JSON.stringify({ text: 'Rate limited' })}\n\n`);++ expect(events).toEqual([{ type: 'error', data: { text: 'Rate limited' } }]);+ });++ it('emits an error with undefined data when the failure body is not JSON', () => {+ jest.spyOn(console, 'error').mockImplementation(() => undefined);+ jest.spyOn(console, 'log').mockImplementation(() => undefined);+ send();+ current().status = 500;+ current().write('Internal Server Error');++ expect(events).toEqual([{ type: 'error', data: undefined }]);+ });++ it('refreshes the token once on a 401 and retries on a new connection', async () => {+ jest.spyOn(request, 'refreshToken').mockResolvedValue({ token: 'token-2' } as never);+ const dispatchTokenUpdated = jest+ .spyOn(request, 'dispatchTokenUpdatedEvent')+ .mockImplementation(() => undefined);+ send();+ current().status = 401;+ current().write('Unauthorized');++ await new Promise(process.nextTick);++ expect(xhrs).toHaveLength(2);+ expect(current().headers.Authorization).toBe('Bearer token-2');+ expect(dispatchTokenUpdated).toHaveBeenCalledWith('token-2');+ expect(events).toEqual([]);+ });++ it('reports a second 401 instead of refreshing again', async () => {+ const refreshToken = jest+ .spyOn(request, 'refreshToken')+ .mockResolvedValue({ token: 'token-2' } as never);+ jest.spyOn(request, 'dispatchTokenUpdatedEvent').mockImplementation(() => undefined);+ jest.spyOn(console, 'error').mockImplementation(() => undefined);+ jest.spyOn(console, 'log').mockImplementation(() => undefined);+ send();+ current().status = 401;+ current().write('Unauthorized');+ await new Promise(process.nextTick);++ current().status = 401;+ current().write('Unauthorized');+ await new Promise(process.nextTick);++ expect(refreshToken).toHaveBeenCalledTimes(1);+ expect(xhrs).toHaveLength(2);+ expect(events).toEqual([{ type: 'error', data: undefined }]);+ });++ it.each([+ ['succeeds', () => Promise.resolve({ token: 'token-2' })],+ ['fails', () => Promise.reject(new Error('refresh failed'))],+ ])(+ 'cancels, and stays closed, when aborted while a 401 refresh %s',+ async (_outcome, refresh) => {+ jest.spyOn(console, 'log').mockImplementation(() => undefined);+ jest.spyOn(request, 'refreshToken').mockImplementation(refresh as never);+ const dispatchTokenUpdated = jest+ .spyOn(request, 'dispatchTokenUpdatedEvent')+ .mockImplementation(() => undefined);+ send();+ current().status = 401;+ current().write('Unauthorized');++ controller.abort();+ await new Promise(process.nextTick);++ expect(xhrs).toHaveLength(1);+ expect(dispatchTokenUpdated).not.toHaveBeenCalled();+ expect(events).toEqual([{ type: 'abort' }]);+ },+ );++ it('emits abort when the caller aborts mid-stream, then goes quiet', () => {+ send();+ current().receiveHeaders();+ current().write(message({ created: true, message: {} }));+ const xhr = current();++ controller.abort();+ xhr.write(message({ final: true }));++ expect(events.map((event) => event.type)).toEqual(['open', 'created', 'abort']);+ });++ it('does not emit abort for a stream that already closed', () => {+ send();+ current().write(message({ final: true }));+ current().emit('load');++ controller.abort();++ expect(events.map((event) => event.type)).toEqual(['final']);+ });++ it('never opens a connection for an already-aborted signal', () => {+ controller.abort();+ send();++ expect(xhrs).toHaveLength(0);+ expect(events).toEqual([]);+ });+});diff --git a/client/src/hooks/SSE/transport/frames.ts b/client/src/hooks/SSE/transport/frames.tsnew file mode 100644index 0000000000..cbf6149482--- /dev/null+++ b/client/src/hooks/SSE/transport/frames.ts@@ -0,0 +1,84 @@+import {+ UsageEvents,+ SteerEvents,+ ApprovalEvents,+ ActivityLabelEvents,+ ReasoningLabelEvents,+} from 'librechat-data-provider';+import type {+ ChatFrame,+ ChatEvent,+ ChatSyncFrame,+ ChatTextFrame,+ ChatEventFrame,+ ChatFinalFrame,+ ChatContentFrame,+ ChatCreatedFrame,+} from 'librechat-data-provider';++/** The keys the server discriminates frames by, in the order they are checked. */+type FrameKeys = {+ final?: unknown;+ created?: unknown;+ event?: unknown;+ sync?: unknown;+ type?: unknown;+ message?: unknown;+};++function normalizeEventFrame(frame: ChatEventFrame): ChatEvent {+ switch (frame.event) {+ case 'title':+ return { type: 'title', data: frame };+ case 'attachment':+ return { type: 'attachment', data: frame.data };+ case UsageEvents.ON_CONTEXT_USAGE:+ return { type: 'context_usage', data: frame.data };+ case UsageEvents.ON_TOKEN_USAGE:+ return { type: 'token_usage', data: frame.data };+ case ApprovalEvents.ON_PENDING_ACTION:+ return { type: 'pending_action', data: frame.data };+ case SteerEvents.ON_STEER_APPLIED:+ return { type: 'steer_applied', data: frame.data };+ case SteerEvents.ON_STEER_UPDATED:+ return { type: 'steer_updated', data: frame.data };+ case ActivityLabelEvents.ON_ACTIVITY_LABEL:+ return { type: 'activity_label', data: frame.data };+ case ReasoningLabelEvents.ON_REASONING_LABEL:+ return { type: 'reasoning_label', data: frame.data };+ case ReasoningLabelEvents.ON_REASONING_LABEL_ATTEMPT:+ return { type: 'reasoning_label_attempt', data: frame.data };+ default:+ return { type: 'step', data: frame };+ }+}++/**+ * Tags one `message` frame by the keys the server wrote, checked in the order+ * the stream hooks have always checked them: a frame carrying both `final`+ * and `event` is final. An `event` the client does not name is a step event,+ * so the step handler keeps seeing new graph events as it did before. A frame+ * with none of the keys returns `undefined`.+ */+export function normalizeFrame(frame: ChatFrame): ChatEvent | undefined {+ const keys: FrameKeys = frame;+ if (keys.final != null) {+ return { type: 'final', data: frame as ChatFinalFrame };+ }+ if (keys.created != null) {+ return { type: 'created', data: frame as ChatCreatedFrame };+ }+ if (keys.event != null) {+ return normalizeEventFrame(frame as ChatEventFrame);+ }+ if (keys.sync != null) {+ return { type: 'sync', data: frame as ChatSyncFrame };+ }+ if (keys.type != null) {+ return { type: 'content', data: frame as ChatContentFrame };+ }+ if (keys.message != null) {+ return { type: 'text', data: frame as ChatTextFrame };+ }+ return undefined;+}diff --git a/client/src/hooks/SSE/transport/index.ts b/client/src/hooks/SSE/transport/index.tsnew file mode 100644index 0000000000..95081978c2--- /dev/null+++ b/client/src/hooks/SSE/transport/index.ts@@ -0,0 +1,2 @@+export { normalizeFrame } from './frames';+export { createSSETransport } from './sse';diff --git a/client/src/hooks/SSE/transport/sse.ts b/client/src/hooks/SSE/transport/sse.tsnew file mode 100644index 0000000000..a0e4c7e1f5--- /dev/null+++ b/client/src/hooks/SSE/transport/sse.ts@@ -0,0 +1,119 @@+import { SSE } from 'sse.js';+import { request } from 'librechat-data-provider';+import type { ChatFrame, ChatTransport, ChatErrorData } from 'librechat-data-provider';+import { normalizeFrame } from './frames';++type StreamErrorEvent = MessageEvent & { responseCode?: number };++const jsonHeaders = (token?: string) => ({+ 'Content-Type': 'application/json',+ Authorization: `Bearer ${token}`,+});++/**+ * POSTs the turn with `sse.js` and normalizes what comes back. Owns the wire:+ * frame parsing, named `attachment`/`error` events, and one token refresh and+ * retry on a 401. A frame that is not JSON is logged and skipped, so the+ * frames behind it in the same chunk still dispatch.+ */+export function createSSETransport({ token }: { token?: string }): ChatTransport {+ return {+ send({ server, payload }, { signal, onEvent }) {+ if (signal.aborted) {+ return;+ }++ const sse = new SSE(server, {+ payload: JSON.stringify(payload),+ headers: jsonHeaders(token),+ });++ sse.addEventListener('open', () => {+ onEvent({ type: 'open' });+ });++ sse.addEventListener('attachment', (e: MessageEvent) => {+ try {+ onEvent({ type: 'attachment', data: JSON.parse(e.data) });+ } catch (error) {+ console.error(error);+ }+ });++ sse.addEventListener('message', (e: MessageEvent) => {+ let frame: ChatFrame;+ try {+ frame = JSON.parse(e.data);+ } catch (error) {+ console.error('Skipping malformed stream frame:', error);+ return;+ }+ const event = normalizeFrame(frame);+ if (event) {+ onEvent(event);+ }+ });++ let refreshed = false;+ /** sse.js marks the connection closed on a 401, but the turn is still+ * live until the retry settles, so an abort meanwhile must still cancel. */+ let refreshing = false;+ sse.addEventListener('error', async (e: StreamErrorEvent) => {+ if (e.responseCode === 401 && !refreshed) {+ refreshed = true;+ refreshing = true;+ try {+ const refreshResponse = await request.refreshToken();+ refreshing = false;+ if (signal.aborted) {+ return;+ }+ const refreshedToken = refreshResponse?.token ?? '';+ if (!refreshedToken) {+ throw new Error('Token refresh failed.');+ }+ sse.headers = jsonHeaders(refreshedToken);+ request.dispatchTokenUpdatedEvent(refreshedToken);+ sse.stream();+ return;+ } catch (error) {+ refreshing = false;+ /* token refresh failed, continue handling the original 401 */+ console.log(error);+ }+ if (signal.aborted) {+ return;+ }+ }++ let data: ChatErrorData | null | undefined;+ try {+ data = JSON.parse(e.data);+ } catch (error) {+ console.error(error);+ console.log(e);+ }+ onEvent({ type: 'error', data });+ });++ sse.addEventListener('cancel', () => {+ onEvent({ type: 'abort' });+ });++ signal.addEventListener(+ 'abort',+ () => {+ const wasOpen = sse.readyState <= 1 || refreshing;+ sse.close();+ if (wasOpen) {+ // @ts-expect-error sse.js declares dispatchEvent as (type, listener); it takes an event+ sse.dispatchEvent(new Event('cancel'));+ }+ },+ { once: true },+ );++ sse.stream();+ },+ };+}diff --git a/client/src/hooks/SSE/useContentHandler.ts b/client/src/hooks/SSE/useContentHandler.tsindex 78840fbd38..84309bf886 100644--- a/client/src/hooks/SSE/useContentHandler.ts+++ b/client/src/hooks/SSE/useContentHandler.ts@@ -8,7 +8,7 @@ import type {ImageFile,ContentPart,PartMetadata,- TContentData,+ ChatContentFrame,EventSubmission,TMessageContentParts,} from 'librechat-data-provider';@@ -20,7 +20,7 @@ type TUseContentHandler = {};type TContentHandler = {- data: TContentData;+ data: ChatContentFrame;submission: EventSubmission;};diff --git a/client/src/hooks/SSE/useEventHandlers.ts b/client/src/hooks/SSE/useEventHandlers.tsindex f40b60d3f5..45d2fd1282 100644--- a/client/src/hooks/SSE/useEventHandlers.ts+++ b/client/src/hooks/SSE/useEventHandlers.ts@@ -19,6 +19,7 @@ import type {TConversation,TStartupConfig,EventSubmission,+ ChatCreatedFrame,TMessageContentParts,} from 'librechat-data-provider';import type { InfiniteData } from '@tanstack/react-query';@@ -270,8 +271,8 @@ const CONNECTION_ERROR_TEXT = 'Error connecting to server, try refreshing the pa/*** The parts the in-flight response has streamed so far: the transcript's tail (a user row there* means no response was placed), without the holes an interrupted stream leaves. Whether anything- * streamed is judged without the slots that never received content — a comparison run's- * `type: ''` placeholders, a text or think part opened before its first delta — but once something+ * streamed is judged without the slots that never received content (a comparison run's+ * `type: ''` placeholders, a text or think part opened before its first delta), but once something* did, those slots stay: a placeholder is what keeps a comparison lane's layout and attribution* when only the other lane produced output. The parts carry the render identity they streamed* under, as the final path stamps it, so the settled row does not remount.@@ -328,7 +329,7 @@ const createErrorMessage = ({'Error cancelling request';const streamedContent = getStreamedContent(latestMessage);if (latestMessage?.conversationId && latestMessage.messageId && streamedContent.length > 0) {- /** The row keeps the envelope it streamed under — author, model, icon, creation time — and+ /** The row keeps the envelope it streamed under (author, model, icon, creation time) and* takes from the failure only what describes the failure: a server payload names `System`* as its sender and the schema dates a fresh envelope now, neither of which applies to a* response that is merely gaining a part. */@@ -575,7 +576,7 @@ export default function useEventHandlers({/** Cleared on every terminal path below: the elapsed anchor must not outlive* its generation, or a later externally-started run attached at this index* would inherit a stale baseline. Navigation teardown deliberately does not- * clear it — a reattach to a still-live run keeps its original start. */+ * clear it: a reattach to a still-live run keeps its original start. */const setSubmissionStart = useSetRecoilState(store.submissionStartFamily(runIndex));const { mutate: reconcileCodeDecision } =useReconcileConversationCodeEnvironmentMutation(setConversation);@@ -620,7 +621,7 @@ export default function useEventHandlers({const location = useLocation();/** Re-queue the turn's quoted excerpts when an early abort restores the draft,- * so retrying the restored message still sends the references — the pending+ * so retrying the restored message still sends the references; the pending* queue was already drained on submit. */const restorePendingQuotes = useRecoilCallback(({ set }) =>@@ -637,7 +638,7 @@ export default function useEventHandlers({const { token } = useAuthContext();const { contentHandler, resetContentHandler } = useContentHandler({ setMessages, getMessages });- /** `refetchType: 'all'` so cached-but-unmounted skill queries refresh too —+ /** `refetchType: 'all'` so cached-but-unmounted skill queries refresh too:* they opt out of `refetchOnMount`, so a plain invalidation would leave* the Skills panel stale until a manual refresh. */const onSkillAuthoringComplete = useCallback(() => {@@ -675,7 +676,7 @@ export default function useEventHandlers({* Historical subagent dialogs rehydrate from the persisted* `subagent_content` on each `tool_call` (written by the backend* at message-save time), so clearing live atoms on switch- * doesn't lose any viewable history — it just keeps `atomFamily`+ * doesn't lose any viewable history; it just keeps `atomFamily`* bounded across multi-conversation sessions.** Rule: reset on real conversation switches, but preserve atoms for@@ -806,7 +807,7 @@ export default function useEventHandlers({* Filtering it out and re-appending at the tail would order any of its* already-present children (abandoned responses from preempted* attempts) before their parent, and the message tree hoists such rows- * into phantom root branches — a folded thread. */+ * into phantom root branches, a folded thread. */const userIndex = _messages.findIndex((msg) => msg.messageId === userMessage.messageId);const messages =userIndex >= 0@@ -879,11 +880,11 @@ export default function useEventHandlers({const focusRegeneratedResponse = useFocusRegeneratedResponse();const createdHandler = useCallback(- (data: TResData, submission: EventSubmission) => {+ (data: ChatCreatedFrame, submission: EventSubmission) => {const { messages, userMessage, isRegenerate = false, isTemporary = false } = submission;/*** The spread carries `manualSkills` through from- * `submission.initialResponse` — `useChatFunctions` seeds the field+ * `submission.initialResponse`: `useChatFunctions` seeds the field* there at construction so the assistant placeholder already has it* by the time this handler fires. Subsequent `useStepHandler`* spreads and `updateContent` spreads preserve it, and@@ -1100,7 +1101,7 @@ export default function useEventHandlers({const isNewConvo = conversation.conversationId !== submissionConvo.conversationId;- // Skip temporary conversations — the server never generates titles for them.+ // Skip temporary conversations; the server never generates titles for them.if (isNewConvo && conversation.conversationId && !_isTemporary) {queueTitleGeneration(conversation.conversationId);}@@ -1200,7 +1201,7 @@ export default function useEventHandlers({/** A title applied locally (e.g. an immediate-mode title fetched while the* response was still streaming) must survive the final event, whose* `conversation` was built before the title was saved and so carries no- * title yet — otherwise the chat reverts to "New Chat" until reload. This+ * title yet, otherwise the chat reverts to "New Chat" until reload. This* holds for a stopped turn too: the server persists a title that finished* generating before the Stop, so the local one stays in sync. */if (setConversation && isAddedRequest !== true) {@@ -1435,7 +1436,7 @@ export default function useEventHandlers({});/** A compaction has no user row: its `userMessage` slot names the leaf* the turn hangs off, which `messages` already holds. Writing it here- * would duplicate that id as an empty, self-parented user message —+ * would duplicate that id as an empty, self-parented user message,* a phantom root the thread then folds into. */setMessages(submission.compact === truediff --git a/client/src/hooks/SSE/useSSE.ts b/client/src/hooks/SSE/useSSE.tsindex ca3eeb0f2a..e7899b0fbc 100644--- a/client/src/hooks/SSE/useSSE.ts+++ b/client/src/hooks/SSE/useSSE.ts@@ -1,31 +1,28 @@import { useEffect, useState } from 'react';import { v4 } from 'uuid';-import { SSE } from 'sse.js';import { useStore } from 'jotai';import { useSetRecoilState } from 'recoil';-import {- request,- UsageEvents,- StepEvents,- createPayload,- ApprovalEvents,- removeNullishValues,-} from 'librechat-data-provider';+import { StepEvents, createPayload, removeNullishValues } from 'librechat-data-provider';import type {Agents,TMessage,TPayload,+ ChatEvent,+ TAttachment,TSubmission,+ ChatErrorData,+ ChatFinalFrame,EventSubmission,} from 'librechat-data-provider';import type { EventHandlerParams } from './useEventHandlers';-import type { TResData } from '~/common';+import type { TResData, TFinalResData } from '~/common';import { clearComposerDrafts, applyPendingAction, findPendingActionMessageIndex } from '~/utils';import { startedAsNewConversation, buildCreatedInitialResponse } from './useEventHandlers';import { pendingApprovalActionFamily } from '~/components/Chat/approval/state';import { useGetStartupConfig, useGetUserBalance } from '~/data-provider';import { useAuthContext } from '~/hooks/AuthContext';import useEventHandlers from './useEventHandlers';+import { createSSETransport } from './transport';import useUsageHandler from './useUsageHandler';import store from '~/store';@@ -34,6 +31,12 @@ type ChatHelpers = Pick<'setMessages' | 'getMessages' | 'setConversation' | 'setIsSubmitting' | 'newConversation'>;+type EventHandlers = ReturnType<typeof useEventHandlers>;+type TSyncData = Parameters<EventHandlers['syncHandler']>[0];+/** The handlers predate the wire types and accept a narrower payload; these+ * frames reached them unchanged before the transport existed. */+type TStepEvent = Parameters<EventHandlers['stepHandler']>[0];+export default function useSSE(submission: TSubmission | null,chatHelpers: ChatHelpers,@@ -117,123 +120,50 @@ export default function useSSE(let { payload } = payloadData;payload = removeNullishValues(payload) as TPayload;- let textIndex = null;clearStepMaps();bindResponse(currentSubmission);- const sse = new SSE(payloadData.server, {- payload: JSON.stringify(payload),- headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${token}` },- });-- sse.addEventListener('attachment', (e: MessageEvent) => {+ const handleFinal = (data: ChatFinalFrame) => {+ /** A queued delta flush reading the older streaming copy must never+ * land on top of the server-final write. */+ cancelPendingDeltaFlush();+ clearComposerDrafts(runIndex, submission.conversation?.conversationId, {+ includeNewChatDraft: startedAsNewConversation(submission),+ });try {- const data = JSON.parse(e.data);- attachmentHandler({ data, submission: currentSubmission });+ finalHandler(data as TFinalResData, currentSubmission);+ finalizeUsage(data, currentSubmission);} catch (error) {- console.error(error);+ console.error('Error in finalHandler:', error);+ setIsSubmitting(false);+ setShowStopButton(false);}- });-- sse.addEventListener('message', (e: MessageEvent) => {- const data = JSON.parse(e.data);+ (startupConfig?.balance?.enabled ?? false) && balanceQuery.refetch();+ console.log('final', data);+ };- if (data.final != null) {- /** A queued delta flush reading the older streaming copy must never- * land on top of the server-final write. */- cancelPendingDeltaFlush();- clearComposerDrafts(runIndex, submission.conversation?.conversationId, {- includeNewChatDraft: startedAsNewConversation(submission),- });- try {- finalHandler(data, currentSubmission);- finalizeUsage(data, currentSubmission);- } catch (error) {- console.error('Error in finalHandler:', error);- setIsSubmitting(false);- setShowStopButton(false);- }- (startupConfig?.balance?.enabled ?? false) && balanceQuery.refetch();- console.log('final', data);- return;- } else if (data.created != null) {- const runId = v4();- setActiveRunId(runId);- const userMessage = { ...currentSubmission.userMessage, ...data.message };- adoptResponse(- userMessage,- buildCreatedInitialResponse({- ...currentSubmission,- userMessage,- }),- );- createdHandler(data, currentSubmission);- } else if (data.event === 'title') {- titleHandler(data);- } else if (data.event === UsageEvents.ON_CONTEXT_USAGE) {- contextHandler(data.data, currentSubmission);- } else if (data.event === UsageEvents.ON_TOKEN_USAGE) {- usageHandler(data.data, currentSubmission);- } else if (data.event === ApprovalEvents.ON_PENDING_ACTION) {- /** The pause card must attach to the same message state the stream- * produced — apply any queued delta before reading the cache. */- flushPendingDeltas();- const pendingAction = data.data as Agents.PendingAction;- const pendingConversationId =- pendingAction.conversationId ?? submission.conversation?.conversationId;- if (pendingConversationId) {- jotaiStore.set(pendingApprovalActionFamily(pendingConversationId), pendingAction);- }- const messages = getMessages() ?? [];- const index = findPendingActionMessageIndex(messages, pendingAction);- if (index >= 0) {- const updated = applyPendingAction(messages[index], pendingAction);- if (updated !== messages[index]) {- const nextMessages = [...messages];- nextMessages[index] = updated;- setMessages(nextMessages);- }- }- } else if (data.event != null) {- if (- data.event === StepEvents.ON_MESSAGE_DELTA ||- data.event === StepEvents.ON_REASONING_DELTA- ) {- tapStream(data.data, currentSubmission);- }- stepHandler(data, currentSubmission);- } else if (data.sync != null) {- const runId = v4();- setActiveRunId(runId);- /* synchronize messages to Assistants API as well as with real DB ID's */- adoptResponse(data.requestMessage, data.responseMessage);- syncHandler(data, currentSubmission);- } else if (data.type != null) {- const { text, index } = data;- if (text != null && index !== textIndex) {- textIndex = index;+ const handlePendingAction = (pendingAction: Agents.PendingAction) => {+ /** The pause card must attach to the same message state the stream+ * produced, so apply any queued delta before reading the cache. */+ flushPendingDeltas();+ const pendingConversationId =+ pendingAction.conversationId ?? submission.conversation?.conversationId;+ if (pendingConversationId) {+ jotaiStore.set(pendingApprovalActionFamily(pendingConversationId), pendingAction);+ }+ const messages = getMessages() ?? [];+ const index = findPendingActionMessageIndex(messages, pendingAction);+ if (index >= 0) {+ const updated = applyPendingAction(messages[index], pendingAction);+ if (updated !== messages[index]) {+ const nextMessages = [...messages];+ nextMessages[index] = updated;+ setMessages(nextMessages);}-- tapContent(text, currentSubmission);- contentHandler({ data, submission: currentSubmission });- } else if (data.message != null) {- const text = data.text ?? data.response;-- adoptResponse({}, { parentMessageId: data.parentMessageId, messageId: data.messageId });-- /** Legacy non-agent streams (handleText) send cumulative text here,- * not via the content path — feed it to the live estimate too */- tapContent(text, currentSubmission);- messageHandler(text, currentSubmission);}- });-- sse.addEventListener('open', () => {- setAbortScroll(false);- console.log('connection is opened');- });+ };- sse.addEventListener('cancel', async () => {+ const handleAbort = async () => {/** FLUSH (not cancel): the abort below synthesizes the partial response* from the cache, so the last queued tokens must land first. */flushPendingDeltas();@@ -251,7 +181,7 @@ export default function useSSE(const latestMessages = getMessages();const conversationId = latestMessages?.[latestMessages.length - 1]?.conversationId;/** Attribute usage billed before the stop to the partial response (the- * branch tail), then reset pending — so it neither drops nor leaks into+ * branch tail), then reset pending, so it neither drops nor leaks into* the next response. Falls back to a plain reset when no response exists. */const tail = latestMessages?.[latestMessages.length - 1];const partialResponseId =@@ -271,42 +201,13 @@ export default function useSSE(setIsSubmitting(false);setShowStopButton(false);}- });-- sse.addEventListener('error', async (e: MessageEvent) => {- /* @ts-ignore */- if (e.responseCode === 401) {- /* token expired, refresh and retry */- try {- const refreshResponse = await request.refreshToken();- const token = refreshResponse?.token ?? '';- if (!token) {- throw new Error('Token refresh failed.');- }- sse.headers = {- 'Content-Type': 'application/json',- Authorization: `Bearer ${token}`,- };-- request.dispatchTokenUpdatedEvent(token);- sse.stream();- return;- } catch (error) {- /* token refresh failed, continue handling the original 401 */- console.log(error);- }- }+ };+ const handleError = (data: ChatErrorData | null | undefined) => {console.log('error in server stream.');(startupConfig?.balance?.enabled ?? false) && balanceQuery.refetch();resetLive(currentSubmission);-- let data: TResData | undefined = undefined;- try {- data = JSON.parse(e.data) as TResData;- } catch (error) {- console.error(error);- console.log(e);+ if (data === undefined) {setIsSubmitting(false);}@@ -314,23 +215,105 @@ export default function useSSE(* the last queued tokens must land before it is synthesized. */flushPendingDeltas();errorHandler({- data,+ data: data as TResData | undefined,submission: currentSubmission,});- });+ };- setIsSubmitting(true);- sse.stream();+ const onEvent = (event: ChatEvent) => {+ switch (event.type) {+ case 'open':+ setAbortScroll(false);+ console.log('connection is opened');+ return;+ case 'final':+ handleFinal(event.data);+ return;+ case 'created': {+ const runId = v4();+ setActiveRunId(runId);+ const userMessage = { ...currentSubmission.userMessage, ...event.data.message };+ adoptResponse(+ userMessage,+ buildCreatedInitialResponse({+ ...currentSubmission,+ userMessage,+ }),+ );+ createdHandler(event.data, currentSubmission);+ return;+ }+ case 'title':+ titleHandler(event.data);+ return;+ case 'attachment':+ attachmentHandler({ data: event.data as TAttachment, submission: currentSubmission });+ return;+ case 'context_usage':+ contextHandler(event.data, currentSubmission);+ return;+ case 'token_usage':+ usageHandler(event.data, currentSubmission);+ return;+ case 'pending_action':+ handlePendingAction(event.data);+ return;+ case 'step':+ if (+ event.data.event === StepEvents.ON_MESSAGE_DELTA ||+ event.data.event === StepEvents.ON_REASONING_DELTA+ ) {+ tapStream(event.data.data, currentSubmission);+ }+ stepHandler(event.data as TStepEvent, currentSubmission);+ return;+ case 'sync': {+ const runId = v4();+ setActiveRunId(runId);+ /* synchronize messages to Assistants API as well as with real DB ID's */+ adoptResponse(event.data.requestMessage ?? {}, event.data.responseMessage ?? {});+ syncHandler(event.data as TSyncData, currentSubmission);+ return;+ }+ case 'content': {+ const text = 'text' in event.data ? event.data.text : undefined;+ tapContent(text, currentSubmission);+ contentHandler({ data: event.data, submission: currentSubmission });+ return;+ }+ case 'text': {+ const { data } = event;+ const text = data.text ?? data.response;- return () => {- const isCancelled = sse.readyState <= 1;- sse.close();- if (isCancelled) {- const e = new Event('cancel');- /* @ts-ignore */- sse.dispatchEvent(e);+ adoptResponse({}, { parentMessageId: data.parentMessageId, messageId: data.messageId });++ /** Legacy non-agent streams (handleText) send cumulative text here,+ * not via the content path; feed it to the live estimate too */+ tapContent(text, currentSubmission);+ messageHandler(text, currentSubmission);+ return;+ }+ case 'error':+ handleError(event.data);+ return;+ case 'abort':+ void handleAbort();+ return;+ default:+ /** Steering and label events belong to agent runs, which stream+ * through `useResumableSSE`; this path never receives them. */+ return;}};++ const controller = new AbortController();+ setIsSubmitting(true);+ createSSETransport({ token }).send(+ { server: payloadData.server, payload },+ { signal: controller.signal, onEvent },+ );++ return () => controller.abort();// eslint-disable-next-line react-hooks/exhaustive-deps}, [submission]);}