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: Reconcile Stopped Generations Before Detaching the Stream (#16788)
lia-by-librechat[bot]abeb255a96cf
diff --git a/client/src/hooks/Chat/__tests__/abort.spec.tsx b/client/src/hooks/Chat/__tests__/abort.spec.tsxindex b501b15359..279bd3a984 100644--- a/client/src/hooks/Chat/__tests__/abort.spec.tsx+++ b/client/src/hooks/Chat/__tests__/abort.spec.tsx@@ -180,10 +180,13 @@ describe('useChatHelpers stopGenerating (abort steer targeting)', () => {runEnd: null,drainAfterAbort: false,};+ let currentSubmission: TSubmission | null = null;function setupStop(conversationId: string, generationCreatedAt: number | null = 41) {let setDrainAfterAbort: ((value: DrainAfterAbort | false) => void) | undefined;+ const stoppedSubmission = submission('stopped-run');function RunEndProbe() {+ currentSubmission = useRecoilValue(store.submissionByIndex(INDEX));observed.runEnd = useAtomValue(runEndByIndex(INDEX));observed.drainAfterAbort = useAtomValue(drainAfterAbortByIndex(INDEX));setDrainAfterAbort = useSetAtom(drainAfterAbortByIndex(INDEX));@@ -194,6 +197,8 @@ describe('useChatHelpers stopGenerating (abort steer targeting)', () => {<QueryClientProvider client={queryClient}><RecoilRootinitializeState={({ set }) => {+ set(store.conversationKeysAtom, [INDEX]);+ set(store.submissionByIndex(INDEX), stoppedSubmission);set(store.conversationByIndex(INDEX), {conversationId,endpoint: 'agents',@@ -216,6 +221,7 @@ describe('useChatHelpers stopGenerating (abort steer targeting)', () => {);return {...renderHook(() => useChatHelpers(INDEX), { wrapper }),+ stoppedSubmission,setDrainAfterAbort: (value: DrainAfterAbort | false) => setDrainAfterAbort?.(value),};}@@ -232,7 +238,27 @@ describe('useChatHelpers stopGenerating (abort steer targeting)', () => {jest.restoreAllMocks();});- it('keeps chips and the drain signal on the new composer while claiming under the resolved id', async () => {+ it.each([String(Constants.NEW_CONVO), 'convo-held'])(+ 'keeps the stopped submission attached for terminal reconciliation in %s',+ async (conversationId) => {+ mockAbortMutateAsync.mockResolvedValue({+ success: true,+ aborted: 'convo-resolved',+ generationProtocolVersion: 2,+ });+ const { result, stoppedSubmission } = setupStop(conversationId);++ await act(async () => {+ await result.current.stopGenerating();+ });++ expect(currentSubmission).toBe(stoppedSubmission);+ expect(observed.runEnd).toBeNull();+ expect(observed.drainAfterAbort).toEqual({ conversationId, generationCreatedAt: 41 });+ },+ );++ it('keeps chips on the new composer while waiting for FINAL to drain', async () => {const pendingSteers = [{ steerId: 's1', text: 'leftover words' }];mockAbortMutateAsync.mockResolvedValue({success: true,@@ -262,11 +288,7 @@ describe('useChatHelpers stopGenerating (abort steer targeting)', () => {generationProtocolVersion: 2,},);- expect(observed.runEnd).toMatchObject({- conversationId: String(Constants.NEW_CONVO),- outcome: 'aborted',- generationCreatedAt: 41,- });+ expect(observed.runEnd).toBeNull();});it('prefers the response resolved id over the client-held id for an existing conversation', async () => {@@ -288,11 +310,7 @@ describe('useChatHelpers stopGenerating (abort steer targeting)', () => {claimConversationId: 'convo-resolved',generationProtocolVersion: 2,});- expect(observed.runEnd).toMatchObject({- conversationId: 'convo-resolved',- outcome: 'aborted',- generationCreatedAt: 41,- });+ expect(observed.runEnd).toBeNull();});it('fences abort to the attached generation epoch', async () => {@@ -373,12 +391,13 @@ describe('useChatHelpers stopGenerating (abort steer targeting)', () => {terminalStatus: 'complete',generationProtocolVersion: 2,});- const { result } = setupStop('convo-held');+ const { result, stoppedSubmission } = setupStop('convo-held');await act(async () => {await result.current.stopGenerating();});+ expect(currentSubmission).toBe(stoppedSubmission);expect(mockConvertSteersToQueued).not.toHaveBeenCalled();expect(observed.runEnd).toBeNull();expect(observed.drainAfterAbort).toBe(false);@@ -464,6 +483,6 @@ describe('useChatHelpers stopGenerating (abort steer targeting)', () => {claimConversationId: 'convo-held',generationProtocolVersion: 2,});- expect(observed.runEnd).toMatchObject({ conversationId: 'convo-held', outcome: 'aborted' });+ expect(observed.runEnd).toBeNull();});});diff --git a/client/src/hooks/Chat/useChatHelpers.ts b/client/src/hooks/Chat/useChatHelpers.tsindex 6d2e30c6d3..81d7245bee 100644--- a/client/src/hooks/Chat/useChatHelpers.ts+++ b/client/src/hooks/Chat/useChatHelpers.ts@@ -52,15 +52,7 @@ export default function useChatHelpers(index = 0, paramId?: string): ChatContrac[index, queueStore],);- /**- * Interrupt & send fallback: clearing submissions below can tear down the- * SSE before its aborted-final event is processed, and only that event- * writes the run-end signal the queue drain consumes. When the one-shot- * interrupt flag is armed and no run-end has landed yet, write it here from- * the abort response so the queued follow-up still auto-sends. If the SSE- * final DOES arrive later, its signal finds the flag already consumed and- * an `aborted` outcome drains nothing, so there is no double fire.- */+ /** A missing job cannot deliver FINAL, so release its armed interrupt queue. */const signalInterruptDrain = useCallback((convoId: string, generationCreatedAt: number, armedConversationId = convoId) => {const armed = queueStore.get(drainAfterAbortByIndex(index));@@ -266,7 +258,6 @@ export default function useChatHelpers(index = 0, paramId?: string): ChatContracrefetchType: 'all',});queryClient.invalidateQueries({ queryKey: ['streamStatus', conversationId] });- clearSubmissionsUnlessReplaced(submissionAtAbort);return;}if (canUseV2AbortResponse && response?.persistenceFailed === true) {@@ -292,11 +283,12 @@ export default function useChatHelpers(index = 0, paramId?: string): ChatContracconversationId,resolvedId: response?.aborted,});- // Steers the run never injected ride the abort response. Consume them- // here as well as on the SSE final event: clearing submissions below- // can close the stream before that event lands, and conversion- // dedupes by steer id so double delivery is a no-op. `claimParked`- // reconciles the replayable parked copy if the final raced this response.+ /** Keep the submission attached until FINAL/status reconciles history.+ * Clearing on the ACK can close SSE during terminal authorization and+ * strand the preliminary response as an unsaved follow-up parent.+ * Only terminal reconciliation may release the interrupt queue. */+ // Restore uninjected steers from the ACK as well as FINAL. Conversion+ // dedupes by steer id; `claimParked` reconciles the replayable copy.if (Array.isArray(response?.pendingSteers)) {convertSteersToQueued(chipConvoId, response.pendingSteers, {claimParked: true,@@ -304,10 +296,6 @@ export default function useChatHelpers(index = 0, paramId?: string): ChatContracgenerationProtocolVersion: canUseV2AbortResponse ? 2 : 1,});}- signalInterruptDrain(chipConvoId, activeGenerationCreatedAt, conversationId);- // The SSE will receive a `done` event with `aborted: true` and clean up- // We still clear submissions as a fallback- clearSubmissionsUnlessReplaced(submissionAtAbort);} catch (error) {console.error('[useChatHelpers] Abort failed:', error);const errorData = (diff --git a/e2e/setup/fake-model.js b/e2e/setup/fake-model.jsindex 151f29e8d6..7035ba3932 100644--- a/e2e/setup/fake-model.js+++ b/e2e/setup/fake-model.js@@ -45,6 +45,7 @@ const COUNTED_REPLY_MARKER = 'E2E_COUNTED_REPLY:';const ORDERED_REPLY_MARKER = 'E2E_ORDERED_REPLY:';const SLOW_REPLY_MARKER = 'E2E_SLOW_REPLY:';const EMPTY_SLOW_REPLY_MARKER = 'E2E_EMPTY_SLOW_REPLY:';+const PRE_TOKEN_REPLY_MARKER = 'E2E_PRE_TOKEN_REPLY:';/** A run that completes having produced no content at all: the shape a* summarizer takes when it returns nothing for a manual compaction. */const EMPTY_REPLY_MARKER = 'E2E_EMPTY_REPLY:';@@ -754,6 +755,11 @@ function replyResponses(text) {return slowReplyResponses(slowName);}+ const preTokenName = getMarkerValue(text, PRE_TOKEN_REPLY_MARKER);+ if (preTokenName) {+ return { responses: [`E2E pre-token reply ${preTokenName}`], sleep: 10_000 };+ }+/** Keep a generation live after `created` without producing any content* that the abort persistence filter accepts. The browser regression waits* for the user row, then interrupts this whitespace-only stream. */diff --git a/e2e/specs/mock/steering.spec.ts b/e2e/specs/mock/steering.spec.tsindex a636a60cb4..d15252055a 100644--- a/e2e/specs/mock/steering.spec.ts+++ b/e2e/specs/mock/steering.spec.ts@@ -793,42 +793,24 @@ test.describe('mid-run steering and queuing', () => {await expect(queuedRows(page)).toHaveCount(0);});- test('Stop preserves an empty response parent for the next turn', async ({ page }) => {- test.setTimeout(120000);- const label = uniqueLabel('stop-empty');- const emptyRunPrompt = `E2E_EMPTY_SLOW_REPLY:${label}`;- const interruptText = `Interrupt empty follow-up ${label}`;-+ test('Stop before the first token saves the follow-up from the new composer', async ({+ page,+ }) => {+ const label = uniqueLabel('stop-before-token');await page.goto(NEW_CHAT_PATH, { timeout: 10000 });await selectMockEndpoint(page, MOCK_ENDPOINTS[0]);- await establishConversation(page, `interrupt-empty-setup-${label}`);-- const conversationId = new URL(page.url()).pathname.split('/').pop();- expect(conversationId).toBeTruthy();- const accessToken = await getAccessToken(page);- const messagesPath = `/api/messages/${encodeURIComponent(conversationId as string)}`;- const run = await sendMessage(page, emptyRunPrompt);- expect(run.ok()).toBeTruthy();-- /** BaseClient starts its user-row write only after `onStart` emitted- * `created`. Waiting for that row proves the server is in the exact- * created-but-still-whitespace state, without relying on a sleep. */- await expect- .poll(- async () => {- const persisted = await requestJson<PersistedMessage[]>(page, {- path: messagesPath,- token: accessToken,- });- return persisted.some(- (message) => message.isCreatedByUser === true && message.text === emptyRunPrompt,- );- },- { timeout: 30000 },- )- .toBe(true);+ let releaseStatus = () => {};+ const statusGate = new Promise<void>((resolve) => {+ releaseStatus = resolve;+ });+ await page.route('**/api/agents/chat/status/**', async (route) => {+ const response = await route.fetch();+ await statusGate;+ await route.fulfill({ response });+ });+ await sendMessage(page, `E2E_PRE_TOKEN_REPLY:${label}`);const [abortResponse] = await Promise.all([page.waitForResponse((response) =>@@ -837,30 +819,126 @@ test.describe('mid-run steering and queuing', () => {),page.getByTestId('stop-generation-button').click(),]);- expect(abortResponse.ok()).toBeTruthy();- await expect(page.getByTestId('stop-generation-button')).toHaveCount(0);- await sendMessage(page, interruptText);- await expect(messageTurns(page)).toHaveCount(6);- await expect(messageTurns(page).nth(5)).toContainText(MOCK_REPLY_TEXT);-+ try {+ expect(abortResponse.ok()).toBeTruthy();+ await expect(page.getByText('Generating a reply…', { exact: true })).toBeVisible();+ } finally {+ releaseStatus();+ }+ await expect(page.getByText('Generating a reply…', { exact: true })).toHaveCount(0);+ const stoppedTurns = await messageTurns(page).count();+ expect([0, 2]).toContain(stoppedTurns);+ await expect(page).toHaveURL(stoppedTurns === 0 ? /\/c\/new$/ : /\/c\/[0-9a-fA-F-]{36}$/);++ const followUp = replyPrompt(`after-${label}`);+ const followUpStart = await sendMessage(page, followUp);+ const { streamId: conversationId } = (await followUpStart.json()) as { streamId: string };+ await expect(messagesView(page).getByText(replyText(`after-${label}`))).toBeVisible();const persisted = await requestJson<PersistedMessage[]>(page, {- path: messagesPath,- token: accessToken,+ path: `/api/messages/${encodeURIComponent(conversationId)}`,+ token: await getAccessToken(page),});- const interruptedUser = persisted.find(- (message) => message.isCreatedByUser === true && message.text === emptyRunPrompt,+ expect(persisted.some((message) => message.isCreatedByUser && message.text === followUp)).toBe(+ true,);- expect(interruptedUser).toBeTruthy();- expect(- persisted.find(- (message) =>- message.isCreatedByUser === false &&- message.parentMessageId === interruptedUser?.messageId,- ),- ).toMatchObject({ content: [], unfinished: true });- await expect(queuedRows(page)).toHaveCount(0);+ await page.reload();+ await expect(messageTurns(page)).toHaveCount(stoppedTurns + 2);+ await expect(messagesView(page).getByText(replyText(`after-${label}`))).toBeVisible();});+ for (const startingPoint of ['new', 'existing'] as const) {+ test(`Stop preserves an empty response parent in a ${startingPoint} chat`, async ({ page }) => {+ test.setTimeout(120000);+ const label = uniqueLabel('stop-empty');+ const emptyRunPrompt = `E2E_EMPTY_SLOW_REPLY:${label}`;+ const interruptText = `Interrupt empty follow-up ${label}`;++ await page.goto(NEW_CHAT_PATH, { timeout: 10000 });+ await selectMockEndpoint(page, MOCK_ENDPOINTS[0]);+ if (startingPoint === 'existing') {+ await establishConversation(page, `interrupt-empty-setup-${label}`);+ }++ const run = await sendMessage(page, emptyRunPrompt);+ expect(run.ok()).toBeTruthy();+ const { streamId: conversationId } = (await run.json()) as { streamId: string };+ const accessToken = await getAccessToken(page);+ const messagesPath = `/api/messages/${encodeURIComponent(conversationId)}`;++ /** BaseClient starts its user-row write only after `onStart` emitted+ * `created`. Waiting for that row proves the server is in the exact+ * created-but-still-whitespace state, without relying on a sleep. */+ await expect+ .poll(+ async () => {+ const persisted = await requestJson<PersistedMessage[]>(page, {+ path: messagesPath,+ token: accessToken,+ });+ return persisted.some(+ (message) => message.isCreatedByUser === true && message.text === emptyRunPrompt,+ );+ },+ { timeout: 30000 },+ )+ .toBe(true);++ let releaseStatus = () => {};+ const statusGate = new Promise<void>((resolve) => {+ releaseStatus = resolve;+ });+ await page.route('**/api/agents/chat/status/**', async (route) => {+ const response = await route.fetch();+ await statusGate;+ await route.fulfill({ response });+ });++ const [abortResponse] = await Promise.all([+ page.waitForResponse(+ (response) =>+ response.request().method() === 'POST' &&+ new URL(response.url()).pathname === '/api/agents/chat/abort',+ ),+ page.getByTestId('stop-generation-button').click(),+ ]);+ try {+ expect(abortResponse.ok()).toBeTruthy();+ await expect(page.getByText('Generating a reply…', { exact: true })).toBeVisible();+ } finally {+ releaseStatus();+ }+ await expect(page.getByText('Generating a reply…', { exact: true })).toHaveCount(0);+ await sendMessage(page, interruptText);+ const expectedTurns = startingPoint === 'existing' ? 6 : 4;+ await expect(messageTurns(page)).toHaveCount(expectedTurns);+ await expect(messageTurns(page).last()).toContainText(MOCK_REPLY_TEXT);++ const persisted = await requestJson<PersistedMessage[]>(page, {+ path: messagesPath,+ token: accessToken,+ });+ const interruptedUser = persisted.find(+ (message) => message.isCreatedByUser === true && message.text === emptyRunPrompt,+ );+ expect(interruptedUser).toBeTruthy();+ expect(+ persisted.find(+ (message) =>+ message.isCreatedByUser === false &&+ message.parentMessageId === interruptedUser?.messageId,+ ),+ ).toMatchObject({ content: [], unfinished: true });+ const followUp = persisted.find(+ (message) => message.isCreatedByUser === true && message.text === interruptText,+ );+ expect(followUp).toBeTruthy();+ await page.reload();+ await expect(messageTurns(page)).toHaveCount(expectedTurns);+ await expect(messageTurns(page).last()).toContainText(MOCK_REPLY_TEXT);+ await expect(queuedRows(page)).toHaveCount(0);+ });+ }+/** The other interrupt chord uses the same no-tool-boundary continuation. */test('interrupt & steer (Cmd/Ctrl+Shift+Enter) seals mid-stream and injects with no tool boundary', async ({page,