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: Preserve Durable Parents for Queued Turns (#15787)

Danny Avilaf0c9dee66971
diff --git a/client/src/hooks/Chat/__tests__/useChatFunctions.regenerate.spec.tsx b/client/src/hooks/Chat/__tests__/useChatFunctions.regenerate.spec.tsx
index d44fa9b7d8..85f440f9bf 100644
--- a/client/src/hooks/Chat/__tests__/useChatFunctions.regenerate.spec.tsx
+++ b/client/src/hooks/Chat/__tests__/useChatFunctions.regenerate.spec.tsx
@@ -1,5 +1,5 @@
import { renderHook, act } from '@testing-library/react';
-import { Constants, EModelEndpoint } from 'librechat-data-provider';
+import { Constants, ContentTypes, EModelEndpoint, createPayload } from 'librechat-data-provider';
import type {
CodeWorkspaceSelection,
TConversation,
@@ -167,6 +167,24 @@ describe('useChatFunctions ask', () => {
expect(submission.codeApprovalMode).toBe('acceptEdits');
});
+ it('preallocates a durable Agents user id for the optimistic response anchor', () => {
+ const { result, setSubmission } = renderAsk([]);
+
+ act(() => {
+ result.current.ask({ text: 'Queue safely', conversationId: 'conversation-1' });
+ });
+
+ const submission = setSubmission.mock.calls.at(-1)?.[0] as TSubmission;
+ const userMessageId = submission.userMessage.messageId;
+ expect(submission.endpointOption.overrideUserMessageId).toBe(
+ `${userMessageId}${Constants.COMMON_DIVIDER}0`,
+ );
+ expect(createPayload(submission).payload.overrideUserMessageId).toBe(
+ `${userMessageId}${Constants.COMMON_DIVIDER}0`,
+ );
+ expect(submission.initialResponse?.clientQueueParentMessageId).toBe(userMessageId);
+ });
+
it('submits the latest validated workspace selection', () => {
const selection = { environmentId: 'personal-vm', workspaceId: 'project-a' };
mockResolveCodeWorkspaceSubmission.mockReturnValue({ codeWorkspaces: [selection] });
@@ -346,6 +364,7 @@ describe('useChatFunctions regenerate', () => {
expect(submission.userMessage.responseMessageId).toBe('assistant-1_');
expect(submission.initialResponse?.messageId).toBe('assistant-1_');
expect(submission.initialResponse?.parentMessageId).toBe('user-1');
+ expect(submission.initialResponse?.clientQueueParentMessageId).toBe('user-1');
expect(submission.messages.map((message) => message.messageId)).toEqual(['user-1']);
expect(submission.regenerateMessages?.map((message) => message.messageId)).toEqual([
'user-1',
@@ -360,6 +379,38 @@ describe('useChatFunctions regenerate', () => {
).toEqual(['user-1', 'assistant-1_']);
expect(messages.at(-1)?.messageId).toBe('assistant-1_');
});
+
+ it.each(['assistant-1', 'assistant_1_'])(
+ 'marks an edited optimistic response %s with its durable user anchor',
+ (responseMessageId) => {
+ const parent = userMessage('user-1');
+ const response = {
+ ...assistantMessage(responseMessageId, parent.messageId),
+ content: [{ type: ContentTypes.TEXT, [ContentTypes.TEXT]: 'before' }],
+ } as TMessage;
+ const { result, setSubmission } = renderAsk([parent, response]);
+
+ act(() => {
+ result.current.ask(
+ { ...parent },
+ {
+ isRegenerate: true,
+ isEdited: true,
+ editedMessageId: responseMessageId,
+ editedContent: {
+ index: 0,
+ type: ContentTypes.TEXT,
+ [ContentTypes.TEXT]: 'after',
+ },
+ },
+ );
+ });
+
+ const submission = setSubmission.mock.calls.at(-1)?.[0] as TSubmission;
+ expect(submission.initialResponse?.messageId).toBe(responseMessageId);
+ expect(submission.initialResponse?.clientQueueParentMessageId).toBe('user-1');
+ },
+ );
});
describe('useChatFunctions ask attachments', () => {
diff --git a/client/src/hooks/Chat/__tests__/useSteering.spec.tsx b/client/src/hooks/Chat/__tests__/useSteering.spec.tsx
index af68491473..5ad9353f15 100644
--- a/client/src/hooks/Chat/__tests__/useSteering.spec.tsx
+++ b/client/src/hooks/Chat/__tests__/useSteering.spec.tsx
@@ -338,6 +338,77 @@ describe('useSteering', () => {
);
});
+ it.each([
+ ['new response', 'user-message_'],
+ ['regenerated response', 'old-assistant_'],
+ ['edited response', 'old-assistant'],
+ ])('anchors an optimistic %s through its durable user parent', async (_label, messageId) => {
+ mockMessages = [
+ {
+ messageId: 'user-message',
+ parentMessageId: Constants.NO_PARENT,
+ isCreatedByUser: true,
+ createdAt: '2026-09-09T12:00:00.000Z',
+ updatedAt: '2026-09-09T12:00:00.000Z',
+ } as TMessage,
+ ...(messageId === 'old-assistant_'
+ ? [
+ {
+ messageId: 'old-assistant',
+ parentMessageId: 'user-message',
+ isCreatedByUser: false,
+ createdAt: '2026-09-09T12:00:01.000Z',
+ updatedAt: '2026-09-09T12:00:01.000Z',
+ } as TMessage,
+ ]
+ : []),
+ {
+ messageId,
+ parentMessageId: 'user-message',
+ isCreatedByUser: false,
+ clientQueueParentMessageId: 'user-message',
+ } as TMessage,
+ ];
+ const { result } = setupServerQueue();
+
+ await act(async () => {
+ expect(result.current.steering.queueFromComposer('follow the pending answer')).toBe(true);
+ await Promise.resolve();
+ });
+
+ expect(mockEnqueueQueuedTurn).toHaveBeenCalledWith(
+ expect.objectContaining({ parentMessageId: 'user-message' }),
+ expect.any(Object),
+ );
+ expect(result.current.queue).toEqual([
+ expect.objectContaining({ parentMessageId: 'user-message' }),
+ ]);
+ });
+
+ it('preserves an exact persisted assistant id ending in an underscore', async () => {
+ mockMessages = [
+ {
+ messageId: 'persisted-assistant_',
+ parentMessageId: 'user-message',
+ isCreatedByUser: false,
+ } as TMessage,
+ ];
+ const { result } = setupServerQueue();
+
+ await act(async () => {
+ expect(result.current.steering.queueFromComposer('keep the exact branch')).toBe(true);
+ await Promise.resolve();
+ });
+
+ expect(mockEnqueueQueuedTurn).toHaveBeenCalledWith(
+ expect.objectContaining({ parentMessageId: 'persisted-assistant_' }),
+ expect.any(Object),
+ );
+ expect(result.current.queue).toEqual([
+ expect.objectContaining({ parentMessageId: 'persisted-assistant_' }),
+ ]);
+ });
+
it('applies an admitted POST replay to the consumed predecessor set', async () => {
mockEnqueueQueuedTurn.mockImplementation((input, options) => {
options.onSuccess({
diff --git a/client/src/hooks/Chat/useChatFunctions.ts b/client/src/hooks/Chat/useChatFunctions.ts
index eb918117b8..075dedbdfd 100644
--- a/client/src/hooks/Chat/useChatFunctions.ts
+++ b/client/src/hooks/Chat/useChatFunctions.ts
@@ -527,7 +527,11 @@ export default function useChatFunctions({
endpoint,
endpointType,
overrideConvoId,
- overrideUserMessageId,
+ overrideUserMessageId:
+ overrideUserMessageId ??
+ (endpoint === EModelEndpoint.agents && !regenerateShaped && !isContinued
+ ? `${intermediateId}${Constants.COMMON_DIVIDER}0`
+ : undefined),
},
convo,
chatProjectId ? { chatProjectId } : {},
@@ -643,6 +647,7 @@ export default function useChatFunctions({
model: convo?.model,
error: false,
iconURL,
+ clientQueueParentMessageId: regenerateShaped ? messageId : intermediateId,
/**
* Seed the assistant placeholder with the turn's manually-invoked
* skill names so `ContentParts` can render interim `SkillCall` cards
diff --git a/client/src/hooks/Chat/useSteering.ts b/client/src/hooks/Chat/useSteering.ts
index d150af96d4..9701d4d132 100644
--- a/client/src/hooks/Chat/useSteering.ts
+++ b/client/src/hooks/Chat/useSteering.ts
@@ -147,10 +147,10 @@ interface LiveMessageState {
}
function selectLiveMessageState(message: TMessage | null): LiveMessageState {
- const parentMessageId =
- message?.isCreatedByUser === false && typeof message.messageId === 'string'
- ? message.messageId
- : undefined;
+ let parentMessageId: string | undefined;
+ if (message?.isCreatedByUser === false && typeof message.messageId === 'string') {
+ parentMessageId = message.clientQueueParentMessageId ?? message.messageId;
+ }
return { approval: hasLiveToolApproval(message), parentMessageId };
}
@@ -695,8 +695,9 @@ export default function useSteering({
}
}, [pendingSteers, queueKey]);
- /** The exact visible assistant tail is captured into a server queued turn,
- * while the approval bit keeps the steering controls honest. */
+ /** Capture a durable branch anchor into a server queued turn. Optimistic
+ * assistant placeholders are siblings of their eventual persisted response,
+ * so they anchor through their stable user parent. */
const latestMessage = useLatestMessage(index, hasRealConvoId ? conversationId : null);
const liveMessageState = useMemo(() => selectLiveMessageState(latestMessage), [latestMessage]);
/** Both approval cards and `ask_user_question` suspend the current
diff --git a/packages/api/src/agents/queuedTurns.spec.ts b/packages/api/src/agents/queuedTurns.spec.ts
index ca5eb6f100..adb41ec79d 100644
--- a/packages/api/src/agents/queuedTurns.spec.ts
+++ b/packages/api/src/agents/queuedTurns.spec.ts
@@ -492,6 +492,82 @@ describe('Agent queued-turn continuation', () => {
);
});
+ it('does not reinterpret a missing underscore-suffixed anchor', async () => {
+ const { methods, spies } = resolverMethods();
+ const queued = claim();
+ queued.parentMessageId = 'user-1_';
+ spies.claimNextAgentQueuedTurn.mockResolvedValueOnce({ outcome: 'acquired', claim: queued });
+ spies.getMessages.mockResolvedValueOnce([
+ persistedMessage({
+ messageId: 'user-1',
+ parentMessageId: 'root',
+ isCreatedByUser: true,
+ createdAt: new Date(NOW - 1_000),
+ }),
+ persistedMessage({
+ messageId: 'assistant-1',
+ parentMessageId: 'user-1',
+ isCreatedByUser: false,
+ createdAt: new Date(NOW),
+ }),
+ ]);
+ const resolve = createAgentQueuedTurnResolver({
+ methods,
+ getGenerationJob: async () => null,
+ now: () => NOW,
+ claimBy: 'worker-1',
+ });
+
+ await expect(resolve(envelope(), { idempotencyKey: 'trigger-1' })).rejects.toMatchObject({
+ code: 'PARENT_NOT_FOUND',
+ });
+ expect(spies.releaseAgentQueuedTurn).toHaveBeenCalledWith(
+ expect.objectContaining({
+ queuedTurnId: queued.queuedTurnId,
+ disposition: 'dead',
+ failure: expect.objectContaining({ code: 'PARENT_NOT_FOUND' }),
+ }),
+ );
+ });
+
+ it('continues after the newest regenerated response under a durable user anchor', async () => {
+ const { methods, spies } = resolverMethods();
+ const queued = claim();
+ queued.parentMessageId = 'user-1';
+ spies.claimNextAgentQueuedTurn.mockResolvedValueOnce({ outcome: 'acquired', claim: queued });
+ spies.getMessages.mockResolvedValueOnce([
+ persistedMessage({
+ messageId: 'user-1',
+ parentMessageId: 'root',
+ isCreatedByUser: true,
+ createdAt: new Date(NOW - 3_000),
+ }),
+ persistedMessage({
+ messageId: 'old-assistant',
+ parentMessageId: 'user-1',
+ isCreatedByUser: false,
+ createdAt: new Date(NOW - 2_000),
+ }),
+ persistedMessage({
+ messageId: 'regenerated-assistant',
+ parentMessageId: 'user-1',
+ isCreatedByUser: false,
+ createdAt: new Date(NOW),
+ }),
+ ]);
+ const resolve = createAgentQueuedTurnResolver({
+ methods,
+ getGenerationJob: async () => null,
+ now: () => NOW,
+ claimBy: 'worker-1',
+ });
+
+ await expect(resolve(envelope(), { idempotencyKey: 'trigger-1' })).resolves.toMatchObject({
+ status: 'ready',
+ parentMessageId: 'regenerated-assistant',
+ });
+ });
+
it('dead-letters a legacy admission order that cannot be reconstructed safely', async () => {
const { methods, spies } = resolverMethods();
(
diff --git a/packages/data-provider/src/schemas.ts b/packages/data-provider/src/schemas.ts
index 7dc914837e..7fe252767d 100644
--- a/packages/data-provider/src/schemas.ts
+++ b/packages/data-provider/src/schemas.ts
@@ -1064,6 +1064,8 @@ export type TMessage = z.input<typeof tMessageSchema> & {
siblingIndex?: number;
attachments?: TAttachment[];
clientTimestamp?: string;
+ /** Client-only durable branch anchor while this message is an optimistic response. */
+ clientQueueParentMessageId?: string;
feedback?: TFeedback;
};