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: Erase Vectors in Their Recorded Namespaces (#17457)
lia-by-librechat[bot]761bfa8e6abc
diff --git a/api/server/services/Files/Azure/crud.spec.js b/api/server/services/Files/Azure/crud.spec.jsindex ba6fdbac09..e5483e0402 100644--- a/api/server/services/Files/Azure/crud.spec.js+++ b/api/server/services/Files/Azure/crud.spec.js@@ -115,17 +115,28 @@ describe('deleteFileFromAzure', () => {mockDelete.mockRejectedValueOnce(error);await expect(deleteFileFromAzure(req, file, undefined, onDelete)).rejects.toBe(error);expect(onDelete.mock.calls).toEqual([[]]);- expect(deleteRagFile).not.toHaveBeenCalled();+ expect(deleteRagFile).toHaveBeenCalledWith({ userId: 'owner', file });});- it('confirms deletion before a later RAG denial', async () => {+ it('retains the blob when RAG cleanup returns false', async () => {+ const onDelete = jest.fn();+ deleteRagFile.mockResolvedValueOnce(false);+ await expect(deleteFileFromAzure(req, file, undefined, onDelete)).rejects.toThrow(+ 'Vector deletion was not confirmed',+ );+ expect(onDelete).not.toHaveBeenCalled();+ expect(mockDelete).not.toHaveBeenCalled();+ });++ it('does not dispatch blob deletion when RAG cleanup is denied', async () => {const onDelete = jest.fn();const error = Object.assign(new Error('RAG denied'), { statusCode: 403 });deleteRagFile.mockImplementationOnce(async () => {- expect(onDelete.mock.calls).toEqual([[], ['confirmed']]);+ expect(onDelete).not.toHaveBeenCalled();throw error;});await expect(deleteFileFromAzure(req, file, undefined, onDelete)).rejects.toBe(error);- expect(onDelete.mock.calls).toEqual([[], ['confirmed']]);+ expect(onDelete).not.toHaveBeenCalled();+ expect(mockDelete).not.toHaveBeenCalled();});});diff --git a/api/server/services/Files/VectorDB/crud.js b/api/server/services/Files/VectorDB/crud.jsindex 359058dafa..e7f805c9f7 100644--- a/api/server/services/Files/VectorDB/crud.js+++ b/api/server/services/Files/VectorDB/crud.js@@ -15,6 +15,8 @@ const deleteVectors = (req, file) =>baseUrl: process.env.RAG_API_URL,httpClient: axios,generateToken: generateShortLivedToken,+ ownershipTrackingStart: req.config?.fileConfig?.vectorOwnershipTrackingStart,+ namespaceConcurrency: req.config?.fileConfig?.vectorDeletionConcurrency,})(req, file);/**diff --git a/api/server/services/Files/process.js b/api/server/services/Files/process.jsindex 0dc3a0bfe3..e4988b4283 100644--- a/api/server/services/Files/process.js+++ b/api/server/services/Files/process.js@@ -1243,6 +1243,11 @@ const processAgentFileUpload = async ({ req, res, metadata, sseStream }) => {// SECOND: Upload to Vector DBconst { uploadVectors } = require('./VectorDB/crud');+ /* Vectors live under the entity that embedded them, and priming asks which namespaces+ * hold them rather than reading the root flag. Omitting it here re-embeds the file on+ * the first search, and aborts that search if RAG is briefly unavailable. */+ fileInfoMetadata = entity_id != null ? { embeddedEntities: [entity_id] } : {};+embeddingResult = await withStoredUploadCleanup({req,@@ -1255,6 +1260,7 @@ const processAgentFileUpload = async ({ req, res, metadata, sseStream }) => {source,/* The embed request may commit before its response is lost; deleting is idempotent. */embedded: true,+ metadata: fileInfoMetadata,filepath: storageResult.filepath,...getStorageMetadata({filepath: storageResult.filepath,@@ -1272,11 +1278,6 @@ const processAgentFileUpload = async ({ req, res, metadata, sseStream }) => {entity_id,}),);-- /* Vectors live under the entity that embedded them, and priming asks which namespaces- * hold them rather than reading the root flag. Omitting it here re-embeds the file on- * the first search, and aborts that search if RAG is briefly unavailable. */- fileInfoMetadata = entity_id != null ? { embeddedEntities: [entity_id] } : {};} else if (isImage) {/* The conversion is this file's storage step. Uploading the original first left a* second object nothing references, and the record's size and dimensions describingdiff --git a/api/server/services/Files/process.spec.js b/api/server/services/Files/process.spec.jsindex 1f140e34ef..077abb3f3e 100644--- a/api/server/services/Files/process.spec.js+++ b/api/server/services/Files/process.spec.js@@ -3946,7 +3946,11 @@ describe('stored upload cleanup across storage-before-record paths', () => {}),).rejects.toThrow('db down');- expectStoredObjectDeleted(req, { file_id: 'agent-file', embedded: true });+ expectStoredObjectDeleted(req, {+ file_id: 'agent-file',+ embedded: true,+ metadata: { embeddedEntities: ['agent-abc'] },+ });});it('deletes the stored object when the vector upload fails', async () => {@@ -3967,6 +3971,10 @@ describe('stored upload cleanup across storage-before-record paths', () => {}),).rejects.toThrow('rag unavailable');- expectStoredObjectDeleted(req, { file_id: 'agent-file', embedded: true });+ expectStoredObjectDeleted(req, {+ file_id: 'agent-file',+ embedded: true,+ metadata: { embeddedEntities: ['agent-abc'] },+ });});});diff --git a/packages/api/src/files/orphan.spec.ts b/packages/api/src/files/orphan.spec.tsindex 2cb1bec14b..33a4638905 100644--- a/packages/api/src/files/orphan.spec.ts+++ b/packages/api/src/files/orphan.spec.ts@@ -1,9 +1,20 @@+import fs from 'node:fs';+import path from 'node:path';+import { tmpdir } from 'node:os';+import { FileSources } from 'librechat-data-provider';import type { StoredUploadRef } from './orphan';+import {+ createOwnedBlobFileDeleter,+ extractAzureBlobPath,+ extractFirebaseBlobPath,+} from '../storage/ownedBlobDelete';import {resolveStoredUploadTarget,withStoredUploadCleanup,createStoredUploadDelete,} from './orphan';+import { createLocalFileDeleter } from '../storage/local';+import { createVectorFileDeleter } from './rag';const stored: StoredUploadRef = {file_id: 'file-1',@@ -45,7 +56,13 @@ describe('withStoredUploadCleanup', () => {},),).rejects.toBe(failure);- expect(deleteFile).toHaveBeenCalledWith(req, { ...stored, user: 'u1', tenantId: 't1' });+ expect(deleteFile).toHaveBeenCalledWith(req, {+ ...stored,+ user: 'u1',+ tenantId: 't1',+ embeddingOwnersComplete: true,+ unrecordedUpload: true,+ });});it('deletes without a record lookup when the failure precedes the record write', async () => {@@ -212,18 +229,62 @@ describe('createStoredUploadDelete', () => {it('removes the vector and code environment copies named by the reference', async () => {const primary = jest.fn().mockResolvedValue(undefined);- const vector = jest.fn().mockResolvedValue(undefined);+ const vector = jest.fn().mockResolvedValue({ deleted: true });const code = jest.fn().mockResolvedValue(undefined);const file = { ...stored, embedded: true, metadata: { codeEnvRef: { file_id: 'c1' } } };await createStoredUploadDelete({source: 's3',getDeleteFile: strategies({ s3: primary, vectordb: vector, execute_code: code }),})(req, file);- expect(primary).toHaveBeenCalledWith(req, file);+ expect(primary).toHaveBeenCalledWith(req, { ...file, embedded: false });+ expect(file.embedded).toBe(true);expect(vector).toHaveBeenCalledWith(req, file);expect(code).toHaveBeenCalledWith(req, file);});+ it.each([undefined, false, { deleted: false }])(+ 'rejects unconfirmed orphan vector cleanup: %j',+ async (receipt) => {+ const primary = jest.fn().mockResolvedValue(undefined);+ const vector = jest.fn().mockResolvedValue(receipt);+ const file = { ...stored, embedded: true };+ await expect(+ createStoredUploadDelete({+ source: 's3',+ getDeleteFile: strategies({ s3: primary, vectordb: vector }),+ })(req, file),+ ).rejects.toThrow('Vector deletion was not confirmed');+ expect(primary).toHaveBeenCalledWith(req, { ...file, embedded: false });+ },+ );++ it('keeps a vector-primary rollback embedded and requires its receipt', async () => {+ const vector = jest.fn().mockResolvedValue(undefined);+ const file = { ...stored, source: FileSources.vectordb, embedded: true };+ await expect(+ createStoredUploadDelete({+ source: FileSources.vectordb,+ getDeleteFile: strategies({ vectordb: vector }),+ })(req, file),+ ).rejects.toThrow('Vector deletion was not confirmed');+ expect(vector).toHaveBeenCalledTimes(1);+ expect(vector).toHaveBeenCalledWith(req, file);+ });++ it('does not let a synchronous provider failure prevent vector cleanup', async () => {+ const vector = jest.fn().mockResolvedValue({ deleted: true });+ await expect(+ createStoredUploadDelete({+ source: 's3',+ getDeleteFile: (source) => {+ if (source === 's3') throw new Error('missing primary');+ return vector;+ },+ })(req, { ...stored, embedded: true }),+ ).rejects.toThrow('missing primary');+ expect(vector).toHaveBeenCalledTimes(1);+ });+it('skips secondary copies the reference does not name', async () => {const primary = jest.fn().mockResolvedValue(undefined);const vector = jest.fn();@@ -238,7 +299,7 @@ describe('createStoredUploadDelete', () => {it('still deletes the secondary copies when the primary delete fails, then rethrows', async () => {const failure = new Error('storage down');const primary = jest.fn().mockRejectedValue(failure);- const vector = jest.fn().mockResolvedValue(undefined);+ const vector = jest.fn().mockResolvedValue({ deleted: true });await expect(createStoredUploadDelete({source: 's3',@@ -248,3 +309,111 @@ describe('createStoredUploadDelete', () => {expect(vector).toHaveBeenCalledTimes(1);});});++describe('failed embedded upload rollback', () => {+ const cases = [+ {+ source: FileSources.azure_blob,+ filepath: 'https://account.blob.core.windows.net/files/uploads/u1/file.txt',+ extractPath: (url: string) => extractAzureBlobPath(url, 'files'),+ },+ {+ source: FileSources.firebase,+ filepath: 'https://firebasestorage.googleapis.com/v0/b/bucket/o/uploads%2Fu1%2Ffile.txt',+ extractPath: extractFirebaseBlobPath,+ },+ {+ source: FileSources.local,+ filepath: '/uploads/u1/file.txt',+ extractPath: (url: string) => url,+ },+ ];++ it.each(cases)(+ 'removes the $source orphan even when embedding and vector rollback fail',+ async ({ source, filepath, extractPath }) => {+ const root = fs.mkdtempSync(path.join(tmpdir(), 'orphan-vector-'));+ const uploads = path.join(root, 'uploads');+ const bytes = path.join(uploads, 'u1', 'file.txt');+ fs.mkdirSync(path.dirname(bytes), { recursive: true });+ fs.writeFileSync(bytes, 'private contents');+ const req = {+ user: { id: 'u1', tenantId: 'tenant-1' },+ config: { paths: { publicPath: root, uploads } },+ };+ const logger = { error: jest.fn(), warn: jest.fn() };+ const httpClient = {+ delete: jest.fn().mockRejectedValue({ response: { status: 503 } }),+ get: jest.fn(),+ };+ const vectors = createVectorFileDeleter({+ baseUrl: 'https://rag.example',+ httpClient,+ generateToken: () => 'token',+ });+ const deleteRagFile = jest.fn(+ async ({ file }: { file: { filepath: string; embedded?: boolean } }) =>+ file.embedded !== true,+ );+ let blobPresent = true;+ const blob = createOwnedBlobFileDeleter({+ extractPath,+ isMissing: () => false,+ deleteRagFile,+ deleteBlob: async () => {+ blobPresent = false;+ },+ });+ const local = createLocalFileDeleter({ deleteRagFile, logger });+ const remove = createStoredUploadDelete({+ source,+ getDeleteFile: (destination) => {+ if (destination === FileSources.vectordb) return vectors;+ return source === FileSources.local ? local : blob;+ },+ });+ const recordExists = jest.fn().mockResolvedValue(false);+ const failure = new Error('embedding unavailable');+ const file = {+ file_id: 'f1',+ filepath,+ source,+ embedded: true,+ metadata: { embeddedEntities: ['agent-a'] },+ };+ try {+ await expect(+ withStoredUploadCleanup(+ {+ stored: file,+ resolveDeleteFile: () => remove,+ recordExists,+ req,+ logger,+ trackWrite: true,+ },+ async () => {+ throw failure;+ },+ ),+ ).rejects.toBe(failure);+ if (source === FileSources.local) expect(fs.existsSync(bytes)).toBe(false);+ else expect(blobPresent).toBe(false);+ expect(recordExists).not.toHaveBeenCalled();+ expect(logger.error).toHaveBeenCalledWith(+ '[withStoredUploadCleanup] Failed to delete stored upload',+ { type: 'Error' },+ );+ expect(httpClient.delete).toHaveBeenCalledWith(+ 'https://rag.example/documents',+ expect.objectContaining({ params: { entity_id: 'agent-a' }, data: ['f1'] }),+ );+ expect(httpClient.delete).toHaveBeenCalledTimes(2);+ expect(file.embedded).toBe(true);+ expect(file.metadata.embeddedEntities).toEqual(['agent-a']);+ } finally {+ fs.rmSync(root, { recursive: true, force: true });+ }+ },+ );+});diff --git a/packages/api/src/files/orphan.ts b/packages/api/src/files/orphan.tsindex 620d5b2f01..15ed908877 100644--- a/packages/api/src/files/orphan.ts+++ b/packages/api/src/files/orphan.ts@@ -15,6 +15,8 @@ export type StoredUploadRef = {tenantId?: string;/** Whether a vector copy exists; the delete strategies remove it only when this is set. */embedded?: boolean;+ embeddingOwnersComplete?: boolean;+ unrecordedUpload?: true;/** Secondary-copy references, such as a code environment ref, that delete strategies read. */metadata?: Record<string, unknown>;};@@ -61,6 +63,9 @@ export async function withStoredUploadCleanup<T>(user: req.user?.id,tenantId: req.user?.tenantId,...stored,+ // This rollback describes only the current upload, not a legacy file record.+ embeddingOwnersComplete: true,+ unrecordedUpload: true,};await resolveDeleteFile()?.(req as never, ref);}@@ -120,15 +125,36 @@ export function createStoredUploadDelete({getDeleteFile: (source: string) => DeleteStoredFile | undefined;}): DeleteStoredFile {return async (req, file) => {- const deleters = [getDeleteFile(source)];+ const sources = [source];if (file.embedded === true && source !== FileSources.vectordb) {- deleters.push(getDeleteFile(FileSources.vectordb));+ sources.push(FileSources.vectordb);}const hasCodeEnvRef = file.metadata?.codeEnvRef != null || file.metadata?.codeEnvRefs != null;if (hasCodeEnvRef && source !== FileSources.execute_code) {- deleters.push(getDeleteFile(FileSources.execute_code));+ sources.push(FileSources.execute_code);}- const results = await Promise.allSettled(deleters.map((deleteFile) => deleteFile?.(req, file)));+ const results = await Promise.allSettled(+ sources.map(async (destination) => {+ // No record exists to retry this rollback. Attempt each store independently;+ // the vector task owns erasure, not the primary strategy's inline RAG cleanup.+ const ref =+ destination === source && source !== FileSources.vectordb && file.embedded === true+ ? { ...file, embedded: false }+ : file;+ const result = await getDeleteFile(destination)?.(req, ref);+ if (+ destination === FileSources.vectordb &&+ file.embedded === true &&+ (result == null ||+ typeof result !== 'object' ||+ !('deleted' in result) ||+ result.deleted !== true)+ ) {+ throw new Error('Vector deletion was not confirmed');+ }+ return result;+ }),+ );const failed = results.find((result) => result.status === 'rejected');if (failed != null) {throw (failed as PromiseRejectedResult).reason;diff --git a/packages/api/src/files/rag.spec.ts b/packages/api/src/files/rag.spec.tsindex 9120646b13..329391869a 100644--- a/packages/api/src/files/rag.spec.ts+++ b/packages/api/src/files/rag.spec.ts@@ -12,6 +12,7 @@ jest.mock('~/crypto/jwt', () => ({jest.mock('axios', () => ({delete: jest.fn(),+ get: jest.fn(),post: jest.fn(),interceptors: {request: { use: jest.fn(), eject: jest.fn() },@@ -45,10 +46,19 @@ describe('deleteRagFile', () => {describe('when file is embedded and RAG_API_URL is configured', () => {it('should delete the document from RAG API successfully', async () => {- const file = { file_id: 'file-123', embedded: true };+ const file = {+ file_id: 'file-123',+ embedded: true,+ embeddingOwnersComplete: true,+ embeddingOwnersTrackedAt: '2026-10-20T00:00:00.000Z',+ };mockedAxios.delete.mockResolvedValueOnce({ status: 200 });- const result = await deleteRagFile({ userId: 'user123', file });+ const result = await deleteRagFile({+ fileConfig: { vectorOwnershipTrackingStart: '2026-10-19T00:00:00.000Z' },+ userId: 'user123',+ file,+ });expect(result).toBe(true);expect(mockedGenerateShortLivedToken).toHaveBeenCalledWith('user123');@@ -60,37 +70,51 @@ describe('deleteRagFile', () => {},data: ['file-123'],});- expect(mockedLogger.debug).toHaveBeenCalledWith(- '[deleteRagFile] Successfully deleted document file-123 from RAG API',- );});- it('should return true and log warning when document is not found (404)', async () => {- const file = { file_id: 'file-not-found', embedded: true };+ it('confirms absence through inventory rather than trusting a 404', async () => {+ const file = {+ file_id: 'file-not-found',+ embedded: true,+ embeddingOwnersComplete: true,+ embeddingOwnersTrackedAt: '2026-10-20T00:00:00.000Z',+ };const error = new Error('Not Found') as Error & { response?: { status?: number } };error.response = { status: 404 };mockedAxios.delete.mockRejectedValueOnce(error);+ mockedAxios.get.mockResolvedValueOnce({ data: [] });- const result = await deleteRagFile({ userId: 'user123', file });+ const result = await deleteRagFile({+ fileConfig: { vectorOwnershipTrackingStart: '2026-10-19T00:00:00.000Z' },+ userId: 'user123',+ file,+ });expect(result).toBe(true);- expect(mockedLogger.warn).toHaveBeenCalledWith(- '[deleteRagFile] Document file-not-found not found in RAG API, may have been deleted already',- );+ expect(mockedAxios.get).toHaveBeenCalledWith('http://localhost:8000/ids', expect.any(Object));});it('should return false and log error on other errors', async () => {- const file = { file_id: 'file-error', embedded: true };+ const file = {+ file_id: 'file-error',+ embedded: true,+ embeddingOwnersComplete: true,+ embeddingOwnersTrackedAt: '2026-10-20T00:00:00.000Z',+ };const error = new Error('Server Error') as Error & { response?: { status?: number } };error.response = { status: 500 };mockedAxios.delete.mockRejectedValueOnce(error);- const result = await deleteRagFile({ userId: 'user123', file });+ const result = await deleteRagFile({+ fileConfig: { vectorOwnershipTrackingStart: '2026-10-19T00:00:00.000Z' },+ userId: 'user123',+ file,+ });expect(result).toBe(false);expect(mockedLogger.error).toHaveBeenCalledWith(- '[deleteRagFile] Error deleting document from RAG API:',- 'Server Error',+ '[deleteRagFile] Vector deletion was not confirmed',+ { type: 'Error' },);});});@@ -99,7 +123,11 @@ describe('deleteRagFile', () => {it('should skip RAG deletion and return true', async () => {const file = { file_id: 'file-123', embedded: false };- const result = await deleteRagFile({ userId: 'user123', file });+ const result = await deleteRagFile({+ fileConfig: { vectorOwnershipTrackingStart: '2026-10-19T00:00:00.000Z' },+ userId: 'user123',+ file,+ });expect(result).toBe(true);expect(mockedAxios.delete).not.toHaveBeenCalled();@@ -109,7 +137,11 @@ describe('deleteRagFile', () => {it('should skip RAG deletion when embedded is undefined', async () => {const file = { file_id: 'file-123' };- const result = await deleteRagFile({ userId: 'user123', file });+ const result = await deleteRagFile({+ fileConfig: { vectorOwnershipTrackingStart: '2026-10-19T00:00:00.000Z' },+ userId: 'user123',+ file,+ });expect(result).toBe(true);expect(mockedAxios.delete).not.toHaveBeenCalled();@@ -117,22 +149,40 @@ describe('deleteRagFile', () => {});describe('when RAG_API_URL is not configured', () => {- it('should skip RAG deletion and return true', async () => {+ it('does not confirm deletion for an unconfigured store', async () => {delete process.env.RAG_API_URL;- const file = { file_id: 'file-123', embedded: true };-- const result = await deleteRagFile({ userId: 'user123', file });+ const file = {+ file_id: 'file-123',+ embedded: true,+ embeddingOwnersComplete: true,+ embeddingOwnersTrackedAt: '2026-10-20T00:00:00.000Z',+ };++ const result = await deleteRagFile({+ fileConfig: { vectorOwnershipTrackingStart: '2026-10-19T00:00:00.000Z' },+ userId: 'user123',+ file,+ });- expect(result).toBe(true);+ expect(result).toBe(false);expect(mockedAxios.delete).not.toHaveBeenCalled();});});describe('userId handling', () => {it('should return false when no userId is provided', async () => {- const file = { file_id: 'file-123', embedded: true };-- const result = await deleteRagFile({ userId: '', file });+ const file = {+ file_id: 'file-123',+ embedded: true,+ embeddingOwnersComplete: true,+ embeddingOwnersTrackedAt: '2026-10-20T00:00:00.000Z',+ };++ const result = await deleteRagFile({+ fileConfig: { vectorOwnershipTrackingStart: '2026-10-19T00:00:00.000Z' },+ userId: '',+ file,+ });expect(result).toBe(false);expect(mockedLogger.error).toHaveBeenCalledWith('[deleteRagFile] No user ID provided');@@ -140,9 +190,18 @@ describe('deleteRagFile', () => {});it('should return false when userId is undefined', async () => {- const file = { file_id: 'file-123', embedded: true };-- const result = await deleteRagFile({ userId: undefined as unknown as string, file });+ const file = {+ file_id: 'file-123',+ embedded: true,+ embeddingOwnersComplete: true,+ embeddingOwnersTrackedAt: '2026-10-20T00:00:00.000Z',+ };++ const result = await deleteRagFile({+ fileConfig: { vectorOwnershipTrackingStart: '2026-10-19T00:00:00.000Z' },+ userId: undefined as unknown as string,+ file,+ });expect(result).toBe(false);expect(mockedLogger.error).toHaveBeenCalledWith('[deleteRagFile] No user ID provided');@@ -234,12 +293,18 @@ describe('hasEntityEmbeddings', () => {describe('createVectorFileDeleter receipts', () => {beforeEach(() => jest.clearAllMocks());- const file = { file_id: 'retained-file', embedded: true };+ const file = {+ file_id: 'retained-file',+ embedded: true,+ embeddingOwnersComplete: true,+ embeddingOwnersTrackedAt: '2026-10-20T00:00:00.000Z',+ };const req = { user: { id: 'owner' } };const setup = (baseUrl: string | undefined = 'https://rag.example') => {const remove = createVectorFileDeleter({baseUrl,httpClient: axios,+ ownershipTrackingStart: '2026-10-19T00:00:00.000Z',generateToken: () => 'test-token',});return remove;@@ -254,14 +319,444 @@ describe('createVectorFileDeleter receipts', () => {);});- it('confirms an already absent vector copy', async () => {+ it('confirms an already absent vector copy through inventory', async () => {mockedAxios.delete.mockRejectedValueOnce({code: 'ERR_BAD_REQUEST',response: { status: 404 },});+ mockedAxios.get.mockResolvedValueOnce({ data: [] });expect(await setup()(req, file)).toEqual({ deleted: true });});+ it('keeps legacy agent files until their embedding ownership has been recovered', async () => {+ await expect(+ setup()(req, { ...file, context: 'agents', embeddingOwnersComplete: undefined }),+ ).rejects.toThrow('ownership must be recorded');+ expect(mockedAxios.delete).not.toHaveBeenCalled();+ });++ it.each([undefined, false])(+ 'rejects partially adopted legacy ownership (%s)',+ async (embeddingOwnersComplete) => {+ const legacy = {+ ...file,+ context: 'agents',+ embeddingOwnersComplete,+ metadata: { embeddedEntities: ['agent-a'] },+ };+ await expect(setup()(req, legacy)).rejects.toThrow('Complete vector ownership');+ expect(mockedAxios.delete).not.toHaveBeenCalled();+ expect(mockedAxios.get).not.toHaveBeenCalled();+ },+ );++ it.each([+ { cutoff: undefined, tracked: '2026-10-20T00:00:00.000Z' },+ { cutoff: '2026-10-21T00:00:00.000Z', tracked: '2026-10-20T00:00:00.000Z' },+ { cutoff: '2026-10-19T00:00:00.000Z', tracked: undefined },+ { cutoff: '2026-10-19T00:00:00.000Z', tracked: 'bad-date' },+ { cutoff: '2999-01-01T00:00:00.000Z', tracked: '2026-10-20T00:00:00.000Z' },+ { cutoff: '2026-10-19T00:00:00.000Z', tracked: '2999-01-01T00:00:00.000Z' },+ ])('retains old-writer damage or inactive rollout: %j', async ({ cutoff, tracked }) => {+ const remove = createVectorFileDeleter({+ baseUrl: 'https://rag.example',+ httpClient: axios,+ generateToken: () => 'token',+ ownershipTrackingStart: cutoff,+ });+ const damaged = {+ ...file,+ embeddingOwnersTrackedAt: tracked,+ metadata: { embeddedEntities: ['agent-a'] },+ };+ await expect(remove(req, damaged)).rejects.toThrow('safe writer rollout');+ expect(mockedAxios.delete).not.toHaveBeenCalled();+ });++ it('does not apply the deployment cutoff to an unrecorded upload rollback', async () => {+ const remove = createVectorFileDeleter({+ baseUrl: 'https://rag.example',+ httpClient: axios,+ generateToken: () => 'token',+ });+ mockedAxios.delete.mockResolvedValueOnce({ status: 200 });+ await expect(+ remove(req, { ...file, unrecordedUpload: true, embeddingOwnersTrackedAt: undefined }),+ ).resolves.toEqual({ deleted: true });+ });++ it('deletes every recorded namespace once, using the authenticated principal', async () => {+ mockedAxios.delete.mockResolvedValue({ status: 200 });+ const scoped = {+ ...file,+ user: 'untrusted-owner',+ metadata: { embeddedEntities: ['agent-a', 'agent-b', 'agent-a', 'owner'] },+ };+ await expect(setup()(req, scoped)).resolves.toEqual({ deleted: true });+ expect(mockedAxios.delete).toHaveBeenCalledTimes(4);+ for (const entity_id of ['agent-a', 'agent-b', 'owner']) {+ expect(mockedAxios.delete).toHaveBeenCalledWith(+ 'https://rag.example/documents',+ expect.objectContaining({+ params: { entity_id },+ data: [file.file_id],+ headers: expect.objectContaining({ Authorization: 'Bearer test-token' }),+ }),+ );+ }+ });++ it.each([+ { entities: ['owner'], owners: ['public'] },+ { entities: ['agent-a', 'agent-b'], owners: ['public', 'agent-a', 'agent-b'] },+ ])(+ 'erases implicit public embeddings alongside recorded namespaces: $entities',+ async ({ entities, owners }) => {+ const copies = new Set(owners);+ const httpClient = {+ delete: jest+ .fn()+ .mockImplementation(async (_url: string, config: { params?: { entity_id: string } }) => {+ const owner = config.params?.entity_id ?? 'public';+ if (!copies.delete(owner))+ throw Object.assign(new Error('Document absent from scope'), {+ response: { status: 404 },+ });+ return { status: 200 };+ }),+ get: jest+ .fn()+ .mockImplementation(async (_url: string, config: { params?: { entity_id: string } }) => ({+ data: copies.has(config.params?.entity_id ?? 'public') ? [file.file_id] : [],+ })),+ };+ const remove = createVectorFileDeleter({+ baseUrl: 'https://rag.example',+ httpClient,+ ownershipTrackingStart: '2026-10-19T00:00:00.000Z',+ generateToken: () => 'token',+ });+ await expect(+ remove(req, { ...file, metadata: { embeddedEntities: entities } }),+ ).resolves.toEqual({ deleted: true });+ expect([...copies]).toEqual([]);+ expect(httpClient.delete.mock.calls.some(([, config]) => config.params == null)).toBe(true);+ },+ );++ it('mints credentials at dispatch so a queue longer than token TTL still converges', async () => {+ let clock = 0;+ const owners = Array.from({ length: 20 }, (_, index) => `agent-${index}`);+ const copies = new Set([...owners, 'public']);+ let rejected = 0;+ const generateToken = jest.fn(() => String(clock));+ const httpClient = {+ delete: jest+ .fn()+ .mockImplementation(+ async (+ _url: string,+ config: { headers: { Authorization: string }; params?: { entity_id: string } },+ ) => {+ if (clock - Number(config.headers.Authorization.slice(7)) >= 300_000) {+ rejected++;+ throw Object.assign(new Error('expired token'), { response: { status: 401 } });+ }+ clock += 20_000;+ copies.delete(config.params?.entity_id ?? 'public');+ return { status: 200 };+ },+ ),+ get: jest.fn(),+ };+ const erase = createVectorFileDeleter({+ baseUrl: 'https://rag.example',+ httpClient,+ generateToken,+ namespaceConcurrency: 1,+ ownershipTrackingStart: '2026-10-19T00:00:00.000Z',+ });+ await expect(erase(req, { ...file, metadata: { embeddedEntities: owners } })).resolves.toEqual({+ deleted: true,+ });+ expect(clock).toBeGreaterThan(300_000);+ expect(rejected).toBe(0);+ expect(copies.size).toBe(0);+ expect(generateToken).toHaveBeenCalledTimes(21);+ });++ it('renews credentials for inventory when the DELETE outlives its token', async () => {+ let clock = 0;+ const generateToken = jest.fn(() => String(clock));+ const httpClient = {+ delete: jest.fn().mockImplementation(async () => {+ clock += 301_000;+ throw Object.assign(new Error('already erased'), { response: { status: 404 } });+ }),+ get: jest+ .fn()+ .mockImplementation(+ async (_url: string, config: { headers: { Authorization: string } }) => {+ expect(config.headers.Authorization).toBe(`Bearer ${clock}`);+ return { data: [] };+ },+ ),+ };+ const erase = createVectorFileDeleter({+ baseUrl: 'https://rag.example',+ httpClient,+ generateToken,+ ownershipTrackingStart: '2026-10-19T00:00:00.000Z',+ });+ await expect(erase(req, file)).resolves.toEqual({ deleted: true });+ expect(generateToken).toHaveBeenCalledTimes(2);+ });++ it('does not mistake a wrong-namespace 404 for erasure', async () => {+ mockedAxios.delete.mockRejectedValueOnce({ response: { status: 404 } });+ mockedAxios.get.mockResolvedValueOnce({ data: [file.file_id] });+ const scoped = { ...file, metadata: { embeddedEntities: ['agent-a'] } };+ await expect(setup()(req, scoped)).rejects.toThrow('Vector deletion was not confirmed');+ expect(mockedAxios.get).toHaveBeenCalledWith(+ 'https://rag.example/ids',+ expect.objectContaining({ params: { entity_id: 'agent-a' } }),+ );+ });++ it.each([undefined, {}, { ids: [] }, [1]])(+ 'rejects an invalid inventory response: %j',+ async (data) => {+ mockedAxios.delete.mockRejectedValueOnce({ response: { status: 404 } });+ mockedAxios.get.mockResolvedValueOnce({ data });+ await expect(setup()(req, file)).rejects.toThrow('Vector deletion was not confirmed');+ },+ );++ it('retains failure when the inventory check is unavailable', async () => {+ mockedAxios.delete.mockRejectedValueOnce({ response: { status: 404 } });+ mockedAxios.get.mockRejectedValueOnce({ response: { status: 404 } });+ const error = await setup()(req, file).catch((error) => error);+ expect(error.message).toBe('Vector deletion was not confirmed');+ expect(error.response).toBeUndefined();+ });++ describe('namespace concurrency', () => {+ const entities = Array.from({ length: 32 }, (_, index) => `agent-${index}`);+ const scoped = { ...file, metadata: { embeddedEntities: entities } };+ type NamespaceConfig = { params?: { entity_id: string } };+ const deferred = () => {+ let resolve!: () => void;+ const promise = new Promise<void>((done) => {+ resolve = done;+ });+ return { promise, resolve };+ };++ it.each([0, -1, 1.5, Infinity, NaN])(+ 'rejects invalid concurrency at factory creation: %s',+ (namespaceConcurrency) => {+ expect(() =>+ createVectorFileDeleter({+ baseUrl: 'https://rag.example',+ httpClient: axios,+ ownershipTrackingStart: '2026-10-19T00:00:00.000Z',+ generateToken: () => 'token',+ namespaceConcurrency,+ }),+ ).toThrow('positive integer');+ expect(mockedAxios.delete).not.toHaveBeenCalled();+ expect(mockedAxios.get).not.toHaveBeenCalled();+ },+ );++ it.each([undefined, 1, 3, 16])(+ 'bounds DELETE and inventory requests until every namespace settles: %s',+ async (namespaceConcurrency) => {+ const concurrency = namespaceConcurrency ?? 4;+ const copies = new Set<string>();+ const deletesStarted = deferred();+ const inventoriesStarted = deferred();+ const finishDeletes = deferred();+ const finishInventories = deferred();+ let active = 0;+ let peak = 0;+ let deletes = 0;+ let inventories = 0;+ let settled = false;+ const start = () => {+ active++;+ peak = Math.max(peak, active);+ };+ const httpClient = {+ delete: jest.fn().mockImplementation(async (_url: string, config: NamespaceConfig) => {+ start();+ if (++deletes === concurrency) deletesStarted.resolve();+ try {+ await finishDeletes.promise;+ if (!copies.delete(config.params?.entity_id ?? 'public')) {+ throw { response: { status: 404 } };+ }+ return { status: 200 };+ } finally {+ active--;+ }+ }),+ get: jest.fn().mockImplementation(async (_url: string, config: NamespaceConfig) => {+ start();+ if (++inventories === concurrency) inventoriesStarted.resolve();+ try {+ await finishInventories.promise;+ return {+ data: copies.has(config.params?.entity_id ?? 'public') ? [file.file_id] : [],+ };+ } finally {+ active--;+ }+ }),+ };+ const remove = createVectorFileDeleter({+ baseUrl: 'https://rag.example',+ httpClient,+ ownershipTrackingStart: '2026-10-19T00:00:00.000Z',+ generateToken: () => 'token',+ namespaceConcurrency,+ });+ const deletion = remove(req, scoped).then((receipt) => {+ settled = true;+ return receipt;+ });+ try {+ await deletesStarted.promise;+ expect(active).toBe(concurrency);+ expect(httpClient.delete).toHaveBeenCalledTimes(concurrency);+ finishDeletes.resolve();+ await inventoriesStarted.promise;+ expect(active).toBe(concurrency);+ expect(httpClient.delete).toHaveBeenCalledTimes(concurrency);+ expect(httpClient.get).toHaveBeenCalledTimes(concurrency);+ expect(settled).toBe(false);+ } finally {+ finishDeletes.resolve();+ finishInventories.resolve();+ }+ await expect(deletion).resolves.toEqual({ deleted: true });+ expect(httpClient.delete).toHaveBeenCalledTimes(entities.length + 1);+ expect(httpClient.get).toHaveBeenCalledTimes(entities.length + 1);+ expect(peak).toBe(concurrency);+ expect(active).toBe(0);+ },+ );++ it('shares the bound across deletions from the same factory', async () => {+ const started = deferred();+ const finish = deferred();+ let active = 0;+ let peak = 0;+ const httpClient = {+ delete: jest.fn().mockImplementation(async () => {+ active++;+ peak = Math.max(peak, active);+ if (active === 2) started.resolve();+ try {+ await finish.promise;+ return { status: 200 };+ } finally {+ active--;+ }+ }),+ get: jest.fn(),+ };+ const remove = createVectorFileDeleter({+ baseUrl: 'https://rag.example',+ httpClient,+ ownershipTrackingStart: '2026-10-19T00:00:00.000Z',+ generateToken: () => 'token',+ namespaceConcurrency: 2,+ });+ const deletions = Promise.all([+ remove(req, scoped),+ remove(req, { ...scoped, file_id: 'other-file' }),+ ]);+ try {+ await started.promise;+ expect(httpClient.delete).toHaveBeenCalledTimes(2);+ } finally {+ finish.resolve();+ }+ await expect(deletions).resolves.toEqual([{ deleted: true }, { deleted: true }]);+ expect(httpClient.delete).toHaveBeenCalledTimes((entities.length + 1) * 2);+ expect(peak).toBe(2);+ expect(active).toBe(0);+ });++ it('waits after partial failure and converges on retry through verified 404s', async () => {+ const copies = new Set(entities);+ const inventoryStarted = deferred();+ const finishInventory = deferred();+ const secret = 'private-provider-token';+ let fail = true;+ let settled = false;+ const httpClient = {+ delete: jest.fn().mockImplementation(async (_url: string, config: NamespaceConfig) => {+ const owner = config.params?.entity_id ?? 'public';+ if (owner === entities[1] && fail) {+ throw Object.assign(new Error(secret), {+ response: { status: 503, data: secret },+ });+ }+ if (!copies.delete(owner)) throw { response: { status: 404 } };+ return { status: 200 };+ }),+ get: jest.fn().mockImplementation(async (_url: string, config: NamespaceConfig) => {+ const owner = config.params?.entity_id ?? 'public';+ if (owner === 'public') {+ inventoryStarted.resolve();+ await finishInventory.promise;+ }+ return { data: copies.has(owner) ? [file.file_id] : [] };+ }),+ };+ const remove = createVectorFileDeleter({+ baseUrl: 'https://rag.example',+ httpClient,+ ownershipTrackingStart: '2026-10-19T00:00:00.000Z',+ generateToken: () => 'token',+ namespaceConcurrency: 3,+ });+ const deletion = remove(req, scoped).then(+ (receipt) => {+ settled = true;+ return receipt;+ },+ (error: Error) => {+ settled = true;+ return error;+ },+ );+ try {+ await inventoryStarted.promise;+ expect(httpClient.delete).toHaveBeenCalledTimes(entities.length + 1);+ expect(settled).toBe(false);+ } finally {+ finishInventory.resolve();+ }+ const failure = await deletion;+ expect(failure).toBeInstanceOf(Error);+ expect(failure).toMatchObject({ message: 'Vector deletion was not confirmed' });+ expect(failure).not.toHaveProperty('response');+ expect(JSON.stringify(failure)).not.toContain(secret);+ expect([...copies]).toEqual([entities[1]]);++ fail = false;+ httpClient.delete.mockClear();+ httpClient.get.mockClear();+ await expect(remove(req, scoped)).resolves.toEqual({ deleted: true });+ expect([...copies]).toEqual([]);+ expect(httpClient.delete).toHaveBeenCalledTimes(entities.length + 1);+ expect(httpClient.get).toHaveBeenCalledTimes(entities.length);+ });+ });+it('does not issue a receipt for an unconfigured store or a non-embedded file', async () => {expect(await setup('')(req, file)).toBeUndefined();expect(await setup()(req, { ...file, embedded: false })).toBeUndefined();@@ -273,6 +768,6 @@ describe('createVectorFileDeleter receipts', () => {{ response: { status: 500 } },])('propagates failed requests without a deletion receipt', async (error) => {mockedAxios.delete.mockRejectedValueOnce(error);- await expect(setup()(req, file)).rejects.toBe(error);+ await expect(setup()(req, file)).rejects.toThrow('Vector deletion was not confirmed');});});diff --git a/packages/api/src/files/rag.ts b/packages/api/src/files/rag.tsindex 109c76766d..33690b4520 100644--- a/packages/api/src/files/rag.ts+++ b/packages/api/src/files/rag.ts@@ -1,16 +1,25 @@import axios from 'axios';import { logger } from '@librechat/data-schemas';+import type { TFileConfig } from 'librechat-data-provider';import type { AxiosInstance } from 'axios';+import { createConcurrencyLimiter } from '~/utils/promise';import { generateShortLivedToken } from '~/crypto/jwt';-import { isMissingStorageError } from './storage';+import { getSafeErrorMetadata } from '~/utils/errors';interface DeleteRagFileParams {/** The user ID. Required for authentication. If not provided, the function returns false and logs an error. */userId: string;+ fileConfig?: Pick<TFileConfig, 'vectorOwnershipTrackingStart' | 'vectorDeletionConcurrency'>;/** The file object. Must have `embedded` and `file_id` properties. */file: {file_id: string;embedded?: boolean;+ context?: string;+ embeddingOwnersComplete?: boolean;+ embeddingOwnersTrackedAt?: Date | string;+ /** Internal rollback descriptor, never persisted on File. */+ unrecordedUpload?: true;+ metadata?: { embeddedEntities?: string[] };};}@@ -24,40 +33,28 @@ interface DeleteRagFileParams {* @param params.file - The file object. Must have `embedded` and `file_id` properties.* @returns Returns true if deletion was successful or skipped, false if there was an error.*/-export async function deleteRagFile({ userId, file }: DeleteRagFileParams): Promise<boolean> {- if (!file.embedded || !process.env.RAG_API_URL) {- return true;- }-+export async function deleteRagFile({+ userId,+ file,+ fileConfig,+}: DeleteRagFileParams): Promise<boolean> {+ if (!file.embedded) return true;if (!userId) {logger.error('[deleteRagFile] No user ID provided');return false;}-- const jwtToken = generateShortLivedToken(userId);-try {- await axios.delete(`${process.env.RAG_API_URL}/documents`, {- headers: {- Authorization: `Bearer ${jwtToken}`,- 'Content-Type': 'application/json',- accept: 'application/json',- },- data: [file.file_id],- });- logger.debug(`[deleteRagFile] Successfully deleted document ${file.file_id} from RAG API`);- return true;+ const deleted = await createVectorFileDeleter({+ baseUrl: process.env.RAG_API_URL,+ httpClient: axios,+ generateToken: generateShortLivedToken,+ ownershipTrackingStart: fileConfig?.vectorOwnershipTrackingStart,+ namespaceConcurrency: fileConfig?.vectorDeletionConcurrency,+ })({ user: { id: userId } }, file);+ return deleted?.deleted === true;} catch (error) {- const axiosError = error as { response?: { status?: number }; message?: string };- if (axiosError.response?.status === 404) {- logger.warn(- `[deleteRagFile] Document ${file.file_id} not found in RAG API, may have been deleted already`,- );- return true;- } else {- logger.error('[deleteRagFile] Error deleting document from RAG API:', axiosError.message);- return false;- }+ logger.error('[deleteRagFile] Vector deletion was not confirmed', getSafeErrorMetadata(error));+ return false;}}@@ -116,27 +113,92 @@ export function createVectorFileDeleter({baseUrl,httpClient,generateToken,+ namespaceConcurrency = 4,+ ownershipTrackingStart,}: {baseUrl?: string;- httpClient: Pick<AxiosInstance, 'delete'>;+ httpClient: Pick<AxiosInstance, 'delete' | 'get'>;generateToken: (userId: string) => string;+ namespaceConcurrency?: number;+ ownershipTrackingStart?: string;}): (req: { user: { id: string } },- file: { file_id: string; embedded?: boolean },+ file: DeleteRagFileParams['file'],) => Promise<{ deleted: true } | undefined> {+ const limit = createConcurrencyLimiter(namespaceConcurrency);return async (req, file) => {if (!file.embedded || !baseUrl) return undefined;- try {- await httpClient.delete(`${baseUrl}/documents`, {- headers: {- Authorization: `Bearer ${generateToken(req.user.id)}`,- 'Content-Type': 'application/json',- accept: 'application/json',- },- data: [file.file_id],+ if (!req.user.id) throw new Error('Invalid vector deletion principal');+ const entities = file.metadata?.embeddedEntities;+ if (+ entities != null &&+ (!Array.isArray(entities) || entities.some((id) => typeof id !== 'string' || !id))+ ) {+ throw new Error('Invalid file embedding snapshot');+ }+ if (file.embeddingOwnersComplete !== true) {+ throw new Error('Complete vector ownership must be recorded before deletion');+ }+ if (file.unrecordedUpload !== true) {+ const start = ownershipTrackingStart == null ? NaN : Date.parse(ownershipTrackingStart);+ const tracked = file.embeddingOwnersTrackedAt;+ let trackedAt = NaN;+ if (tracked instanceof Date) trackedAt = tracked.getTime();+ else if (typeof tracked === 'string') trackedAt = Date.parse(tracked);+ const now = Date.now();+ // Old writers can preserve the boolean while dropping owners. Exclude the overlap era.+ if (+ !Number.isFinite(start) ||+ start > now ||+ !Number.isFinite(trackedAt) ||+ trackedAt < start ||+ trackedAt > now+ ) {+ throw new Error('Vector ownership predates the safe writer rollout');+ }+ }+ const headers = () => ({+ Authorization: `Bearer ${generateToken(req.user.id)}`,+ 'Content-Type': 'application/json',+ accept: 'application/json',+ });+ // Unscoped embeds can live in RAG's public scope even when metadata records a user ID.+ const namespaces = [...new Set(entities ?? []), undefined];+ const results = await Promise.allSettled(+ namespaces.map((entity_id) =>+ limit(async () => {+ const config = entity_id ? { params: { entity_id } } : {};+ try {+ await httpClient.delete(`${baseUrl}/documents`, {+ ...config,+ headers: headers(),+ data: [file.file_id],+ });+ } catch (error) {+ // A 404 can mean a wrong scope. Only a successful inventory can establish absence,+ // including when a prior attempt removed just some of the namespaces.+ if (getSafeErrorMetadata(error).status !== 404) throw error;+ const { data } = await httpClient.get<string[]>(`${baseUrl}/ids`, {+ ...config,+ headers: headers(),+ });+ if (+ !Array.isArray(data) ||+ data.some((id) => typeof id !== 'string') ||+ data.includes(file.file_id)+ ) {+ throw new Error('Vector absence was not confirmed');+ }+ }+ }),+ ),+ );+ const failure = results.find((result) => result.status === 'rejected');+ if (failure?.status === 'rejected') {+ // Do not expose a provider 404 to generic storage cleanup, which forgives missing blobs.+ throw new Error('Vector deletion was not confirmed', {+ cause: getSafeErrorMetadata(failure.reason),});- } catch (error) {- if (!isMissingStorageError(error)) throw error;}return { deleted: true };};diff --git a/packages/api/src/files/storage.spec.ts b/packages/api/src/files/storage.spec.tsindex 6fc34687af..472a47d533 100644--- a/packages/api/src/files/storage.spec.ts+++ b/packages/api/src/files/storage.spec.ts@@ -6,13 +6,19 @@ import type { FileStorageDeletionObserver } from './dispatch';import { createDeleteFileWithSecondaryStorage, isMissingStorageError } from './storage';import { createFileProvisionRecovery } from './operations';import { dispatchFileDeletion } from './dispatch';+import { createVectorFileDeleter } from './rag';const req: {user: { id: string; tenantId: string };- config: { fileConfig: { retainedFileCleanup?: boolean } };+ config: { fileConfig: { retainedFileCleanup?: boolean; vectorOwnershipTrackingStart?: string } };} = {user: { id: 'owner', tenantId: 'tenant-a' },- config: { fileConfig: { retainedFileCleanup: true } },+ config: {+ fileConfig: {+ retainedFileCleanup: true,+ vectorOwnershipTrackingStart: '2026-10-19T00:00:00.000Z',+ },+ },};const client = { provider: 'openai' };const file = {@@ -20,6 +26,8 @@ const file = {user: 'owner',tenantId: 'tenant-a',embedded: true,+ embeddingOwnersComplete: true,+ embeddingOwnersTrackedAt: '2026-10-20T00:00:00.000Z',metadata: { codeEnvRef: { file_id: 'code-copy' } },};@@ -77,6 +85,93 @@ describe('createDeleteFileWithSecondaryStorage', () => {file.embedded = true;file.metadata = { codeEnvRef: { file_id: 'code-copy' } };});+ it.each([FileSources.local, FileSources.vectordb])(+ 'retains the embedding snapshot and primary on unverified vector 404 (%s)',+ async (source) => {+ const { primary, vectors, remove, clearFileEmbeddings } = setup(source);+ const httpClient = {+ delete: jest.fn().mockRejectedValue({ response: { status: 404 } }),+ get: jest.fn().mockRejectedValue({ response: { status: 404 } }),+ };+ const deleteVectors = createVectorFileDeleter({+ baseUrl: 'https://rag.example',+ ownershipTrackingStart: req.config.fileConfig.vectorOwnershipTrackingStart,+ httpClient,+ generateToken: () => 'token',+ });+ (source === FileSources.vectordb ? primary : vectors).mockImplementation(deleteVectors);+ const retained = { ...file, metadata: { ...file.metadata, embeddedEntities: ['agent-a'] } };+ await expect(remove(req, retained)).rejects.toThrow('Vector deletion was not confirmed');+ expect(clearFileEmbeddings).not.toHaveBeenCalled();+ expect(retained.embedded).toBe(true);+ expect(retained.metadata.embeddedEntities).toEqual(['agent-a']);+ if (source === FileSources.local) expect(primary).not.toHaveBeenCalled();+ },+ );++ it.each([FileSources.local, FileSources.vectordb])(+ 'retains a partially adopted legacy file and its unknown agent-b vectors (%s)',+ async (source) => {+ const { primary, vectors, remove, clearFileEmbeddings, isFileStorageClean } = setup(source);+ const copies = new Set(['agent-a', 'agent-b']);+ const httpClient = {+ delete: jest.fn().mockImplementation(async () => {+ copies.delete('agent-a');+ return { status: 200 };+ }),+ get: jest.fn().mockResolvedValue({ data: [] }),+ };+ const deleteVectors = createVectorFileDeleter({+ baseUrl: 'https://rag.example',+ ownershipTrackingStart: req.config.fileConfig.vectorOwnershipTrackingStart,+ httpClient,+ generateToken: () => 'token',+ });+ (source === FileSources.vectordb ? primary : vectors).mockImplementation(deleteVectors);+ const legacy = {+ ...file,+ embeddingOwnersComplete: false,+ metadata: { ...file.metadata, embeddedEntities: ['agent-a'] },+ };+ await expect(remove(req, legacy)).rejects.toThrow('Complete vector ownership');+ expect([...copies]).toEqual(['agent-a', 'agent-b']);+ expect(httpClient.delete).not.toHaveBeenCalled();+ expect(clearFileEmbeddings).not.toHaveBeenCalled();+ if (source === FileSources.local) {+ expect(isFileStorageClean).not.toHaveBeenCalled();+ expect(primary).not.toHaveBeenCalled();+ }+ expect(legacy.metadata.embeddedEntities).toEqual(['agent-a']);+ expect(legacy.embedded).toBe(true);+ },+ );++ it.each([FileSources.local, FileSources.vectordb])(+ 'keeps the primary and metadata when an old writer damages overlap-era ownership (%s)',+ async (source) => {+ const { primary, vectors, remove, clearFileEmbeddings } = setup(source);+ const httpClient = { delete: jest.fn(), get: jest.fn() };+ const erase = createVectorFileDeleter({+ baseUrl: 'https://rag.example',+ httpClient,+ generateToken: () => 'token',+ ownershipTrackingStart: req.config.fileConfig.vectorOwnershipTrackingStart,+ });+ (source === FileSources.vectordb ? primary : vectors).mockImplementation(erase);+ const damaged = {+ ...file,+ embeddingOwnersTrackedAt: '2026-10-18T00:00:00.000Z',+ metadata: { ...file.metadata, embeddedEntities: ['agent-a'] },+ };+ await expect(remove(req, damaged)).rejects.toThrow('safe writer rollout');+ expect(httpClient.delete).not.toHaveBeenCalled();+ expect(clearFileEmbeddings).not.toHaveBeenCalled();+ if (source === FileSources.local) expect(primary).not.toHaveBeenCalled();+ expect(damaged.embedded).toBe(true);+ expect(damaged.metadata.embeddedEntities).toEqual(['agent-a']);+ },+ );+it('waits for both secondaries before deleting the primary with its provider client', async () => {const { primary, vectors, code, remove } = setup(FileSources.openai);let finishCode: () => void = () => {};@@ -399,6 +494,7 @@ describe('createDeleteFileWithSecondaryStorage', () => {tenantId: retained.tenantId,updatedAt: undefined,embeddedEntities: ['namespace'],+ ownershipTrackingStart: req.config.fileConfig.vectorOwnershipTrackingStart,});expect(primary.mock.invocationCallOrder[0]).toBeLessThan(clearFileEmbeddings.mock.invocationCallOrder[0],@@ -470,6 +566,7 @@ describe('createDeleteFileWithSecondaryStorage', () => {tenantId: 'tenant-a',updatedAt: undefined,embeddedEntities: ['agent-a', 'agent-b'],+ ownershipTrackingStart: req.config.fileConfig.vectorOwnershipTrackingStart,});expect(retained.embedded).toBe(false);expect(retained.metadata).toEqual({diff --git a/packages/api/src/files/storage.ts b/packages/api/src/files/storage.tsindex 485c1364d3..835089e0f5 100644--- a/packages/api/src/files/storage.ts+++ b/packages/api/src/files/storage.ts@@ -76,7 +76,9 @@ function readEmbeddedEntities(value: unknown): string[] | undefined {export function createDeleteFileWithSecondaryStorage<TRequest extends {user: { id: string; tenantId?: string };- config?: { fileConfig?: { retainedFileCleanup?: boolean } };+ config?: {+ fileConfig?: { retainedFileCleanup?: boolean; vectorOwnershipTrackingStart?: string };+ };body?: { assistant_id?: string };},TFile extends StorageFile,@@ -160,6 +162,7 @@ export function createDeleteFileWithSecondaryStorage<tenantId: file.tenantId,updatedAt: file.updatedAt,embeddedEntities: readEmbeddedEntities(file.metadata?.embeddedEntities),+ ownershipTrackingStart: req.config?.fileConfig?.vectorOwnershipTrackingStart,}))) {throw new Error('Embedding snapshot changed');diff --git a/packages/api/src/projects/resources.spec.ts b/packages/api/src/projects/resources.spec.tsindex 265f0d7a93..c4e79cbfe0 100644--- a/packages/api/src/projects/resources.spec.ts+++ b/packages/api/src/projects/resources.spec.ts@@ -248,6 +248,8 @@ describe('ChatProject resource hydration', () => {const methods = createMethods(mongoose);const stored = await File.create(file('repair', owner, {+ embeddingOwnersComplete: true,+ embeddingOwnersTrackedAt: new Date('2026-10-20'),source: 's3',storageKey: 'owner/repair',storageRegion: 'region',@@ -260,6 +262,7 @@ describe('ChatProject resource hydration', () => {expect(await methods.clearFileEmbeddings({file_id: 'repair',+ ownershipTrackingStart: '2026-10-19T00:00:00.000Z',userId: owner,updatedAt: stored.updatedAt,}),diff --git a/packages/api/src/storage/local-delete.spec.ts b/packages/api/src/storage/local-delete.spec.tsindex 22c8c883ac..7e2a2da601 100644--- a/packages/api/src/storage/local-delete.spec.ts+++ b/packages/api/src/storage/local-delete.spec.ts@@ -37,6 +37,13 @@ describe('local file deletion', () => {expect(deleteRagFile).toHaveBeenCalledWith({ userId: 'user-1', file });});+ it('preserves bytes when vector cleanup returns false', async () => {+ const file = uploadedFile('retained.txt');+ deleteRagFile.mockResolvedValueOnce(false);+ await expect(remove(req, file)).rejects.toThrow('Vector deletion was not confirmed');+ expect(fs.existsSync(path.join(root, 'uploads', 'user-1', 'retained.txt'))).toBe(true);+ });+it('accepts missing storage but rejects other unlink failures', async () => {const file = { file_id: 'file-1', filepath: '/uploads/user-1/missing.txt', user: 'user-1' };await expect(remove(req, file)).resolves.toBeUndefined();diff --git a/packages/api/src/storage/local.ts b/packages/api/src/storage/local.tsindex 829b013d14..48a4775683 100644--- a/packages/api/src/storage/local.ts+++ b/packages/api/src/storage/local.ts@@ -2,6 +2,7 @@ import path from 'path';import crypto from 'node:crypto';import { EModelEndpoint } from 'librechat-data-provider';import { mkdir, copyFile, rename, unlink, writeFile } from 'fs/promises';+import type { TFileConfig } from 'librechat-data-provider';import { stripCacheBust } from './path';export interface LocalStoragePaths {@@ -17,11 +18,15 @@ interface LocalFile {interface LocalDeleteRequest {user: { id: string };- config: { paths: LocalStoragePaths };+ config: { paths: LocalStoragePaths; fileConfig?: TFileConfig };}interface LocalFileDeleteDependencies {- deleteRagFile: (args: { userId: string; file: LocalFile }) => Promise<unknown>;+ deleteRagFile: (args: {+ userId: string;+ file: LocalFile;+ fileConfig?: TFileConfig;+ }) => Promise<unknown>;logger: { warn: (...args: unknown[]) => void; error: (...args: unknown[]) => void };}@@ -43,6 +48,11 @@ export function createLocalFileDeleter({ deleteRagFile, logger }: LocalFileDeletreturn async (req: LocalDeleteRequest, file: LocalFile): Promise<void> => {const { publicPath, uploads } = req.config.paths;const ownerId = req.user.id;+ const ragParams = {+ userId: ownerId,+ file,+ ...(req.config.fileConfig ? { fileConfig: req.config.fileConfig } : {}),+ };if (!ownerId) throw new Error('Invalid file owner');const cleanFilepath = stripCacheBust(file.filepath);const uploadPrefix = `/uploads/${ownerId}/`;@@ -53,7 +63,9 @@ export function createLocalFileDeleter({ deleteRagFile, logger }: LocalFileDeletif (!isStrictlyWithin(userUploadDir, filePath)) {throw new Error(`Invalid file path: ${cleanFilepath}`);}- await deleteRagFile({ userId: ownerId, file });+ if ((await deleteRagFile(ragParams)) === false) {+ throw new Error('Vector deletion was not confirmed');+ }await unlinkStoredFile(filePath);return;}@@ -61,7 +73,9 @@ export function createLocalFileDeleter({ deleteRagFile, logger }: LocalFileDeletconst parts = cleanFilepath.split(path.sep);const subfolder = parts[1];if (!subfolder && parts[0] === EModelEndpoint.agents) {- await deleteRagFile({ userId: ownerId, file });+ if ((await deleteRagFile(ragParams)) === false) {+ throw new Error('Vector deletion was not confirmed');+ }logger.warn(`Agent File ${file.file_id} is missing filepath, may have been deleted already`);return;}@@ -69,7 +83,9 @@ export function createLocalFileDeleter({ deleteRagFile, logger }: LocalFileDeletif (!subfolder || !isStrictlyWithin(path.join(publicPath, subfolder, ownerId), filePath)) {throw new Error('Invalid file path');}- await deleteRagFile({ userId: ownerId, file });+ if ((await deleteRagFile(ragParams)) === false) {+ throw new Error('Vector deletion was not confirmed');+ }await unlinkStoredFile(filePath);};}diff --git a/packages/api/src/storage/ownedBlobDelete.spec.ts b/packages/api/src/storage/ownedBlobDelete.spec.tsindex d0e2610f70..eb2d253525 100644--- a/packages/api/src/storage/ownedBlobDelete.spec.ts+++ b/packages/api/src/storage/ownedBlobDelete.spec.ts@@ -38,6 +38,12 @@ describe.each([expect(deleteRagFile).toHaveBeenCalledWith({ userId: 'author-1', file });});+ it('retains the blob when vector cleanup returns false', async () => {+ deleteRagFile.mockResolvedValueOnce(false);+ await expect(remove(req, { filepath })).rejects.toThrow('Vector deletion was not confirmed');+ expect(deleteBlob).not.toHaveBeenCalled();+ });+it('rejects an owner mismatch before deleting either blob or RAG data', async () => {await expect(remove({ user: { id: 'author-2' } }, { filepath, user: 'author-1' }),@@ -61,12 +67,12 @@ describe.each([expect(deleteRagFile).not.toHaveBeenCalled();});- it('does not clean up RAG data when remote deletion fails', async () => {+ it('attempts vector cleanup before deleting remote storage', async () => {deleteBlob.mockRejectedValueOnce(new Error('storage unavailable'));await expect(remove(req, { filepath, user: 'author-1' })).rejects.toThrow('storage unavailable',);- expect(deleteRagFile).not.toHaveBeenCalled();+ expect(deleteRagFile).toHaveBeenCalled();});it('treats an already missing blob as deleted and still cleans up RAG data', async () => {diff --git a/packages/api/src/storage/ownedBlobDelete.ts b/packages/api/src/storage/ownedBlobDelete.tsindex d8ed747864..455653f7c3 100644--- a/packages/api/src/storage/ownedBlobDelete.ts+++ b/packages/api/src/storage/ownedBlobDelete.ts@@ -1,3 +1,5 @@+import type { TFileConfig } from 'librechat-data-provider';+interface StoredBlobFile {filepath: string;user?: { toString(): string };@@ -7,7 +9,11 @@ interface OwnedBlobDeleteDependencies {extractPath: (url: string) => string;deleteBlob: (path: string) => Promise<unknown>;isMissing: (error: unknown) => boolean;- deleteRagFile: (args: { userId: string; file: StoredBlobFile }) => Promise<unknown>;+ deleteRagFile: (args: {+ userId: string;+ file: StoredBlobFile;+ fileConfig?: TFileConfig;+ }) => Promise<unknown>;}/** File descriptors cannot override the storage owner supplied by the request. */@@ -17,7 +23,10 @@ export function createOwnedBlobFileDeleter({isMissing,deleteRagFile,}: OwnedBlobDeleteDependencies) {- return async (req: { user: { id: string } }, file: StoredBlobFile): Promise<void> => {+ return async (+ req: { user: { id: string }; config?: { fileConfig?: TFileConfig } },+ file: StoredBlobFile,+ ): Promise<void> => {const ownerId = req.user.id;const blobPath = extractPath(file.filepath);const segments = blobPath.split('/');@@ -32,12 +41,20 @@ export function createOwnedBlobFileDeleter({throw new Error('Invalid file path');}+ if (+ (await deleteRagFile({+ userId: ownerId,+ file,+ ...(req.config?.fileConfig ? { fileConfig: req.config.fileConfig } : {}),+ })) === false+ ) {+ throw new Error('Vector deletion was not confirmed');+ }try {await deleteBlob(blobPath);} catch (error) {if (!isMissing(error)) throw error;}- await deleteRagFile({ userId: ownerId, file });};}diff --git a/packages/api/src/storage/s3/__tests__/crud.test.ts b/packages/api/src/storage/s3/__tests__/crud.test.tsindex 9e523df5f3..ed5f0e6ade 100644--- a/packages/api/src/storage/s3/__tests__/crud.test.ts+++ b/packages/api/src/storage/s3/__tests__/crud.test.ts@@ -48,6 +48,7 @@ jest.mock('@librechat/data-schemas', () => ({import { getSignedUrl } from '@aws-sdk/s3-request-presigner';import { deleteRagFile } from '~/files';import { logger } from '@librechat/data-schemas';+import { createStoredUploadDelete } from '~/files/orphan';describe('S3 CRUD', () => {let originalEnv: NodeJS.ProcessEnv;@@ -909,21 +910,22 @@ describe('S3 CRUD', () => {const { deleteFileFromS3 } = await import('../crud');await expect(deleteFileFromS3(mockReq, mockFile, undefined, onDelete)).rejects.toBe(failure);expect(onDelete.mock.calls).toEqual([[]]);- expect(deleteRagFile).not.toHaveBeenCalled();+ expect(deleteRagFile).toHaveBeenCalledWith({ userId: 'user123', file: mockFile });});- it('confirms DeleteObject before a later RAG cleanup denial', async () => {+ it('keeps DeleteObject undispatched when RAG cleanup is denied', async () => {const mockFile = { filepath: 'images/user123/file.jpg', user: 'user123' } as TFile;const onDelete = jest.fn();s3Mock.on(HeadObjectCommand).resolves({});const failure = Object.assign(new Error('RAG denied'), { status: 403 });jest.mocked(deleteRagFile).mockImplementationOnce(async () => {- expect(onDelete.mock.calls).toEqual([[], ['confirmed']]);+ expect(onDelete).not.toHaveBeenCalled();throw failure;});const { deleteFileFromS3 } = await import('../crud');await expect(deleteFileFromS3(mockReq, mockFile, undefined, onDelete)).rejects.toBe(failure);- expect(onDelete.mock.calls).toEqual([[], ['confirmed']]);+ expect(onDelete).not.toHaveBeenCalled();+ expect(s3Mock.commandCalls(DeleteObjectCommand)).toHaveLength(0);});it('reports a definitive DeleteObject denial', async () => {@@ -939,6 +941,54 @@ describe('S3 CRUD', () => {expect(onDelete.mock.calls).toEqual([[], ['rejected']]);});+ it.each([FileSources.s3, FileSources.cloudfront])(+ 'deletes an unrecorded %s upload independently of vector rollback',+ async (source) => {+ const mockFile = {+ filepath: 'images/user123/file.jpg',+ user: 'user123',+ file_id: 'failed-upload',+ source,+ embedded: true,+ metadata: { embeddedEntities: ['agent-a'] },+ } as TFile;+ s3Mock.on(HeadObjectCommand).resolves({});+ jest+ .mocked(deleteRagFile)+ .mockImplementationOnce(async ({ file }) => file.embedded !== true);+ const { deleteFileFromS3 } = await import('../crud');+ const failure = new Error('Vector deletion was not confirmed');+ const vectors = jest.fn().mockRejectedValue(failure);+ const remove = createStoredUploadDelete({+ source,+ getDeleteFile: (destination) =>+ destination === FileSources.vectordb+ ? vectors+ : async (_req, file) => deleteFileFromS3(mockReq, { ...mockFile, ...file, source }),+ });+ await expect(remove(mockReq as never, { ...mockFile, source })).rejects.toBe(failure);+ expect(s3Mock.commandCalls(DeleteObjectCommand)).toHaveLength(1);+ expect(deleteRagFile).toHaveBeenCalledWith({+ userId: 'user123',+ file: { ...mockFile, embedded: false },+ });+ expect(vectors).toHaveBeenCalledWith(mockReq, mockFile);+ expect(mockFile.embedded).toBe(true);+ expect(mockFile.metadata?.embeddedEntities).toEqual(['agent-a']);+ },+ );++ it('keeps the S3 object when vector cleanup returns false', async () => {+ const mockFile = { filepath: 'images/user123/file.jpg', user: 'user123' } as TFile;+ s3Mock.on(HeadObjectCommand).resolves({});+ jest.mocked(deleteRagFile).mockResolvedValueOnce(false);+ const { deleteFileFromS3 } = await import('../crud');+ await expect(deleteFileFromS3(mockReq, mockFile)).rejects.toThrow(+ 'Vector deletion was not confirmed',+ );+ expect(s3Mock.commandCalls(DeleteObjectCommand)).toHaveLength(0);+ });+it('uses the file owner for RAG cleanup when a different authorized user deletes', async () => {const requesterReq = { user: { id: 'sharedUser' } } as ServerRequest;const mockFile = {diff --git a/packages/api/src/storage/s3/crud.ts b/packages/api/src/storage/s3/crud.tsindex 5be7b13f5c..099a46c68d 100644--- a/packages/api/src/storage/s3/crud.ts+++ b/packages/api/src/storage/s3/crud.ts@@ -757,6 +757,11 @@ export async function deleteFileFromS3(}const params = { Bucket: bucketName, Key: key };+ const ragParams = {+ userId: ownerId,+ file,+ ...(req.config?.fileConfig ? { fileConfig: req.config.fileConfig } : {}),+ };try {try {@@ -767,14 +772,18 @@ export async function deleteFileFromS3(if ((headErr as { name?: string }).name === 'NotFound') {logger.warn(`[deleteFileFromS3] File does not exist: ${key}`);onDelete?.('confirmed');- await deleteRagFile({ userId: ownerId, file });+ if ((await deleteRagFile(ragParams)) === false) {+ throw new Error('Vector deletion was not confirmed');+ }return;}throw headErr;}+ if ((await deleteRagFile(ragParams)) === false) {+ throw new Error('Vector deletion was not confirmed');+ }await dispatchFileDeletion(onDelete, () => s3.send(new DeleteObjectCommand(params)));- await deleteRagFile({ userId: ownerId, file });logger.debug('[deleteFileFromS3] S3 File deletion completed');} catch (error) {logger.error(`[deleteFileFromS3] Error deleting file from S3: ${(error as Error).message}`);@@ -782,7 +791,9 @@ export async function deleteFileFromS3(if ((error as { name?: string }).name === 'NoSuchKey') {onDelete?.('confirmed');- await deleteRagFile({ userId: ownerId, file });+ if ((await deleteRagFile(ragParams)) === false) {+ throw new Error('Vector deletion was not confirmed');+ }return;}throw error;diff --git a/packages/data-provider/src/file-config.spec.ts b/packages/data-provider/src/file-config.spec.tsindex 5b0ce3e9fc..2eef63783f 100644--- a/packages/data-provider/src/file-config.spec.ts+++ b/packages/data-provider/src/file-config.spec.ts@@ -2263,3 +2263,27 @@ describe('retained file cleanup rollout', () => {expect(mergeFileConfig({ retainedFileCleanup: false }).retainedFileCleanup).toBe(false);});});++describe('vector erasure rollout and concurrency settings', () => {+ it('leaves ownership trust disabled until an operator sets the post-upgrade cutoff', () => {+ expect(mergeFileConfig(undefined).vectorOwnershipTrackingStart).toBeUndefined();+ expect(mergeFileConfig(undefined).vectorDeletionConcurrency).toBe(4);+ const config = fileConfigSchema.parse({+ vectorOwnershipTrackingStart: '2026-10-26T21:00:00.000Z',+ vectorDeletionConcurrency: 2,+ });+ expect(mergeFileConfig(config)).toEqual(expect.objectContaining(config));+ });+ it.each(['not-a-date', '', '2026-10-26'])(+ 'rejects a non-UTC rollout cutoff: %j',+ (vectorOwnershipTrackingStart) => {+ expect(fileConfigSchema.safeParse({ vectorOwnershipTrackingStart }).success).toBe(false);+ },+ );+ it.each([0, -1, 1.5, 17])(+ 'rejects unsafe namespace concurrency: %s',+ (vectorDeletionConcurrency) => {+ expect(fileConfigSchema.safeParse({ vectorDeletionConcurrency }).success).toBe(false);+ },+ );+});diff --git a/packages/data-provider/src/file-config.ts b/packages/data-provider/src/file-config.tsindex 5404bc9f5d..92ec4b499c 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,+ vectorDeletionConcurrency: 4,endpoints: {[EModelEndpoint.assistants]: assistantsFileConfig,[EModelEndpoint.azureAssistants]: assistantsFileConfig,@@ -662,6 +663,9 @@ 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(),+ /** 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(),endpoints: z.record(z.string(), endpointFileConfigSchema).optional(),skills: skillFileConfigSchema.optional(),serverFileSizeLimit: z.number().min(0).optional(),@@ -1278,6 +1282,13 @@ function buildMergedFileConfig(dynamic: DynamicFileConfig | undefined): FileConfmergedConfig.retainedFileCleanup = dynamic.retainedFileCleanup;}+ if (dynamic.vectorOwnershipTrackingStart !== undefined) {+ mergedConfig.vectorOwnershipTrackingStart = dynamic.vectorOwnershipTrackingStart;+ }+ if (dynamic.vectorDeletionConcurrency !== undefined) {+ mergedConfig.vectorDeletionConcurrency = dynamic.vectorDeletionConcurrency;+ }+if (dynamic.defaultLLMDeliveryPath !== undefined) {mergedConfig.defaultLLMDeliveryPath = dynamic.defaultLLMDeliveryPath;}diff --git a/packages/data-provider/src/types/files.ts b/packages/data-provider/src/types/files.tsindex 457ee5e3c8..7dcf857da5 100644--- a/packages/data-provider/src/types/files.ts+++ b/packages/data-provider/src/types/files.ts@@ -60,6 +60,8 @@ export type EndpointFileConfig = {export type FileConfig = {/** Enable after all replicas and rollback targets support retained file destinations. */retainedFileCleanup?: boolean;+ vectorOwnershipTrackingStart?: string;+ vectorDeletionConcurrency?: number;endpoints: {[key: string]: EndpointFileConfig;};@@ -105,6 +107,8 @@ export type FileConfig = {export type FileConfigInput = {/** Fail closed on embedded-file deletion until marker-aware readers are deployed. */retainedFileCleanup?: boolean;+ vectorOwnershipTrackingStart?: string;+ vectorDeletionConcurrency?: number;endpoints?: {[key: string]: EndpointFileConfig;};@@ -168,6 +172,10 @@ export type TFile = {temp_file_id?: string;bytes: number;embedded: boolean;+ /** Every vector namespace has been tracked since this record was inserted. */+ embeddingOwnersComplete?: boolean;+ /** Insert-time proof, trusted only after the deployment rollout cutoff. */+ embeddingOwnersTrackedAt?: string | Date;filename: string;filepath: string;object: 'file';diff --git a/packages/data-schemas/src/methods/file.ownership.spec.ts b/packages/data-schemas/src/methods/file.ownership.spec.tsnew file mode 100644index 0000000000..a0373e5b7f--- /dev/null+++ b/packages/data-schemas/src/methods/file.ownership.spec.ts@@ -0,0 +1,239 @@+import mongoose from 'mongoose';+import { MongoMemoryServer } from 'mongodb-memory-server';+import { FileContext, FileSources } from 'librechat-data-provider';+import type { IMongoFile } from '~/types/file';+import { createFileStorageMethods } from './fileStorage';+import { createFileMethods } from './file';+import fileSchema from '~/schema/file';++let mongo: MongoMemoryServer;+let File: mongoose.Model<IMongoFile>;+let methods: ReturnType<typeof createFileMethods>;+let storage: ReturnType<typeof createFileStorageMethods>;+const user = new mongoose.Types.ObjectId();+const data = {+ file_id: 'ownership-file',+ user,+ tenantId: 'tenant-a',+ filename: 'notes.pdf',+ filepath: '/uploads/notes.pdf',+ type: 'application/pdf',+ bytes: 12,+ source: FileSources.local,+ context: FileContext.agents,+};+const claim = {+ file_id: data.file_id,+ userId: user.toString(),+ tenantId: data.tenantId,+ token: 'search',+};+const ownershipTrackingStart = '2020-01-01T00:00:00.000Z';+const read = () => File.findOne({ file_id: data.file_id }).lean();++beforeAll(async () => {+ mongo = await MongoMemoryServer.create({ instance: { args: ['--nounixsocket'] } });+ await mongoose.connect(mongo.getUri());+ File = mongoose.model('File', fileSchema);+ await File.init();+ methods = createFileMethods(mongoose);+ storage = createFileStorageMethods(mongoose);+});+beforeEach(async () => {+ await File.deleteMany({});+});+afterAll(async () => {+ await mongoose.disconnect();+ mongoose.deleteModel('File');+ await mongo?.stop();+});++it('marks only a newly inserted file as completely tracked', async () => {+ const file = await methods.createFile(data, true);+ expect(file?.embeddingOwnersComplete).toBe(true);+ expect(file?.embeddingOwnersTrackedAt).toBeInstanceOf(Date);+ await methods.updateFile({ ...data, metadata: { destinationChosen: true } });+ expect((await read())?.embeddingOwnersComplete).toBe(true);+});++it.each([undefined, false])(+ 'never promotes a legacy upsert or update (%s)',+ async (embeddingOwnersComplete) => {+ await File.create({+ ...data,+ embedded: true,+ metadata: { embeddedEntities: ['agent-a'] },+ embeddingOwnersComplete,+ });+ await methods.createFile({ ...data, embeddingOwnersComplete: true }, true);+ await methods.updateFile({ ...data, embeddingOwnersComplete: true });+ expect((await read())?.embeddingOwnersComplete).toBe(embeddingOwnersComplete);+ },+);++it('keeps partial legacy adoption incomplete through provisioning and refuses reconciliation', async () => {+ await File.create({ ...data, embedded: true });+ await methods.adoptLegacySearchEmbeddings({+ files: [{ file_id: data.file_id, user: user.toString(), tenantId: data.tenantId }],+ agentId: 'agent-a',+ });+ expect(await storage.acquireFileProvision(claim)).toBe(true);+ expect(await storage.commitFileProvision({ claim, embedded: true, entityId: 'agent-c' })).toBe(+ true,+ );+ const file = await read();+ expect(file?.metadata?.embeddedEntities).toEqual(['agent-a', 'agent-c']);+ expect(file?.embeddingOwnersComplete).toBeUndefined();+ expect(+ await methods.clearFileEmbeddings({+ ...claim,+ ownershipTrackingStart,+ updatedAt: file?.updatedAt,+ embeddedEntities: ['agent-a', 'agent-c'],+ }),+ ).toBe(false);+ expect((await read())?.embedded).toBe(true);+ expect((await read())?.metadata?.embeddedEntities).toEqual(['agent-a', 'agent-c']);+});++it('preserves complete tracking across additive provisioning and verified cleanup', async () => {+ await methods.createFile(data, true);+ expect(await storage.acquireFileProvision(claim)).toBe(true);+ expect(await storage.commitFileProvision({ claim, embedded: true, entityId: 'agent-a' })).toBe(+ true,+ );+ expect(await storage.commitFileProvision({ claim, embedded: true, entityId: 'agent-b' })).toBe(+ true,+ );+ const file = await read();+ expect(file?.embeddingOwnersComplete).toBe(true);+ expect(+ await methods.clearFileEmbeddings({+ ...claim,+ ownershipTrackingStart,+ updatedAt: file?.updatedAt,+ embeddedEntities: ['agent-a', 'agent-b'],+ }),+ ).toBe(true);+ expect((await read())?.embeddingOwnersComplete).toBe(true);+ expect((await read())?.embedded).toBe(false);+});++it('does not promote a reused generated-output claim', async () => {+ const code = { ...data, context: FileContext.execute_code, conversationId: 'conversation' };+ await File.create(code);+ await methods.claimCodeFile({ ...code, user: user.toString() });+ expect((await read())?.embeddingOwnersComplete).toBeUndefined();+});++it('marks newly claimed generated output complete before deferred embeddings', async () => {+ const file = await methods.claimCodeFile({+ file_id: data.file_id,+ user: user.toString(),+ tenantId: data.tenantId,+ filename: 'output.csv',+ conversationId: 'conversation',+ });+ expect(file.embeddingOwnersComplete).toBe(true);+});++it.each(['create', 'update', 'output'] as const)(+ 'preserves owners added after a stale %s metadata snapshot',+ async (writer) => {+ const original = await methods.createFile(+ { ...data, embedded: true, metadata: { embeddedEntities: ['agent-a'] } },+ true,+ );+ await methods.addFileEmbeddedEntity({ file_id: data.file_id, entityId: 'agent-b' });+ const stale = { ...data, metadata: original?.metadata };+ if (writer === 'create') await methods.createFile(stale, true);+ else if (writer === 'update') await methods.updateFile(stale);+ else {+ expect(await storage.acquireFileProvision(claim)).toBe(true);+ expect(+ await storage.commitFileProvision({+ claim,+ output: { file: { ...stale, user: user.toString() } },+ }),+ ).toBe(true);+ }+ const current = await read();+ expect(current?.metadata?.embeddedEntities).toEqual(['agent-a', 'agent-b']);+ expect(current?.embeddingOwnersComplete).toBe(true);+ },+);++it('never trusts an overlap-era marker after an old writer loses an owner', async () => {+ const original = await methods.createFile(+ { ...data, embedded: true, metadata: { embeddedEntities: ['agent-a'] } },+ true,+ );+ await methods.addFileEmbeddedEntity({ file_id: data.file_id, entityId: 'agent-b' });+ // Reproduce the old binary's whole-metadata replacement, bypassing the new writer.+ await File.collection.updateOne(+ { file_id: data.file_id },+ { $set: { metadata: original?.metadata } },+ );+ const damaged = await read();+ expect(damaged?.metadata?.embeddedEntities).toEqual(['agent-a']);+ expect(damaged?.embeddingOwnersComplete).toBe(true);+ await File.collection.updateOne(+ { file_id: data.file_id },+ { $set: { embeddingOwnersTrackedAt: new Date('2026-10-19') } },+ );+ const afterDrain = '2026-10-20T00:00:00.000Z';+ expect(+ await methods.clearFileEmbeddings({+ ...claim,+ ownershipTrackingStart: afterDrain,+ updatedAt: damaged?.updatedAt,+ embeddedEntities: ['agent-a'],+ }),+ ).toBe(false);+ expect(+ await methods.clearFileEmbeddings({+ ...claim,+ updatedAt: damaged?.updatedAt,+ embeddedEntities: ['agent-a'],+ }),+ ).toBe(false);+ expect((await read())?.embedded).toBe(true);+});++it('cannot upgrade an overlap-era timestamp through content or output payloads', async () => {+ const old = new Date('2019-01-01');+ await File.create({ ...data, embeddingOwnersComplete: true, embeddingOwnersTrackedAt: old });+ await methods.createFile({ ...data, embeddingOwnersTrackedAt: new Date() }, true);+ await methods.updateFile({ ...data, embeddingOwnersTrackedAt: new Date() });+ expect(await storage.acquireFileProvision(claim)).toBe(true);+ const file = { ...data, user: user.toString(), embeddingOwnersTrackedAt: new Date() };+ expect(await storage.commitFileProvision({ claim, output: { file } })).toBe(true);+ expect((await read())?.embeddingOwnersTrackedAt).toEqual(old);+});++it.each([undefined, 'bad-date', '2999-01-01T00:00:00.000Z'])(+ 'leaves erasure disabled for an unset or inactive cutoff: %s',+ async (ownershipTrackingStart) => {+ const file = await methods.createFile({ ...data, embedded: true }, true);+ expect(+ await methods.clearFileEmbeddings({+ ...claim,+ ownershipTrackingStart,+ updatedAt: file?.updatedAt,+ }),+ ).toBe(false);+ expect((await read())?.embedded).toBe(true);+ },+);++it('rejects boolean-only markers left by the prior implementation', async () => {+ await File.create({ ...data, embedded: true, embeddingOwnersComplete: true });+ const file = await read();+ expect(+ await methods.clearFileEmbeddings({+ ...claim,+ ownershipTrackingStart,+ updatedAt: file?.updatedAt,+ }),+ ).toBe(false);+});diff --git a/packages/data-schemas/src/methods/file.publication.spec.ts b/packages/data-schemas/src/methods/file.publication.spec.tsindex 66a6e6757a..d107cf957c 100644--- a/packages/data-schemas/src/methods/file.publication.spec.ts+++ b/packages/data-schemas/src/methods/file.publication.spec.ts@@ -104,6 +104,7 @@ describe('Run artifact persistence', () => {expect(file.metadata.codeEnvRef).toBeUndefined();expect(file.metadata.codeEnvRefs).toBeUndefined();expect(file.metadata.embeddedEntities).toBeUndefined();+ expect(file.embeddingOwnersComplete).toBe(true);expect(await methods.claimRunArtifactFile(scope)).toEqual({ file_id: file.file_id, file });expect(await methods.listRunArtifacts(scope)).toEqual([file]);expect(await methods.getRunFileCandidates([file.file_id], scope.tenantId)).toEqual([file]);diff --git a/packages/data-schemas/src/methods/file.spec.ts b/packages/data-schemas/src/methods/file.spec.tsindex 637b844496..6e03c7131d 100644--- a/packages/data-schemas/src/methods/file.spec.ts+++ b/packages/data-schemas/src/methods/file.spec.ts@@ -485,7 +485,10 @@ describe('File Methods', () => {});it('persists each copy without mutating input or invalidating the embedding snapshot', async () => {- await seed();+ await seed({+ embeddingOwnersComplete: true,+ embeddingOwnersTrackedAt: new Date('2026-10-20'),+ });const input = structuredClone(snapshot);expect(await fileMethods.clearFileCodeEnvRefs(snapshot)).toBe(true);expect(@@ -500,6 +503,7 @@ describe('File Methods', () => {...snapshot,updatedAt,embeddedEntities: metadata.embeddedEntities,+ ownershipTrackingStart: '2026-10-19T00:00:00.000Z',}),).toBe(true);const stored = await read();@@ -513,7 +517,10 @@ describe('File Methods', () => {{ tenantId: 'tenant-b' },{ tenantId: undefined },])('returns false without changing an unauthorized file: %p', async (scope) => {- await seed();+ await seed({+ embeddingOwnersComplete: true,+ embeddingOwnersTrackedAt: new Date('2026-10-20'),+ });const before = await read();expect(await fileMethods.clearFileCodeEnvRefs({ ...snapshot, ...scope })).toBe(false);expect(await read()).toEqual(before);@@ -540,7 +547,10 @@ describe('File Methods', () => {it.each([{ tenantId: 'tenant-b' }, { tenantId: undefined }])('does not let tenant middleware replace the caller scope: %p',async (scope) => {- await seed();+ await seed({+ embeddingOwnersComplete: true,+ embeddingOwnersTrackedAt: new Date('2026-10-20'),+ });const before = await read();const cleared = await tenantStorage.run({ tenantId: snapshot.tenantId }, () =>fileMethods.clearFileCodeEnvRefs({ ...snapshot, ...scope }),@@ -693,6 +703,7 @@ describe('File Methods', () => {const user = new mongoose.Types.ObjectId();const updatedAt = new Date('2026-10-20T00:00:00Z');const snapshot = {+ ownershipTrackingStart: '2026-10-19T00:00:00.000Z',file_id: 'retained-file',userId: user.toString(),tenantId: 'tenant-a',@@ -706,6 +717,8 @@ describe('File Methods', () => {tenantId: snapshot.tenantId,updatedAt,embedded: true,+ embeddingOwnersComplete: true,+ embeddingOwnersTrackedAt: new Date('2026-10-20'),metadata: {embeddedEntities: snapshot.embeddedEntities,codeEnvRef: { file_id: 'still-needed' },@@ -837,19 +850,21 @@ describe('File Methods', () => {},);- it('clears legacy vector flags without an entity list', async () => {+ it('clears fully tracked unscoped vector flags without an entity list', async () => {await seed({ metadata: { destinationChosen: true } });const legacy = { ...snapshot, embeddedEntities: undefined };expect(await fileMethods.clearFileEmbeddings(legacy)).toBe(true);});- it('retains search intent on markerless legacy records without metadata', async () => {+ it('retains search intent on fully tracked records without metadata', async () => {await File.collection.insertOne({file_id: snapshot.file_id,user,tenantId: snapshot.tenantId,updatedAt,embedded: true,+ embeddingOwnersComplete: true,+ embeddingOwnersTrackedAt: new Date('2026-10-20'),});expect(await fileMethods.clearFileEmbeddings({ ...snapshot, embeddedEntities: undefined }),diff --git a/packages/data-schemas/src/methods/file.ts b/packages/data-schemas/src/methods/file.tsindex e14c4a4871..911c81f712 100644--- a/packages/data-schemas/src/methods/file.ts+++ b/packages/data-schemas/src/methods/file.ts@@ -23,6 +23,7 @@ import type {} from '~/types/file';import type { IChatProjectDocument } from '~/types';import { tenantSafeBulkWrite } from '~/utils/tenantBulkWrite';+import { fileContentUpdate } from './fileContent';import { escapeRegExp } from '~/utils/string';import logger from '../config/winston';@@ -50,6 +51,7 @@ export type ClearFileEmbeddingsParams = {tenantId?: string | null;updatedAt?: Date | string;embeddedEntities?: string[];+ ownershipTrackingStart?: string;};export const DEFAULT_AVAILABLE_PROJECT_FILES_LIMIT = 20;@@ -599,6 +601,8 @@ export function createFileMethods(mongoose: typeof import('mongoose')): {object: 'file',source: file.source ?? FileSources.local,embedded: false,+ embeddingOwnersComplete: true,+ embeddingOwnersTrackedAt: new Date(),usage: 1,llmDeliveryPath: file.llmDeliveryPath ?? 'none',metadata: {@@ -1190,6 +1194,8 @@ export function createFileMethods(mongoose: typeof import('mongoose')): {const File = mongoose.models.File as Model<IMongoFile>;const tenantFilter = data.tenantId ? { tenantId: data.tenantId } : { tenantId: null };const insertData = {+ embeddingOwnersComplete: true,+ embeddingOwnersTrackedAt: new Date(),file_id: data.file_id,user: data.user,...(data.tenantId ? { tenantId: data.tenantId } : {}),@@ -1258,7 +1264,10 @@ export function createFileMethods(mongoose: typeof import('mongoose')): {}: {}),},- fileData,+ {+ ...fileContentUpdate(fileData),+ $setOnInsert: { embeddingOwnersComplete: true, embeddingOwnersTrackedAt: new Date() },+ },{ new: true, upsert: true },).lean<IMongoFile>();} catch (error) {@@ -1297,7 +1306,7 @@ export function createFileMethods(mongoose: typeof import('mongoose')): {const File = mongoose.models.File as Model<IMongoFile>;const { file_id, ...update } = data;const updateOperation = {- $set: update,+ ...fileContentUpdate(update),$unset: { expiresAt: '' },};const query: FilterQuery<IMongoFile> = extraFilter ? { file_id, ...extraFilter } : { file_id };@@ -1437,15 +1446,26 @@ export function createFileMethods(mongoose: typeof import('mongoose')): {/** Clears only the embedding snapshot whose vector deletion was confirmed. */async function clearFileEmbeddings(data: ClearFileEmbeddingsParams): Promise<boolean> {const File = mongoose.models.File as Model<IMongoFile>;+ const start =+ data.ownershipTrackingStart == null ? NaN : Date.parse(data.ownershipTrackingStart);+ const now = new Date();+ const ownership =+ Number.isFinite(start) && start <= now.getTime()+ ? [+ {+ embedded: true,+ embeddingOwnersComplete: true,+ embeddingOwnersTrackedAt: { $gte: new Date(start), $lte: now },+ 'metadata.embeddedEntities': data.embeddedEntities ?? null,+ },+ ]+ : [];const query: FilterQuery<IMongoFile> = {file_id: data.file_id,user: data.userId,$and: [{ tenantId: data.tenantId ?? null }],updatedAt: data.updatedAt ?? { $exists: false },- $or: [- { embedded: true, 'metadata.embeddedEntities': data.embeddedEntities ?? null },- { embedded: false, 'metadata.embeddedEntities': { $exists: false } },- ],+ $or: [...ownership, { embedded: false, 'metadata.embeddedEntities': { $exists: false } }],};const result = await File.updateOne(query,diff --git a/packages/data-schemas/src/methods/fileContent.ts b/packages/data-schemas/src/methods/fileContent.tsnew file mode 100644index 0000000000..4366341f7f--- /dev/null+++ b/packages/data-schemas/src/methods/fileContent.ts@@ -0,0 +1,33 @@+/** Only confirmed erasure may remove recorded vector owners. Content writes are additive. */+export function fileContentUpdate(data: object): {+ $set: Record<string, unknown>;+ $addToSet?: Record<string, { $each: string[] }>;+} {+ const update: Record<string, unknown> = { ...data };+ delete update.embeddingOwnersComplete;+ delete update.embeddingOwnersTrackedAt;+ const metadata = update.metadata;+ let owners: string[] | undefined;+ if (metadata !== undefined) {+ if (metadata === null || typeof metadata !== 'object' || Array.isArray(metadata)) {+ throw new Error('Invalid file metadata');+ }+ delete update.metadata;+ for (const [key, value] of Object.entries(metadata)) {+ if (key.includes('.') || key.startsWith('$')) throw new Error('Invalid file metadata key');+ if (key === 'embeddedEntities') {+ if (value === undefined) continue;+ if (!Array.isArray(value) || value.some((id) => typeof id !== 'string' || !id)) {+ throw new Error('Invalid file embedding snapshot');+ }+ owners = value;+ } else {+ update[`metadata.${key}`] = value;+ }+ }+ }+ return {+ $set: update,+ ...(owners?.length ? { $addToSet: { 'metadata.embeddedEntities': { $each: owners } } } : {}),+ };+}diff --git a/packages/data-schemas/src/methods/fileStorage.ts b/packages/data-schemas/src/methods/fileStorage.tsindex cb266de52a..a72bbbb7ec 100644--- a/packages/data-schemas/src/methods/fileStorage.ts+++ b/packages/data-schemas/src/methods/fileStorage.ts@@ -6,6 +6,8 @@ import type {IMongoFile,} from '~/types/file';+import { fileContentUpdate } from './fileContent';+function claimFilter(data: FileStorageClaim): FilterQuery<IMongoFile> {if (typeof data.file_id !== 'string' ||@@ -94,6 +96,11 @@ export function createFileStorageMethods(mongoose: typeof import('mongoose')): {}if (data.embedded === true) update.embedded = true;if (Object.keys(update).length === 0) throw new Error('Missing provisioning result');+ const content = fileContentUpdate(update);+ if (data.entityId) {+ const owners = content.$addToSet?.['metadata.embeddedEntities']?.$each ?? [];+ content.$addToSet = { 'metadata.embeddedEntities': { $each: [...owners, data.entityId] } };+ }const result = await File.updateOne({...claimFilter(data.claim),@@ -110,8 +117,7 @@ export function createFileStorageMethods(mongoose: typeof import('mongoose')): {: {}),},{- $set: update,- ...(data.entityId ? { $addToSet: { 'metadata.embeddedEntities': data.entityId } } : {}),+ ...content,$unset: { expiresAt: '' },},);diff --git a/packages/data-schemas/src/schema/file.ts b/packages/data-schemas/src/schema/file.tsindex e4cb53f57f..42b9e11f8a 100644--- a/packages/data-schemas/src/schema/file.ts+++ b/packages/data-schemas/src/schema/file.ts@@ -75,6 +75,15 @@ const file: Schema<IMongoFile> = new Schema(embedded: {type: Boolean,},+ embeddingOwnersTrackedAt: {+ type: Date,+ default: undefined,+ immutable: true,+ },+ embeddingOwnersComplete: {+ type: Boolean,+ default: undefined,+ },type: {type: String,required: true,diff --git a/packages/data-schemas/src/types/file.ts b/packages/data-schemas/src/types/file.tsindex 0a2ecf4017..90ec08a9ad 100644--- a/packages/data-schemas/src/types/file.ts+++ b/packages/data-schemas/src/types/file.ts@@ -201,6 +201,9 @@ export interface IMongoFile extends Omit<Document, 'model'> {};object: 'file';embedded?: boolean;+ /** Absent on legacy records, including partially adopted namespace lists. */+ embeddingOwnersComplete?: boolean;+ embeddingOwnersTrackedAt?: Date;type: string;context?: string;usage: number;