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

⏹️ 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.tsx
index 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}>
<RecoilRoot
initializeState={({ 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.ts
index 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): ChatContrac
refetchType: '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): ChatContrac
conversationId,
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): ChatContrac
generationProtocolVersion: 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.js
index 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.ts
index 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,