@@ -254,7 +252,7 @@ function RootLayout() {
gtmId={config?.analyticsGtmId}
consentRequired={config?.interface?.analyticsConsent !== false}
/>
-
+
{config?.interface?.termsOfService?.modalAcceptance === true && (
{
'refetch-success',
'refetch-denial',
'workspace',
+ 'manual-edit',
] as const) {
test(`continues a finished child and preserves pending words on ${action} @scenario:subagent-continue-opens-side-chat-${action}`, async ({
page,
@@ -367,7 +368,8 @@ test.describe('detached subagent activity', () => {
sawWorkspace = resolve;
});
let workspaceConversation = '';
- const refetch = action === 'refetch-success' || action === 'refetch-denial';
+ const refetch =
+ action === 'refetch-success' || action === 'refetch-denial' || action === 'manual-edit';
const promote = action === 'promote' || action === 'promote-clear';
/** The fixture's parent dispatches exactly two children; the first is the one continued. */
const childNames = [
@@ -412,16 +414,8 @@ test.describe('detached subagent activity', () => {
});
createdAgentIds.push(parent.id);
- /** Warm the canonical query through its ordinary UI before testing stale success. */
- if (refetch) {
- const warm = page.waitForResponse(
- (response) => new URL(response.url()).pathname === `/api/agents/${children[0].id}`,
- );
- await selectAgent(page, childNames[0]);
- expect((await warm).ok()).toBeTruthy();
- }
/** The destination's history can load before its selected agent details. */
- await page.route(`**/api/agents/${children[0].id}`, async (route) => {
+ const gateAgent = async (route: Route) => {
if (route.request().method() !== 'GET') {
await route.continue();
return;
@@ -448,7 +442,8 @@ test.describe('detached subagent activity', () => {
} else {
await route.continue();
}
- });
+ };
+ if (!refetch) await page.route(`**/api/agents/${children[0].id}`, gateAgent);
await selectAgent(page, parentName);
const response = await sendMessageAndWaitForCompletion(
@@ -458,6 +453,19 @@ test.describe('detached subagent activity', () => {
expect(response.ok()).toBeTruthy();
/** The path, not the whole address: the app drops the agent query once the turn is in. */
const parentPath = new URL(page.url()).pathname;
+ if (refetch) {
+ /** Warm after parent setup. Return through history so selecting another builder
+ * agent cannot discard the target cache that this case needs to keep. */
+ const warm = page.waitForResponse(
+ (response) => new URL(response.url()).pathname === `/api/agents/${children[0].id}`,
+ );
+ await selectAgent(page, childNames[0]);
+ expect((await warm).ok()).toBeTruthy();
+ await openChatHistory(page);
+ await conversationRow(page, `${new URL(page.url()).origin}${parentPath}`).click();
+ await expect(page).toHaveURL(new RegExp(`${parentPath}$`));
+ await page.route(`**/api/agents/${children[0].id}`, gateAgent);
+ }
if (workspace) {
/** Reuse the paired-worker boundary fixture. Reload only setup configuration, before
@@ -539,6 +547,24 @@ test.describe('detached subagent activity', () => {
await expect(sideChat.getByRole('textbox', { name: 'Message input' })).toHaveValue(
'What did you find?',
);
+ if (action === 'manual-edit') {
+ await sideChat.locator('button[id^="edit-"]').first().click();
+ await sideChat.getByTestId('message-text-editor').fill('Follow up from the transcript.');
+ await sideChat.getByRole('button', { name: 'Update & rerun', exact: true }).click();
+ await expect.poll(() => starts.slice(startsBefore)).toEqual([sideConversationId]);
+ await expect(sideChat).toContainText(MOCK_REPLY_TEXT, { timeout: 30_000 });
+ await expect(sideChat.getByRole('button', { name: 'Stop generating' })).toHaveCount(0);
+ const details = page.waitForResponse(
+ (response) => new URL(response.url()).pathname === `/api/agents/${children[0].id}`,
+ );
+ releaseAgent();
+ expect((await details).ok()).toBeTruthy();
+ await expect(sideChat.getByRole('textbox', { name: 'Message input' })).toHaveValue(
+ 'What did you find?',
+ );
+ expect(starts.slice(startsBefore)).toEqual([sideConversationId]);
+ return;
+ }
if (workspace) {
/** Only the coding destination's resolved details cause this first status query. */
await workspaceRequested;
diff --git a/packages/chat/src/components/pane/Driven.tsx b/packages/chat/src/components/pane/Driven.tsx
index db6ac58bf49..0e483f19b76 100644
--- a/packages/chat/src/components/pane/Driven.tsx
+++ b/packages/chat/src/components/pane/Driven.tsx
@@ -11,6 +11,7 @@ export type DrivenThreadProps = {
/** The pane the host keys this chat's state by; see `useDrivenContract`. */
index: number;
handoff?: boolean;
+ onAccepted?: () => void;
slots?: ChatScreenMessagesSlots;
/** Drawn under the list, inside the chat's contract: the surface's composer. */
children?: (contract: ReturnType) => ReactElement | null;
@@ -26,10 +27,11 @@ export default function DrivenThread({
followed,
index,
handoff,
+ onAccepted,
slots,
children,
}: DrivenThreadProps): ReactElement {
- const contract = useDrivenContract({ id, followed, index, handoff });
+ const contract = useDrivenContract({ id, followed, index, handoff, onAccepted });
return (
<>
diff --git a/packages/chat/src/components/side/__tests__/panel.spec.tsx b/packages/chat/src/components/side/__tests__/panel.spec.tsx
index ff49bceaaad..c8d6d6e9b30 100644
--- a/packages/chat/src/components/side/__tests__/panel.spec.tsx
+++ b/packages/chat/src/components/side/__tests__/panel.spec.tsx
@@ -19,6 +19,7 @@ import { createMessagesHost } from '../../../__fixtures__/messagesHost';
import { turnInputs } from '../../../core/code/__fixtures__/turn';
import { SideChatHostProvider } from '../../../react/side/host';
import { MessagePartsHostProvider } from '../../../react/host';
+import { useChatContext } from '../../../react/chat/context';
import { ChatHostProvider } from '../../../react/chat/host';
import { initEnglish } from '../../../__fixtures__/i18n';
import { useFollowChat } from '../../../react/follow';
@@ -108,7 +109,17 @@ const comparison = { conversationId: 'main-comparison', endpoint: 'openAI' } as
/** Reads what a row of the side chat is given, from where a row reads it. */
function UserRow({ text }: { text: string }) {
const added = useMessagesHost().useGetAddedConvo()();
- return {`user=${text}`}
;
+ const chat = useChatContext();
+ return (
+ <>
+ {`user=${text}`}
+
+ >
+ );
}
const messagesHost = createMessagesHost({
@@ -152,9 +163,19 @@ function setup({
getStatus: async () => ({ active: false }),
};
const openConversation = jest.fn();
+ let activeChat: ReturnType['chat'];
const sideChatHost: SideChatHost = {
- useChat: ({ conversationId: id, endpoint }, options) =>
- useFollowChat({ id: id ?? '', transport, loadMessages, endpoint, ...options }),
+ useChat: ({ conversationId: id, endpoint }, options) => {
+ const followed = useFollowChat({
+ id: id ?? '',
+ transport,
+ loadMessages,
+ endpoint,
+ ...options,
+ });
+ activeChat = followed.chat;
+ return followed;
+ },
useOpenConversation: () => openConversation,
useSheetLayout: () => false,
useClearsFooter: () => false,
@@ -194,9 +215,11 @@ function setup({
onClose();
setCurrent(null);
}}
- onHandedTextTaken={() => {
- onHandedTextTaken();
- setCurrent((value) => value && { conversation: value.conversation });
+ onHandedTextTaken={(expected) => {
+ onHandedTextTaken(expected);
+ setCurrent((value) =>
+ value === expected ? { conversation: value.conversation } : value,
+ );
}}
/>
);
@@ -235,6 +258,7 @@ function setup({
return {
...view,
store,
+ getChat: () => activeChat,
queryClient,
open: (next: SideChat) => act(() => store.set(sideChatAtom, next)),
refresh: () => view.rerender(tree()),
@@ -262,6 +286,92 @@ const settle = () =>
});
describe('SideChatPanel', () => {
+ it('does not clear a newer same-destination draft published during actual send acceptance', async () => {
+ const services = createTurnServices({ readiness: 'pending' });
+ const view = setup({ chat: { conversation, text: 'Old question.' }, services });
+ await waitFor(() => expect(field()).toHaveValue('Old question.'));
+ let replaced = false;
+ const unsubscribe = view.queryClient.getQueryCache().subscribe((event) => {
+ if (replaced || event.type !== 'updated' || event.query.queryKey[0] !== 'messages') return;
+ const rows = event.query.state.data as TMessage[] | undefined;
+ if (!rows?.some((row) => row.text === 'Old question.')) return;
+ replaced = true;
+ view.store.set(sideChatDraftFamily(conversationId), '');
+ view.store.set(sideChatAtom, { conversation, text: 'New question.' });
+ });
+ services.readiness = 'ready';
+ view.refresh();
+ await waitFor(() => expect(view.streams).toHaveLength(1));
+ expect(replaced).toBe(true);
+ expect(view.store.get(sideChatDraftFamily(conversationId))).toBe('New question.');
+ expect(view.store.get(sideChatAtom)?.text).toBe('New question.');
+ unsubscribe();
+ });
+
+ it('an accepted transcript edit supersedes automatic intent without discarding its unsent draft', async () => {
+ const services = createTurnServices({ readiness: 'pending' });
+ const view = setup({ chat: { conversation, text: 'Original question.' }, services });
+ await waitFor(() => expect(field()).toHaveValue('Original question.'));
+ fireEvent.click(screen.getAllByRole('button', { name: 'Resubmit transcript' })[0]);
+ await waitFor(() => expect(view.streams).toHaveLength(1));
+ expect(view.store.get(sideChatAtom)?.text).toBeUndefined();
+ expect(field()).toHaveValue('Original question.');
+ act(() =>
+ view.streams[0].push({
+ type: 'final',
+ data: {
+ final: true,
+ earlyAbort: true,
+ conversation: { conversationId },
+ requestMessage: null,
+ responseMessage: null,
+ },
+ } as unknown as ChatEvent),
+ );
+ await settle();
+ services.readiness = 'ready';
+ view.refresh();
+ await settle();
+ expect(view.sendMessages).toHaveBeenCalledTimes(1);
+ expect(field()).toHaveValue('Original question.');
+ expect(view.onHandedTextTaken).toHaveBeenCalledTimes(1);
+ });
+
+ it('keeps a declined automatic request editable and releases its synchronous send lock', async () => {
+ const services = createTurnServices({ readiness: 'pending' });
+ const view = setup({ chat: { conversation, text: 'Keep these words.' }, services });
+ await waitFor(() => expect(field()).toHaveValue('Keep these words.'));
+ const decline = jest.spyOn(view.getChat()!, 'sendMessage').mockResolvedValueOnce(undefined);
+ services.readiness = 'ready';
+ view.refresh();
+ await settle();
+ expect(view.sendMessages).not.toHaveBeenCalled();
+ expect(field()).toHaveValue('Keep these words.');
+ decline.mockRestore();
+ fireEvent.click(screen.getByTestId('composer-send-button'));
+ await waitFor(() => expect(view.streams).toHaveLength(1));
+ expect(view.sendMessages.mock.calls[0][0].payload).toMatchObject({ text: 'Keep these words.' });
+ expect(field()).toHaveValue('');
+ });
+
+ it('accepts a genuinely new handoff for the same mounted destination', async () => {
+ const view = setup({ chat: { conversation, text: 'First question.' } });
+ await waitFor(() => expect(view.streams).toHaveLength(1));
+ const asked = view.sendMessages.mock.calls[0][0].payload as unknown as TMessage;
+ act(() =>
+ view.streams[0].push(final(asked, reply('answer-first', 'First answer.', asked.messageId))),
+ );
+ await waitFor(() =>
+ expect(screen.queryByRole('button', { name: 'Stop generating' })).not.toBeInTheDocument(),
+ );
+ await settle();
+ view.open({ conversation, text: 'Second question.' });
+ await waitFor(() => expect(view.streams).toHaveLength(2));
+ expect(view.sendMessages.mock.calls[1][0].payload).toMatchObject({ text: 'Second question.' });
+ expect(field()).toHaveValue('');
+ expect(view.onHandedTextTaken).toHaveBeenCalledTimes(2);
+ });
+
it('shows the conversation beside the main one, under its title', async () => {
setup();
diff --git a/packages/chat/src/components/side/panel.tsx b/packages/chat/src/components/side/panel.tsx
index 061c822c032..da272edd9ee 100644
--- a/packages/chat/src/components/side/panel.tsx
+++ b/packages/chat/src/components/side/panel.tsx
@@ -23,12 +23,11 @@ type SideChatComposerProps = {
/** The reader's unsent words, which the panel holds so they outlive the composer. */
value: string;
onChange: (value: string) => void;
- conversationId: string;
title: string;
/** Whether the conversation is in and the pane holds it, so a turn can be built for it. */
ready: boolean;
/** Words written for this conversation before it opened; see {@link SideChat.text}. */
- handedText?: string;
+ handoff?: SideChat;
onHandedTextTaken: () => void;
clearsFooter: boolean;
/**
@@ -49,10 +48,9 @@ function SideChatComposer({
readiness,
value,
onChange: setValue,
- conversationId,
title,
ready,
- handedText,
+ handoff,
onHandedTextTaken,
clearsFooter,
focusWhenReady,
@@ -78,31 +76,32 @@ function SideChatComposer({
* Words the reader wrote before this conversation opened are its next turn. They are sent
* once, when the conversation can take them; if it cannot, they are left in the field.
*/
- const handed = useRef();
+ const handedText = handoff?.text;
+ const handed = useRef();
useEffect(() => {
if (
!ready ||
readiness === 'pending' ||
handedText == null ||
handedText === '' ||
- handed.current === conversationId
+ handed.current === handoff
) {
return;
}
const outcome = value === handedText && readiness === 'ready' ? attempt(handedText) : 'blocked';
if (outcome === 'pending') return;
- handed.current = conversationId;
+ handed.current = handoff;
if (outcome === 'accepted') setValue('');
- onHandedTextTaken();
- }, [attempt, conversationId, handedText, onHandedTextTaken, readiness, ready, setValue, value]);
+ else onHandedTextTaken();
+ }, [attempt, handoff, handedText, onHandedTextTaken, readiness, ready, setValue, value]);
- /** Editing or an accepted manual send supersedes automatic intent, including after rollback. */
+ /** Editing supersedes automatic intent; accepted sends consume it at the driven owner. */
const consume = useCallback(() => {
- if (handedText && handed.current !== conversationId) {
- handed.current = conversationId;
+ if (handedText && handed.current !== handoff) {
+ handed.current = handoff;
onHandedTextTaken();
}
- }, [conversationId, handedText, onHandedTextTaken]);
+ }, [handoff, handedText, onHandedTextTaken]);
const change = useCallback(
(text: string) => {
consume();
@@ -116,9 +115,9 @@ function SideChatComposer({
if (text === '' || ask({ text }) === false) {
return;
}
- consume();
+ handed.current = handoff;
setValue('');
- }, [ask, consume, setValue, value]);
+ }, [ask, handoff, setValue, value]);
/** The main chat form's own Enter decision table, so a rebound submit shortcut holds here. */
const resolveKeyVerdict = useCallback(
@@ -177,7 +176,7 @@ export default function SideChatPanel({
chat: SideChat;
onClose: () => void;
/** The words handed over with the conversation were sent, or put in the field. */
- onHandedTextTaken: () => void;
+ onHandedTextTaken: (expected: SideChat) => void;
}): ReactNode {
const localize = useLocalize();
const host = useSideChatHost();
@@ -187,6 +186,7 @@ export default function SideChatPanel({
const { handOffComposerText } = useChatSurface();
const conversationId = chat.conversation.conversationId ?? '';
const [draft, setDraft] = useAtom(sideChatDraftFamily(conversationId));
+ const takeText = useCallback(() => onHandedTextTaken(chat), [chat, onHandedTextTaken]);
/**
* A turn stopped before the server kept it is gone from the list. Its words go back in the
* field, as main chat keeps them as a draft, unless the reader has written something since.
@@ -283,6 +283,7 @@ export default function SideChatPanel({
index={SIDE_CHAT_PANE}
followed={followed}
handoff={!!chat.text}
+ onAccepted={chat.text ? takeText : undefined}
>
{(contract) => (
diff --git a/packages/chat/src/core/code/__tests__/turn.spec.ts b/packages/chat/src/core/code/__tests__/turn.spec.ts
index 1b239498ab3..3aac557b983 100644
--- a/packages/chat/src/core/code/__tests__/turn.spec.ts
+++ b/packages/chat/src/core/code/__tests__/turn.spec.ts
@@ -3,6 +3,34 @@ import { resolveTurnCode, resolveTurnCodeResult } from '../turn';
import * as workspace from '../workspace';
describe('resolveTurnCode', () => {
+ it.each(['fetching', 'paused'] as const)(
+ 'retains a cached-error workspace during %s',
+ (fetchStatus) => {
+ const inputs = turnInputs();
+ inputs.workspace.statuses['personal-vm'] = {
+ ...inputs.workspace.statuses['personal-vm']!,
+ isLoading: false,
+ isError: true,
+ fetchStatus,
+ };
+ expect(resolveTurnCodeResult(inputs, inputs.workspace.conversation).state).toBe('pending');
+ inputs.workspace.statuses['personal-vm']!.fetchStatus = 'idle';
+ expect(resolveTurnCodeResult(inputs, inputs.workspace.conversation).state).toBe('blocked');
+ },
+ );
+
+ it('distinguishes a partial catalog from a settled missing catalog', () => {
+ const inputs = turnInputs();
+ inputs.workspace.primaryAgent = { ...agent, agent_ids: ['later-page'] };
+ inputs.workspace.agentsMap = { [agent.id]: agent };
+ inputs.workspace.agentsPending = true;
+ expect(resolveTurnCodeResult(inputs, inputs.workspace.conversation).state).toBe('pending');
+ inputs.workspace.agentsPending = false;
+ expect(resolveTurnCodeResult(inputs, inputs.workspace.conversation).state).toBe('blocked');
+ inputs.workspace.agentsMap = undefined;
+ expect(resolveTurnCodeResult(inputs, inputs.workspace.conversation).state).toBe('blocked');
+ });
+
it('admits a sealed without-attached decision before irrelevant linked metadata loads', () => {
const inputs = turnInputs();
inputs.workspace.primaryAgent = { ...agent, agent_ids: ['agent_child'] };
diff --git a/packages/chat/src/core/code/turn.ts b/packages/chat/src/core/code/turn.ts
index ecb24e572fd..002e8d0a417 100644
--- a/packages/chat/src/core/code/turn.ts
+++ b/packages/chat/src/core/code/turn.ts
@@ -43,6 +43,12 @@ export function resolveTurnCodeResult(
return { state: 'blocked' };
}
if (workspace.recoveryPending || workspace.replacingDecision) return { state: 'pending' };
+ if (
+ Object.values(workspace.statuses).some(
+ (status) => status?.fetchStatus === 'fetching' || status?.fetchStatus === 'paused',
+ )
+ )
+ return { state: 'pending' };
const terminal = derivation.environments.some(
({ state }) => state === 'unavailable' || state === 'unsupported' || state === 'missing',
);
diff --git a/packages/chat/src/core/code/workspace.ts b/packages/chat/src/core/code/workspace.ts
index 1500ddef944..70b2bdda500 100644
--- a/packages/chat/src/core/code/workspace.ts
+++ b/packages/chat/src/core/code/workspace.ts
@@ -96,6 +96,8 @@ export interface CodeEnvironmentStatusSnapshot {
data?: TCodeEnvironmentStatusResponse;
isLoading: boolean;
isError: boolean;
+ /** Native observer state, including an optimistic mount refetch or offline pause. */
+ fetchStatus?: 'fetching' | 'paused' | 'idle';
}
export interface CodeWorkspaceProtocol {
@@ -143,6 +145,8 @@ export interface CodeWorkspaceAgents {
primaryAgent?: Agent;
addedAgent?: Agent;
agentsMap?: TAgentsMap;
+ /** The existing catalog owner is still loading missing linked metadata. */
+ agentsPending?: boolean;
statefulCodeSessions?: CodeSessionsConfig;
}
@@ -1021,7 +1025,7 @@ export function resolveCodeWorkspace(inputs: CodeWorkspaceInputs): CodeWorkspace
mode: inferredMode,
state: status.state,
canSubmit,
- metadataPending: !reachable.complete && agentsMap == null,
+ metadataPending: !reachable.complete && (inputs.agentsPending ?? agentsMap == null),
visible: status.visible,
environments: environments.environmentResults,
machineOptions: environments.machineOptions,
diff --git a/packages/chat/src/react/chat/__tests__/driven.spec.tsx b/packages/chat/src/react/chat/__tests__/driven.spec.tsx
index 41100244ad0..1535a11bcd9 100644
--- a/packages/chat/src/react/chat/__tests__/driven.spec.tsx
+++ b/packages/chat/src/react/chat/__tests__/driven.spec.tsx
@@ -22,6 +22,7 @@ import { showStopButtonByIndex } from '../../generation';
import { isSubmittingFamily } from '../../submission';
import { useDrivenContract } from '../driven';
import { useFollowChat } from '../../follow';
+import { useTurnActions } from '../actions';
import { ChatHostProvider } from '../host';
import { filesFamily } from '../../pane';
@@ -179,7 +180,13 @@ function setup({
stored = [user, reply('response-1', 'Hi')],
services = createTurnServices(),
canSend,
-}: { stored?: TMessage[]; services?: TurnServices; canSend?: () => boolean } = {}) {
+ onAccepted,
+}: {
+ stored?: TMessage[];
+ services?: TurnServices;
+ canSend?: () => boolean;
+ onAccepted?: () => void;
+} = {}) {
const queryClient = new QueryClient();
const store = createStore();
const harness = createTransport();
@@ -220,8 +227,10 @@ function setup({
id: conversationId,
followed: canSend == null ? followed : { ...followed, canSend },
index: SIDE_PANE,
+ onAccepted,
});
- return { followed, contract };
+ const actions = useTurnActions(contract.ask, conversationId);
+ return { followed, contract, actions };
},
{ wrapper, initialProps: { live: false } },
);
@@ -230,6 +239,57 @@ function setup({
}
describe('useDrivenContract', () => {
+ it.each(['edit', 'regenerate', 'continue', 'preview'] as const)(
+ 'announces actual acceptance for %s',
+ async (action) => {
+ const onAccepted = jest.fn();
+ const view = setup({ onAccepted });
+ await view.ready();
+ act(() => {
+ if (action === 'edit')
+ view.result.current.contract.ask(
+ { ...user, text: 'Edited question' },
+ { isEdited: true },
+ );
+ else if (action === 'regenerate')
+ view.result.current.contract.regenerate({ parentMessageId: user.messageId });
+ else if (action === 'preview')
+ view.result.current.actions.sendMessage({
+ parts: [{ type: 'text', text: 'Preview followup.' }],
+ });
+ else
+ view.result.current.contract.handleContinue({
+ preventDefault: jest.fn(),
+ } as unknown as React.MouseEvent);
+ });
+ await waitFor(() => expect(view.sendMessages).toHaveBeenCalledTimes(1));
+ expect(onAccepted).toHaveBeenCalledTimes(1);
+ },
+ );
+
+ it('retains automatic intent when the real follower declines after preflight', async () => {
+ const onAccepted = jest.fn();
+ const view = setup({ onAccepted });
+ await view.ready();
+ const decline = jest
+ .spyOn(view.result.current.followed.chat!, 'sendMessage')
+ .mockResolvedValueOnce(undefined);
+ let outcome: string | undefined;
+ act(() => {
+ outcome = view.result.current.contract.attempt('Keep these words.');
+ });
+ expect(outcome).not.toBe('accepted');
+ expect(onAccepted).not.toHaveBeenCalled();
+ expect(view.sendMessages).not.toHaveBeenCalled();
+ decline.mockRestore();
+ view.rerender({ live: false });
+ act(() => {
+ outcome = view.result.current.contract.attempt('Keep these words.');
+ });
+ expect(outcome).toBe('accepted');
+ expect(onAccepted).toHaveBeenCalledTimes(1);
+ });
+
it('retains manual refusal diagnostics and false/accepted-undefined return values', async () => {
const inputs = createTurnCodeInputs({ recoveryPending: true });
const services = createTurnServices({ readCodeInputs: () => inputs });
diff --git a/packages/chat/src/react/chat/driven.ts b/packages/chat/src/react/chat/driven.ts
index 653378addb8..3ce81279654 100644
--- a/packages/chat/src/react/chat/driven.ts
+++ b/packages/chat/src/react/chat/driven.ts
@@ -27,6 +27,8 @@ export type DrivenContractOptions = {
*/
index: number;
handoff?: boolean;
+ /** The driven chat synchronously accepted a submission from any of its actions. */
+ onAccepted?: () => void;
};
const ignore = (): void => undefined;
@@ -50,6 +52,7 @@ export function useDrivenContract({
followed,
index,
handoff = false,
+ onAccepted,
}: DrivenContractOptions): ChatContract & {
readiness: TurnReadiness;
attempt: ReturnType['attempt'];
@@ -101,11 +104,13 @@ export function useDrivenContract({
* to arrives in the same call.
*/
const shown = useRef();
+ const accepted = useRef(false);
const holdRows = useCallback((messages: TMessage[]) => {
shown.current = messages;
}, []);
const sendSubmission = useCallback(
(next: SetStateAction) => {
+ accepted.current = false;
const submission = typeof next === 'function' ? next(null) : next;
const messages = shown.current;
shown.current = undefined;
@@ -116,13 +121,17 @@ export function useDrivenContract({
/** The chat took nothing, so the flags `ask` raised for the turn come back down. */
setIsSubmitting(false);
setShowStopButton(false);
+ } else {
+ accepted.current = true;
+ onAccepted?.();
}
},
- [send, setIsSubmitting, setShowStopButton],
+ [send, setIsSubmitting, setShowStopButton, onAccepted],
);
const turnsParams: ChatTurnsParams = {
index,
+ handoff,
files,
setFiles,
getMessages,
@@ -141,7 +150,12 @@ export function useDrivenContract({
};
const useReadiness = host.useTurnReadiness ?? useReady;
const readiness = useReadiness(conversation, handoff);
- const turns = useTurns(turnsParams, services, () => (!canSend() ? 'pending' : readiness));
+ const turns = useTurns(
+ turnsParams,
+ services,
+ () => (!canSend() ? 'pending' : readiness),
+ () => accepted.current,
+ );
const attempt = turns.attempt;
const { ask, regenerate, handleRegenerate, handleContinue } = useTurnHandlers({
ask: turns.ask,
diff --git a/packages/chat/src/react/chat/host.tsx b/packages/chat/src/react/chat/host.tsx
index d38cfebc520..adc80c87034 100644
--- a/packages/chat/src/react/chat/host.tsx
+++ b/packages/chat/src/react/chat/host.tsx
@@ -45,6 +45,8 @@ export interface AbortStreamResponse {
/** The pane state `ask` and `regenerate` read and write for one pane. */
export type ChatTurnsParams = {
index: number;
+ /** A driven automatic handoff is waiting for admission; ordinary panes omit it. */
+ handoff?: boolean;
files?: Map;
/** Without it a send leaves the composer's files alone. */
setFiles?: Dispatch>>;
diff --git a/packages/chat/src/react/chat/turns.ts b/packages/chat/src/react/chat/turns.ts
index 6092d7031cf..e1f9240aacc 100644
--- a/packages/chat/src/react/chat/turns.ts
+++ b/packages/chat/src/react/chat/turns.ts
@@ -57,6 +57,8 @@ export function useTurns(
}: ChatTurnsParams,
services: TurnServices,
admission?: () => TurnReadiness,
+ /** Optional synchronous confirmation from the driven publication owner. */
+ accepted?: () => boolean,
): { ask: TAskFunction; attempt: (text: string) => Attempt; regenerate: TRegenerateFunction } {
const store = useStore();
const queryClient = useQueryClient();
@@ -373,13 +375,16 @@ export function useTurns(
? current
: codeDecision.apply(current),
);
- /** Armed at the point of no return: every refusal above returns before it, so a rejected
- * send never has to unwind the guard, and `ask` runs to completion synchronously, which is
- * the whole window it has to cover. */
+ /** Close the synchronous double-submit window before publication. A driven owner that
+ * declines after preflight releases this attempt's lock below. */
askInFlightRef.current = true;
setSubmissionStart(Date.now());
store.set(launchedConversationFamily(index), submission.conversation);
setSubmission(submission);
+ if (accepted?.() === false) {
+ askInFlightRef.current = false;
+ return admission?.() === 'pending' ? 'pending' : 'blocked';
+ }
logger.dir('message_stream', {
conversationId,
messageId: currentMsg.messageId,
From 728545533e94262270c0ac7b0de18c3b664379cf Mon Sep 17 00:00:00 2001
From: Dustin Healy <54083382+dustinhealy@users.noreply.github.com>
Date: Wed, 18 Nov 2026 17:08:39 -0800
Subject: [PATCH 6/7] Preserve Driven Composer Ownership Until Actual
Acceptance
---
client/src/components/Chat/Presentation.tsx | 5 +-
.../__tests__/useAgentsCatalog.spec.tsx | 42 ++++-
client/src/hooks/Agents/useAgentsMap.ts | 4 +-
.../services.readCodeInputs.spec.tsx | 23 ++-
client/src/hooks/Chat/services.ts | 3 +-
.../__tests__/useSetFilesToDelete.spec.ts | 58 +++++++
client/src/hooks/Files/useSetFilesToDelete.ts | 42 +++++
.../components/side/__tests__/panel.spec.tsx | 80 ++++++++-
packages/chat/src/components/side/panel.tsx | 44 ++++-
packages/chat/src/core/__tests__/chat.spec.ts | 103 +++++++++++
packages/chat/src/core/chat.ts | 16 ++
packages/chat/src/react.ts | 1 +
.../chat/src/react/__tests__/follow.spec.tsx | 52 +++++-
.../src/react/chat/__tests__/driven.spec.tsx | 97 +++++++++++
packages/chat/src/react/chat/driven.ts | 22 +--
packages/chat/src/react/chat/host.tsx | 2 +
packages/chat/src/react/chat/turns.ts | 162 +++++++++++++-----
packages/chat/src/react/follow.ts | 3 +
.../src/react/side/__tests__/state.spec.ts | 43 ++++-
packages/chat/src/react/side/state.ts | 17 ++
20 files changed, 736 insertions(+), 83 deletions(-)
create mode 100644 client/src/hooks/Files/__tests__/useSetFilesToDelete.spec.ts
diff --git a/client/src/components/Chat/Presentation.tsx b/client/src/components/Chat/Presentation.tsx
index 93ec15b3e9c..05e88b5fe2f 100644
--- a/client/src/components/Chat/Presentation.tsx
+++ b/client/src/components/Chat/Presentation.tsx
@@ -4,6 +4,7 @@ import { EModelEndpoint } from 'librechat-data-provider';
import { useRecoilValue, useSetRecoilState, useResetRecoilState } from 'recoil';
import {
sideChatAtom,
+ sideChatDraftSubmittedAtom,
SIDE_CHAT_PANE,
sideChatBesideAtom,
sideChatRequestAtom,
@@ -71,6 +72,7 @@ export default function Presentation({
const sideChat = useAtomValue(sideChatAtom);
const isSideChatSubmitting = useIsSubmitting(SIDE_CHAT_PANE);
const setSideChat = useSetAtom(sideChatAtom);
+ const submitSideChatDraft = useSetAtom(sideChatDraftSubmittedAtom);
const closeSideChat = useCallback(() => setSideChat(null), [setSideChat]);
const takeSideChatText = useCallback(
(expected: SideChat) =>
@@ -231,12 +233,13 @@ export default function Presentation({
chat={sideChat}
onClose={closeSideChat}
onHandedTextTaken={takeSideChatText}
+ onDraftSubmitted={submitSideChatDraft}
/>
);
- }, [closeSideChat, isSideChatSubmitting, sideChat, takeSideChatText]);
+ }, [closeSideChat, isSideChatSubmitting, sideChat, submitSideChatDraft, takeSideChatText]);
/* Undocked, the pane renders into its own window: the side panel gives its
* width back to the conversation instead of holding an empty column. */
diff --git a/client/src/hooks/Agents/__tests__/useAgentsCatalog.spec.tsx b/client/src/hooks/Agents/__tests__/useAgentsCatalog.spec.tsx
index 87be6f4e3f8..c558ac75521 100644
--- a/client/src/hooks/Agents/__tests__/useAgentsCatalog.spec.tsx
+++ b/client/src/hooks/Agents/__tests__/useAgentsCatalog.spec.tsx
@@ -1,6 +1,6 @@
import { act, renderHook, waitFor } from '@testing-library/react';
-import { QueryKeys, EModelEndpoint, dataService } from 'librechat-data-provider';
import { QueryClient, QueryClientProvider, onlineManager } from '@tanstack/react-query';
+import { QueryKeys, EModelEndpoint, PermissionBits, dataService } from 'librechat-data-provider';
import type { AgentListResponse } from 'librechat-data-provider';
import type { ReactNode } from 'react';
import { activateCatalog, resetCatalogWarmup } from '~/hooks/useCatalogWarmup';
@@ -28,11 +28,14 @@ function setup({
enabled,
available = true,
authenticated = true,
-}: { enabled?: boolean; available?: boolean; authenticated?: boolean } = {}) {
- const client = new QueryClient({
- defaultOptions: { queries: { retry: false } },
- logger: { log: jest.fn(), warn: jest.fn(), error: jest.fn() },
- });
+ client: supplied,
+}: { enabled?: boolean; available?: boolean; authenticated?: boolean; client?: QueryClient } = {}) {
+ const client =
+ supplied ??
+ new QueryClient({
+ defaultOptions: { queries: { retry: false } },
+ logger: { log: jest.fn(), warn: jest.fn(), error: jest.fn() },
+ });
client.setQueryData([QueryKeys.endpoints], available ? { [EModelEndpoint.agents]: {} } : {});
const wrapper = ({ children }: { children: ReactNode }) => (
{children}
@@ -125,3 +128,30 @@ it('retains a warmup wait without starting an eager request', async () => {
await waitFor(() => expect(result.current.catalog.pending).toBe(false));
expect(list).toHaveBeenCalledTimes(1);
});
+
+it.each(['complete', 'error'] as const)(
+ 'keeps unreleased warmup pending with stale cached %s data',
+ async (cached) => {
+ const client = new QueryClient({
+ defaultOptions: { queries: { retry: false } },
+ logger: { log: jest.fn(), warn: jest.fn(), error: jest.fn() },
+ });
+ const key = [QueryKeys.agents, { requiredPermission: PermissionBits.VIEW }];
+ client.setQueryData(
+ key,
+ { pages: [page('old-root')], pageParams: [undefined] },
+ { updatedAt: Date.now() - 10000 },
+ );
+ if (cached === 'error')
+ await client.fetchInfiniteQuery(key, () => Promise.reject(denied)).catch(() => undefined);
+ resetCatalogWarmup();
+ list.mockResolvedValue(page('new-child'));
+ const { result } = setup({ client });
+ expect(result.current.catalog.pending).toBe(true);
+ expect(list).not.toHaveBeenCalled();
+ act(() => activateCatalog('agents'));
+ await waitFor(() => expect(result.current.catalog.pending).toBe(false));
+ expect(result.current.catalog.agentsMap?.['new-child']).toBeDefined();
+ expect(list).toHaveBeenCalledTimes(1);
+ },
+);
diff --git a/client/src/hooks/Agents/useAgentsMap.ts b/client/src/hooks/Agents/useAgentsMap.ts
index 0e4944ff08a..16d497d8fad 100644
--- a/client/src/hooks/Agents/useAgentsMap.ts
+++ b/client/src/hooks/Agents/useAgentsMap.ts
@@ -28,7 +28,9 @@ export function useAgentsCatalog({ isAuthenticated, enabled }: Options) {
isAuthenticated &&
enabled !== false &&
!unavailable &&
- (query.fetchStatus !== 'idle' || (!query.isComplete && !query.isError));
+ ((enabled == null && !ready) ||
+ query.fetchStatus !== 'idle' ||
+ (!query.isComplete && !query.isError));
return { agentsMap, pending };
}
diff --git a/client/src/hooks/Chat/__tests__/services.readCodeInputs.spec.tsx b/client/src/hooks/Chat/__tests__/services.readCodeInputs.spec.tsx
index 74897495e5f..5380b08408f 100644
--- a/client/src/hooks/Chat/__tests__/services.readCodeInputs.spec.tsx
+++ b/client/src/hooks/Chat/__tests__/services.readCodeInputs.spec.tsx
@@ -16,7 +16,11 @@ const mockGetLatestConversation = jest.fn(() => null);
const mockComparisons: { workspace?: unknown; approval?: unknown } = {};
jest.mock('react-router-dom', () => ({ useNavigate: () => jest.fn() }));
-jest.mock('~/hooks/Files/useSetFilesToDelete', () => () => jest.fn());
+jest.mock('~/hooks/Files/useSetFilesToDelete', () => ({
+ __esModule: true,
+ ...jest.requireActual('~/hooks/Files/useSetFilesToDelete'),
+ default: () => jest.fn(),
+}));
jest.mock('~/hooks/Input/useUserKey', () => () => ({ getExpiry: jest.fn() }));
jest.mock('~/Providers/AgentsMapContext', () => ({ useAgentsMapContext: () => ({}) }));
jest.mock('~/hooks/Conversations/useGetConversation', () => () => mockGetLatestConversation);
@@ -196,4 +200,21 @@ describe('useTurnServices readCodeInputs', () => {
mockGetLatestConversation.mockReturnValue(latest);
expect(result.current.readCodeInputs().latest).toBe(latest);
});
+
+ it('keeps a storage-denied captured cleanup safe without using the legacy clear', () => {
+ const getItem = jest.spyOn(Storage.prototype, 'getItem').mockImplementation(() => {
+ throw new Error('Storage denied');
+ });
+ const submitted = conversation({ endpoint: EModelEndpoint.openAI, model: 'gpt-5' });
+ const { result } = renderHook(() => useTurnServices({ index: 3, conversation: submitted }), {
+ wrapper,
+ });
+ const legacy = jest.spyOn(result.current, 'clearFilesToDelete');
+ const cleanup =
+ result.current.captureFilesToDelete?.(['file-1']) ?? result.current.clearFilesToDelete;
+ expect(cleanup).toBeDefined();
+ expect(() => cleanup?.()).not.toThrow();
+ expect(legacy).not.toHaveBeenCalled();
+ getItem.mockRestore();
+ });
});
diff --git a/client/src/hooks/Chat/services.ts b/client/src/hooks/Chat/services.ts
index ee1a73f07d4..1db6436875f 100644
--- a/client/src/hooks/Chat/services.ts
+++ b/client/src/hooks/Chat/services.ts
@@ -13,10 +13,10 @@ import {
bindComposerLaunch,
getRouteChatProjectId,
} from '~/utils';
+import useSetFilesToDelete, { captureFilesToDelete } from '~/hooks/Files/useSetFilesToDelete';
import useGetConversation from '~/hooks/Conversations/useGetConversation';
import useDiscardPastedFiles from '~/hooks/Files/useDiscardPastedFiles';
import useCodeApprovalMode from '~/hooks/Agents/useCodeApprovalMode';
-import useSetFilesToDelete from '~/hooks/Files/useSetFilesToDelete';
import { useAgentsMapContext } from '~/Providers/AgentsMapContext';
import { useChatSettings } from '~/Providers/ChatSettingsContext';
import useCodeWorkspace from '~/hooks/Agents/useCodeWorkspace';
@@ -107,5 +107,6 @@ export default function useTurnServices({
discardFiles,
releaseFiles: (fileIds) => markPasteSubmitted(...fileIds),
clearFilesToDelete: () => setFilesToDelete({}),
+ captureFilesToDelete,
};
}
diff --git a/client/src/hooks/Files/__tests__/useSetFilesToDelete.spec.ts b/client/src/hooks/Files/__tests__/useSetFilesToDelete.spec.ts
new file mode 100644
index 00000000000..557307a83cd
--- /dev/null
+++ b/client/src/hooks/Files/__tests__/useSetFilesToDelete.spec.ts
@@ -0,0 +1,58 @@
+import { LocalStorageKeys } from 'librechat-data-provider';
+import { captureFilesToDelete } from '../useSetFilesToDelete';
+
+const key = LocalStorageKeys.FILES_TO_DELETE;
+const original = { file_id: 'file-original', progress: 1 };
+const write = (files: Record) => localStorage.setItem(key, JSON.stringify(files));
+const read = () => JSON.parse(localStorage.getItem(key) ?? '{}');
+afterEach(() => {
+ jest.restoreAllMocks();
+ localStorage.clear();
+});
+
+it('removes captured markers while keeping another pane and a newly added upload', () => {
+ write({ owned: original, other: { file_id: 'other-pane' } });
+ const commit = captureFilesToDelete(['owned']);
+ write({ owned: original, other: { file_id: 'other-pane' }, added: { file_id: 'new-upload' } });
+ commit();
+ expect(read()).toEqual({ other: { file_id: 'other-pane' }, added: { file_id: 'new-upload' } });
+});
+
+it.each([
+ { ...original, progress: 0.5 },
+ { file_id: 'replacement', progress: 1 },
+])('preserves a newer same-key marker: %j', (replacement) => {
+ write({ owned: original });
+ const commit = captureFilesToDelete(['owned']);
+ write({ owned: replacement });
+ commit();
+ expect(read()).toEqual({ owned: replacement });
+});
+
+it('returns a no-op capture when reading storage is denied', () => {
+ write({ owned: original });
+ jest.spyOn(Storage.prototype, 'getItem').mockImplementationOnce(() => {
+ throw new Error('denied');
+ });
+ const set = jest.spyOn(Storage.prototype, 'setItem');
+ const commit = captureFilesToDelete(['owned']);
+ expect(() => commit()).not.toThrow();
+ expect(set).not.toHaveBeenCalled();
+ expect(read()).toEqual({ owned: original });
+});
+
+it('does not interrupt accepted ownership when cleanup storage becomes unavailable', () => {
+ write({ owned: original });
+ const commit = captureFilesToDelete(['owned']);
+ jest.spyOn(Storage.prototype, 'setItem').mockImplementationOnce(() => {
+ throw new Error('denied');
+ });
+ expect(() => commit()).not.toThrow();
+});
+
+it.each(['[1]', 'null', '{bad'])('leaves unsupported legacy storage alone: %s', (raw) => {
+ localStorage.setItem(key, raw);
+ const set = jest.spyOn(Storage.prototype, 'setItem');
+ captureFilesToDelete(['owned'])();
+ expect(set).not.toHaveBeenCalled();
+});
diff --git a/client/src/hooks/Files/useSetFilesToDelete.ts b/client/src/hooks/Files/useSetFilesToDelete.ts
index b1559b319ec..641df1c90fb 100644
--- a/client/src/hooks/Files/useSetFilesToDelete.ts
+++ b/client/src/hooks/Files/useSetFilesToDelete.ts
@@ -9,3 +9,45 @@ export default function useSetFilesToDelete() {
);
return setFilesToDelete;
}
+
+/** Snapshot app-owned file markers without consuming another pane or newer upload edits. */
+export function captureFilesToDelete(keys: readonly string[]): () => void {
+ const read = (): Record | undefined => {
+ try {
+ const raw = localStorage.getItem(LocalStorageKeys.FILES_TO_DELETE);
+ if (raw == null) return;
+ const files: Record | null = JSON.parse(raw);
+ return files != null && typeof files === 'object' && !Array.isArray(files)
+ ? files
+ : undefined;
+ } catch {
+ return;
+ }
+ };
+ const owned = new Set(keys);
+ const captured = Object.entries(read() ?? {})
+ .filter(([key]) => owned.has(key))
+ .map(([key, file]) => [key, JSON.stringify(file)] as const);
+ return () => {
+ if (captured.length === 0) return;
+ const current = read();
+ if (current == null) return;
+ let changed = false;
+ for (const [key, value] of captured) {
+ if (
+ !Object.prototype.hasOwnProperty.call(current, key) ||
+ JSON.stringify(current[key]) !== value
+ )
+ continue;
+ delete current[key];
+ changed = true;
+ }
+ if (changed) {
+ try {
+ localStorage.setItem(LocalStorageKeys.FILES_TO_DELETE, JSON.stringify(current));
+ } catch {
+ /* Storage cannot interrupt an accepted turn's ownership commit. */
+ }
+ }
+ };
+}
diff --git a/packages/chat/src/components/side/__tests__/panel.spec.tsx b/packages/chat/src/components/side/__tests__/panel.spec.tsx
index c8d6d6e9b30..eee712ab822 100644
--- a/packages/chat/src/components/side/__tests__/panel.spec.tsx
+++ b/packages/chat/src/components/side/__tests__/panel.spec.tsx
@@ -10,17 +10,23 @@ import type { ChatStream, ChatTransport, ChatSendRequest } from '../../../core';
import type { ChatHost, TurnServices } from '../../../react/chat/host';
import type { SideChatHost } from '../../../react/side/host';
import type { SideChat } from '../../../react/side/state';
+import {
+ sideChatAtom,
+ sideChatDraftFamily,
+ sideChatDraftSubmittedAtom,
+} from '../../../react/side/state';
import { createTurnServices as createBaseTurnServices } from '../../../react/chat/__fixtures__/services';
import { MessagesHostProvider, useMessagesHost } from '../../../react/messages/host';
-import { sideChatAtom, sideChatDraftFamily } from '../../../react/side/state';
import { createMessagePartsHost } from '../../../__fixtures__/partsHost';
import { ChatSurfaceProvider } from '../../../react/subagents/provider';
import { createMessagesHost } from '../../../__fixtures__/messagesHost';
import { turnInputs } from '../../../core/code/__fixtures__/turn';
import { SideChatHostProvider } from '../../../react/side/host';
import { MessagePartsHostProvider } from '../../../react/host';
+import { isSubmittingFamily } from '../../../react/submission';
import { useChatContext } from '../../../react/chat/context';
import { ChatHostProvider } from '../../../react/chat/host';
+import { SIDE_CHAT_PANE } from '../../../react/side/state';
import { initEnglish } from '../../../__fixtures__/i18n';
import { useFollowChat } from '../../../react/follow';
import SideChatPanel from '../panel';
@@ -140,12 +146,14 @@ function setup({
stored = [user, reply('response-1', 'It shipped.')],
loadMessages = jest.fn(async () => stored),
services = createTurnServices(),
+ ownedDrafts = true,
}: {
chat?: SideChat;
draft?: string;
stored?: TMessage[];
loadMessages?: jest.Mock>;
services?: TestServices;
+ ownedDrafts?: boolean;
} = {}) {
const streams: TestStream[] = [];
const sendMessages = jest.fn(
@@ -215,6 +223,15 @@ function setup({
onClose();
setCurrent(null);
}}
+ onDraftSubmitted={
+ ownedDrafts
+ ? (expected, submitted) => {
+ if (store.get(sideChatAtom) === expected && expected.text)
+ onHandedTextTaken(expected);
+ store.set(sideChatDraftSubmittedAtom, expected, submitted);
+ }
+ : undefined
+ }
onHandedTextTaken={(expected) => {
onHandedTextTaken(expected);
setCurrent((value) =>
@@ -286,6 +303,67 @@ const settle = () =>
});
describe('SideChatPanel', () => {
+ it('preserves the optional draft callback contract for ordinary manual submissions', async () => {
+ const view = setup({ ownedDrafts: false });
+ await waitFor(() => expect(rows()).toHaveLength(2));
+ fireEvent.change(field(), { target: { value: ' Manual question. ' } });
+ fireEvent.click(screen.getByTestId('composer-send-button'));
+ await waitFor(() => expect(view.streams).toHaveLength(1));
+ expect(field()).toHaveValue('');
+ expect(view.store.get(sideChatAtom)?.text).toBeUndefined();
+ });
+
+ it.each([true, false])(
+ 'preserves a new same-ID handoff introduced by accepted commit (automatic=%s)',
+ async (automatic) => {
+ const services = createTurnServices({ readiness: automatic ? 'pending' : 'ready' });
+ const view = setup({
+ chat: { conversation, text: automatic ? 'Same words.' : undefined },
+ services,
+ });
+ await waitFor(() => expect(rows()).toHaveLength(2));
+ if (!automatic) fireEvent.change(field(), { target: { value: 'Same words.' } });
+ expect(field()).toHaveValue('Same words.');
+ let replaced = false;
+ const unsubscribe = view.store.sub(isSubmittingFamily(SIDE_CHAT_PANE), () => {
+ if (replaced || !view.store.get(isSubmittingFamily(SIDE_CHAT_PANE))) return;
+ replaced = true;
+ view.store.set(sideChatDraftFamily(conversationId), '');
+ view.store.set(sideChatAtom, { conversation, text: 'Same words.' });
+ });
+ services.readiness = 'ready';
+ if (automatic) view.refresh();
+ else fireEvent.click(screen.getByTestId('composer-send-button'));
+ await waitFor(() => expect(view.streams).toHaveLength(1));
+ expect(replaced).toBe(true);
+ expect(view.store.get(sideChatDraftFamily(conversationId))).toBe('Same words.');
+ expect(view.store.get(sideChatAtom)?.text).toBe('Same words.');
+ unsubscribe();
+ },
+ );
+
+ it('waits for an old turn before sending a new handoff to the same mounted conversation', async () => {
+ const view = setup();
+ await waitFor(() => expect(rows()).toHaveLength(2));
+ fireEvent.change(field(), { target: { value: 'First question.' } });
+ fireEvent.click(screen.getByTestId('composer-send-button'));
+ await waitFor(() => expect(view.streams).toHaveLength(1));
+ const asked = view.sendMessages.mock.calls[0][0].payload as unknown as TMessage;
+ view.open({ conversation, text: 'Question after this turn.' });
+ await settle();
+ expect(view.store.get(sideChatAtom)?.text).toBe('Question after this turn.');
+ expect(field()).toHaveValue('Question after this turn.');
+ expect(view.sendMessages).toHaveBeenCalledTimes(1);
+ act(() =>
+ view.streams[0].push(final(asked, reply('answer-first', 'First answer.', asked.messageId))),
+ );
+ await waitFor(() => expect(view.streams).toHaveLength(2));
+ expect(view.sendMessages.mock.calls[1][0].payload).toMatchObject({
+ text: 'Question after this turn.',
+ });
+ expect(view.onHandedTextTaken).toHaveBeenCalledTimes(1);
+ });
+
it('does not clear a newer same-destination draft published during actual send acceptance', async () => {
const services = createTurnServices({ readiness: 'pending' });
const view = setup({ chat: { conversation, text: 'Old question.' }, services });
diff --git a/packages/chat/src/components/side/panel.tsx b/packages/chat/src/components/side/panel.tsx
index da272edd9ee..550567ab499 100644
--- a/packages/chat/src/components/side/panel.tsx
+++ b/packages/chat/src/components/side/panel.tsx
@@ -18,6 +18,7 @@ import DrivenThread from '../pane/Driven';
type SideChatComposerProps = {
contract: ChatContract;
+ ask: (text: string) => false | void;
attempt: ReturnType['attempt'];
readiness: TurnReadiness;
/** The reader's unsent words, which the panel holds so they outlive the composer. */
@@ -44,6 +45,7 @@ type SideChatComposerProps = {
*/
function SideChatComposer({
contract,
+ ask,
attempt,
readiness,
value,
@@ -60,7 +62,7 @@ function SideChatComposer({
enterToSend,
composerBindings: { shortcutsEnabled, submitOverride, yieldedChords },
} = useChatSurface();
- const { ask, isSubmitting, stopGenerating } = contract;
+ const { isSubmitting, stopGenerating } = contract;
const field = useRef(null);
const focused = useRef(false);
@@ -91,8 +93,7 @@ function SideChatComposer({
const outcome = value === handedText && readiness === 'ready' ? attempt(handedText) : 'blocked';
if (outcome === 'pending') return;
handed.current = handoff;
- if (outcome === 'accepted') setValue('');
- else onHandedTextTaken();
+ if (outcome === 'blocked') onHandedTextTaken();
}, [attempt, handoff, handedText, onHandedTextTaken, readiness, ready, setValue, value]);
/** Editing supersedes automatic intent; accepted sends consume it at the driven owner. */
@@ -112,12 +113,11 @@ function SideChatComposer({
const submit = useCallback(() => {
const text = value.trim();
- if (text === '' || ask({ text }) === false) {
+ if (text === '' || ask(text) === false) {
return;
}
handed.current = handoff;
- setValue('');
- }, [ask, handoff, setValue, value]);
+ }, [ask, handoff, value]);
/** The main chat form's own Enter decision table, so a rebound submit shortcut holds here. */
const resolveKeyVerdict = useCallback(
@@ -172,11 +172,14 @@ export default function SideChatPanel({
chat,
onClose,
onHandedTextTaken,
+ onDraftSubmitted,
}: {
chat: SideChat;
onClose: () => void;
/** The words handed over with the conversation were sent, or put in the field. */
onHandedTextTaken: (expected: SideChat) => void;
+ /** Atomically retire the captured composer draft and intent after actual acceptance. */
+ onDraftSubmitted?: (expected: SideChat, submitted: string) => void;
}): ReactNode {
const localize = useLocalize();
const host = useSideChatHost();
@@ -186,6 +189,30 @@ export default function SideChatPanel({
const { handOffComposerText } = useChatSurface();
const conversationId = chat.conversation.conversationId ?? '';
const [draft, setDraft] = useAtom(sideChatDraftFamily(conversationId));
+ // Only composer calls own its draft; transcript actions consume intent without clearing it.
+ const composerCall = useRef<{ chat: SideChat; draft: string }>();
+ const withDraft = (send: () => T): T => {
+ const previous = composerCall.current;
+ composerCall.current = { chat, draft };
+ try {
+ return send();
+ } finally {
+ composerCall.current = previous;
+ }
+ };
+ const accepted = useCallback(() => {
+ const captured = composerCall.current;
+ if (captured?.chat === chat) {
+ if (onDraftSubmitted) {
+ onDraftSubmitted(chat, captured.draft);
+ } else {
+ setDraft((current) => (current === captured.draft ? '' : current));
+ if (chat.text) onHandedTextTaken(chat);
+ }
+ } else if (chat.text) {
+ onHandedTextTaken(chat);
+ }
+ }, [chat, onDraftSubmitted, onHandedTextTaken, setDraft]);
const takeText = useCallback(() => onHandedTextTaken(chat), [chat, onHandedTextTaken]);
/**
* A turn stopped before the server kept it is gone from the list. Its words go back in the
@@ -283,12 +310,13 @@ export default function SideChatPanel({
index={SIDE_CHAT_PANE}
followed={followed}
handoff={!!chat.text}
- onAccepted={chat.text ? takeText : undefined}
+ onAccepted={accepted}
>
{(contract) => (
withDraft(() => contract.ask({ text }))}
+ attempt={(text) => withDraft(() => contract.attempt(text))}
readiness={contract.readiness}
value={draft}
onChange={setDraft}
diff --git a/packages/chat/src/core/__tests__/chat.spec.ts b/packages/chat/src/core/__tests__/chat.spec.ts
index 91eddf14f70..54c0119587a 100644
--- a/packages/chat/src/core/__tests__/chat.spec.ts
+++ b/packages/chat/src/core/__tests__/chat.spec.ts
@@ -139,6 +139,109 @@ const setup = (
const flush = () => new Promise((resolve) => setTimeout(resolve, 0));
describe('Chat', () => {
+ it('publishes availability after the hidden answer claim releases', async () => {
+ let refuse!: (error: Error) => void;
+ const { chat, state } = setup(
+ {},
+ {
+ resume: () =>
+ new Promise((_, reject) => {
+ refuse = reject;
+ }),
+ },
+ );
+ const pause = {
+ actionId: 'question',
+ streamId: 'convo-1',
+ conversationId: 'convo-1',
+ createdAt: 1,
+ expiresAt: Date.now() + 60000,
+ payload: {
+ type: 'ask_user_question',
+ tool_call_id: 'question',
+ question: { question: 'Which?' },
+ },
+ } as Agents.PendingAction;
+ state.status = 'error';
+ chat.restorePendingAction(pause, 100);
+ const answered = chat
+ .addToolOutput({ toolCallId: 'question', output: 'This one.' })
+ .catch((error: Error) => error);
+ chat.restorePendingAction({ ...pause, expiresAt: Date.now() - 1 }, 100);
+ expect(chat.pendingAction).toBeUndefined();
+ expect(chat.canRequest).toBe(false);
+ const availability: boolean[] = [];
+ chat.subscribe(() => availability.push(chat.canRequest));
+ const rows = chat.messages;
+ refuse(Object.assign(new Error('Answer refused'), { status: 400 }));
+ const result = await answered;
+ expect(result).toBeInstanceOf(Error);
+ expect(chat.canRequest).toBe(true);
+ expect(chat.status).toBe('error');
+ expect(chat.messages).toBe(rows);
+ expect(availability).toEqual([true]);
+ chat.dispose();
+ });
+
+ it('projects expiry without housekeeping and preserves request reentrancy checks', async () => {
+ const { chat, transport } = setup();
+ const now = Date.now();
+ const pause = {
+ actionId: 'expiring',
+ streamId: 'convo-1',
+ conversationId: 'convo-1',
+ createdAt: 1,
+ expiresAt: now + 60000,
+ payload: {
+ type: 'ask_user_question',
+ tool_call_id: 'question',
+ question: { question: 'Which?' },
+ },
+ } as Agents.PendingAction;
+ chat.restorePendingAction(pause, 100);
+ const clock = jest.spyOn(Date, 'now').mockReturnValue(now + 60001);
+ try {
+ expect(chat.canRequest).toBe(true);
+ expect(chat.pendingAction).toBe(pause);
+ chat.subscribe(() => {
+ if (!chat.pendingAction) chat.dispose();
+ });
+ await expect(chat.sendMessage({ parts: [{ type: 'text', text: 'Next.' }] })).rejects.toThrow(
+ 'disposed',
+ );
+ expect(transport.sendMessages).not.toHaveBeenCalled();
+ } finally {
+ clock.mockRestore();
+ chat.dispose();
+ }
+ });
+
+ it('projects live pause ownership even when public status is error', async () => {
+ const { chat, state } = setup();
+ const pause = {
+ actionId: 'paused',
+ streamId: 'convo-1',
+ conversationId: 'convo-1',
+ createdAt: 1,
+ expiresAt: Date.now() + 60000,
+ payload: {
+ type: 'ask_user_question',
+ tool_call_id: 'question',
+ question: { question: 'Which?' },
+ },
+ } as Agents.PendingAction;
+ chat.restorePendingAction(pause, 100);
+ state.status = 'error';
+ try {
+ expect(chat.canRequest).toBe(false);
+ await expect(chat.sendMessage({ parts: [{ type: 'text', text: 'Wait.' }] })).rejects.toThrow(
+ 'paused generation',
+ );
+ } finally {
+ chat.dispose();
+ }
+ });
+
it('walks submitted, streaming and ready, merging the final messages', async () => {
const { chat, stream, transport, state, onFinish, onEvent } = setup();
diff --git a/packages/chat/src/core/chat.ts b/packages/chat/src/core/chat.ts
index 3debb743ed7..917f2d91061 100644
--- a/packages/chat/src/core/chat.ts
+++ b/packages/chat/src/core/chat.ts
@@ -996,6 +996,17 @@ export class Chat {
return this.action;
}
+ /** Pure projection of request ownership. Expired pauses still undergo request's
+ * notifying cleanup and reentrant checks before a turn is actually taken. */
+ get canRequest(): boolean {
+ return (
+ !this.disposed &&
+ !this.active &&
+ (!this.action || (isExpired(this.action) && this.resuming !== this.action.actionId)) &&
+ (!this.answering || this.answering.ended)
+ );
+ }
+
/** Submits a user turn. Rejects while another turn of this chat is in flight. */
sendMessage(input: SendMessageInput, options?: ChatRequestOptions): Promise {
return this.request({ trigger: 'submit-message', input }, options);
@@ -2959,6 +2970,8 @@ export class Chat {
}
throw error;
} finally {
+ const available = this.canRequest;
+ const revision = this.revision;
if (this.answering === claim) {
this.answering = undefined;
}
@@ -2973,6 +2986,9 @@ export class Chat {
this.clearAction();
}
}
+ /** A visible pause may clear before its answer claim; publish only the coherent
+ * final availability if no existing transition already announced it. */
+ if (!available && this.canRequest && revision === this.revision) this.notify();
}
}
diff --git a/packages/chat/src/react.ts b/packages/chat/src/react.ts
index ef1c0971ebc..6ca3401e21e 100644
--- a/packages/chat/src/react.ts
+++ b/packages/chat/src/react.ts
@@ -134,6 +134,7 @@ export { useDrivenContract } from './react/chat/driven';
export type { DrivenContractOptions } from './react/chat/driven';
export {
sideChatAtom,
+ sideChatDraftSubmittedAtom,
SIDE_CHAT_PANE,
sideChatBesideAtom,
sideChatRequestAtom,
diff --git a/packages/chat/src/react/__tests__/follow.spec.tsx b/packages/chat/src/react/__tests__/follow.spec.tsx
index 28e70413fce..cfa07938095 100644
--- a/packages/chat/src/react/__tests__/follow.spec.tsx
+++ b/packages/chat/src/react/__tests__/follow.spec.tsx
@@ -4,7 +4,7 @@
import { act, renderHook, waitFor } from '@testing-library/react';
import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
import { Constants, StepTypes, StepEvents, ContentTypes, QueryKeys } from 'librechat-data-provider';
-import type { TMessage, ChatEvent } from 'librechat-data-provider';
+import type { TMessage, ChatEvent, Agents } from 'librechat-data-provider';
import type { ReactNode } from 'react';
import type { ChatStream, ChatTransport, ChatStreamStatus } from '../../core';
import type { FollowChatOptions } from '../follow';
@@ -160,6 +160,56 @@ const setup = (initial: Partial & Pick {
+ it('wakes once when pause ownership retires without messages or status changing', async () => {
+ const { transport } = createTransport(idle);
+ const client = new QueryClient();
+ const wrapper = ({ children }: { children: ReactNode }) => (
+ {children}
+ );
+ let renders = 0;
+ const view = renderHook(
+ () => {
+ renders++;
+ const followed = useFollowChat({
+ id: 'thread-1',
+ transport,
+ loadMessages: async () => [brief],
+ });
+ return { followed, free: followed.canSend() };
+ },
+ { wrapper },
+ );
+ await waitFor(() => expect(view.result.current.free).toBe(true));
+ const chat = view.result.current.followed.chat!;
+ const pause = {
+ actionId: 'question',
+ streamId: 'thread-1',
+ conversationId: 'thread-1',
+ createdAt: 1,
+ expiresAt: Date.now() + 60000,
+ payload: {
+ type: 'ask_user_question',
+ tool_call_id: 'question',
+ question: { question: 'Which?' },
+ },
+ } as Agents.PendingAction;
+ act(() => chat.restorePendingAction(pause, 2000));
+ await waitFor(() => expect(view.result.current.free).toBe(false));
+ const messages = chat.messages;
+ const status = chat.status;
+ const before = renders;
+ // Ownership snapshots stay primitive: repeated native notifications add no renders.
+ act(() => {
+ for (let index = 0; index < 20; index++) chat.restorePendingAction(pause, 2000);
+ });
+ expect(renders).toBe(before);
+ act(() => chat.restorePendingAction({ ...pause, expiresAt: Date.now() - 1 }, 2000));
+ await waitFor(() => expect(view.result.current.free).toBe(true));
+ expect(chat.messages).toBe(messages);
+ expect(chat.status).toBe(status);
+ expect(renders).toBe(before + 1);
+ view.unmount();
+ });
it.each([
{ outcome: 'joined', observed: true },
{ outcome: 'failed', observed: true },
diff --git a/packages/chat/src/react/chat/__tests__/driven.spec.tsx b/packages/chat/src/react/chat/__tests__/driven.spec.tsx
index 1535a11bcd9..19e5cc6ad84 100644
--- a/packages/chat/src/react/chat/__tests__/driven.spec.tsx
+++ b/packages/chat/src/react/chat/__tests__/driven.spec.tsx
@@ -12,11 +12,17 @@ import {
StepEvents,
ContentTypes,
EModelEndpoint,
+ ReasoningEffort,
} from 'librechat-data-provider';
import type { TMessage, ChatEvent, TConversation } from 'librechat-data-provider';
import type { ChatStream, ChatTransport, ChatSendRequest, ChatStreamStatus } from '../../../core';
import type { ChatHost, TurnServices } from '../host';
import type { ExtendedFile } from '../../../core';
+import {
+ pendingManualSkillsByConvoId,
+ pendingQuotesByConvoId,
+ pendingReasoningOverrideFamily,
+} from '../../composer';
import { createTurnServices, createTurnCodeInputs } from '../__fixtures__/services';
import { showStopButtonByIndex } from '../../generation';
import { isSubmittingFamily } from '../../submission';
@@ -239,6 +245,97 @@ function setup({
}
describe('useDrivenContract', () => {
+ it('commits only captured inputs before notifying acceptance', async () => {
+ const order: string[] = [];
+ const cleanup = jest.fn(() => order.push('markers'));
+ const services = createTurnServices({
+ captureFilesToDelete: jest.fn(() => cleanup),
+ releaseFiles: jest.fn(() => order.push('files')),
+ });
+ const onAccepted = jest.fn(() => order.push('accepted'));
+ const view = setup({ services, onAccepted });
+ await view.ready();
+ const original = { file_id: 'original-file', progress: 1, size: 1 };
+ const replacement = { file_id: 'replacement-file', progress: 1, size: 1 };
+ const added = { file_id: 'later-file', progress: 1, size: 1 };
+ const reasoning = { key: 'reasoning_effort', value: ReasoningEffort.high } as const;
+ const laterReasoning = { key: 'reasoning_effort', value: ReasoningEffort.low } as const;
+ act(() => {
+ view.store.set(filesFamily(SIDE_PANE), new Map([['upload', original]]));
+ view.store.set(pendingManualSkillsByConvoId(conversationId), ['skill-original']);
+ view.store.set(pendingQuotesByConvoId(conversationId), ['quoted-original']);
+ view.store.set(pendingReasoningOverrideFamily(conversationId), reasoning);
+ });
+ let staged = false;
+ const unsubscribe = view.result.current.followed.chat!.subscribe(() => {
+ if (staged || view.result.current.followed.chat!.status !== 'submitted') return;
+ staged = true;
+ view.store.set(
+ filesFamily(SIDE_PANE),
+ new Map([
+ ['upload', replacement],
+ ['added', added],
+ ]),
+ );
+ view.store.set(pendingManualSkillsByConvoId(conversationId), [
+ 'skill-original',
+ 'skill-later',
+ ]);
+ view.store.set(pendingQuotesByConvoId(conversationId), ['quoted-original', 'quoted-later']);
+ view.store.set(pendingReasoningOverrideFamily(conversationId), laterReasoning);
+ });
+ act(() => view.result.current.contract.ask({ text: 'Capture these inputs.' }));
+ await waitFor(() => expect(view.sendMessages).toHaveBeenCalledTimes(1));
+ expect(staged).toBe(true);
+ expect(view.store.get(pendingManualSkillsByConvoId(conversationId))).toEqual(['skill-later']);
+ expect(view.store.get(pendingQuotesByConvoId(conversationId))).toEqual(['quoted-later']);
+ expect(view.store.get(pendingReasoningOverrideFamily(conversationId))).toBe(laterReasoning);
+ expect(view.store.get(filesFamily(SIDE_PANE))).toEqual(
+ new Map([
+ ['upload', replacement],
+ ['added', added],
+ ]),
+ );
+ expect(services.releaseFiles).toHaveBeenCalledWith(expect.arrayContaining(['original-file']));
+ expect(services.captureFilesToDelete).toHaveBeenCalledWith(['upload']);
+ expect(services.clearFilesToDelete).not.toHaveBeenCalled();
+ expect(order).toEqual(['files', 'markers', 'accepted']);
+ expect(onAccepted).toHaveBeenCalledTimes(1);
+ unsubscribe();
+ });
+
+ it('keeps every captured composer input when actual publication is declined', async () => {
+ const view = setup();
+ await view.ready();
+ const file = { file_id: 'staged-file', progress: 1, size: 1 };
+ const reasoning = { key: 'reasoning_effort', value: ReasoningEffort.high } as const;
+ act(() => {
+ view.store.set(filesFamily(SIDE_PANE), new Map([[file.file_id, file]]));
+ view.store.set(pendingManualSkillsByConvoId(conversationId), ['skill-original']);
+ view.store.set(pendingQuotesByConvoId(conversationId), ['quoted-original']);
+ view.store.set(pendingReasoningOverrideFamily(conversationId), reasoning);
+ });
+ const decline = jest
+ .spyOn(view.result.current.followed.chat!, 'sendMessage')
+ .mockResolvedValueOnce(undefined);
+ act(() => view.result.current.contract.ask({ text: 'Keep all inputs.' }));
+ expect(view.store.get(pendingManualSkillsByConvoId(conversationId))).toEqual([
+ 'skill-original',
+ ]);
+ expect(view.store.get(pendingQuotesByConvoId(conversationId))).toEqual(['quoted-original']);
+ expect(view.store.get(pendingReasoningOverrideFamily(conversationId))).toBe(reasoning);
+ expect(view.store.get(filesFamily(SIDE_PANE)).get(file.file_id)).toBe(file);
+ expect(view.services.releaseFiles).not.toHaveBeenCalled();
+ expect(view.services.clearFilesToDelete).not.toHaveBeenCalled();
+ decline.mockRestore();
+ act(() => view.result.current.contract.ask({ text: 'Keep all inputs.' }));
+ await waitFor(() => expect(view.sendMessages).toHaveBeenCalledTimes(1));
+ expect(view.sendMessages.mock.calls[0][0].payload).toMatchObject({
+ manualSkills: ['skill-original'],
+ quotes: ['quoted-original'],
+ });
+ });
+
it.each(['edit', 'regenerate', 'continue', 'preview'] as const)(
'announces actual acceptance for %s',
async (action) => {
diff --git a/packages/chat/src/react/chat/driven.ts b/packages/chat/src/react/chat/driven.ts
index 3ce81279654..081a524317e 100644
--- a/packages/chat/src/react/chat/driven.ts
+++ b/packages/chat/src/react/chat/driven.ts
@@ -117,16 +117,9 @@ export function useDrivenContract({
if (submission == null) {
return;
}
- if (messages == null || !send({ submission, messages })) {
- /** The chat took nothing, so the flags `ask` raised for the turn come back down. */
- setIsSubmitting(false);
- setShowStopButton(false);
- } else {
- accepted.current = true;
- onAccepted?.();
- }
+ if (messages != null && send({ submission, messages })) accepted.current = true;
},
- [send, setIsSubmitting, setShowStopButton, onAccepted],
+ [send],
);
const turnsParams: ChatTurnsParams = {
@@ -150,12 +143,11 @@ export function useDrivenContract({
};
const useReadiness = host.useTurnReadiness ?? useReady;
const readiness = useReadiness(conversation, handoff);
- const turns = useTurns(
- turnsParams,
- services,
- () => (!canSend() ? 'pending' : readiness),
- () => accepted.current,
- );
+ const turns = useTurns(turnsParams, services, {
+ readiness: () => (!canSend() ? 'pending' : readiness),
+ accepted: () => accepted.current,
+ committed: onAccepted,
+ });
const attempt = turns.attempt;
const { ask, regenerate, handleRegenerate, handleContinue } = useTurnHandlers({
ask: turns.ask,
diff --git a/packages/chat/src/react/chat/host.tsx b/packages/chat/src/react/chat/host.tsx
index adc80c87034..68097db00ad 100644
--- a/packages/chat/src/react/chat/host.tsx
+++ b/packages/chat/src/react/chat/host.tsx
@@ -111,6 +111,8 @@ export type TurnServices = {
discardFiles?: (fileIds: string[]) => void;
/** Forgets the files queued for deletion once the composer is cleared. */
clearFilesToDelete: () => void;
+ /** Captures app-owned file-marker cleanup before a driven publication can stage new files. */
+ captureFilesToDelete?: (keys: readonly string[]) => () => void;
};
/** The conversation a pane shows, and the setter that replaces or updates it. */
diff --git a/packages/chat/src/react/chat/turns.ts b/packages/chat/src/react/chat/turns.ts
index e1f9240aacc..91d9273f81f 100644
--- a/packages/chat/src/react/chat/turns.ts
+++ b/packages/chat/src/react/chat/turns.ts
@@ -35,6 +35,11 @@ import { isHistoryRevalidating } from './guards';
type Attempt = 'accepted' | 'pending' | 'blocked';
type Submit = (props: TAskProps, options?: TOptions, automatic?: boolean) => Attempt;
+type Admission = {
+ readiness: () => TurnReadiness;
+ accepted: () => boolean;
+ committed?: () => void;
+};
/**
* Submits and regenerates turns for one pane: refuses a send the chat cannot take yet, drains
@@ -56,9 +61,7 @@ export function useTurns(
conversation: immutableConversation,
}: ChatTurnsParams,
services: TurnServices,
- admission?: () => TurnReadiness,
- /** Optional synchronous confirmation from the driven publication owner. */
- accepted?: () => boolean,
+ admission?: Admission,
): { ask: TAskFunction; attempt: (text: string) => Attempt; regenerate: TRegenerateFunction } {
const store = useStore();
const queryClient = useQueryClient();
@@ -66,6 +69,7 @@ export function useTurns(
const setSubmissionStart = useSetAtom(submissionStartFamily(index));
const setShowStopButton = useSetAtom(showStopButtonByIndex(index));
const { logger } = services;
+ const deferred = admission != null;
/**
* `ask` refuses while `isSubmitting`, but that value only reads true from the next commit
@@ -156,8 +160,12 @@ export function useTurns(
const regenerateShaped = isRegenerate || compact;
/** An accepted or revealed local turn is newer explicit intent; it must not arm an
* automatic retry. Temporary transport/workspace phases below keep their pending intent. */
+ if (askInFlightRef.current) {
+ if (!automatic) return 'blocked';
+ const readiness = admission?.readiness() ?? 'pending';
+ if (readiness !== 'ready') return readiness;
+ }
if (
- askInFlightRef.current ||
store.get(revealedQueuedTurnFamily(immutableConversation?.conversationId ?? '')) != null ||
(!regenerateShaped && !isSubmittableMessage(text, availableFileCount))
) {
@@ -176,7 +184,7 @@ export function useTurns(
/** The builder resolves `promptPrefix` on its copy; the pane's conversation stays as is. */
const conversation = immutableConversation == null ? null : { ...immutableConversation };
if (services.canSubmit?.(conversation) === false) {
- return admission?.() === 'pending' ? 'pending' : 'blocked';
+ return admission?.readiness() === 'pending' ? 'pending' : 'blocked';
}
const codeResult = resolveTurnCodeResult(services.readCodeInputs(), conversation);
if (codeResult.state !== 'ready') {
@@ -236,7 +244,7 @@ export function useTurns(
return 'pending';
}
- setShowStopButton(false);
+ if (!deferred) setShowStopButton(false);
const convoKey = conversationId ?? Constants.NEW_CONVO;
const endpointsConfig = services.getEndpointsConfig();
@@ -246,8 +254,10 @@ export function useTurns(
* leaves the compose-time queue alone; a fresh submit drains the queue into the message.
*/
const replaysTurn = regenerateShaped || isContinued || isEdited;
+ const take = (family: typeof pendingQuotesByConvoId): string[] =>
+ deferred ? store.get(family(convoKey)) : drain(family, convoKey);
const manualSkills =
- overrideManualSkills ?? (replaysTurn ? [] : drain(pendingManualSkillsByConvoId, convoKey));
+ overrideManualSkills ?? (replaysTurn ? [] : take(pendingManualSkillsByConvoId));
/**
* Quoted excerpts resolve like manual skills, but are skipped entirely for Assistants
* endpoints: those bypass the server's quote merge, so the quote UI is hidden there and a
@@ -256,15 +266,18 @@ export function useTurns(
*/
let quotes: string[] = [];
if (!isAssistantsEndpoint(endpoint)) {
- quotes = overrideQuotes ?? (replaysTurn ? [] : drain(pendingQuotesByConvoId, convoKey));
+ quotes = overrideQuotes ?? (replaysTurn ? [] : take(pendingQuotesByConvoId));
}
let reasoningOverride = overrideReasoning ?? undefined;
const reasoningStateKey = getReasoningStateKey(conversationId, index);
const drainedReasoning = overrideReasoning === undefined && !replaysTurn;
if (drainedReasoning) {
- reasoningOverride = drainPendingReasoning(reasoningStateKey);
+ reasoningOverride = deferred
+ ? store.get(pendingReasoningOverrideFamily(reasoningStateKey))
+ : drainPendingReasoning(reasoningStateKey);
}
const stagedReasoning = reasoningOverride;
+ let keepReasoning = false;
if (reasoningOverride != null) {
const resolved = resolveSubmittedReasoning({
queryClient,
@@ -278,7 +291,8 @@ export function useTurns(
});
reasoningOverride = resolved.reasoningOverride;
/** Refused only because the catalog is not loaded yet: put a drained choice back. */
- if (resolved.restoreStaged && drainedReasoning && stagedReasoning != null) {
+ keepReasoning = resolved.restoreStaged;
+ if (!deferred && resolved.restoreStaged && drainedReasoning && stagedReasoning != null) {
store.set(pendingReasoningOverrideFamily(reasoningStateKey), stagedReasoning);
}
}
@@ -326,41 +340,61 @@ export function useTurns(
conversationId = turn.conversationId;
logger.log('message_state', initialResponse);
- if (turn.newChatPath != null) {
- services.openNewChat(turn.newChatPath);
- }
- if (fileEffects != null && setFiles) {
- markComposerFilesTaken([
- ...(fileEffects.canceledUploadIds ?? []),
- ...(fileEffects.replacedFileIds ?? []),
- ]);
- services.releaseFiles(fileEffects.submittedFileIds);
- if (fileEffects.canceledUploadIds?.length) {
- services.cancelUploads?.(fileEffects.canceledUploadIds);
+ const capturedFiles =
+ deferred && fileEffects?.clearComposer && files ? new Map(files) : undefined;
+ const clearFilesToDelete =
+ deferred && fileEffects?.clearComposer
+ ? (services.captureFilesToDelete?.(Array.from(capturedFiles?.keys() ?? [])) ??
+ services.clearFilesToDelete)
+ : services.clearFilesToDelete;
+ const commitComposer = (): void => {
+ if (turn.newChatPath != null) {
+ services.openNewChat(turn.newChatPath);
}
- if (fileEffects.replacedFileIds?.length) {
- services.discardFiles?.(fileEffects.replacedFileIds);
+ if (fileEffects != null && setFiles) {
+ markComposerFilesTaken([
+ ...(fileEffects.canceledUploadIds ?? []),
+ ...(fileEffects.replacedFileIds ?? []),
+ ]);
+ services.releaseFiles(fileEffects.submittedFileIds);
+ if (fileEffects.canceledUploadIds?.length) {
+ services.cancelUploads?.(fileEffects.canceledUploadIds);
+ }
+ if (fileEffects.replacedFileIds?.length) {
+ services.discardFiles?.(fileEffects.replacedFileIds);
+ }
+ if (fileEffects.clearComposer) {
+ if (!deferred) setFiles(new Map());
+ else
+ setFiles((current) => {
+ let next = current;
+ for (const [key, file] of capturedFiles ?? []) {
+ if (current.get(key) !== file) continue;
+ if (next === current) next = new Map(current);
+ next.delete(key);
+ }
+ return next;
+ });
+ clearFilesToDelete();
+ }
}
- if (fileEffects.clearComposer) {
- setFiles(new Map());
- services.clearFilesToDelete();
+ if (turn.startsSubmitting) {
+ setIsSubmitting(true);
+ setShowStopButton(true);
}
- }
- if (turn.startsSubmitting) {
- setIsSubmitting(true);
- setShowStopButton(true);
- }
- /** Bound before the optimistic tail is published, not after the first provider event: a
- * waiting request already owns a turn even when no usage exists. */
- store.set(
- activeUsageResponseIdFamily(conversationId ?? Constants.NEW_CONVO),
- initialResponse.messageId,
- );
+ /** Bound before the optimistic tail is published, not after the first provider event: a
+ * waiting request already owns a turn even when no usage exists. */
+ store.set(
+ activeUsageResponseIdFamily(conversationId ?? Constants.NEW_CONVO),
+ initialResponse.messageId,
+ );
+ };
+ if (!deferred) commitComposer();
if (turn.regenerateShaped) {
setMessages([...submissionMessages, initialResponse]);
- if (initialResponse.parentMessageId != null) {
+ if (!deferred && initialResponse.parentMessageId != null) {
store.set(siblingIdxFamily(siblingKey(initialResponse.parentMessageId)), 0);
}
} else {
@@ -370,20 +404,54 @@ export function useTurns(
/** Carries the submitted choice through the first saved-chat event instead of re-deriving
* it from agent defaults. Optimistic: the stream's error path reconciles an existing chat
* with its authoritative server decision if admission fails. */
- setConversation((current) =>
- current == null || current.conversationId !== conversation?.conversationId
- ? current
- : codeDecision.apply(current),
- );
+ const commitConversation = (): void => {
+ setConversation((current) =>
+ current == null || current.conversationId !== conversation?.conversationId
+ ? current
+ : codeDecision.apply(current),
+ );
+ };
+ if (!deferred) commitConversation();
/** Close the synchronous double-submit window before publication. A driven owner that
* declines after preflight releases this attempt's lock below. */
askInFlightRef.current = true;
- setSubmissionStart(Date.now());
- store.set(launchedConversationFamily(index), submission.conversation);
+ const commitLaunch = (): void => {
+ setSubmissionStart(Date.now());
+ store.set(launchedConversationFamily(index), submission.conversation);
+ };
+ if (!deferred) commitLaunch();
setSubmission(submission);
- if (accepted?.() === false) {
+ if (admission?.accepted() === false) {
askInFlightRef.current = false;
- return admission?.() === 'pending' ? 'pending' : 'blocked';
+ return admission.readiness() === 'pending' ? 'pending' : 'blocked';
+ }
+ if (deferred) {
+ /** Remove only what this accepted turn captured; publication can stage newer inputs. */
+ const consume = (family: typeof pendingQuotesByConvoId, captured: string[]): void => {
+ if (captured.length === 0) return;
+ store.set(family(convoKey), (current) => {
+ if (current === captured) return [];
+ const sent = new Set(captured);
+ const remaining = current.filter((value) => !sent.has(value));
+ return remaining.length === current.length ? current : remaining;
+ });
+ };
+ if (!replaysTurn && overrideManualSkills == null)
+ consume(pendingManualSkillsByConvoId, manualSkills);
+ if (!replaysTurn && overrideQuotes == null && !isAssistantsEndpoint(endpoint))
+ consume(pendingQuotesByConvoId, quotes);
+ if (drainedReasoning && !keepReasoning && stagedReasoning != null) {
+ store.set(pendingReasoningOverrideFamily(reasoningStateKey), (current) =>
+ current === stagedReasoning ? undefined : current,
+ );
+ }
+ setShowStopButton(false);
+ commitComposer();
+ if (turn.regenerateShaped && initialResponse.parentMessageId != null)
+ store.set(siblingIdxFamily(siblingKey(initialResponse.parentMessageId)), 0);
+ commitConversation();
+ commitLaunch();
+ admission.committed?.();
}
logger.dir('message_stream', {
conversationId,
diff --git a/packages/chat/src/react/follow.ts b/packages/chat/src/react/follow.ts
index 69c6cc29f51..53c545546eb 100644
--- a/packages/chat/src/react/follow.ts
+++ b/packages/chat/src/react/follow.ts
@@ -550,6 +550,7 @@ export function useFollowChat({
!attaching &&
!driving &&
reads === 0 &&
+ chat.canRequest &&
(chat.status === 'ready' || chat.status === 'error');
/** A refused eligibility check opts into one wake; read-only followers and accepted
@@ -736,6 +737,8 @@ export function useFollowChat({
const status = useSnapshot(subscribe, () => chat?.status ?? 'ready');
const connection = useSnapshot(subscribe, () => chat?.connection ?? 'idle');
const error = useSnapshot(subscribe, () => chat?.error);
+ /** Core pause/answer ownership can change without messages or status changing. */
+ useSnapshot(subscribe, () => chat?.canRequest ?? false);
const retry = useCallback(() => setAttempt((count) => count + 1), []);
const pageBack = current?.loadEarlier;
const loadEarlier = useCallback(() => void pageBack?.(), [pageBack]);
diff --git a/packages/chat/src/react/side/__tests__/state.spec.ts b/packages/chat/src/react/side/__tests__/state.spec.ts
index a2649bfe00c..f470587a655 100644
--- a/packages/chat/src/react/side/__tests__/state.spec.ts
+++ b/packages/chat/src/react/side/__tests__/state.spec.ts
@@ -1,6 +1,11 @@
import { createStore } from 'jotai';
import type { TConversation } from 'librechat-data-provider';
-import { sideChatAtom, sideChatDraftFamily, sideChatRequestAtom } from '../state';
+import {
+ sideChatAtom,
+ sideChatDraftFamily,
+ sideChatRequestAtom,
+ sideChatDraftSubmittedAtom,
+} from '../state';
const conversation = { conversationId: 'destination' } as TConversation;
@@ -102,3 +107,39 @@ it('normalizes a functional destination change while preserving both drafts', ()
expect(store.get(sideChatDraftFamily('other'))).toBe('Owned draft.');
expect(store.get(sideChatAtom)?.text).toBeUndefined();
});
+
+it.each([undefined, 'My question.'])(
+ 'retires only the accepted current composer draft with intent %s',
+ (text) => {
+ const store = createStore();
+ store.set(sideChatAtom, { conversation, text });
+ store.set(sideChatDraftFamily('destination'), 'My question.');
+ const expected = store.get(sideChatAtom)!;
+ store.set(sideChatDraftSubmittedAtom, expected, 'My question.');
+ expect(store.get(sideChatDraftFamily('destination'))).toBe('');
+ expect(store.get(sideChatAtom)?.text).toBeUndefined();
+ if (!text) expect(store.get(sideChatAtom)).toBe(expected);
+ },
+);
+
+it('preserves a newer edit while retiring the accepted old intent', () => {
+ const store = createStore();
+ store.set(sideChatAtom, { conversation, text: 'Sent.' });
+ const expected = store.get(sideChatAtom)!;
+ store.set(sideChatDraftFamily('destination'), 'New edit.');
+ store.set(sideChatDraftSubmittedAtom, expected, 'Sent.');
+ expect(store.get(sideChatDraftFamily('destination'))).toBe('New edit.');
+ expect(store.get(sideChatAtom)?.text).toBeUndefined();
+});
+
+it('does not retire a replacement same-ID same-text owner', () => {
+ const store = createStore();
+ store.set(sideChatAtom, { conversation, text: 'Same words.' });
+ const expected = store.get(sideChatAtom)!;
+ store.set(sideChatDraftFamily('destination'), '');
+ store.set(sideChatAtom, { conversation, text: 'Same words.' });
+ const replacement = store.get(sideChatAtom);
+ store.set(sideChatDraftSubmittedAtom, expected, 'Same words.');
+ expect(store.get(sideChatAtom)).toBe(replacement);
+ expect(store.get(sideChatDraftFamily('destination'))).toBe('Same words.');
+});
diff --git a/packages/chat/src/react/side/state.ts b/packages/chat/src/react/side/state.ts
index 7260034e6ca..b8a7e044e34 100644
--- a/packages/chat/src/react/side/state.ts
+++ b/packages/chat/src/react/side/state.ts
@@ -90,3 +90,20 @@ export const sideChatAtom: WritableAtom = atom(
+ null,
+ (get, set, expected: SideChat, submitted: string) => {
+ if (get(shownSideChatAtom) !== expected) return;
+ const id = expected.conversation.conversationId;
+ if (!id) return;
+ const draft = sideChatDraftFamily(id);
+ if (get(draft) === submitted) set(draft, '');
+ if (expected.text) {
+ set(sideChatAtom, (current) =>
+ current === expected ? { conversation: current.conversation } : current,
+ );
+ }
+ },
+);
From fdb75af05a702da0557c08622e6c51cf940cc2be Mon Sep 17 00:00:00 2001
From: Dustin Healy <54083382+dustinhealy@users.noreply.github.com>
Date: Wed, 18 Nov 2026 17:45:51 -0800
Subject: [PATCH 7/7] Fence Deferred Cleanup and Expired Pause Availability
---
client/src/hooks/Chat/services.ts | 3 +-
.../__tests__/useDiscardPastedFiles.spec.tsx | 16 ++
.../Files/__tests__/useFileHandling.test.ts | 165 +++++++++++++++++-
.../__tests__/useSetFilesToDelete.spec.ts | 10 ++
.../src/hooks/Files/useDiscardPastedFiles.ts | 10 +-
client/src/hooks/Files/useFileHandling.ts | 32 +++-
client/src/hooks/Files/useSetFilesToDelete.ts | 6 +-
packages/chat/src/core/__tests__/chat.spec.ts | 87 +++++++++
packages/chat/src/core/chat.ts | 13 +-
.../src/react/chat/__tests__/driven.spec.tsx | 115 +++++++++++-
packages/chat/src/react/chat/host.tsx | 11 +-
packages/chat/src/react/chat/turns.ts | 62 +++++--
12 files changed, 504 insertions(+), 26 deletions(-)
diff --git a/client/src/hooks/Chat/services.ts b/client/src/hooks/Chat/services.ts
index 1db6436875f..6427cd85083 100644
--- a/client/src/hooks/Chat/services.ts
+++ b/client/src/hooks/Chat/services.ts
@@ -14,13 +14,13 @@ import {
getRouteChatProjectId,
} from '~/utils';
import useSetFilesToDelete, { captureFilesToDelete } from '~/hooks/Files/useSetFilesToDelete';
+import { cancelUploads, captureUploadOwnership } from '~/hooks/Files/useFileHandling';
import useGetConversation from '~/hooks/Conversations/useGetConversation';
import useDiscardPastedFiles from '~/hooks/Files/useDiscardPastedFiles';
import useCodeApprovalMode from '~/hooks/Agents/useCodeApprovalMode';
import { useAgentsMapContext } from '~/Providers/AgentsMapContext';
import { useChatSettings } from '~/Providers/ChatSettingsContext';
import useCodeWorkspace from '~/hooks/Agents/useCodeWorkspace';
-import { cancelUploads } from '~/hooks/Files/useFileHandling';
import useUserKey from '~/hooks/Input/useUserKey';
import { isTargetReady } from './ask/guards';
@@ -104,6 +104,7 @@ export default function useTurnServices({
navigate(path);
},
cancelUploads,
+ captureFileOwnership: captureUploadOwnership,
discardFiles,
releaseFiles: (fileIds) => markPasteSubmitted(...fileIds),
clearFilesToDelete: () => setFilesToDelete({}),
diff --git a/client/src/hooks/Files/__tests__/useDiscardPastedFiles.spec.tsx b/client/src/hooks/Files/__tests__/useDiscardPastedFiles.spec.tsx
index f6f8c40cdf6..46845c4a275 100644
--- a/client/src/hooks/Files/__tests__/useDiscardPastedFiles.spec.tsx
+++ b/client/src/hooks/Files/__tests__/useDiscardPastedFiles.spec.tsx
@@ -54,6 +54,22 @@ describe('superseded pasted files', () => {
});
});
+ it('rechecks ownership after cancellation callbacks before scheduling deletion', () => {
+ const { result } = setup();
+ let current = true;
+ jest.mocked(cancelUploads).mockImplementationOnce(() => {
+ current = false;
+ });
+ act(() => result.current(['temporary-paste'], () => current));
+ expect(retainFileDeletion).not.toHaveBeenCalled();
+ });
+
+ it('protects a cached row through a newer sibling temp alias absent from the request', () => {
+ const { result } = setup();
+ act(() => result.current(['stored-paste'], (id) => id !== 'temporary-paste'));
+ expect(retainFileDeletion).not.toHaveBeenCalled();
+ });
+
it('never deletes a paste another draft or tab owns', () => {
jest.mocked(collectForeignAttachmentClaims).mockReturnValueOnce(new Set(['temporary-paste']));
const { result } = setup();
diff --git a/client/src/hooks/Files/__tests__/useFileHandling.test.ts b/client/src/hooks/Files/__tests__/useFileHandling.test.ts
index 467b149253c..6561b9a5877 100644
--- a/client/src/hooks/Files/__tests__/useFileHandling.test.ts
+++ b/client/src/hooks/Files/__tests__/useFileHandling.test.ts
@@ -8,7 +8,7 @@ import {
EModelEndpoint,
getEndpointFileConfig,
} from 'librechat-data-provider';
-import type { ExtendedFile } from '~/common';
+import type { ExtendedFile, FileSetter } from '~/common';
import { setFileSearchChoice, clearFileSearchChoices } from '~/utils/choices';
type MockUploadMutationOptions = {
@@ -2385,6 +2385,169 @@ describe('useFileHandling', () => {
expect(mockMutate).toHaveBeenCalledTimes(1);
});
+ it('preserves a guarded preassigned recovery while configuration is pending', async () => {
+ mockIsConfigPending = true;
+ let releaseConfig!: () => void;
+ mockWaitForConfig.mockImplementationOnce(
+ () =>
+ new Promise((resolve) => {
+ releaseConfig = resolve;
+ }),
+ );
+ const {
+ default: useFileHandling,
+ hasInFlightUpload,
+ cancelUploads,
+ captureUploadOwnership,
+ } = await import('../useFileHandling');
+ const owns = captureUploadOwnership(['guarded-preassigned']);
+ const { result } = renderHook(() => useFileHandling());
+ let accepted!: Promise;
+ act(() => {
+ accepted = result.current.handleFiles([new File(['hello'], 'notes.txt')], undefined, {
+ fileId: 'guarded-preassigned',
+ });
+ });
+ try {
+ expect(hasInFlightUpload('guarded-preassigned')).toBe(true);
+ expect(mockAddFile).not.toHaveBeenCalled();
+ expect(owns('guarded-preassigned')).toBe(false);
+ act(() => cancelUploads(['guarded-preassigned'], owns));
+ expect(hasInFlightUpload('guarded-preassigned')).toBe(true);
+ } finally {
+ await act(async () => {
+ releaseConfig();
+ await accepted;
+ });
+ act(() => cancelUploads(['guarded-preassigned']));
+ }
+ });
+
+ it('rechecks captured registry ownership between cancellation callbacks', async () => {
+ mockIsConfigPending = true;
+ let releaseConfig!: () => void;
+ mockWaitForConfig.mockImplementationOnce(
+ () =>
+ new Promise((resolve) => {
+ releaseConfig = resolve;
+ }),
+ );
+ const {
+ default: useFileHandling,
+ hasInFlightUpload,
+ cancelUploads,
+ captureUploadOwnership,
+ } = await import('../useFileHandling');
+ const { result } = renderHook(() => useFileHandling());
+ const calls: Promise[] = [];
+ act(() => {
+ calls.push(
+ result.current.handleFiles([new File(['first'], 'first.txt')], undefined, {
+ fileId: 'cancel-first',
+ onAbort: () => {
+ calls.push(
+ result.current.handleFiles([new File(['new second'], 'second.txt')], undefined, {
+ fileId: 'cancel-second',
+ }),
+ );
+ },
+ }),
+ );
+ calls.push(
+ result.current.handleFiles([new File(['old second'], 'second.txt')], undefined, {
+ fileId: 'cancel-second',
+ }),
+ );
+ });
+ const owns = captureUploadOwnership(['cancel-first', 'cancel-second']);
+ try {
+ act(() => cancelUploads(['cancel-first', 'cancel-second'], owns));
+ expect(hasInFlightUpload('cancel-first')).toBe(false);
+ expect(hasInFlightUpload('cancel-second')).toBe(true);
+ expect(owns('cancel-second')).toBe(false);
+ } finally {
+ mockWaitForConfig.mockResolvedValue(undefined);
+ await act(async () => {
+ releaseConfig();
+ await Promise.all(calls);
+ });
+ act(() => cancelUploads(['cancel-first', 'cancel-second']));
+ }
+ });
+
+ it('lets a protected native upload callback update the actual composer after config release', async () => {
+ mockIsConfigPending = true;
+ let releaseConfig!: () => void;
+ mockWaitForConfig.mockImplementationOnce(
+ () =>
+ new Promise((resolve) => {
+ releaseConfig = resolve;
+ }),
+ );
+ const updateFiles = jest.mocked((await import('../useUpdateFiles')).default);
+ const chatContext = jest.mocked((await import('~/Providers/ChatContext')).useChatContext);
+ const previousUpdate = updateFiles.getMockImplementation()!;
+ const previousContext = chatContext.getMockImplementation()!;
+ let files = new Map();
+ const setFiles: FileSetter = (next) => {
+ files = typeof next === 'function' ? next(files) : next;
+ };
+ updateFiles.mockImplementation(jest.requireActual('../useUpdateFiles').default);
+ chatContext.mockImplementation(() => ({ ...previousContext(), files, setFiles }));
+ const {
+ default: useFileHandling,
+ captureUploadOwnership,
+ cancelUploads,
+ hasInFlightUpload,
+ } = await import('../useFileHandling');
+ const owns = captureUploadOwnership(['native-protected-upload']);
+ const view = renderHook(() => useFileHandling());
+ let accepted!: Promise;
+ try {
+ act(() => {
+ accepted = view.result.current.handleFiles(
+ [new File(['new words'], 'paste.txt', { type: 'text/plain' })],
+ undefined,
+ { fileId: 'native-protected-upload', pastedText: 'new words' },
+ );
+ });
+ expect(files.has('native-protected-upload')).toBe(true);
+ act(() => cancelUploads(['native-protected-upload'], owns));
+ expect(hasInFlightUpload('native-protected-upload')).toBe(true);
+ await act(async () => {
+ releaseConfig();
+ await accepted;
+ });
+ const body = mockMutate.mock.calls[0][0] as FormData;
+ act(() =>
+ mockUploadOptions.onSuccess?.(
+ {
+ temp_file_id: 'native-protected-upload',
+ file_id: 'native-protected-server',
+ filepath: '/uploads/native.txt',
+ filename: 'paste.txt',
+ type: 'text/plain',
+ source: 'local',
+ embedded: false,
+ },
+ body,
+ ),
+ );
+ expect([...files.values()]).toEqual(
+ expect.arrayContaining([
+ expect.objectContaining({ file_id: 'native-protected-server', progress: 1 }),
+ ]),
+ );
+ } finally {
+ releaseConfig();
+ await accepted;
+ cancelUploads(['native-protected-upload']);
+ view.unmount();
+ updateFiles.mockImplementation(previousUpdate);
+ chatContext.mockImplementation(previousContext);
+ }
+ });
+
it('uses a preassigned file id and marks it in flight before the config wait', async () => {
mockIsConfigPending = true;
let releaseConfig!: () => void;
diff --git a/client/src/hooks/Files/__tests__/useSetFilesToDelete.spec.ts b/client/src/hooks/Files/__tests__/useSetFilesToDelete.spec.ts
index 557307a83cd..23b233a8b56 100644
--- a/client/src/hooks/Files/__tests__/useSetFilesToDelete.spec.ts
+++ b/client/src/hooks/Files/__tests__/useSetFilesToDelete.spec.ts
@@ -56,3 +56,13 @@ it.each(['[1]', 'null', '{bad'])('leaves unsupported legacy storage alone: %s',
captureFilesToDelete(['owned'])();
expect(set).not.toHaveBeenCalled();
});
+
+it('preserves identical serialized metadata belonging to a newer live draft owner', () => {
+ write({ owned: { ...original, file: new File(['original'], 'same.txt') } });
+ let current = true;
+ const commit = captureFilesToDelete(['owned'], () => current);
+ write({ owned: { ...original, file: new File(['replacement'], 'same.txt') } });
+ current = false;
+ commit();
+ expect(read()).toHaveProperty('owned');
+});
diff --git a/client/src/hooks/Files/useDiscardPastedFiles.ts b/client/src/hooks/Files/useDiscardPastedFiles.ts
index 211de314692..de81e49c98e 100644
--- a/client/src/hooks/Files/useDiscardPastedFiles.ts
+++ b/client/src/hooks/Files/useDiscardPastedFiles.ts
@@ -14,8 +14,9 @@ import { cancelUploads } from './useFileHandling';
export default function useDiscardPastedFiles(index: number, conversationId?: string | null) {
const queryClient = useQueryClient();
return useCallback(
- (fileIds: string[]) => {
- cancelUploads(fileIds);
+ (fileIds: string[], isCurrent?: (fileId: string) => boolean) => {
+ if (isCurrent) cancelUploads(fileIds, isCurrent);
+ else cancelUploads(fileIds);
const ids = new Set(fileIds);
const foreign = collectForeignAttachmentClaims(
[
@@ -27,6 +28,11 @@ export default function useDiscardPastedFiles(index: number, conversationId?: st
const files = queryClient.getQueryData([QueryKeys.files]);
for (const file of files ?? []) {
if (!ids.has(file.file_id) && (!file.temp_file_id || !ids.has(file.temp_file_id))) continue;
+ if (
+ isCurrent?.(file.file_id) === false ||
+ (file.temp_file_id != null && isCurrent?.(file.temp_file_id) === false)
+ )
+ continue;
if (
isPasteSubmitted(file.file_id) ||
isPasteSubmitted(file.temp_file_id) ||
diff --git a/client/src/hooks/Files/useFileHandling.ts b/client/src/hooks/Files/useFileHandling.ts
index a83c63b9727..3401c46a383 100644
--- a/client/src/hooks/Files/useFileHandling.ts
+++ b/client/src/hooks/Files/useFileHandling.ts
@@ -157,7 +157,12 @@ const failUploadRecovery = (fileId: string, body?: FormData): UploadRecovery | u
return takeUploadRecovery(fileId, body);
};
-export const clearUploadRecovery = (fileId: string, retainFileSearch = false) => {
+export const clearUploadRecovery = (
+ fileId: string,
+ retainFileSearch = false,
+ isCurrent?: (fileId: string) => boolean,
+) => {
+ if (isCurrent?.(fileId) === false) return;
const recovery = uploadErrorCallbacks.get(fileId);
const onAbort = recovery?.onAbort;
if (retainFileSearch && recovery?.fileSearch && recovery.status !== 'canceled') {
@@ -175,17 +180,34 @@ export const clearUploadRecovery = (fileId: string, retainFileSearch = false) =>
storePendingDiscardIds(index, [...new Set([...loadPendingDiscardIds(index), fileId])]);
}
recovery.controller?.abort();
- recovery.dispose?.();
+ if (isCurrent?.(fileId) !== false) recovery.dispose?.();
}
}
- if (!retainFileSearch) {
+ if (!retainFileSearch && isCurrent?.(fileId) !== false) {
cancelFileSearchUpload(fileId);
}
onAbort?.(fileId);
};
-export const cancelUploads = (fileIds: string[]): void => {
- for (const fileId of fileIds) clearUploadRecovery(fileId);
+/** Capture app-owned operation identity before publication can replace an upload. */
+export const captureUploadOwnership = (
+ fileIds: readonly string[],
+): ((fileId: string) => boolean) => {
+ const captured = new Map(
+ fileIds.map((id) => {
+ const recovery = uploadErrorCallbacks.get(id);
+ return [id, { recovery, body: recovery?.body }] as const;
+ }),
+ );
+ return (id) => {
+ const current = uploadErrorCallbacks.get(id);
+ const previous = captured.get(id);
+ return current == null || (current === previous?.recovery && current.body === previous?.body);
+ };
+};
+
+export const cancelUploads = (fileIds: string[], isCurrent?: (fileId: string) => boolean): void => {
+ for (const fileId of fileIds) clearUploadRecovery(fileId, false, isCurrent);
};
export const hasInFlightUpload = (fileId: string, conversationId?: string): boolean => {
diff --git a/client/src/hooks/Files/useSetFilesToDelete.ts b/client/src/hooks/Files/useSetFilesToDelete.ts
index 641df1c90fb..4276dae1bea 100644
--- a/client/src/hooks/Files/useSetFilesToDelete.ts
+++ b/client/src/hooks/Files/useSetFilesToDelete.ts
@@ -11,7 +11,10 @@ export default function useSetFilesToDelete() {
}
/** Snapshot app-owned file markers without consuming another pane or newer upload edits. */
-export function captureFilesToDelete(keys: readonly string[]): () => void {
+export function captureFilesToDelete(
+ keys: readonly string[],
+ isCurrent?: (key: string) => boolean,
+): () => void {
const read = (): Record | undefined => {
try {
const raw = localStorage.getItem(LocalStorageKeys.FILES_TO_DELETE);
@@ -35,6 +38,7 @@ export function captureFilesToDelete(keys: readonly string[]): () => void {
let changed = false;
for (const [key, value] of captured) {
if (
+ isCurrent?.(key) === false ||
!Object.prototype.hasOwnProperty.call(current, key) ||
JSON.stringify(current[key]) !== value
)
diff --git a/packages/chat/src/core/__tests__/chat.spec.ts b/packages/chat/src/core/__tests__/chat.spec.ts
index 54c0119587a..cd41470a0bb 100644
--- a/packages/chat/src/core/__tests__/chat.spec.ts
+++ b/packages/chat/src/core/__tests__/chat.spec.ts
@@ -139,6 +139,93 @@ const setup = (
const flush = () => new Promise((resolve) => setTimeout(resolve, 0));
describe('Chat', () => {
+ it.each([
+ { generation: 200, actionId: 'next-question', createdAt: 2, free: true },
+ { generation: 100, actionId: 'next-question', createdAt: 2, free: true },
+ { generation: 99, actionId: 'next-question', createdAt: 2, free: false },
+ { generation: 100, actionId: 'question', createdAt: 1, free: false },
+ { generation: 100, actionId: 'older-question', createdAt: 0, free: false },
+ ])(
+ 'publishes hidden-answer supersession only when eligible: %j',
+ async ({ generation, actionId, createdAt, free }) => {
+ let refuse!: (error: Error) => void;
+ const { chat, state } = setup(
+ {},
+ {
+ resume: () =>
+ new Promise((_, reject) => {
+ refuse = reject;
+ }),
+ },
+ );
+ const pause = {
+ actionId: 'question',
+ streamId: 'convo-1',
+ conversationId: 'convo-1',
+ createdAt: 1,
+ expiresAt: Date.now() + 60000,
+ payload: {
+ type: 'ask_user_question',
+ tool_call_id: 'question',
+ question: { question: 'Which?' },
+ },
+ } as Agents.PendingAction;
+ state.status = 'error';
+ chat.restorePendingAction(pause, 100);
+ const answered = chat
+ .addToolOutput({ toolCallId: 'question', output: 'This one.' })
+ .catch((error: Error) => error);
+ chat.restorePendingAction({ ...pause, expiresAt: Date.now() - 1 }, 100);
+ const availability: boolean[] = [];
+ const unsubscribe = chat.subscribe(() => availability.push(chat.canRequest));
+ try {
+ const rows = chat.messages;
+ chat.restorePendingAction(
+ { ...pause, actionId, createdAt, expiresAt: Date.now() - 1 },
+ generation,
+ );
+ expect(chat.canRequest).toBe(free);
+ expect(chat.messages).toBe(rows);
+ expect(chat.status).toBe('error');
+ expect(availability).toEqual(free ? [true] : []);
+ refuse(Object.assign(new Error('Old answer ended'), { status: 400 }));
+ await answered;
+ expect(availability).toEqual([true]);
+ } finally {
+ unsubscribe();
+ chat.dispose();
+ refuse(Object.assign(new Error('Cleanup'), { status: 400 }));
+ await answered;
+ }
+ },
+ );
+
+ it('does not duplicate an expired visible pause release notification', () => {
+ const { chat } = setup();
+ const pause = {
+ actionId: 'visible-question',
+ streamId: 'convo-1',
+ conversationId: 'convo-1',
+ createdAt: 1,
+ expiresAt: Date.now() + 60000,
+ payload: {
+ type: 'ask_user_question',
+ tool_call_id: 'question',
+ question: { question: 'Which?' },
+ },
+ } as Agents.PendingAction;
+ chat.restorePendingAction(pause, 100);
+ const availability: boolean[] = [];
+ const unsubscribe = chat.subscribe(() => availability.push(chat.canRequest));
+ try {
+ chat.restorePendingAction({ ...pause, expiresAt: Date.now() - 1 }, 100);
+ expect(availability).toEqual([true]);
+ } finally {
+ unsubscribe();
+ chat.dispose();
+ }
+ });
+
it('publishes availability after the hidden answer claim releases', async () => {
let refuse!: (error: Error) => void;
const { chat, state } = setup(
diff --git a/packages/chat/src/core/chat.ts b/packages/chat/src/core/chat.ts
index 917f2d91061..7b6ac4492c3 100644
--- a/packages/chat/src/core/chat.ts
+++ b/packages/chat/src/core/chat.ts
@@ -996,6 +996,11 @@ export class Chat {
return this.action;
}
+ /** Publish a newly free request owner only if this transition has not already notified. */
+ private notifyRequestAvailability(previous: boolean, revision: number): void {
+ if (!previous && this.canRequest && revision === this.revision) this.notify();
+ }
+
/** Pure projection of request ownership. Expired pauses still undergo request's
* notifying cleanup and reentrant checks before a turn is actually taken. */
get canRequest(): boolean {
@@ -1893,6 +1898,8 @@ export class Chat {
* An expired pause is stale: the server will refuse its resume. It also supersedes a pause
* restored for an older generation, which no longer runs.
*/
+ const available = this.canRequest;
+ const revision = this.revision;
const superseded =
this.action != null &&
(generationCreatedAt !== this.generationCreatedAt ||
@@ -1902,6 +1909,7 @@ export class Chat {
if (this.action?.actionId === action.actionId || superseded) {
this.clearAction();
}
+ this.notifyRequestAvailability(available, revision);
return;
}
if (this.action?.actionId !== action.actionId && this.releasedPause !== action.actionId) {
@@ -2666,12 +2674,15 @@ export class Chat {
const generation = this.generationCreatedAt;
this.seePause(expired, generation);
const held = this.action;
+ const available = this.canRequest;
+ const revision = this.revision;
const superseded = held != null && generation != null && this.isSupersededBy(held, expired);
/** A later pause of the generation replaces the answered one, even though it already expired. */
this.replaceAnswer(expired, generation);
if (held?.actionId === expired.actionId || superseded) {
this.clearAction();
}
+ this.notifyRequestAvailability(available, revision);
}
/**
@@ -2988,7 +2999,7 @@ export class Chat {
}
/** A visible pause may clear before its answer claim; publish only the coherent
* final availability if no existing transition already announced it. */
- if (!available && this.canRequest && revision === this.revision) this.notify();
+ this.notifyRequestAvailability(available, revision);
}
}
diff --git a/packages/chat/src/react/chat/__tests__/driven.spec.tsx b/packages/chat/src/react/chat/__tests__/driven.spec.tsx
index 19e5cc6ad84..186fb67ab07 100644
--- a/packages/chat/src/react/chat/__tests__/driven.spec.tsx
+++ b/packages/chat/src/react/chat/__tests__/driven.spec.tsx
@@ -24,6 +24,7 @@ import {
pendingReasoningOverrideFamily,
} from '../../composer';
import { createTurnServices, createTurnCodeInputs } from '../__fixtures__/services';
+import { isComposerFileTaken, releaseComposerFile } from '../../../core';
import { showStopButtonByIndex } from '../../generation';
import { isSubmittingFamily } from '../../submission';
import { useDrivenContract } from '../driven';
@@ -245,6 +246,118 @@ function setup({
}
describe('useDrivenContract', () => {
+ it.each(['same-id', 'temp-alias', 'source-alias'])(
+ 'protects a newer upload through %s at actual publication',
+ async (kind) => {
+ const services = createTurnServices({ cancelUploads: jest.fn(), discardFiles: jest.fn() });
+ const view = setup({ services });
+ await view.ready();
+ const id = `captured-${kind}`;
+ const original = {
+ file_id: id,
+ temp_file_id: `${id}-temp`,
+ pastedText: 'Original paste.',
+ progress: 0.5,
+ size: 1,
+ };
+ const replacement = {
+ file_id: kind === 'same-id' ? id : `${id}-new`,
+ temp_file_id: kind === 'temp-alias' ? id : undefined,
+ replacesFileId: kind === 'source-alias' ? id : undefined,
+ progress: 0.5,
+ size: 1,
+ };
+ act(() => view.store.set(filesFamily(SIDE_PANE), new Map([[id, original]])));
+ let staged = false;
+ const unsubscribe = view.result.current.followed.chat!.subscribe(() => {
+ if (staged || view.result.current.followed.chat!.status !== 'submitted') return;
+ staged = true;
+ view.store.set(
+ filesFamily(SIDE_PANE),
+ new Map([[kind === 'same-id' ? id : `${id}-new`, replacement]]),
+ );
+ });
+ try {
+ act(() => view.result.current.contract.ask({ text: 'Send original paste.' }));
+ await waitFor(() => expect(view.sendMessages).toHaveBeenCalledTimes(1));
+ expect(isComposerFileTaken(id)).toBe(false);
+ expect(services.cancelUploads).not.toHaveBeenCalledWith(
+ expect.arrayContaining([id]),
+ expect.anything(),
+ );
+ expect(
+ (services.cancelUploads as jest.Mock).mock.calls.flatMap(([ids]) => ids),
+ ).not.toContain(id);
+ expect([...view.store.get(filesFamily(SIDE_PANE)).values()]).toContain(replacement);
+ } finally {
+ unsubscribe();
+ releaseComposerFile(id);
+ releaseComposerFile(`${id}-temp`);
+ }
+ },
+ );
+
+ it('keeps accepted durable refs protected while a new attachment reuses their ID', async () => {
+ const view = setup();
+ await view.ready();
+ const original = {
+ file_id: 'accepted-server-ref',
+ temp_file_id: 'old-upload',
+ progress: 1,
+ size: 1,
+ };
+ const reattached = { ...original, filename: 'reattached.txt' };
+ act(() => view.store.set(filesFamily(SIDE_PANE), new Map([['old-key', original]])));
+ let staged = false;
+ const unsubscribe = view.result.current.followed.chat!.subscribe(() => {
+ if (staged || view.result.current.followed.chat!.status !== 'submitted') return;
+ staged = true;
+ view.store.set(filesFamily(SIDE_PANE), new Map([['new-key', reattached]]));
+ });
+ act(() => view.result.current.contract.ask({ text: 'Send this reference.' }));
+ await waitFor(() => expect(view.sendMessages).toHaveBeenCalledTimes(1));
+ expect(view.services.releaseFiles).toHaveBeenCalledWith(['accepted-server-ref']);
+ expect(view.store.get(filesFamily(SIDE_PANE)).get('new-key')).toBe(reattached);
+ unsubscribe();
+ });
+
+ it('rechecks alias ownership after a reentrant host release callback', async () => {
+ const replacement = { file_id: 'pending-after-release', progress: 0.5, size: 1 };
+ const services = createTurnServices({
+ cancelUploads: jest.fn(),
+ releaseFiles: jest.fn(() => {
+ releaseComposerFile('pending-after-release');
+ view.store.set(filesFamily(SIDE_PANE), new Map([['pending-after-release', replacement]]));
+ }),
+ });
+ const view = setup({ services });
+ await view.ready();
+ const ready = { file_id: 'durable-before-release', progress: 1, size: 1 };
+ const pending = {
+ file_id: 'pending-after-release',
+ progress: 0.5,
+ size: 1,
+ pastedText: 'Inline original.',
+ };
+ act(() =>
+ view.store.set(
+ filesFamily(SIDE_PANE),
+ new Map([
+ [ready.file_id, ready],
+ [pending.file_id, pending],
+ ]),
+ ),
+ );
+ act(() => view.result.current.contract.ask({ text: 'Send both.' }));
+ await waitFor(() => expect(view.sendMessages).toHaveBeenCalledTimes(1));
+ expect((services.cancelUploads as jest.Mock).mock.calls.flatMap(([ids]) => ids)).not.toContain(
+ pending.file_id,
+ );
+ expect(view.store.get(filesFamily(SIDE_PANE)).get(pending.file_id)).toBe(replacement);
+ // A deliberate native add clears any earlier taken marker before installing its entry.
+ releaseComposerFile(pending.file_id);
+ });
+
it('commits only captured inputs before notifying acceptance', async () => {
const order: string[] = [];
const cleanup = jest.fn(() => order.push('markers'));
@@ -297,7 +410,7 @@ describe('useDrivenContract', () => {
]),
);
expect(services.releaseFiles).toHaveBeenCalledWith(expect.arrayContaining(['original-file']));
- expect(services.captureFilesToDelete).toHaveBeenCalledWith(['upload']);
+ expect(services.captureFilesToDelete).toHaveBeenCalledWith(['upload'], expect.any(Function));
expect(services.clearFilesToDelete).not.toHaveBeenCalled();
expect(order).toEqual(['files', 'markers', 'accepted']);
expect(onAccepted).toHaveBeenCalledTimes(1);
diff --git a/packages/chat/src/react/chat/host.tsx b/packages/chat/src/react/chat/host.tsx
index 68097db00ad..0fb716edf09 100644
--- a/packages/chat/src/react/chat/host.tsx
+++ b/packages/chat/src/react/chat/host.tsx
@@ -106,13 +106,18 @@ export type TurnServices = {
/** Marks composer files as submitted, so draft cleanup keeps them. */
releaseFiles: (fileIds: (string | undefined)[]) => void;
/** Cancels uploads whose exact local paste was accepted inline, without marking them submitted. */
- cancelUploads?: (fileIds: string[]) => void;
+ cancelUploads?: (fileIds: string[], isCurrent?: (fileId: string) => boolean) => void;
/** Discards uploaded sources superseded by an accepted inline replacement. */
- discardFiles?: (fileIds: string[]) => void;
+ discardFiles?: (fileIds: string[], isCurrent?: (fileId: string) => boolean) => void;
/** Forgets the files queued for deletion once the composer is cleared. */
clearFilesToDelete: () => void;
/** Captures app-owned file-marker cleanup before a driven publication can stage new files. */
- captureFilesToDelete?: (keys: readonly string[]) => () => void;
+ captureFilesToDelete?: (
+ keys: readonly string[],
+ isCurrent?: (key: string) => boolean,
+ ) => () => void;
+ /** Captures opaque app upload ownership, including operations not staged in the composer yet. */
+ captureFileOwnership?: (fileIds: readonly string[]) => (fileId: string) => boolean;
};
/** The conversation a pane shows, and the setter that replaces or updates it. */
diff --git a/packages/chat/src/react/chat/turns.ts b/packages/chat/src/react/chat/turns.ts
index 91d9273f81f..c30c2ed5bd0 100644
--- a/packages/chat/src/react/chat/turns.ts
+++ b/packages/chat/src/react/chat/turns.ts
@@ -32,6 +32,7 @@ import { resolveSubmittedReasoning } from './reasoning';
import { activeUsageResponseIdFamily } from '../usage';
import { isSubmittingFamily } from '../submission';
import { isHistoryRevalidating } from './guards';
+import { filesFamily } from '../pane';
type Attempt = 'accepted' | 'pending' | 'blocked';
type Submit = (props: TAskProps, options?: TOptions, automatic?: boolean) => Attempt;
@@ -340,11 +341,39 @@ export function useTurns(
conversationId = turn.conversationId;
logger.log('message_state', initialResponse);
- const capturedFiles =
- deferred && fileEffects?.clearComposer && files ? new Map(files) : undefined;
+ const capturedFiles = deferred && fileEffects && files ? new Map(files) : undefined;
+ const ownsUpload =
+ deferred && fileEffects
+ ? services.captureFileOwnership?.(
+ [
+ ...fileEffects.submittedFileIds,
+ ...(fileEffects.canceledUploadIds ?? []),
+ ...(fileEffects.replacedFileIds ?? []),
+ ].filter((id): id is string => !!id),
+ )
+ : undefined;
+ const ownsFile = (id: string): boolean => {
+ if (!deferred) return true;
+ if (ownsUpload?.(id) === false) return false;
+ for (const [key, file] of store.get(filesFamily(index))) {
+ if (capturedFiles?.get(key) === file) continue;
+ if (
+ key === id ||
+ file.file_id === id ||
+ file.temp_file_id === id ||
+ file.replacesFileId === id
+ )
+ return false;
+ }
+ return true;
+ };
+ // Accepted server refs must remain protected from deletion even when deliberately reattached.
+ const durableIds = deferred
+ ? new Set(currentMsg.files?.map((file) => file.file_id))
+ : undefined;
const clearFilesToDelete =
deferred && fileEffects?.clearComposer
- ? (services.captureFilesToDelete?.(Array.from(capturedFiles?.keys() ?? [])) ??
+ ? (services.captureFilesToDelete?.(Array.from(capturedFiles?.keys() ?? []), ownsFile) ??
services.clearFilesToDelete)
: services.clearFilesToDelete;
const commitComposer = (): void => {
@@ -352,16 +381,27 @@ export function useTurns(
services.openNewChat(turn.newChatPath);
}
if (fileEffects != null && setFiles) {
- markComposerFilesTaken([
+ const takenIds = [
...(fileEffects.canceledUploadIds ?? []),
...(fileEffects.replacedFileIds ?? []),
- ]);
- services.releaseFiles(fileEffects.submittedFileIds);
- if (fileEffects.canceledUploadIds?.length) {
- services.cancelUploads?.(fileEffects.canceledUploadIds);
- }
- if (fileEffects.replacedFileIds?.length) {
- services.discardFiles?.(fileEffects.replacedFileIds);
+ ];
+ markComposerFilesTaken(deferred ? takenIds.filter(ownsFile) : takenIds);
+ if (!deferred) {
+ services.releaseFiles(fileEffects.submittedFileIds);
+ if (fileEffects.canceledUploadIds?.length)
+ services.cancelUploads?.(fileEffects.canceledUploadIds);
+ if (fileEffects.replacedFileIds?.length)
+ services.discardFiles?.(fileEffects.replacedFileIds);
+ } else {
+ for (const id of new Set(fileEffects.submittedFileIds)) {
+ if (id && (durableIds?.has(id) || ownsFile(id))) services.releaseFiles([id]);
+ }
+ for (const id of fileEffects.canceledUploadIds ?? []) {
+ if (ownsFile(id)) services.cancelUploads?.([id], ownsFile);
+ }
+ for (const id of fileEffects.replacedFileIds ?? []) {
+ if (ownsFile(id)) services.discardFiles?.([id], ownsFile);
+ }
}
if (fileEffects.clearComposer) {
if (!deferred) setFiles(new Map());