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: 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.js
index 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.js
index 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.js
index 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 DB
const { 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 describing
diff --git a/api/server/services/Files/process.spec.js b/api/server/services/Files/process.spec.js
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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 }: LocalFileDelet
return 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 }: LocalFileDelet
if (!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 }: LocalFileDelet
const 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 }: LocalFileDelet
if (!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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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): FileConf
mergedConfig.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.ts
index 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.ts
new file mode 100644
index 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.ts
index 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.ts
index 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.ts
index 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.ts
new file mode 100644
index 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.ts
index 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.ts
index 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.ts
index 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;