📓 fix: Keep Typed Text When Starting a New Chat (#15985)

* 📓 fix: Keep Typed Text When Starting a New Chat

* 🧷 fix: Keep the Draft Claim Through the Empty-Files Write

---------

Co-authored-by: Lia <lia@librechat.ai>
This commit is contained in:
lia-by-librechat[bot] 2026-09-16 01:45:04 -04:00 • committed by GitHub
parent 35d5a70b21
commit 52293e1298
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
4 changed files with 128 additions and 15 deletions

View file

@ -7,6 +7,7 @@ const mockNewConversation = jest.fn();
const mockClearMessagesCache = jest.fn();
const mockInvalidateQueries = jest.fn();
const mockClearAllDrafts = jest.fn();
const mockClearFilesDraft = jest.fn();
const mockDeleteFiles = jest.fn();
const mockScheduleRetainedRetry = jest.fn();
@ -78,6 +79,7 @@ jest.mock('~/hooks/useNewConvo', () => ({
jest.mock('~/utils', () => ({
clearMessagesCache: (...args: unknown[]) => mockClearMessagesCache(...args),
clearAllDrafts: (...args: unknown[]) => mockClearAllDrafts(...args),
clearFilesDraft: (...args: unknown[]) => mockClearFilesDraft(...args),
getNewConversationDraftId: (index = 0) => (index === 0 ? 'new' : `new:${index}`),
getPendingDraftId: (index = 0) => (index === 0 ? 'pending' : `pending:${index}`),
getComposerDraftId: (index = 0, conversationId?: string | null) => {
@ -260,24 +262,34 @@ describe('useNewChat', () => {
expect(mockNewConversation).toHaveBeenCalledTimes(1);
});
it('drops the unsaved-chat draft before the reset restores from it', () => {
it('drops the unsaved-chat attachments before the reset restores from them', () => {
const { result } = renderHook(() => useNewChat());
act(() => result.current.startNewChat());
expect(mockClearAllDrafts).toHaveBeenCalledWith('new');
expect(mockClearAllDrafts.mock.invocationCallOrder[0]).toBeLessThan(
expect(mockClearFilesDraft).toHaveBeenCalledWith('new');
expect(mockClearFilesDraft.mock.invocationCallOrder[0]).toBeLessThan(
mockNewConversation.mock.invocationCallOrder[0],
);
});
it('drops only its own pane unsaved-chat draft', () => {
/** The reset is also how a user gets back to an unsaved chat they typed in and left, and the
* restore that puts an unwanted paste back is the same one that puts the message back. */
it('keeps what was typed in the unsaved chat', () => {
const { result } = renderHook(() => useNewChat());
act(() => result.current.startNewChat());
expect(mockClearAllDrafts).not.toHaveBeenCalledWith('new');
});
it('drops only its own pane unsaved-chat attachments', () => {
const { result } = renderHook(() => useNewChat({ index: 1 }));
act(() => result.current.startNewChat());
expect(mockClearAllDrafts).toHaveBeenCalledWith('new:1');
expect(mockClearAllDrafts).not.toHaveBeenCalledWith('new');
expect(mockClearFilesDraft).toHaveBeenCalledWith('new:1');
expect(mockClearFilesDraft).not.toHaveBeenCalledWith('new');
});
it('deletes the draft uploads a draft-saving user is discarding with the draft', () => {
@ -315,7 +327,7 @@ describe('useNewChat', () => {
],
});
expect(mockDeleteFiles.mock.invocationCallOrder[0]).toBeLessThan(
mockClearAllDrafts.mock.invocationCallOrder[0],
mockClearFilesDraft.mock.invocationCallOrder[0],
);
});
@ -490,7 +502,7 @@ describe('useNewChat', () => {
act(() => result.current.startNewChat());
expect(mockDeleteFiles).not.toHaveBeenCalled();
expect(mockClearAllDrafts).not.toHaveBeenCalledWith('new');
expect(mockClearFilesDraft).not.toHaveBeenCalledWith('new');
expect(mockClearAllDrafts).toHaveBeenCalledWith('pending');
});
@ -895,7 +907,7 @@ describe('useNewChat', () => {
act(() => result.current.startNewChat());
expect(mockClearAllDrafts).toHaveBeenCalledWith('pending');
expect(mockClearAllDrafts).toHaveBeenCalledWith('new');
expect(mockClearFilesDraft).toHaveBeenCalledWith('new');
});
it('deletes pending-draft uploads before clearing them', () => {
@ -944,7 +956,7 @@ describe('useNewChat', () => {
expect(mockDeleteFiles).not.toHaveBeenCalled();
expect(mockClearAllDrafts).not.toHaveBeenCalledWith('pending');
expect(mockClearAllDrafts).toHaveBeenCalledWith('new');
expect(mockClearFilesDraft).toHaveBeenCalledWith('new');
});
it('spares a reattached file from a retained deletion retry', async () => {

View file

@ -9,6 +9,7 @@ import type { FilesDraft } from '~/utils';
import {
beginRetainedDeletionPass,
clearAllDrafts,
clearFilesDraft,
clearMessagesCache,
clearRetainedFileDeletion,
failedFileIdsFrom,
@ -299,10 +300,13 @@ export default function useNewChat({
const startNewChat = useCallback(() => {
clearMessagesCache(queryClient, conversationId);
queryClient.invalidateQueries([QueryKeys.messages]);
/** `newConversation` empties the composer, but the unsaved-chat draft key outlives it and
* `useAutoSave` restores from that key on the way in, so an unsent paste came back on every
* later new chat. Dropping the key first makes an explicit new chat an actual clean slate,
* for the text draft and its attachments alike. Per-conversation drafts are untouched.
/** The unsaved-chat draft key outlives the reset and `useAutoSave` restores from it on the way
* in, so an unsent paste came back on every later new chat. Its attachments are dropped here to
* make an explicit new chat a clean slate; its text is deliberately kept, because the restore
* is also what puts a draft back when the user simply leaves the unsaved chat and returns, and
* clearing it made that the one composer that forgot what had been typed in it. Nothing else is
* gained by clearing it: unlike an attachment there is no upload behind it to leave dangling.
* Per-conversation drafts are untouched either way.
*
* With draft saving on, `newConversation` deliberately leaves the draft's files alive
* because a draft normally keeps them restorable; discarding the draft removes the only
@ -442,8 +446,11 @@ export default function useNewChat({
if (isFilesDraftOwnedByThisTab(pendingDraft)) {
clearAllDrafts(pendingId);
}
/** Attachments only: the uploads behind them have just been deleted, so restoring the chips
* would reference files that are gone, while the typed message is what the user expects to
* find again on the way back into the unsaved chat. */
if (isFilesDraftOwnedByThisTab(idleDraft)) {
clearAllDrafts(draftId);
clearFilesDraft(draftId);
}
const discardedFileIds = Array.from(
new Set([

View file

@ -4,6 +4,7 @@ import {
applyPendingPastesToDraft,
clearAllDrafts,
clearComposerDrafts,
clearFilesDraft,
decodeBase64,
encodeBase64,
resolvePendingPasteInsertStart,
@ -796,6 +797,73 @@ describe('browser tab ownership of unsaved-chat drafts', () => {
});
});
describe('clearFilesDraft', () => {
const newChatKey = getNewConversationDraftId();
beforeEach(() => {
localStorage.clear();
sessionStorage.clear();
});
it('discards the attachments and keeps the text', () => {
setDraft({ id: newChatKey, value: 'half-written message' });
setFilesDraft(newChatKey, { fileIds: ['file-1'], pendingPastes: {} });
clearFilesDraft(newChatKey);
expect(getFilesDraft(newChatKey).fileIds).toEqual([]);
expect(getDraft(newChatKey)).toBe('half-written message');
});
it('keeps this tab claim on the text it left behind', () => {
/** `setFilesDraft` drops the whole record once nothing is attached, and that record is the
* only ownership stamp the shared text draft has: without it another tab's New Chat would be
* free to clear text this tab is still holding. */
setDraft({ id: newChatKey, value: 'half-written message' });
setFilesDraft(newChatKey, { fileIds: ['file-1'], pendingPastes: {} });
clearFilesDraft(newChatKey);
expect(getFilesDraft(newChatKey).tabId).toBe(getBrowserTabId());
});
/** The reset empties the file map, and `useAutoSave`'s attachment effect then writes the draft
* with nothing in it. That write used to delete the record this helper had just re-stamped, so
* the preserved text sat unowned until the next keystroke and another live tab finishing a
* new-chat run could clear it as though nobody were holding it. */
it('keeps the claim through the empty-map write the reset triggers', () => {
setDraft({ id: newChatKey, value: 'half-written message' });
setFilesDraft(newChatKey, { fileIds: ['file-1'], pendingPastes: {} });
clearFilesDraft(newChatKey);
/** What the attachment effect writes once the composer's file map is empty. */
setFilesDraft(newChatKey, { fileIds: [], pastedTextIds: [], pendingPastes: {} });
expect(getFilesDraft(newChatKey).tabId).toBe(getBrowserTabId());
expect(getDraft(newChatKey)).toBe('half-written message');
});
it('leaves no claim behind when there was no text to hold', () => {
setFilesDraft(newChatKey, { fileIds: ['file-1'], pendingPastes: {} });
clearFilesDraft(newChatKey);
expect(localStorage.getItem(`${LocalStorageKeys.FILES_DRAFT}${newChatKey}`)).toBeNull();
});
it('refuses a record another live tab owns', () => {
markTabLive('other-tab');
localStorage.setItem(
`${LocalStorageKeys.FILES_DRAFT}${newChatKey}`,
JSON.stringify({ fileIds: ['other-tab-file'], tabId: 'other-tab' }),
);
clearFilesDraft(newChatKey);
expect(getFilesDraft(newChatKey).fileIds).toEqual(['other-tab-file']);
});
});
describe('migrateFilesDraft', () => {
beforeEach(() => {
localStorage.clear();

View file

@ -889,6 +889,17 @@ export const setFilesDraft = (id: string, draft: FilesDraft): void => {
pendingPasteEntries.length === 0 &&
(draft.pastedTextIds?.length ?? 0) === 0
) {
/** Nothing attached, but on a shared key this record is also the only thing saying whose text
* is stored there, and dropping it leaves that text unowned for another tab to clear.
* `useAutoSave` rewrites the draft with an empty file map on every reset and every composer
* mount, so a claim that did not survive this branch barely survived at all. The text itself
* is the condition, exactly as in `releaseComposerDraftTab`: with none, the claim is residue
* and the record still goes. */
const holdsText = (getLocalStorageItem(`${LocalStorageKeys.TEXT_DRAFT}${id}`) ?? '') !== '';
if (tabId != null && holdsText && isSharedComposerDraftId(id)) {
setLocalStorageItem(key, JSON.stringify({ fileIds: [], tabId }));
return;
}
removeLocalStorageItem(key);
return;
}
@ -1246,6 +1257,21 @@ export const setDraft = ({
export const getDraft = (id?: string): string | null =>
decodeBase64((getLocalStorageItem(`${LocalStorageKeys.TEXT_DRAFT}${id ?? ''}`) ?? '') || '');
/** Discards a key's attachments while leaving its text where it is. New Chat deletes the uploads
* the draft was holding, so restoring those chips would put back a file the server no longer has;
* a typed message has no such resource behind it, and losing it is what made an unsaved chat the
* one composer whose draft did not survive leaving and coming back.
*
* Written as an empty draft rather than a direct delete so the claim rule lives in one place:
* `setFilesDraft` keeps a shared key's stamp while text is stored under it and drops the record
* otherwise, which is also what the autosave write that follows this one has to do. */
export const clearFilesDraft = (id: string): void => {
if (!mayClearComposerDrafts(id)) {
return;
}
setFilesDraft(id, { fileIds: [], pendingPastes: {} });
};
/**
* Draft-key prefix for a live `ask_user_question` answer phase. While the
* composer doubles as the free-form answer box, its autosave switches to a key