Skip to content

Enhanced ChatGPT Clone: Features Agents, MCP, Skills, DeepSeek, Anthropic, AWS, OpenAI, Responses API, Azure, Groq, o1, GPT-5, Mistral, OpenRouter, Vertex AI, Gemini, Artifacts, AI model switching, message search, Code Interpreter, langchain, DALL-E-3, OpenAPI Actions, Functions, Secure Multi-User Auth, Presets, open-source for self-hosting. Active

🔚 fix: Bound Abandoned File Deletion Retries (#17640)

lia-by-librechat[bot]b3f71196f386
diff --git a/api/server/services/Files/process.spec.js b/api/server/services/Files/process.spec.js
index 077abb3f3e..e051b6fd4b 100644
--- a/api/server/services/Files/process.spec.js
+++ b/api/server/services/Files/process.spec.js
@@ -2702,6 +2702,63 @@ describe('processDeleteRequest', () => {
expect(result).toEqual({ deletedFileIds: ['expired-file'], failedFileIds: [] });
});
+ it('removes eight stale uploads after local ENOENT and an unknown Code API user session', async () => {
+ const { createCodeFileDeleter } = jest.requireActual(
+ '../../../../packages/api/src/files/code/delete',
+ );
+ const httpClient = jest.fn().mockRejectedValue({ response: { status: 403 } });
+ const clearFileCodeEnvRefs = jest.fn().mockResolvedValue(true);
+ const deleteCodeFile = createCodeFileDeleter({
+ httpClient,
+ clearFileCodeEnvRefs,
+ getAuthHeaders: async () => ({}),
+ getBaseUrl: () => 'https://code.example',
+ routeKey: () => 'default',
+ profileHeaders: () => ({}),
+ downloadQuery: () => '?kind=user&id=user-123',
+ logger,
+ });
+ const deleteLocalFile = jest
+ .fn()
+ .mockRejectedValue(Object.assign(new Error('no such file'), { code: 'ENOENT' }));
+ getStrategyFunctions.mockImplementation((source) => ({
+ deleteFile: source === FileSources.execute_code ? deleteCodeFile : deleteLocalFile,
+ }));
+ const files = Array.from({ length: 8 }, (_, index) => ({
+ file_id: `expired-file-${index}`,
+ source: FileSources.local,
+ user: 'user-123',
+ filepath: `/uploads/user-123/expired-${index}.txt`,
+ metadata: {
+ codeEnvRef: {
+ kind: 'user',
+ id: 'user-123',
+ file_id: `remote-${index}`,
+ storage_session_id: 'expired-session',
+ provisionedAt: 1,
+ },
+ },
+ }));
+ const result = await processDeleteRequest({
+ req: {
+ body: {},
+ config: { fileConfig: { retainedFileCleanup: true } },
+ user: { id: 'user-123' },
+ },
+ files,
+ });
+ const ids = files.map((file) => file.file_id);
+ expect(result).toEqual({ deletedFileIds: ids, failedFileIds: [] });
+ expect(httpClient).toHaveBeenCalledTimes(8);
+ expect(deleteLocalFile).toHaveBeenCalledTimes(8);
+ expect(clearFileCodeEnvRefs).toHaveBeenCalledTimes(8);
+ expect(db.deleteFiles).toHaveBeenCalledWith(
+ ids,
+ undefined,
+ expect.objectContaining({ userId: 'user-123' }),
+ );
+ });
+
it('does not treat unrelated not found messages as missing storage', async () => {
const deleteFile = jest.fn().mockRejectedValue(new Error('Configuration not found'));
getStrategyFunctions.mockReturnValue({ deleteFile });
diff --git a/client/src/components/Chat/Presentation.tsx b/client/src/components/Chat/Presentation.tsx
index a9f60d709e..7b2c146548 100644
--- a/client/src/components/Chat/Presentation.tsx
+++ b/client/src/components/Chat/Presentation.tsx
@@ -1,12 +1,10 @@
import { Suspense, useCallback, useEffect, useMemo, useRef } from 'react';
import { useRecoilValue } from 'recoil';
import { useAtomValue, useSetAtom } from 'jotai';
+import { EModelEndpoint } from 'librechat-data-provider';
import { activeSubagentPanel, useIsSubmitting } from '@librechat/chat/react';
-import { EModelEndpoint, FileSources, LocalStorageKeys } from 'librechat-data-provider';
-import type { ExtendedFile } from '~/common';
import { ParentSubagentsProvider } from '~/components/Chat/Subagents/ParentSubagentsProvider';
import useArtifactsRegistryLifetime from '~/hooks/Artifacts/useArtifactsRegistryLifetime';
-import { useDeleteFilesMutation, useGetStartupConfig } from '~/data-provider';
import { MessageSurfaceContext } from '~/components/Chat/Messages/ui/surface';
import DragDropWrapper from '~/components/Chat/Input/Files/DragDropWrapper';
import UndockedArtifacts from '~/components/Artifacts/UndockedArtifacts';
@@ -14,9 +12,9 @@ import { artifactsUndocked } from '~/components/Artifacts/state';
import { EditorProvider, ArtifactsProvider } from '~/Providers';
import { SidePanelGroup } from '~/components/SidePanel';
import AppChatSurface from '~/components/Chat/Surface';
+import { useGetStartupConfig } from '~/data-provider';
import { lazyWithRecovery } from '~/lib/assets/lazy';
-import { useSetFilesToDelete } from '~/hooks';
-import { failedFileIdsFrom } from '~/utils';
+import { migrateStoredFileDeletions } from '~/utils';
import store from '~/store';
const Artifacts = lazyWithRecovery(() => import('~/components/Artifacts/Artifacts'));
@@ -68,59 +66,9 @@ export default function Presentation({
}
}, [conversationId, setSelectedSubagent]);
- const setFilesToDelete = useSetFilesToDelete();
-
const { data: startupConfig, isSuccess: hasStartupConfig } = useGetStartupConfig();
- const { mutateAsync } = useDeleteFilesMutation({
- onSuccess: (result) => {
- console.log('Temporary Files deleted');
- const failed = new Set(failedFileIdsFrom(result));
- if (failed.size === 0) {
- setFilesToDelete({});
- return;
- }
- try {
- const filesToDelete = localStorage.getItem(LocalStorageKeys.FILES_TO_DELETE);
- const map = JSON.parse(filesToDelete ?? '{}') as Record<string, ExtendedFile>;
- const remaining: Record<string, ExtendedFile> = {};
- for (const [key, file] of Object.entries(map)) {
- if (
- (file.file_id != null && failed.has(file.file_id)) ||
- (file.temp_file_id != null && failed.has(file.temp_file_id))
- ) {
- remaining[key] = file;
- }
- }
- setFilesToDelete(remaining);
- } catch {
- // Keep existing records if reading or parsing fails.
- }
- },
- onError: (error) => {
- console.log('Error deleting temporary files:', error);
- },
- });
-
- useEffect(() => {
- const filesToDelete = localStorage.getItem(LocalStorageKeys.FILES_TO_DELETE);
- const map = JSON.parse(filesToDelete ?? '{}') as Record<string, ExtendedFile>;
- const files = Object.values(map)
- .filter(
- (file) =>
- file.filepath != null && file.source && !(file.embedded ?? false) && file.temp_file_id,
- )
- .map((file) => ({
- file_id: file.file_id,
- filepath: file.filepath as string,
- source: file.source as FileSources,
- embedded: !!(file.embedded ?? false),
- }));
- if (files.length === 0) {
- return;
- }
- mutateAsync({ files });
- }, [mutateAsync]);
+ useEffect(() => migrateStoredFileDeletions(), []);
/* The deployment's answer about the undocked window, resolved once by the
* host and handed to the pane. Until the config has actually answered the
diff --git a/client/src/hooks/Conversations/__tests__/useNewChat.spec.ts b/client/src/hooks/Conversations/__tests__/useNewChat.spec.ts
index dfa6516a38..643f632f24 100644
--- a/client/src/hooks/Conversations/__tests__/useNewChat.spec.ts
+++ b/client/src/hooks/Conversations/__tests__/useNewChat.spec.ts
@@ -35,7 +35,7 @@ const mockState = {
return getDefaultStore().get(filesFamily(0));
},
set files(files: Map<string, LiveFile>) {
- getDefaultStore().set(filesFamily(0), files as Map<string, ExtendedFile>);
+ act(() => getDefaultStore().set(filesFamily(0), files as Map<string, ExtendedFile>));
},
retainedDeletions: [] as { file_id: string; filepath: string; source: string }[],
markedPasteIds: [] as string[],
@@ -46,6 +46,7 @@ const mockState = {
foreignLiveAttachmentIds: [] as string[],
foreignDraftedIds: [] as string[],
retainedPassInFlight: false,
+ fileConfig: { deletionRetryLimit: 5 } as { deletionRetryLimit: number } | undefined,
persistedPendingDiscardIds: [] as string[],
retainedListener: null as (() => void) | null,
pendingDiscardListener: null as (() => void) | null,
@@ -121,6 +122,19 @@ jest.mock('~/utils', () => ({
};
},
takeRetainedFileDeletions: () => mockState.retainedDeletions,
+ claimFileDeletionRetries: (records: typeof mockState.retainedDeletions) => {
+ const unique = Array.from(new Map(records.map((record) => [record.file_id, record])).values());
+ mockState.retainedDeletions = unique;
+ return unique;
+ },
+ settleFileDeletionRetries: (
+ _records: typeof mockState.retainedDeletions,
+ failed: Set<string>,
+ ) => {
+ mockState.retainedDeletions = mockState.retainedDeletions.filter((record) =>
+ failed.has(record.file_id),
+ );
+ },
clearRetainedFileDeletion: (fileId: string) => {
mockState.retainedDeletions = mockState.retainedDeletions.filter(
(record) => record.file_id !== fileId,
@@ -128,7 +142,8 @@ jest.mock('~/utils', () => ({
},
failedFileIdsFrom: (result: { failedFileIds?: string[] } | void) =>
result != null && Array.isArray(result.failedFileIds) ? result.failedFileIds : [],
- scheduleRetainedFileDeletionRetry: () => mockScheduleRetainedRetry(),
+ scheduleRetainedFileDeletionRetry: (pendingDiscard?: boolean) =>
+ mockScheduleRetainedRetry(pendingDiscard),
isPastedTextFileMarked: (fileId: string) => mockState.markedPasteIds.includes(fileId),
isPasteSubmitted: (fileId: string) => mockState.submittedPasteIds.includes(fileId),
collectLiveAttachmentIds: ({ excludeOwnPane }: { excludeOwnPane?: number | 'tab' } = {}) =>
@@ -209,6 +224,7 @@ jest.mock('~/utils', () => ({
jest.mock('~/data-provider', () => ({
useGetFiles: () => ({ data: mockState.fileList }),
useDeleteFilesMutation: () => ({ mutateAsync: mockDeleteFiles }),
+ useGetFileConfig: () => ({ data: mockState.fileConfig, isSuccess: mockState.fileConfig != null }),
}));
jest.mock('~/store', () => ({
@@ -255,6 +271,7 @@ describe('useNewChat', () => {
mockState.foreignLiveAttachmentIds = [];
mockState.foreignDraftedIds = [];
mockState.retainedPassInFlight = false;
+ mockState.fileConfig = { deletionRetryLimit: 5 };
mockScheduleRetainedRetry.mockClear();
});
@@ -696,6 +713,32 @@ describe('useNewChat', () => {
expect(mockState.retainedDeletions).toHaveLength(0);
});
+ it('waits for the configured budget before claiming restored cleanup work', async () => {
+ mockState.fileConfig = undefined;
+ mockState.fileList = [];
+ mockState.retainedDeletions = [
+ { file_id: 'retained-file', filepath: '/uploads/file.txt', source: 'local' },
+ ];
+ const { rerender } = renderHook(() => useNewChat());
+ await act(async () => undefined);
+ expect(mockDeleteFiles).not.toHaveBeenCalled();
+ expect(mockState.retainedDeletions).toHaveLength(1);
+ mockState.fileConfig = { deletionRetryLimit: 10 };
+ await act(async () => rerender());
+ expect(mockDeleteFiles).toHaveBeenCalledTimes(1);
+ });
+
+ it('asks for a deferred wakeup when another mounted pane owns the cleanup pass', () => {
+ mockState.retainedPassInFlight = true;
+ mockState.persistedPendingDiscardIds = ['late-paste'];
+ mockState.fileList = [
+ { file_id: 'late-paste', filepath: '/uploads/late.txt', source: 'local' },
+ ];
+ renderHook(() => useNewChat());
+ expect(mockDeleteFiles).not.toHaveBeenCalled();
+ expect(mockScheduleRetainedRetry).toHaveBeenCalledWith(true);
+ });
+
it('keeps retained deletions when the retried request fails again', async () => {
mockDeleteFiles.mockRejectedValueOnce(new Error('offline'));
mockState.retainedDeletions = [
diff --git a/client/src/hooks/Conversations/useNewChat.ts b/client/src/hooks/Conversations/useNewChat.ts
index a34739b876..bb48911a45 100644
--- a/client/src/hooks/Conversations/useNewChat.ts
+++ b/client/src/hooks/Conversations/useNewChat.ts
@@ -10,6 +10,8 @@ import type { ExtendedFile } from '~/common';
import type { FilesDraft } from '~/utils';
import {
beginRetainedDeletionPass,
+ claimFileDeletionRetries,
+ settleFileDeletionRetries,
clearAllDrafts,
clearFilesDraft,
clearMessagesCache,
@@ -33,7 +35,7 @@ import {
subscribeRetainedFileDeletions,
takeRetainedFileDeletions,
} from '~/utils';
-import { useGetFiles, useDeleteFilesMutation } from '~/data-provider';
+import { useGetFiles, useGetFileConfig, useDeleteFilesMutation } from '~/data-provider';
import { useChatSettings } from '~/Providers/ChatSettingsContext';
import useNewConvo from '~/hooks/useNewConvo';
import store from '~/store';
@@ -124,6 +126,8 @@ export default function useNewChat({
const files = useAtomValue(filesFamily(index));
const { saveDrafts } = useChatSettings();
const { data: fileList } = useGetFiles<TFile[]>();
+ const { data: fileConfig, isSuccess: hasFileConfig } = useGetFileConfig();
+ const retryLimit = fileConfig?.deletionRetryLimit;
const { mutateAsync } = useDeleteFilesMutation();
/** The cleanup pass runs on a timer nobody asked for, so it reports nothing: a storage failure
* that keeps failing would otherwise toast on every retry, and success would arrive minutes
@@ -175,16 +179,19 @@ export default function useNewChat({
useEffect(() => {
const retained = takeRetainedFileDeletions();
- if ((pendingDiscardIds.length === 0 && retained.length === 0) || fileList == null) {
+ if (
+ (pendingDiscardIds.length === 0 && retained.length === 0) ||
+ fileList == null ||
+ !hasFileConfig
+ ) {
return;
}
/** Another mounted instance is already running this pass. Ask for a later one rather than
* dropping the work: whatever it does not resolve has to be revisited by someone. */
if (!beginRetainedDeletionPass()) {
- scheduleRetainedFileDeletionRetry();
+ scheduleRetainedFileDeletionRetry(pendingDiscardIds.length > 0);
return;
}
- let cancelled = false;
const attempt = async () => {
removeTabAttachmentPresence(
[...pendingDiscardIds, ...retained.map((record) => record.file_id)],
@@ -253,42 +260,27 @@ export default function useNewChat({
clearRetainedFileDeletion(record.file_id);
}
}
- const batch = [...deletable, ...retainedToRetry];
- if (batch.length > 0) {
- try {
- const result = await mutateAsyncSilently({ files: batch });
- const failed = new Set(failedFileIdsFrom(result));
- for (const record of retainedToRetry) {
- if (!failed.has(record.file_id)) {
- clearRetainedFileDeletion(record.file_id);
- }
- }
- for (const record of deletable) {
- if (failed.has(record.file_id)) {
- stillPending.push(record.file_id);
- }
- }
- /** A reported failure leaves both stores exactly as they were, so this effect has no
- * dependency left to move it: the next attempt has to be asked for, same as a rejection. */
- if (failed.size > 0) {
- scheduleRetainedFileDeletionRetry();
- }
- } catch {
- /** The draft is already gone, so these ids are the only record of what to clean:
- * keep them for the next files-cache update rather than orphaning the uploads. Nothing
- * here moves an effect dependency, so the next attempt has to be asked for. */
- scheduleRetainedFileDeletionRetry();
- return;
- }
- }
- if (!cancelled && stillPending.length !== pendingDiscardIds.length) {
+ const batch = claimFileDeletionRetries([...deletable, ...retainedToRetry], retryLimit);
+ // Once resolved, the retained queue owns the payload and its retry budget.
+ if (stillPending.length !== pendingDiscardIds.length) {
setPendingDiscardIds(stillPending);
}
+ if (batch.length === 0) {
+ return;
+ }
+ try {
+ const result = await mutateAsyncSilently({ files: batch });
+ settleFileDeletionRetries(batch, new Set(failedFileIdsFrom(result)), retryLimit);
+ } catch {
+ settleFileDeletionRetries(
+ batch,
+ new Set(batch.map((record) => record.file_id)),
+ retryLimit,
+ );
+ }
+ scheduleRetainedFileDeletionRetry();
};
void attempt().finally(endRetainedDeletionPass);
- return () => {
- cancelled = true;
- };
}, [
pendingDiscardIds,
conversationId,
@@ -297,6 +289,8 @@ export default function useNewChat({
index,
mutateAsyncSilently,
retainedGeneration,
+ hasFileConfig,
+ retryLimit,
setPendingDiscardIds,
]);
diff --git a/client/src/utils/__tests__/retainedFileDeletions.spec.ts b/client/src/utils/__tests__/retainedFileDeletions.spec.ts
index b62261aafa..d4cdb634f4 100644
--- a/client/src/utils/__tests__/retainedFileDeletions.spec.ts
+++ b/client/src/utils/__tests__/retainedFileDeletions.spec.ts
@@ -1,4 +1,4 @@
-import { FileSources } from 'librechat-data-provider';
+import { FileSources, LocalStorageKeys } from 'librechat-data-provider';
const RETAINED_KEY = 'librechat-retained-file-deletions';
@@ -197,3 +197,171 @@ describe('retained file deletions', () => {
expect(reloaded.isPastedTextFileMarked('other-paste-id')).toBe(false);
});
});
+
+describe('bounded file deletion retries', () => {
+ beforeEach(() => {
+ jest.resetModules();
+ sessionStorage.clear();
+ localStorage.clear();
+ });
+
+ it.each(['partial failure', 'rejection'])(
+ 'stops and clears storage after five automatic attempts (%s)',
+ async (mode) => {
+ jest.useFakeTimers();
+ const queue = await import('../files');
+ try {
+ queue.retainFileDeletion(record);
+ const request = jest.fn(async () => {
+ const batch = queue.claimFileDeletionRetries(queue.takeRetainedFileDeletions());
+ try {
+ const result = await (mode === 'rejection'
+ ? Promise.reject(new Error('offline'))
+ : Promise.resolve({ message: 'partial failure', failedFileIds: [record.file_id] }));
+ queue.settleFileDeletionRetries(batch, new Set(queue.failedFileIdsFrom(result)));
+ } catch {
+ queue.settleFileDeletionRetries(batch, new Set(batch.map((file) => file.file_id)));
+ }
+ queue.scheduleRetainedFileDeletionRetry();
+ });
+ const unsubscribe = queue.subscribeRetainedFileDeletions(request);
+ queue.scheduleRetainedFileDeletionRetry();
+ await jest.runAllTimersAsync();
+ expect(request).toHaveBeenCalledTimes(5);
+ expect(queue.takeRetainedFileDeletions()).toEqual([]);
+ expect(sessionStorage.getItem(RETAINED_KEY)).toBeNull();
+ expect(jest.getTimerCount()).toBe(0);
+ unsubscribe();
+ } finally {
+ queue.clearRetainedFileDeletions();
+ jest.useRealTimers();
+ }
+ },
+ );
+
+ it('persists attempts before dispatch and does not reset them on reload or duplicate retention', async () => {
+ let queue = await import('../files');
+ queue.retainFileDeletion(record);
+ for (let attempt = 0; attempt < 4; attempt++) {
+ expect(queue.claimFileDeletionRetries([record])).toEqual([record]);
+ queue.settleFileDeletionRetries([record], new Set([record.file_id]));
+ queue.retainFileDeletion(record);
+ jest.resetModules();
+ queue = await import('../files');
+ }
+ expect(JSON.parse(sessionStorage.getItem(RETAINED_KEY) ?? '[]')[0].attempts).toBe(4);
+ expect(queue.claimFileDeletionRetries([record])).toEqual([record]);
+ queue.settleFileDeletionRetries([record], new Set([record.file_id]));
+ expect(queue.takeRetainedFileDeletions()).toEqual([]);
+ expect(sessionStorage.getItem(RETAINED_KEY)).toBeNull();
+ });
+
+ it('drops a final in-flight attempt restored after a reload without dispatching it again', async () => {
+ sessionStorage.setItem(RETAINED_KEY, JSON.stringify([{ ...record, attempts: 5 }]));
+ const queue = await import('../files');
+ expect(queue.claimFileDeletionRetries(queue.takeRetainedFileDeletions())).toEqual([]);
+ expect(sessionStorage.getItem(RETAINED_KEY)).toBeNull();
+ });
+
+ it('counts each file once and removes successful files without exhausting the rest', async () => {
+ const queue = await import('../files');
+ const other = { ...record, file_id: 'other-file' };
+ expect(queue.claimFileDeletionRetries([record, record, other], 2)).toEqual([record, other]);
+ queue.settleFileDeletionRetries([record, other], new Set([other.file_id]), 2);
+ expect(queue.takeRetainedFileDeletions()).toEqual([other]);
+ expect(queue.claimFileDeletionRetries([other], 2)).toEqual([other]);
+ queue.settleFileDeletionRetries([other], new Set([other.file_id]), 2);
+ expect(sessionStorage.getItem(RETAINED_KEY)).toBeNull();
+ });
+
+ it('persists retry accounting once per batch rather than once per file', async () => {
+ const queue = await import('../files');
+ const batch = Array.from({ length: 8 }, (_, index) => ({
+ ...record,
+ file_id: `file-${index}`,
+ }));
+ const write = jest.spyOn(Storage.prototype, 'setItem');
+ const remove = jest.spyOn(Storage.prototype, 'removeItem');
+ queue.claimFileDeletionRetries(batch);
+ expect(write.mock.calls.filter(([key]) => key === RETAINED_KEY)).toHaveLength(1);
+ queue.settleFileDeletionRetries(batch, new Set());
+ expect(remove.mock.calls.filter(([key]) => key === RETAINED_KEY)).toHaveLength(1);
+ });
+
+ it('does not count reconnects or scheduling as attempts', async () => {
+ jest.useFakeTimers();
+ const queue = await import('../files');
+ try {
+ queue.retainFileDeletion(record);
+ queue.scheduleRetainedFileDeletionRetry();
+ queue.scheduleRetainedFileDeletionRetry();
+ window.dispatchEvent(new Event('online'));
+ expect(queue.takeRetainedFileDeletions()).toEqual([record]);
+ expect(JSON.parse(sessionStorage.getItem(RETAINED_KEY) ?? '[]')[0].attempts).toBeUndefined();
+ } finally {
+ queue.clearRetainedFileDeletions();
+ jest.useRealTimers();
+ }
+ });
+
+ it('preserves a deferred discard wakeup when the other pane drains the retained queue', async () => {
+ jest.useFakeTimers();
+ const queue = await import('../files');
+ try {
+ queue.claimFileDeletionRetries([record]);
+ const listener = jest.fn();
+ const unsubscribe = queue.subscribeRetainedFileDeletions(listener);
+ queue.scheduleRetainedFileDeletionRetry(true);
+ queue.settleFileDeletionRetries([record], new Set());
+ expect(queue.takeRetainedFileDeletions()).toEqual([]);
+ jest.advanceTimersByTime(5_000);
+ expect(listener).toHaveBeenCalledTimes(1);
+ expect(jest.getTimerCount()).toBe(0);
+ unsubscribe();
+ } finally {
+ queue.clearRetainedFileDeletions();
+ jest.useRealTimers();
+ }
+ });
+
+ it('wakes deferred work even when the claimed pass had no resolvable payload', async () => {
+ jest.useFakeTimers();
+ const queue = await import('../files');
+ try {
+ const listener = jest.fn();
+ const unsubscribe = queue.subscribeRetainedFileDeletions(listener);
+ queue.scheduleRetainedFileDeletionRetry(true);
+ jest.advanceTimersByTime(5_000);
+ expect(listener).toHaveBeenCalledTimes(1);
+ unsubscribe();
+ } finally {
+ queue.clearRetainedFileDeletions();
+ jest.useRealTimers();
+ }
+ });
+
+ it('migrates the remount queue only once and preserves an existing retry budget', async () => {
+ const queue = await import('../files');
+ queue.claimFileDeletionRetries([record]);
+ localStorage.setItem(
+ LocalStorageKeys.FILES_TO_DELETE,
+ JSON.stringify({
+ [record.file_id]: { ...record, temp_file_id: 'upload-id' },
+ }),
+ );
+ queue.migrateStoredFileDeletions();
+ expect(localStorage.getItem(LocalStorageKeys.FILES_TO_DELETE)).toBeNull();
+ expect(queue.takeRetainedFileDeletions()).toEqual([record]);
+ expect(JSON.parse(sessionStorage.getItem(RETAINED_KEY) ?? '[]')[0].attempts).toBe(1);
+ queue.migrateStoredFileDeletions();
+ expect(queue.takeRetainedFileDeletions()).toEqual([record]);
+ });
+
+ it('does not re-enqueue or dispatch deletion work after sign-out', async () => {
+ const queue = await import('../files');
+ queue.clearRetainedFileDeletions();
+ expect(queue.claimFileDeletionRetries([record])).toEqual([]);
+ queue.retainFileDeletion(record);
+ expect(sessionStorage.getItem(RETAINED_KEY)).toBeNull();
+ });
+});
diff --git a/client/src/utils/files.ts b/client/src/utils/files.ts
index 491f496212..15a8e0fe47 100644
--- a/client/src/utils/files.ts
+++ b/client/src/utils/files.ts
@@ -1,5 +1,6 @@
import {
Tools,
+ LocalStorageKeys,
megabyte,
Providers,
QueryKeys,
@@ -708,13 +709,15 @@ const RETAINED_DELETION_STORAGE_KEY = 'librechat-retained-file-deletions';
const RETAINED_RETRY_BASE_DELAY_MS = 5_000;
const RETAINED_RETRY_MAX_DELAY_MS = 60_000;
-const readStoredRetainedDeletions = (): PendingFileDeletion[] => {
+type RetainedFileDeletion = PendingFileDeletion & { attempts?: number };
+
+const readStoredRetainedDeletions = (): RetainedFileDeletion[] => {
try {
const raw = sessionStorage.getItem(RETAINED_DELETION_STORAGE_KEY);
if (raw == null || raw === '') {
return [];
}
- const parsed = JSON.parse(raw) as PendingFileDeletion[] | null;
+ const parsed = JSON.parse(raw) as RetainedFileDeletion[] | null;
return Array.isArray(parsed) ? parsed : [];
} catch {
return [];
@@ -723,12 +726,15 @@ const readStoredRetainedDeletions = (): PendingFileDeletion[] => {
/** Survives a reload: the chip these came from is gone, so once the tab forgets the payload the
* upload on the server has no reference left at all. */
-const retainedFileDeletions = new Map<string, PendingFileDeletion>(
+const retainedFileDeletions = new Map<string, RetainedFileDeletion>(
readStoredRetainedDeletions().map((record) => [record.file_id, record]),
);
const retainedFileDeletionListeners = new Set<() => void>();
const persistRetainedFileDeletions = (): void => {
+ if (retainedFileDeletions.size === 0) {
+ retainedRetryDelayMs = RETAINED_RETRY_BASE_DELAY_MS;
+ }
try {
if (retainedFileDeletions.size === 0) {
sessionStorage.removeItem(RETAINED_DELETION_STORAGE_KEY);
@@ -757,17 +763,20 @@ const bindOnlineRetainedRetry = (): void => {
}
onlineRetryBound = true;
window.addEventListener('online', () => {
- retainedRetryDelayMs = RETAINED_RETRY_BASE_DELAY_MS;
- notifyRetainedFileDeletions();
+ if (retainedFileDeletions.size > 0) {
+ retainedRetryDelayMs = RETAINED_RETRY_BASE_DELAY_MS;
+ notifyRetainedFileDeletions();
+ }
});
};
-/** A retry that fails again changes nothing the cleanup effect depends on, and the files query
- * does not refetch on reconnect, so without an explicit wake-up the payload would sit untouched
- * until some unrelated cache update happened to arrive. Backs off to a slow poll rather than
- * giving up, because giving up is what orphans the upload. */
-export const scheduleRetainedFileDeletionRetry = (): void => {
- if (retainedRetryTimer != null) {
+/** Wake unchanged queues after a failure, with backoff between automatic attempts. */
+export const scheduleRetainedFileDeletionRetry = (pendingDiscard = false): void => {
+ if (
+ retainedRetryTimer != null ||
+ (retainedFileDeletions.size === 0 && !pendingDiscard) ||
+ !retentionOpen
+ ) {
return;
}
bindOnlineRetainedRetry();
@@ -823,12 +832,11 @@ export const openFileDeletionRetention = (): void => {
};
export const retainFileDeletion = (record: PendingFileDeletion): void => {
- if (!retentionOpen) {
+ if (!retentionOpen || retainedFileDeletions.has(record.file_id)) {
return;
}
retainedFileDeletions.set(record.file_id, record);
persistRetainedFileDeletions();
- retainedRetryDelayMs = RETAINED_RETRY_BASE_DELAY_MS;
notifyRetainedFileDeletions();
};
@@ -837,12 +845,88 @@ export const clearRetainedFileDeletion = (fileId: string): void => {
return;
}
persistRetainedFileDeletions();
- retainedRetryDelayMs = RETAINED_RETRY_BASE_DELAY_MS;
};
-/** The deletions waiting for a retry; ownership stays with the store until one succeeds. */
+/** Keep retry accounting private rather than sending it in the delete payload. */
export const takeRetainedFileDeletions = (): PendingFileDeletion[] =>
- Array.from(retainedFileDeletions.values());
+ Array.from(retainedFileDeletions.values(), ({ attempts: _attempts, ...record }) => record);
+
+/** Persist before dispatch so a reload during the request cannot reset its budget. */
+export const claimFileDeletionRetries = (
+ records: PendingFileDeletion[],
+ limit = defaultFileConfig.deletionRetryLimit,
+): PendingFileDeletion[] => {
+ if (!retentionOpen) {
+ return [];
+ }
+ const batch: PendingFileDeletion[] = [];
+ const seen = new Set<string>();
+ for (const record of records) {
+ if (seen.has(record.file_id)) {
+ continue;
+ }
+ seen.add(record.file_id);
+ const attempts = retainedFileDeletions.get(record.file_id)?.attempts ?? 0;
+ if (attempts >= limit) {
+ retainedFileDeletions.delete(record.file_id);
+ continue;
+ }
+ retainedFileDeletions.set(record.file_id, { ...record, attempts: attempts + 1 });
+ batch.push(record);
+ }
+ persistRetainedFileDeletions();
+ return batch;
+};
+
+/** Successful and exhausted records leave the queue; only retryable failures remain. */
+export const settleFileDeletionRetries = (
+ records: PendingFileDeletion[],
+ failedIds: Set<string>,
+ limit = defaultFileConfig.deletionRetryLimit,
+): void => {
+ let changed = false;
+ for (const record of records) {
+ if (
+ !failedIds.has(record.file_id) ||
+ (retainedFileDeletions.get(record.file_id)?.attempts ?? 0) >= limit
+ ) {
+ changed = retainedFileDeletions.delete(record.file_id) || changed;
+ }
+ }
+ if (changed) {
+ persistRetainedFileDeletions();
+ }
+};
+
+/** Move the legacy remount queue into the same bounded, ownership-checked retry path. */
+export const migrateStoredFileDeletions = (): void => {
+ try {
+ const raw = localStorage.getItem(LocalStorageKeys.FILES_TO_DELETE);
+ if (raw == null) {
+ return;
+ }
+ const map = JSON.parse(raw) as Record<string, ExtendedFile> | null;
+ for (const file of Object.values(map ?? {})) {
+ if (
+ file?.file_id &&
+ file.filepath != null &&
+ file.source &&
+ !(file.embedded ?? false) &&
+ file.temp_file_id
+ ) {
+ retainFileDeletion({
+ file_id: file.file_id,
+ filepath: file.filepath,
+ source: file.source as FileSources,
+ embedded: false,
+ });
+ }
+ }
+ localStorage.removeItem(LocalStorageKeys.FILES_TO_DELETE);
+ } catch {
+ // Unavailable storage cannot supply legacy cleanup work.
+ }
+};
/** Subscribe to a retained deletion being recorded so a retry effect can run without waiting
* for an unrelated files-cache update. */
diff --git a/packages/api/src/files/code/delete.spec.ts b/packages/api/src/files/code/delete.spec.ts
index 2a3e4b34cf..1a07055f4d 100644
--- a/packages/api/src/files/code/delete.spec.ts
+++ b/packages/api/src/files/code/delete.spec.ts
@@ -28,9 +28,9 @@ function setup() {
return { httpClient, clearFileCodeEnvRefs, remove };
}
-it.each([204, 404])('reconciles a confirmed code deletion or absence (%s)', async (status) => {
+it.each([204, 403, 404])('reconciles a confirmed code deletion or absence (%s)', async (status) => {
const { httpClient, clearFileCodeEnvRefs, remove } = setup();
- if (status === 404) httpClient.mockRejectedValue({ response: { status } });
+ if (status !== 204) httpClient.mockRejectedValue({ response: { status } });
const file = { file_id: 'stored-file', metadata: { codeEnvRefs: { default: ref } } };
await expect(remove(req, file)).resolves.toEqual({ deleted: true });
expect(clearFileCodeEnvRefs).toHaveBeenCalledWith({
@@ -139,3 +139,30 @@ it('invalidates a confirmed code pointer even when a later vector deletion fails
expect(primary).not.toHaveBeenCalled();
expect(clearFileEmbeddings).not.toHaveBeenCalled();
});
+
+it.each([401, 409, 429, 500, 503])(
+ 'preserves retryable or unrelated Code API failures (%s)',
+ async (status) => {
+ const { httpClient, clearFileCodeEnvRefs, remove } = setup();
+ const error = { response: { status } };
+ httpClient.mockRejectedValue(error);
+ await expect(
+ remove(req, { file_id: 'stored-file', metadata: { codeEnvRef: ref } }),
+ ).rejects.toBe(error);
+ expect(clearFileCodeEnvRefs).not.toHaveBeenCalled();
+ },
+);
+
+it.each([
+ { ...ref, kind: 'skill' as const, id: 'skill-id', version: 1 },
+ { ...ref, kind: 'agent' as const, id: 'agent-id' },
+ { ...ref, id: 'other-owner' },
+])('does not forgive a forbidden session outside the file owner identity', async (otherRef) => {
+ const { httpClient, clearFileCodeEnvRefs, remove } = setup();
+ const error = { response: { status: 403 } };
+ httpClient.mockRejectedValue(error);
+ await expect(
+ remove(req, { file_id: 'stored-file', metadata: { codeEnvRef: otherRef } }),
+ ).rejects.toBe(error);
+ expect(clearFileCodeEnvRefs).not.toHaveBeenCalled();
+});
diff --git a/packages/api/src/files/code/delete.ts b/packages/api/src/files/code/delete.ts
index d889855440..b117a1e461 100644
--- a/packages/api/src/files/code/delete.ts
+++ b/packages/api/src/files/code/delete.ts
@@ -100,14 +100,22 @@ export function createCodeFileDeleter({
} catch (error) {
const response = (error as { response?: { status?: number; data?: { error?: string } } })
?.response;
- if (response?.status !== 404) {
+ // Code API also returns 403 when its user-session ownership record has expired.
+ const unavailableUserSession =
+ response?.status === 403 &&
+ ref.kind === 'user' &&
+ ref.id === (file.user?.toString() ?? req.user?.id);
+ if (response?.status !== 404 && !unavailableUserSession) {
if (response?.status === 409 && response.data?.error === 'execution_profile_mismatch') {
skipped = true;
continue;
}
throw error;
}
- logger.warn('Code storage copy already absent during delete', getSafeErrorMetadata(error));
+ logger.warn(
+ 'Code storage copy unavailable during owner-authorized delete',
+ getSafeErrorMetadata(error),
+ );
}
if (file.file_id) {
try {
diff --git a/packages/data-provider/src/file-config.spec.ts b/packages/data-provider/src/file-config.spec.ts
index 82df83f6d4..37954c4f49 100644
--- a/packages/data-provider/src/file-config.spec.ts
+++ b/packages/data-provider/src/file-config.spec.ts
@@ -2317,3 +2317,15 @@ describe('vector erasure rollout and concurrency settings', () => {
},
);
});
+
+describe('file deletion retry limit', () => {
+ it('defaults to five automatic retries and accepts an override', () => {
+ expect(mergeFileConfig(undefined).deletionRetryLimit).toBe(5);
+ const config = fileConfigSchema.parse({ deletionRetryLimit: 3 });
+ expect(mergeFileConfig(config).deletionRetryLimit).toBe(3);
+ });
+
+ it.each([0, -1, 1.5, '5'])('rejects invalid retry limit %s', (deletionRetryLimit) => {
+ expect(fileConfigSchema.safeParse({ deletionRetryLimit }).success).toBe(false);
+ });
+});
diff --git a/packages/data-provider/src/file-config.ts b/packages/data-provider/src/file-config.ts
index 4774e8a438..3e37bf2701 100644
--- a/packages/data-provider/src/file-config.ts
+++ b/packages/data-provider/src/file-config.ts
@@ -567,6 +567,7 @@ const assistantsFileConfig = {
export const fileConfig = {
retainedFileCleanup: false,
+ deletionRetryLimit: 5,
vectorDeletionConcurrency: 4,
endpoints: {
[EModelEndpoint.assistants]: assistantsFileConfig,
@@ -663,6 +664,8 @@ const skillFileConfigSchema = z.object({
export const fileConfigSchema = z.object({
/** Enable only after every replica and rollback target reads retained file destinations. */
retainedFileCleanup: z.boolean().optional(),
+ /** Maximum automatic retries per discarded upload, persisted across tab reloads. */
+ deletionRetryLimit: z.number().int().positive().optional(),
/** UTC cutoff chosen after all legacy writers and rollback targets are retired. */
vectorOwnershipTrackingStart: z.string().datetime().optional(),
vectorDeletionConcurrency: z.number().int().min(1).max(16).optional(),
@@ -1287,6 +1290,10 @@ function buildMergedFileConfig(dynamic: DynamicFileConfig | undefined): FileConf
mergedConfig.retainedFileCleanup = dynamic.retainedFileCleanup;
}
+ if (dynamic.deletionRetryLimit !== undefined) {
+ mergedConfig.deletionRetryLimit = dynamic.deletionRetryLimit;
+ }
+
if (dynamic.vectorOwnershipTrackingStart !== undefined) {
mergedConfig.vectorOwnershipTrackingStart = dynamic.vectorOwnershipTrackingStart;
}
diff --git a/packages/data-provider/src/types/files.ts b/packages/data-provider/src/types/files.ts
index 7dcf857da5..c716167ea0 100644
--- a/packages/data-provider/src/types/files.ts
+++ b/packages/data-provider/src/types/files.ts
@@ -60,6 +60,7 @@ export type EndpointFileConfig = {
export type FileConfig = {
/** Enable after all replicas and rollback targets support retained file destinations. */
retainedFileCleanup?: boolean;
+ deletionRetryLimit?: number;
vectorOwnershipTrackingStart?: string;
vectorDeletionConcurrency?: number;
endpoints: {
@@ -107,6 +108,7 @@ export type FileConfig = {
export type FileConfigInput = {
/** Fail closed on embedded-file deletion until marker-aware readers are deployed. */
retainedFileCleanup?: boolean;
+ deletionRetryLimit?: number;
vectorOwnershipTrackingStart?: string;
vectorDeletionConcurrency?: number;
endpoints?: {