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
🔌 fix: Reattach a Resume Stream Whose Body Ends Before Final (#16438)
Marco Berettaca8fb372e747
diff --git a/client/src/hooks/SSE/__tests__/sse.spec.ts b/client/src/hooks/SSE/__tests__/sse.spec.tsindex 77f0f1ea62..d03d1a5429 100644--- a/client/src/hooks/SSE/__tests__/sse.spec.ts+++ b/client/src/hooks/SSE/__tests__/sse.spec.ts@@ -375,7 +375,7 @@ describe('createSSETransport().reconnectToStream', () => {expect(connection.closed).toBe(true);});- it('reports closed once the response body ends without a terminal event', () => {+ it('reports a body that ends before the terminal frame as a dropped connection', () => {const connection = attach();current().receiveHeaders();current().write(message({ created: true, message: {} }));@@ -384,8 +384,63 @@ describe('createSSETransport().reconnectToStream', () => {current().emit('load');expect(connection.closed).toBe(true);+ expect(events).toEqual([+ { type: 'open' },+ { type: 'created', data: { created: true, message: {} } },+ { type: 'error', status: 0 },+ ]);controller.abort();- expect(events.map((event) => event.type)).toEqual(['open', 'created']);+ expect(events).toHaveLength(3);+ });++ it('ends quietly once the terminal frame arrived before the body ended', () => {+ attach();+ current().receiveHeaders();+ current().write(message({ final: true, terminalStatus: 'complete' }));++ current().emit('load');++ expect(events.map((event) => event.type)).toEqual(['open', 'final']);+ });++ it('reports a body that ends without carrying any frame', () => {+ attach();+ current().receiveHeaders();++ current().emit('load');++ expect(events).toEqual([{ type: 'open' }, { type: 'error', status: 0 }]);+ });++ it('counts the terminal frame parsed out of the closing chunk', () => {+ attach();+ current().receiveHeaders();+ /** The trailing frame has no blank line yet, so `progress` keeps it buffered+ * and only the closing `load` parses and dispatches it. */+ current().write('data: ' + JSON.stringify({ final: true }) + '\n');++ current().emit('load');++ expect(events.map((event) => event.type)).toEqual(['open', 'final']);+ });++ it('reports a body that ends without the final frame after a 401 reattachment', async () => {+ jest.spyOn(request, 'refreshToken').mockResolvedValue({ token: 'token-2' } as never);+ jest.spyOn(request, 'dispatchTokenUpdatedEvent').mockImplementation(() => undefined);+ attach();+ current().status = 401;+ current().write('Unauthorized');++ await new Promise(process.nextTick);+ current().receiveHeaders();+ current().write(message({ created: true, message: {} }));+ current().emit('load');++ expect(events).toEqual([+ { type: 'open' },+ { type: 'created', data: { created: true, message: {} } },+ { type: 'error', status: 0 },+ ]);});it('refreshes the token on a 401 and reattaches with the request headers', async () => {diff --git a/client/src/hooks/SSE/__tests__/useResumableSSE.spec.ts b/client/src/hooks/SSE/__tests__/useResumableSSE.spec.tsindex dece3fe1cf..7cd24ef385 100644--- a/client/src/hooks/SSE/__tests__/useResumableSSE.spec.ts+++ b/client/src/hooks/SSE/__tests__/useResumableSSE.spec.ts@@ -33,7 +33,10 @@ interface MockSSEInstance {headers: Record<string, string>;readyState: number;_listeners: Record<string, SSEEventListener>;- _emit: (event: string, data?: Partial<MessageEvent> & { responseCode?: number }) => void;+ _emit: (+ event: string,+ data?: Partial<MessageEvent> & { responseCode?: number; readyState?: number },+ ) => void;}const mockSSEInstances: MockSSEInstance[] = [];@@ -1631,6 +1634,34 @@ describe('useResumableSSE', () => {unmount();});+ it('reattaches without waiting for the foreground once the resume body ends before final', async () => {+ jest.useFakeTimers();+ const submission = buildSubmission();+ const chatHelpers = buildChatHelpers();++ const { unmount } = renderHook(() => useResumableSSE(submission, chatHelpers));+ await flushMicrotasks();++ const initialSSE = getLastSSE();+ await act(async () => {+ initialSSE._emit('message', {+ data: JSON.stringify({ event: 'on.message.delta', data: { text: 'part' } }),+ });+ });++ await act(async () => {+ initialSSE._emit('readystatechange', { readyState: 2 });+ });+ await advanceRetryTimer(1000);++ expect(mockSSEInstances).toHaveLength(2);+ expect(getLastSSE()._url).toBe(+ '/api/agents/chat/stream/stream-123?resume=true&generationCreatedAt=1000&generationProtocolVersion=2',+ );+ expect(mockErrorHandler).not.toHaveBeenCalled();+ unmount();+ });+it('preserves the generation protocol header across a 401 token refresh', async () => {(request.refreshToken as jest.Mock).mockResolvedValueOnce({ token: 'refreshed-token' });const submission = buildSubmission();diff --git a/client/src/hooks/SSE/transport/sse.ts b/client/src/hooks/SSE/transport/sse.tsindex 5970a15ec5..26c1e032ea 100644--- a/client/src/hooks/SSE/transport/sse.ts+++ b/client/src/hooks/SSE/transport/sse.ts@@ -10,6 +10,7 @@ import type {import { normalizeFrame } from './frames';type StreamErrorEvent = MessageEvent & { responseCode?: number };+type ReadyStateChangeEvent = Event & { readyState?: number };type EventCallback = (event: ChatEvent) => void;const jsonHeaders = (token?: string) => ({@@ -156,14 +157,32 @@ export function createSSETransport({ token }: { token?: string }): ChatTransportmethod: 'GET',});+ /**+ * sse.js closes a 2xx body that simply ends without dispatching+ * anything, so the frames decide what that means: after `final` it is+ * the ordinary end of the stream, before it an intermediary dropped the+ * connection underneath the attachment. `failureSeen` is set by every+ * `error` and `abort` (including a 401 whose refresh restreams), so the+ * silent close below does not add a second verdict to one they already+ * accounted for; `open` clears it for the refreshed reattachment.+ */+ let final = false;+ let failureSeen = false;+ const dispatch = (event: ChatEvent) => {+ final ||= event.type === 'final';+ onEvent(event);+ };+sse.addEventListener('open', () => {- onEvent({ type: 'open' });+ failureSeen = false;+ dispatch({ type: 'open' });});- sse.addEventListener('message', emitFrame(onEvent));+ sse.addEventListener('message', emitFrame(dispatch));let refreshed = false;sse.addEventListener('error', async (e: StreamErrorEvent) => {+ failureSeen = true;if (e.responseCode === 401 && !refreshed) {refreshed = true;const refreshedToken = await refreshToken();@@ -177,7 +196,7 @@ export function createSSETransport({ token }: { token?: string }): ChatTransportreturn;}}- onEvent({+ dispatch({type: 'error',status: e.responseCode,data: parseErrorBody(e.data, e.responseCode),@@ -186,7 +205,15 @@ export function createSSETransport({ token }: { token?: string }): ChatTransport/** sse.js dispatches `abort` when the XHR is cancelled, by our close or by the user agent. */sse.addEventListener('abort', () => {- onEvent(signal.aborted ? { type: 'abort' } : { type: 'error', status: 0 });+ failureSeen = true;+ dispatch(signal.aborted ? { type: 'abort' } : { type: 'error', status: 0 });+ });++ sse.addEventListener('readystatechange', (e: ReadyStateChangeEvent) => {+ if (e.readyState !== SSE.CLOSED || final || failureSeen) {+ return;+ }+ dispatch({ type: 'error', status: 0 });});signal.addEventListener('abort', () => sse.close(), { once: true });diff --git a/e2e/specs/mock/scenarios/resume-body-end.spec.ts b/e2e/specs/mock/scenarios/resume-body-end.spec.tsnew file mode 100644index 0000000000..e0a756b03d--- /dev/null+++ b/e2e/specs/mock/scenarios/resume-body-end.spec.ts@@ -0,0 +1,71 @@+import { expect, test } from '@playwright/test';+import {+ MOCK_ENDPOINTS,+ NEW_CHAT_PATH,+ messagesView,+ selectMockEndpoint,+ sendMessage,+} from '../helpers';++/** Last chunk streamed by the fake model's slow replies (160 chunks, 0-indexed). */+const SLOW_REPLY_LAST_CHUNK = 'chunk-159';++const STREAM_ROUTE = /\/api\/agents\/chat\/stream\//;++test.describe('resume stream body end', () => {+ test('reattaches and completes when the resume body ends before the terminal frame @scenario:resume-stream-reattaches-when-body-ends-before-final', async ({+ page,+ }) => {+ test.setTimeout(120_000);+ const label = `body-end-${Date.now()}`;++ await page.goto(NEW_CHAT_PATH, { timeout: 10_000 });+ await selectMockEndpoint(page, MOCK_ENDPOINTS[0]);++ /** The first attachment is answered with a complete 2xx body that carries+ * no terminal frame: what an intermediary closing the connection leaves+ * the client holding. Every later request passes through untouched, so+ * the reconnect the transport schedules attaches to the still-running+ * turn instead of reconciling a finished one. */+ let intercepted = false;+ await page.route(STREAM_ROUTE, async (route) => {+ if (intercepted) {+ await route.continue();+ return;+ }+ intercepted = true;+ await route.fulfill({+ status: 200,+ headers: { 'content-type': 'text/event-stream' },+ body: ': connection cut\n\n',+ });+ });++ /** The initial attachment carries no `resume` cursor; only the reconnect+ * the dropped body triggers does, so this waiter sees the recovery and+ * not the connection that was cut. */+ const reattached = page.waitForResponse(+ (response) =>+ response.request().method() === 'GET' &&+ STREAM_ROUTE.test(new URL(response.url()).pathname) &&+ response.url().includes('resume=true'),+ { timeout: 30_000 },+ );++ const response = await sendMessage(page, `E2E_SLOW_REPLY:${label}`);+ expect(response.ok()).toBeTruthy();++ await expect(page.getByRole('button', { name: 'Stop generating' })).toBeVisible({+ timeout: 30_000,+ });++ const resumeResponse = await reattached;+ expect(resumeResponse.status()).toBe(200);++ const assistantMessage = messagesView(page).locator('.message-render').last();+ await expect(assistantMessage).toContainText(SLOW_REPLY_LAST_CHUNK, {+ timeout: 90_000,+ });+ await expect(page.getByRole('button', { name: 'Stop generating' })).toBeHidden();+ });+});diff --git a/packages/data-provider/src/types/transport.ts b/packages/data-provider/src/types/transport.tsindex af3751edfa..c9d3eef0bb 100644--- a/packages/data-provider/src/types/transport.ts+++ b/packages/data-provider/src/types/transport.ts@@ -263,8 +263,10 @@ export type ChatStreamRequest = {/** The handle `reconnectToStream` returns for one attachment. */export interface ChatStreamConnection {/**- * Whether the connection has closed. A response body that simply ends- * dispatches no event, so this is the only way to see that it did.+ * Whether the connection has closed. A response body that ends before the+ * terminal frame reports itself as `{ type: 'error', status: 0 }`; this is+ * what a check that cannot listen for events (the foreground reattach)+ * reads to notice a body that ended after `final`.*/readonly closed: boolean;}@@ -283,11 +285,12 @@ export interface ChatTransport<TRequest = ChatTransportRequest> {* Attaches to a running generation and reports it through the same events* as `send`. Aborting the signal while the stream is open emits* `{ type: 'abort' }`; a cancel the caller did not issue (a backgrounded or- * frozen tab) is a dropped connection and emits `{ type: 'error', status: 0 }`.- * The first 401 refreshes the token and reattaches on the same handle; a- * failed refresh or a second 401 is reported as the 401, so the caller's own- * retry budget bounds it. A server-written error that is not JSON arrives as- * its raw text.+ * frozen tab) is a dropped connection and emits `{ type: 'error', status: 0 }`,+ * and so does a response body that ends before the terminal frame; after it+ * the ordinary end of the body dispatches nothing. The first 401 refreshes+ * the token and reattaches on the same handle; a failed refresh or a second+ * 401 is reported as the 401, so the caller's own retry budget bounds it. A+ * server-written error that is not JSON arrives as its raw text.** AI SDK: `reconnectToStream`, which resolves to a stream (or `null` when* nothing is running); here the caller learns that from a 404 `error`.