Enhanced ChatGPT Clone: Features Agents, MCP, Skills, DeepSeek, Anthropic, AWS, OpenAI, Responses API, Azure, Groq, o1, GPT-5, Mistral, OpenRouter, Vertex AI, Gemini, Artifacts, AI model switching, message search, Code Interpreter, langchain, DALL-E-3, OpenAPI Actions, Functions, Secure Multi-User Auth, Presets, open-source for self-hosting. Active
TypeScript aianthropicartifactsawsazurechatgptchatgpt-cloneclaudeclonedeepseekgeminigooglegpt-5librechatmcpo1openairesponses-apivisionwebui
📎 fix: Never Let a Stalled Attachment Disable the Composer (#15013)
Danny Avila2f50e38217a4
diff --git a/client/src/components/Chat/Input/__tests__/ChatForm.attachments.spec.tsx b/client/src/components/Chat/Input/__tests__/ChatForm.attachments.spec.tsxnew file mode 100644index 0000000000..dc21d840f2--- /dev/null+++ b/client/src/components/Chat/Input/__tests__/ChatForm.attachments.spec.tsx@@ -0,0 +1,226 @@+import React, { Profiler, useMemo, useState } from 'react';+import '@testing-library/jest-dom';+import { DndProvider } from 'react-dnd';+import { useForm } from 'react-hook-form';+import { RecoilRoot, useRecoilState } from 'recoil';+import userEvent from '@testing-library/user-event';+import { HTML5Backend } from 'react-dnd-html5-backend';+import { BrowserRouter as Router } from 'react-router-dom';+import { render, screen, waitFor } from '@testing-library/react';+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';+import { QueryKeys, FileSources, EModelEndpoint } from 'librechat-data-provider';+import type { TFile, TFileUpload, TConversation } from 'librechat-data-provider';+import type { ChatFormValues } from '~/common';+import { ChatContext, ChatFormProvider } from '~/Providers';+import { AuthContextProvider } from '~/hooks/AuthContext';+import ChatForm from '../ChatForm';+import store from '~/store';++const mockUpload = jest.fn();++jest.mock('librechat-data-provider', () => {+ const actual = jest.requireActual('librechat-data-provider');+ return {+ ...actual,+ dataService: {+ ...actual.dataService,+ uploadImage: (...args: unknown[]) => mockUpload(...args),+ uploadFile: (...args: unknown[]) => mockUpload(...args),+ },+ };+});++const conversation = {+ conversationId: 'new',+ endpoint: EModelEndpoint.openAI,+ model: 'gpt-4o',+ title: 'New Chat',+} as TConversation;++const uploadResponse = {+ message: 'File uploaded',+ file_id: 'server-file-id',+ temp_file_id: 'temp-file-id',+ filename: 'cat.png',+ filepath: '/images/cat.png',+ type: 'image/png',+ bytes: 2048,+ height: 100,+ width: 100,+ source: FileSources.local,+ embedded: false,+} as unknown as TFileUpload;++/** jsdom never decodes images; `decodes` mirrors a browser that can or cannot. */+let decodes = true;++class StubImage {+ onload: (() => void) | null = null;+ onerror: (() => void) | null = null;+ width = 100;+ height = 100;+ set src(_value: string) {+ setTimeout(() => (decodes ? this.onload?.() : this.onerror?.()), 0);+ }+}++let commits = 0;++function Harness() {+ const [files, setFiles] = useRecoilState(store.filesByIndex(0));+ const [isSubmitting] = useRecoilState(store.isSubmittingFamily(0));+ const [, setFilesLoading] = useState(false);+ const methods = useForm<ChatFormValues>({ defaultValues: { text: '' } });++ const chatHelpers = useMemo(+ () =>+ ({+ index: 0,+ conversation,+ setConversation: () => undefined,+ files,+ setFiles,+ isSubmitting,+ setIsSubmitting: () => undefined,+ filesLoading: false,+ setFilesLoading,+ newConversation: () => undefined,+ handleStopGenerating: () => undefined,+ stopGenerating: () => undefined,+ getMessages: () => undefined,+ setMessages: () => undefined,+ ask: () => undefined,+ regenerate: () => undefined,+ setSiblingIdx: () => undefined,+ showPopover: false,+ setShowPopover: () => undefined,+ abortScroll: false,+ setAbortScroll: () => undefined,+ preset: null,+ setPreset: () => undefined,+ optionSettings: {},+ setOptionSettings: () => undefined,+ handleRegenerate: () => undefined,+ handleContinue: () => undefined,+ }) as unknown as React.ContextType<typeof ChatContext>,+ [files, setFiles, isSubmitting],+ );++ return (+ <ChatFormProvider {...methods}>+ <ChatContext.Provider value={chatHelpers}>+ <Profiler id="composer" onRender={() => (commits += 1)}>+ <ChatForm index={0} />+ </Profiler>+ </ChatContext.Provider>+ </ChatFormProvider>+ );+}++function renderComposer() {+ const queryClient = new QueryClient({+ defaultOptions: { queries: { retry: false }, mutations: { retry: false } },+ });+ queryClient.setQueryData([QueryKeys.fileConfig], {});+ queryClient.setQueryData<TFile[]>([QueryKeys.files], []);+ queryClient.setQueryData([QueryKeys.endpoints], { [EModelEndpoint.openAI]: { order: 0 } });++ return render(+ <QueryClientProvider client={queryClient}>+ <RecoilRoot>+ <Router>+ <AuthContextProvider authConfig={{ loginRedirect: '', test: true }}>+ <DndProvider backend={HTML5Backend}>+ <Harness />+ </DndProvider>+ </AuthContextProvider>+ </Router>+ </RecoilRoot>+ </QueryClientProvider>,+ );+}++const sendButton = () => screen.getByTestId('send-button');+const attach = (container: HTMLElement, file: File) =>+ userEvent.upload(container.querySelector('input[type="file"]') as HTMLInputElement, file);+const image = () => new File(['image-bytes'], 'cat.png', { type: 'image/png' });++describe('ChatForm attachments', () => {+ beforeEach(() => {+ localStorage.clear();+ decodes = true;+ commits = 0;+ global.URL.createObjectURL = jest.fn(() => 'blob:preview');+ global.URL.revokeObjectURL = jest.fn();+ (global as unknown as { Image: unknown }).Image = StubImage;+ mockUpload.mockReset();+ /** The server echoes the id the client sent back as `temp_file_id`. */+ mockUpload.mockImplementation((body: FormData) =>+ Promise.resolve({ ...uploadResponse, temp_file_id: body.get('file_id') as string }),+ );+ });++ test('re-enables send once an attachment finishes uploading', async () => {+ const { container } = renderComposer();++ const textarea = await screen.findByTestId('text-input');+ await userEvent.type(textarea, 'hi');+ expect(sendButton()).toBeEnabled();++ await attach(container, image());+ await waitFor(() => expect(mockUpload).toHaveBeenCalled());++ await waitFor(() => expect(sendButton()).toBeEnabled());+ expect(textarea).toHaveValue('hi');+ }, 20000);++ test('enables send for an attachment with no composer text', async () => {+ const { container } = renderComposer();+ await screen.findByTestId('text-input');+ expect(sendButton()).toBeDisabled();++ await attach(container, image());+ await waitFor(() => expect(mockUpload).toHaveBeenCalled());++ await waitFor(() => expect(sendButton()).toBeEnabled());+ }, 20000);++ /**+ * The upload only starts once the browser has decoded the image. A decode it+ * refuses used to leave the attachment below `progress: 1`, which reads as+ * "still uploading" and disabled the send button for the rest of the session.+ */+ test('drops an image the browser cannot decode instead of disabling send', async () => {+ decodes = false;+ const { container } = renderComposer();++ const textarea = await screen.findByTestId('text-input');+ await userEvent.type(textarea, 'hi');++ await attach(container, image());+ await waitFor(() => expect(screen.queryByLabelText('Remove file')).not.toBeInTheDocument());++ expect(mockUpload).not.toHaveBeenCalled();+ expect(sendButton()).toBeEnabled();+ expect(textarea).toHaveValue('hi');+ }, 20000);++ /**+ * The composer is the app's busiest surface: every keystroke already re-renders+ * it for the row count and the send button's enabled state, so anything that+ * multiplies that work per character is a regression worth failing on. The+ * measured cost is ~2.5 commits per character (react-scan reports one ChatForm+ * render per keystroke in a real browser); the bound leaves headroom for jsdom+ * scheduling without tolerating a doubling.+ */+ test('keeps typing render-bounded', async () => {+ renderComposer();+ const textarea = await screen.findByTestId('text-input');+ await waitFor(() => expect(sendButton()).toBeInTheDocument());++ commits = 0;+ await userEvent.type(textarea, 'hello there');++ expect(commits).toBeLessThanOrEqual('hello there'.length * 3);+ }, 20000);+});diff --git a/client/src/data-provider/Files/__tests__/uploadNormalization.spec.tsx b/client/src/data-provider/Files/__tests__/uploadNormalization.spec.tsxnew file mode 100644index 0000000000..92326598ab--- /dev/null+++ b/client/src/data-provider/Files/__tests__/uploadNormalization.spec.tsx@@ -0,0 +1,115 @@+import React from 'react';+import { QueryKeys, FileSources } from 'librechat-data-provider';+import { renderHook, act, waitFor } from '@testing-library/react';+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';+import type { TFile, TFileUpload } from 'librechat-data-provider';++const mockUploadFile = jest.fn();++jest.mock('librechat-data-provider', () => {+ const actual = jest.requireActual('librechat-data-provider');+ return {+ ...actual,+ dataService: {+ ...actual.dataService,+ uploadFile: (...args: unknown[]) => mockUploadFile(...args),+ uploadImage: (...args: unknown[]) => mockUploadFile(...args),+ },+ };+});++jest.mock('../../Endpoints', () => ({+ useGetStartupConfig: () => ({ data: undefined }),+}));++import { useUploadFileMutation } from '../mutations';++const REQUEST_FILE_ID = 'client-request-id';++const uploadResponse = {+ file_id: 'server-file-id',+ temp_file_id: 'an-id-the-client-never-sent',+ filename: 'notes.txt',+ filepath: '/files/notes.txt',+ type: 'text/plain',+ bytes: 12,+ object: 'file',+ usage: 0,+ user: 'user-1',+ embedded: false,+ source: FileSources.local,+} as unknown as TFileUpload;++const body = () => {+ const formData = new FormData();+ formData.append('file_id', REQUEST_FILE_ID);+ formData.append('message_file', 'true');+ return formData;+};++/**+ * The composer keys its file map, and the draft it saves, by the `file_id` the+ * request was sent with; `temp_file_id` is only the server's echo of that id.+ * A cached record carrying an echo that disagrees cannot be correlated back to+ * the draft, so `useAutoSave` cannot restore the attachment after a conversation+ * switch or a reload.+ */+describe('useUploadFileMutation — temporary id normalization', () => {+ let queryClient: QueryClient;++ const wrapper = ({ children }: { children: React.ReactNode }) => (+ <QueryClientProvider client={queryClient}>{children}</QueryClientProvider>+ );++ beforeEach(() => {+ queryClient = new QueryClient({+ defaultOptions: { queries: { retry: false }, mutations: { retry: false } },+ });+ mockUploadFile.mockReset();+ mockUploadFile.mockResolvedValue(uploadResponse);+ });++ test('caches the uploaded record under the id the request was sent with', async () => {+ const { result } = renderHook(() => useUploadFileMutation(), { wrapper });++ act(() => {+ result.current.mutate(body());+ });++ await waitFor(() => expect(result.current.isSuccess).toBe(true));++ const [cached] = queryClient.getQueryData<TFile[]>([QueryKeys.files]) ?? [];+ expect(cached).toMatchObject({+ file_id: 'server-file-id',+ temp_file_id: REQUEST_FILE_ID,+ });+ });++ test('hands the normalized record to the caller', async () => {+ const onSuccess = jest.fn();+ const { result } = renderHook(() => useUploadFileMutation({ onSuccess }), { wrapper });++ act(() => {+ result.current.mutate(body());+ });++ await waitFor(() => expect(onSuccess).toHaveBeenCalled());++ expect(onSuccess.mock.calls[0][0]).toMatchObject({ temp_file_id: REQUEST_FILE_ID });+ });++ test('leaves an agreeing response untouched', async () => {+ mockUploadFile.mockResolvedValue({ ...uploadResponse, temp_file_id: REQUEST_FILE_ID });+ const onSuccess = jest.fn();+ const { result } = renderHook(() => useUploadFileMutation({ onSuccess }), { wrapper });++ act(() => {+ result.current.mutate(body());+ });++ await waitFor(() => expect(onSuccess).toHaveBeenCalled());++ const [cached] = queryClient.getQueryData<TFile[]>([QueryKeys.files]) ?? [];+ expect(cached).toBe(onSuccess.mock.calls[0][0]);+ });+});diff --git a/client/src/data-provider/Files/mutations.ts b/client/src/data-provider/Files/mutations.tsindex a538eea4b8..097829022a 100644--- a/client/src/data-provider/Files/mutations.ts+++ b/client/src/data-provider/Files/mutations.ts@@ -44,8 +44,18 @@ export const useUploadFileMutation = (},...options,onSuccess: (data, formData, context) => {+ /** `temp_file_id` is the server's echo of the `file_id` the request was sent+ * with, and that request id is what every client-side handle for the upload+ * is keyed by — the composer's file map, the draft it saves, the delayed+ * toast timer. A record cached under an echo that disagrees cannot be+ * correlated back to the draft, so the attachment is silently dropped on the+ * next conversation switch or reload. Normalize once, on the way in. */+ const requestFileId = (formData.get('file_id') as string | null) ?? data.temp_file_id;+ const file =+ data.temp_file_id === requestFileId ? data : { ...data, temp_file_id: requestFileId };+queryClient.setQueryData<t.TFile[] | undefined>([QueryKeys.files], (_files) => [- data,+ file,...(_files ?? []),]);@@ -56,7 +66,7 @@ export const useUploadFileMutation = (const tool_resource = (formData.get('tool_resource') as string | undefined) ?? '';if (message_file === 'true') {- onSuccess?.(data, formData, context);+ onSuccess?.(file, formData, context);return;}@@ -92,7 +102,7 @@ export const useUploadFileMutation = (}if (!assistant_id) {- onSuccess?.(data, formData, context);+ onSuccess?.(file, formData, context);return;}@@ -136,7 +146,7 @@ export const useUploadFileMutation = (};},);- onSuccess?.(data, formData, context);+ onSuccess?.(file, formData, context);},});};diff --git a/client/src/hooks/Files/__tests__/useFileHandling.test.ts b/client/src/hooks/Files/__tests__/useFileHandling.test.tsindex c643b4b9f4..0378f58b04 100644--- a/client/src/hooks/Files/__tests__/useFileHandling.test.ts+++ b/client/src/hooks/Files/__tests__/useFileHandling.test.ts@@ -8,20 +8,26 @@ import {} from 'librechat-data-provider';type MockUploadMutationOptions = {- onSuccess?: (data: {- temp_file_id: string;- file_id: string;- filepath: string;- type: string;- filename: string;- source: string;- embedded: boolean;- height?: number;- width?: number;- }) => void;+ onSuccess?: (+ data: {+ temp_file_id: string;+ file_id: string;+ filepath: string;+ type: string;+ filename: string;+ source: string;+ embedded: boolean;+ height?: number;+ width?: number;+ },+ body: FormData,+ ) => void;onError?: (error: unknown, body: FormData) => void;};+/** Mirrors a browser that can (or cannot) decode the bytes it was handed. */+let mockImageDecodes = true;+beforeAll(() => {global.URL.createObjectURL = jest.fn(() => 'blob:mock-url');global.URL.revokeObjectURL = jest.fn();@@ -31,9 +37,10 @@ beforeAll(() => {width = 640;height = 480;onload: (() => void) | null = null;+ onerror: (() => void) | null = null;set src(_src: string) {- queueMicrotask(() => this.onload?.());+ queueMicrotask(() => (mockImageDecodes ? this.onload?.() : this.onerror?.()));}},});@@ -131,13 +138,18 @@ jest.mock('../useClientResize', () => ({})),}));+const mockAddFile = jest.fn();+const mockReplaceFile = jest.fn();+const mockUpdateFileById = jest.fn();+const mockDeleteFileById = jest.fn();+jest.mock('../useUpdateFiles', () => ({__esModule: true,default: jest.fn(() => ({- addFile: jest.fn(),- replaceFile: jest.fn(),- updateFileById: jest.fn(),- deleteFileById: jest.fn(),+ addFile: mockAddFile,+ replaceFile: mockReplaceFile,+ updateFileById: mockUpdateFileById,+ deleteFileById: mockDeleteFileById,})),}));@@ -173,6 +185,7 @@ describe('useFileHandling', () => {mockFileConfig = null;mockIsConfigPending = false;mockIsTemporary = false;+ mockImageDecodes = true;mockUploadOptions = {};});@@ -1057,15 +1070,18 @@ describe('useFileHandling', () => {expect(onStart).toHaveBeenCalledWith(fileId);act(() => {- mockUploadOptions.onSuccess?.({- temp_file_id: fileId,- file_id: 'saved-file-id',- filepath: '/files/notes.txt',- type: 'text/plain',- filename: 'notes.txt',- source: 'local',- embedded: false,- });+ mockUploadOptions.onSuccess?.(+ {+ temp_file_id: fileId,+ file_id: 'saved-file-id',+ filepath: '/files/notes.txt',+ type: 'text/plain',+ filename: 'notes.txt',+ source: 'local',+ embedded: false,+ },+ uploadBody,+ );});expect(onSuccess).toHaveBeenCalledWith(fileId);@@ -1160,4 +1176,169 @@ describe('useFileHandling', () => {consoleLog.mockRestore();});});+ describe('stalled attachments', () => {+ /**+ * The upload only starts once the browser has decoded the image, so a decode+ * it refuses must not leave the attachment parked below `progress: 1` — the+ * composer reads that as "still uploading" and disables send for the rest of+ * the session.+ */+ it('drops an image the browser cannot decode instead of parking it mid-upload', async () => {+ mockImageDecodes = false;+ const useFileHandling = await loadHook();+ const { result } = renderHook(() => useFileHandling());++ await act(async () => {+ await result.current.handleFiles([+ new File(['broken'], 'photo.png', { type: 'image/png' }),+ ]);+ });+ await act(async () => {+ await Promise.resolve();+ });++ const addedFile = mockAddFile.mock.calls[0][0] as { file_id: string };+ expect(mockMutate).not.toHaveBeenCalled();+ expect(mockDeleteFileById).toHaveBeenCalledWith(addedFile.file_id);+ });++ it('reports the failure through the upload lifecycle when a decode fails', async () => {+ mockImageDecodes = false;+ const onError = jest.fn();+ const useFileHandling = await loadHook();+ const { result } = renderHook(() => useFileHandling());++ await act(async () => {+ await result.current.handleFiles(+ [new File(['broken'], 'photo.png', { type: 'image/png' })],+ undefined,+ { fileId: 'pending-paste-id', onError },+ );+ });+ await act(async () => {+ await Promise.resolve();+ });++ expect(onError).toHaveBeenCalledWith('pending-paste-id');+ });++ /**+ * Every client-side handle for an upload is keyed by the id the request was+ * sent with; `temp_file_id` is only the server's echo of it. Reconciling+ * against the echo strands the attachment when the two disagree.+ */+ it('keys the completed attachment temporary id to the id the request was sent with', async () => {+ jest.useFakeTimers();+ const consoleLog = jest.spyOn(console, 'log').mockImplementation(() => undefined);+ const useFileHandling = await loadHook();+ const { result } = renderHook(() => useFileHandling());++ await act(async () => {+ await result.current.handleFiles([+ new File(['hello'], 'notes.txt', { type: 'text/plain' }),+ ]);+ });++ const uploadBody = mockMutate.mock.calls[0][0] as FormData;+ const fileId = uploadBody.get('file_id') as string;++ act(() => {+ mockUploadOptions.onSuccess?.(+ {+ temp_file_id: 'an-id-the-client-never-sent',+ file_id: 'saved-file-id',+ filepath: '/files/notes.txt',+ type: 'text/plain',+ filename: 'notes.txt',+ source: 'local',+ embedded: false,+ },+ uploadBody,+ );+ });+ act(() => {+ jest.runAllTimers();+ });+ jest.useRealTimers();++ /** Removal deletes by the value's own ids, so a temporary id that is not the+ * map key leaves a chip the user cannot clear. */+ const [, completion] = mockUpdateFileById.mock.calls.at(-1) as [string, { progress: number }];+ expect(completion).toMatchObject({ progress: 1, temp_file_id: fileId });+ consoleLog.mockRestore();+ });++ it('releases the upload reservation when a decode fails', async () => {+ /** A stable setter so both batches share one upload scope, and a file map that+ * never observes the file — the render that would release the reservation+ * cannot happen once the failed decode has removed it. */+ const sharedState = {+ files: new Map(),+ setFiles: jest.fn(),+ setFilesLoading: mockSetFilesLoading,+ };+ const { useFileHandlingNoChatContext } = await import('../useFileHandling');+ const { result, rerender } = renderHook(() =>+ useFileHandlingNoChatContext(undefined, sharedState),+ );+ const pick = () => new File(['broken'], 'photo.png', { type: 'image/png' });++ mockImageDecodes = false;+ await act(async () => {+ await result.current.handleFiles([pick()]);+ });+ await act(async () => {+ await Promise.resolve();+ });++ rerender();+ mockValidateFileDuplicates.mockClear();+ mockImageDecodes = true;+ await act(async () => {+ await result.current.handleFiles([pick()]);+ });++ /** A reservation the failed decode left behind is merged into the next batch's+ * validation, so re-picking the same file reads as a duplicate and its size+ * keeps counting against the composer's limits. */+ const [{ files: validatedAgainst }] = mockValidateFileDuplicates.mock.calls[0];+ expect(validatedAgainst.size).toBe(0);+ expect(mockMutate).toHaveBeenCalledTimes(1);+ });++ it('completes the attachment against the id the request was sent with', async () => {+ const consoleLog = jest.spyOn(console, 'log').mockImplementation(() => undefined);+ const useFileHandling = await loadHook();+ const { result } = renderHook(() => useFileHandling());++ await act(async () => {+ await result.current.handleFiles([+ new File(['hello'], 'notes.txt', { type: 'text/plain' }),+ ]);+ });++ const uploadBody = mockMutate.mock.calls[0][0] as FormData;+ const fileId = uploadBody.get('file_id') as string;++ act(() => {+ mockUploadOptions.onSuccess?.(+ {+ temp_file_id: 'an-id-the-client-never-sent',+ file_id: 'saved-file-id',+ filepath: '/files/notes.txt',+ type: 'text/plain',+ filename: 'notes.txt',+ source: 'local',+ embedded: false,+ },+ uploadBody,+ );+ });++ const updatedIds = mockUpdateFileById.mock.calls.map(([id]) => id);+ expect(updatedIds).toContain(fileId);+ expect(updatedIds).not.toContain('an-id-the-client-never-sent');+ consoleLog.mockRestore();+ });+ });});diff --git a/client/src/hooks/Files/useFileHandling.ts b/client/src/hooks/Files/useFileHandling.tsindex 8ea2ef3f79..1eac7e627c 100644--- a/client/src/hooks/Files/useFileHandling.ts+++ b/client/src/hooks/Files/useFileHandling.ts@@ -214,16 +214,23 @@ const useFileHandlingCore = (params: UseFileHandling | undefined, fileState: Filconst uploadFile = useUploadFileMutation({- onSuccess: (data) => {- takeUploadRecovery(data.temp_file_id)?.onSuccess?.(data.temp_file_id);- clearUploadTimer(data.temp_file_id);+ onSuccess: (data, body) => {+ /** Every client-side handle for this upload — the file map key, the delayed+ * toast timer, the recovery callbacks — is the id the request was sent with.+ * `temp_file_id` is the server's echo of it, so trusting the echo turns any+ * mismatch into a completion update applied to a key that does not exist:+ * the attachment stays below `progress: 1` and the send button never+ * re-enables. Reconcile against the id we own. */+ const fileId = (body.get('file_id') as string | null) ?? data.temp_file_id;+ takeUploadRecovery(fileId)?.onSuccess?.(fileId);+ clearUploadTimer(fileId);console.log('upload success', data);if (agent_id) {queryClient.refetchQueries([QueryKeys.agent, agent_id]);return;}updateFileById(- data.temp_file_id,+ fileId,{progress: 0.9,filepath: data.filepath,@@ -232,17 +239,22 @@ const useFileHandlingCore = (params: UseFileHandling | undefined, fileState: Fil);setTimeout(() => {- const cachedBlob = getCachedPreview(data.temp_file_id);- if (cachedBlob && data.file_id !== data.temp_file_id) {+ const cachedBlob = getCachedPreview(fileId);+ if (cachedBlob && data.file_id !== fileId) {cachePreview(data.file_id, cachedBlob);- removePreviewEntry(data.temp_file_id);+ removePreviewEntry(fileId);}updateFileById(- data.temp_file_id,+ fileId,{progress: 1,file_id: data.file_id,- temp_file_id: data.temp_file_id,+ /** The stored temporary id has to stay the one this entry is keyed+ * by: removal reads `file_id` and `temp_file_id` off the value and+ * deletes those keys, and the draft restore correlates the cached+ * record by the key it saved. Keeping the server's echo here would+ * leave a chip that Remove deletes server-side but cannot clear. */+ temp_file_id: fileId,filepath: data.filepath,type: data.type,height: data.height,@@ -389,15 +401,35 @@ const useFileHandlingCore = (params: UseFileHandling | undefined, fileState: Fil) => {const img = new Image();img.onload = async () => {- extendedFile.width = img.width;- extendedFile.height = img.height;- extendedFile = {+ const measuredFile: ExtendedFile = {...extendedFile,+ width: img.width,+ height: img.height,progress: 0.6,};- replaceFile(extendedFile);+ replaceFile(measuredFile);- await startUpload(extendedFile, uploadLifecycle);+ await startUpload(measuredFile, uploadLifecycle);+ };+ /** The upload only starts once the browser has decoded the image, so a decode+ * it refuses (unsupported codec, truncated bytes, a revoked object URL) would+ * otherwise strand the attachment below `progress: 1` — which reads as "still+ * uploading" and keeps the composer's send button disabled for the rest of the+ * session, with nothing to click and no error to explain it. Drop the file and+ * say so instead. */+ img.onerror = () => {+ clearUploadTimer(extendedFile.file_id);+ takeUploadRecovery(extendedFile.file_id)?.onError?.(extendedFile.file_id);+ deleteFileById(extendedFile.file_id);+ /** Reservations are released by the render that observes the file in the+ * shared state, which a decode failing before that render never reaches —+ * and once the file is gone no later render can either. A leaked one is+ * merged into every subsequent batch's validation, so re-picking the same+ * file reads as a duplicate and its size keeps counting against the limit. */+ uploadScope.recent.delete(extendedFile.file_id);+ removePreviewEntry(extendedFile.file_id);+ URL.revokeObjectURL(preview);+ setError('com_error_files_process');};img.src = preview;};diff --git a/client/src/hooks/Input/useAutoSave.spec.ts b/client/src/hooks/Input/useAutoSave.spec.tsindex 5293207848..8331f9b54f 100644--- a/client/src/hooks/Input/useAutoSave.spec.ts+++ b/client/src/hooks/Input/useAutoSave.spec.ts@@ -529,3 +529,131 @@ describe('useAutoSave — side-by-side pending drafts', () => {expect(getFilesDraft(`${Constants.NEW_CONVO}:1`)).toEqual({ fileIds: [], pendingPastes: {} });});});++describe('useAutoSave — file cache updates', () => {+ const liveAttachment = {+ file_id: 'client-temp-id',+ type: 'image/png',+ size: 2048,+ progress: 0.9,+ preview: 'blob:local-preview',+ tool_resource: 'file_search',+ file: new File(['bytes'], 'cat.png', { type: 'image/png' }),+ };+ const persistedRecord = {+ file_id: 'server-file-id',+ temp_file_id: 'client-temp-id',+ filename: 'cat.png',+ filepath: '/images/cat.png',+ type: 'image/png',+ bytes: 2048,+ object: 'file',+ usage: 0,+ user: 'user-1',+ embedded: false,+ };++ const applySetFiles = (setFiles: jest.Mock, current: Map<string, unknown>) =>+ setFiles.mock.calls.reduce(+ (files, [update]) => (typeof update === 'function' ? update(files) : update),+ current,+ ) as Map<string, Record<string, unknown>>;++ /**+ * The file cache is rewritten on every upload and on every attachment an agent+ * emits mid-run, and this hook restores from it. An empty draft there means the+ * draft write has not caught up — not that the composer is empty — so clearing+ * would drop an attachment the user just added (and, with no text typed, leave+ * them with nothing submittable).+ */+ it('leaves live attachments alone when the file cache changes with no saved draft', () => {+ const setFiles = jest.fn();+ const files = new Map([['client-temp-id', liveAttachment]]);++ const { rerender } = renderHook(+ ({ fileList }: { fileList: unknown[] }) => {+ (useGetFiles as jest.Mock).mockReturnValue({ data: fileList });+ return useAutoSave({+ conversationId: 'convo-1',+ textAreaRef: makeTextAreaRef(),+ files,+ setFiles,+ });+ },+ { initialProps: { fileList: [] as unknown[] } },+ );++ setFiles.mockClear();+ /** The draft is gone the moment storage refuses or evicts the write — another+ * tab clearing it, a quota failure, private browsing. The attachment the user+ * just added is still in the composer either way. */+ localStorage.clear();+ act(() => {+ rerender({ fileList: [persistedRecord] });+ });++ expect(applySetFiles(setFiles, files).size).toBe(1);+ });++ /**+ * The restore also lands on entries the composer still owns, so it has to layer+ * the persisted record over them rather than replace them: the blob preview the+ * chip renders from and the tool resource the upload was staged under exist only+ * locally, and `attached` decides whether removing the chip deletes the file.+ */+ it('layers the persisted record over a live attachment instead of replacing it', () => {+ const setFiles = jest.fn();+ const files = new Map([['client-temp-id', liveAttachment]]);+ setFilesDraft('convo-1', { fileIds: ['client-temp-id'], pendingPastes: {} });++ const { rerender } = renderHook(+ ({ fileList }: { fileList: unknown[] }) => {+ (useGetFiles as jest.Mock).mockReturnValue({ data: fileList });+ return useAutoSave({+ conversationId: 'convo-1',+ textAreaRef: makeTextAreaRef(),+ files,+ setFiles,+ });+ },+ { initialProps: { fileList: [] as unknown[] } },+ );++ /** Past the mount swap, which clears the composer itself before restoring. */+ setFiles.mockClear();+ act(() => {+ rerender({ fileList: [persistedRecord] });+ });++ const restored = applySetFiles(setFiles, files).get('client-temp-id');+ expect(restored).toMatchObject({+ file_id: 'server-file-id',+ filepath: '/images/cat.png',+ progress: 1,+ preview: 'blob:local-preview',+ tool_resource: 'file_search',+ attached: false,+ });+ expect(restored?.file).toBeInstanceOf(File);+ });++ it('marks a file restored from a draft alone as attached', () => {+ const setFiles = jest.fn();+ setFilesDraft('convo-1', { fileIds: ['client-temp-id'], pendingPastes: {} });++ renderHook(() => {+ (useGetFiles as jest.Mock).mockReturnValue({ data: [persistedRecord] });+ return useAutoSave({+ conversationId: 'convo-1',+ textAreaRef: makeTextAreaRef(),+ files: new Map(),+ setFiles,+ });+ });++ expect(applySetFiles(setFiles, new Map()).get('client-temp-id')).toMatchObject({+ attached: true,+ progress: 1,+ });+ });+});diff --git a/client/src/hooks/Input/useAutoSave.ts b/client/src/hooks/Input/useAutoSave.tsindex 15687b686a..ee9ce33ca2 100644--- a/client/src/hooks/Input/useAutoSave.ts+++ b/client/src/hooks/Input/useAutoSave.ts@@ -65,11 +65,12 @@ export const useAutoSave = ({(id: string): PendingTextAttachmentDraft[] => {const filesDraft = getFilesDraft(id);- if (filesDraft.fileIds.length === 0) {- setFiles(new Map());- return [];- }- if (fileList == null) {+ /** Restoring adds what the draft holds; it never clears. The conversation+ * swap below owns that, and does it explicitly before calling here — while+ * the file-cache path runs on every `QueryKeys.files` write (an upload+ * landing, an SSE attachment during a run), where an empty draft means the+ * write has not caught up yet, not that the user has no attachments. */+ if (filesDraft.fileIds.length === 0 || fileList == null) {return [];}@@ -95,10 +96,20 @@ export const useAutoSave = ({delete pendingPastes[fileId];setFiles((currentFiles) => {const updatedFiles = new Map(currentFiles);+ /** The same entry may still be live in the composer — this path also+ * runs when the upload that created it writes the file cache. Layer+ * the persisted record over it instead of replacing it: the local+ * `File`, the blob preview the chip renders from, and the tool+ * resource the upload was staged under exist nowhere on the server+ * record, and `attached` decides whether removing the chip also+ * deletes the file, which a composer-owned upload still needs. */+ const live = updatedFiles.get(fileIdToRecover);updatedFiles.set(fileIdToRecover, {+ ...live,...fileToRecover,+ preview: live?.preview ?? fileToRecover.preview,progress: 1,- attached: true,+ attached: live ? (live.attached ?? false) : true,size: fileToRecover.bytes,});return updatedFiles;