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: Contain Conversation Import and Upload Failures (#15681)

Dustin Healy037cbf530de3
diff --git a/api/server/routes/__test-utils__/convos-route-mocks.js b/api/server/routes/__test-utils__/convos-route-mocks.js
index 9c6ddc2aef..579e64656a 100644
--- a/api/server/routes/__test-utils__/convos-route-mocks.js
+++ b/api/server/routes/__test-utils__/convos-route-mocks.js
@@ -106,6 +106,7 @@ module.exports = {
deleteConvoSharedLinksWithCleanup: jest.fn(),
deleteAllSharedLinksWithCleanup: jest.fn(),
deleteAgentCheckpoints: jest.fn(),
+ isConversationImportError: jest.fn((error) => error?.name === 'ConversationImportError'),
...overrides,
}),
diff --git a/api/server/routes/__tests__/convos.spec.js b/api/server/routes/__tests__/convos.spec.js
index 620d9c1f54..b17bf098dd 100644
--- a/api/server/routes/__tests__/convos.spec.js
+++ b/api/server/routes/__tests__/convos.spec.js
@@ -271,6 +271,36 @@ describe('Convos Routes', () => {
const { logger } = require('@librechat/data-schemas');
expect(logger.error).not.toHaveBeenCalled();
});
+
+ it('returns an actionable client error for an oversized imported record', async () => {
+ const message = 'Each imported conversation or message must be at most 16711680 bytes';
+ const error = Object.assign(new Error(message), {
+ name: 'ConversationImportError',
+ code: 'invalid_request',
+ statusCode: 413,
+ body: { error: 'invalid_request', message },
+ });
+ importConversations.mockRejectedValue(error);
+
+ const response = await request(app).post('/api/convos/import');
+
+ expect(response.status).toBe(413);
+ expect(response.body).toEqual(error.body);
+ const { logger } = require('@librechat/data-schemas');
+ expect(logger.error).not.toHaveBeenCalled();
+ });
+
+ it('preserves the generic server error contract for other import failures', async () => {
+ const error = new Error('invalid JSON');
+ importConversations.mockRejectedValue(error);
+
+ const response = await request(app).post('/api/convos/import');
+
+ expect(response.status).toBe(500);
+ expect(response.text).toBe('Error processing file');
+ const { logger } = require('@librechat/data-schemas');
+ expect(logger.error).toHaveBeenCalledWith('Error processing file', error);
+ });
});
describe('POST /fork', () => {
@@ -327,6 +357,27 @@ describe('Convos Routes', () => {
expect(response.body).toEqual(error.body);
expect(JSON.stringify(response.body)).not.toContain('PRIVATE-SENTINEL');
});
+
+ it('returns an actionable client error when a cloned record is oversized', async () => {
+ const message = 'Each imported conversation or message must be at most 16711680 bytes';
+ const error = Object.assign(new Error(message), {
+ name: 'ConversationImportError',
+ code: 'invalid_request',
+ statusCode: 413,
+ body: { error: 'invalid_request', message },
+ });
+ forkConversation.mockRejectedValue(error);
+
+ const response = await request(app).post('/api/convos/fork').send({
+ conversationId: 'source-convo',
+ messageId: 'source-message',
+ });
+
+ expect(response.status).toBe(413);
+ expect(response.body).toEqual(error.body);
+ const { logger } = require('@librechat/data-schemas');
+ expect(logger.error).not.toHaveBeenCalled();
+ });
});
describe('POST /duplicate', () => {
@@ -382,6 +433,26 @@ describe('Convos Routes', () => {
expect(response.body).toEqual(error.body);
expect(JSON.stringify(response.body)).not.toContain('PRIVATE-SENTINEL');
});
+
+ it('returns an actionable client error when a cloned record is oversized', async () => {
+ const message = 'Each imported conversation or message must be at most 16711680 bytes';
+ const error = Object.assign(new Error(message), {
+ name: 'ConversationImportError',
+ code: 'invalid_request',
+ statusCode: 413,
+ body: { error: 'invalid_request', message },
+ });
+ duplicateConversation.mockRejectedValue(error);
+
+ const response = await request(app)
+ .post('/api/convos/duplicate')
+ .send({ conversationId: 'source-convo' });
+
+ expect(response.status).toBe(413);
+ expect(response.body).toEqual(error.body);
+ const { logger } = require('@librechat/data-schemas');
+ expect(logger.error).not.toHaveBeenCalled();
+ });
});
describe('DELETE /all', () => {
diff --git a/api/server/routes/__tests__/share.spec.js b/api/server/routes/__tests__/share.spec.js
index 2998ab8750..c8aa9833e3 100644
--- a/api/server/routes/__tests__/share.spec.js
+++ b/api/server/routes/__tests__/share.spec.js
@@ -112,6 +112,7 @@ jest.mock('@librechat/api', () => ({
(error) =>
error?.code === 'content_filter_block' || error?.code === 'content_filter_uninspectable',
),
+ isConversationImportError: jest.fn((error) => error?.name === 'ConversationImportError'),
}));
jest.mock('@librechat/data-schemas', () => ({
@@ -1529,6 +1530,23 @@ describe('share fork route', () => {
expect(response.status).toBe(500);
});
+ it('returns an actionable client error when a cloned record is oversized', async () => {
+ const message = 'Each imported conversation or message must be at most 16711680 bytes';
+ const error = Object.assign(new Error(message), {
+ name: 'ConversationImportError',
+ code: 'invalid_request',
+ statusCode: 413,
+ body: { error: 'invalid_request', message },
+ });
+ forkSharedConversation.mockRejectedValue(error);
+
+ const response = await request(buildApp()).post('/api/share/share-123/fork');
+
+ expect(response.status).toBe(413);
+ expect(response.body).toEqual(error.body);
+ expect(logger.error).not.toHaveBeenCalled();
+ });
+
it('answers 409 when the viewer forks a payload the owner has republished', async () => {
const conflict = new Error('Shared link was updated');
conflict.code = 'SHARE_REVISION_MISMATCH';
diff --git a/api/server/routes/convos.js b/api/server/routes/convos.js
index ef2de837d2..4bbd4f4adf 100644
--- a/api/server/routes/convos.js
+++ b/api/server/routes/convos.js
@@ -19,6 +19,7 @@ const {
inspectContent,
createContentFilter,
isContentFilterError,
+ isConversationImportError,
contentFilterBlockResponse,
extractConversationTitleContent,
extractStoredMessageContent,
@@ -741,6 +742,9 @@ router.post(
if (isContentFilterError(error)) {
return res.status(error.statusCode).json(error.body);
}
+ if (isConversationImportError(error)) {
+ return res.status(error.statusCode).json(error.body);
+ }
logger.error('Error processing file', error);
res.status(500).send('Error processing file');
}
@@ -778,6 +782,9 @@ router.post('/fork', forkIpLimiter, forkUserLimiter, configMiddleware, async (re
if (isContentFilterError(error)) {
return res.status(error.statusCode).json(error.body);
}
+ if (isConversationImportError(error)) {
+ return res.status(error.statusCode).json(error.body);
+ }
logger.error('Error forking conversation:', error);
res.status(500).send('Error forking conversation');
}
@@ -807,6 +814,9 @@ router.post(
if (isContentFilterError(error)) {
return res.status(error.statusCode).json(error.body);
}
+ if (isConversationImportError(error)) {
+ return res.status(error.statusCode).json(error.body);
+ }
logger.error('Error duplicating conversation:', error);
res.status(500).send('Error duplicating conversation');
}
diff --git a/api/server/routes/files/multer.js b/api/server/routes/files/multer.js
index 835bba56f2..023619c579 100644
--- a/api/server/routes/files/multer.js
+++ b/api/server/routes/files/multer.js
@@ -3,6 +3,7 @@ const path = require('path');
const crypto = require('crypto');
const multer = require('multer');
const { sanitizeFilename, createCustomError } = require('@librechat/api');
+const { logger } = require('@librechat/data-schemas');
const {
mergeFileConfig,
inferMimeType,
@@ -16,14 +17,27 @@ const createStorage = ({ uniqueTempPath = false } = {}) =>
destination: function (req, file, cb) {
const appConfig = req.config;
const outputPath = path.join(appConfig.paths.uploads, 'temp', req.user.id);
- if (!fs.existsSync(outputPath)) {
- fs.mkdirSync(outputPath, { recursive: true });
+ try {
+ if (!fs.existsSync(outputPath)) {
+ fs.mkdirSync(outputPath, { recursive: true });
+ }
+ } catch (error) {
+ logger.error(
+ `Failed to prepare upload directory: ${error instanceof Error ? error.message : String(error)}`,
+ );
+ const uploadError = createCustomError(500, 'Failed to prepare upload directory');
+ uploadError.cause = error;
+ return cb(uploadError);
}
cb(null, outputPath);
},
filename: function (req, file, cb) {
req.file_id = crypto.randomUUID();
- file.originalname = decodeURIComponent(file.originalname);
+ try {
+ file.originalname = decodeURIComponent(file.originalname);
+ } catch {
+ return cb(createCustomError(400, 'Invalid filename encoding'));
+ }
const sanitizedFilename = sanitizeFilename(file.originalname);
const stagedFilename = uniqueTempPath
? sanitizeFilename(`${req.file_id}-${sanitizedFilename}`)
diff --git a/api/server/routes/files/multer.spec.js b/api/server/routes/files/multer.spec.js
index 368edbe72d..1c186dc745 100644
--- a/api/server/routes/files/multer.spec.js
+++ b/api/server/routes/files/multer.spec.js
@@ -4,6 +4,11 @@ const fs = require('fs');
const os = require('os');
const path = require('path');
const crypto = require('crypto');
+const multer = require('multer');
+const express = require('express');
+const request = require('supertest');
+const { ErrorController } = require('@librechat/api');
+const { logger } = require('@librechat/data-schemas');
const {
createMulterInstance,
createStorage,
@@ -121,6 +126,19 @@ describe('Multer Configuration', () => {
storage.getFilename(mockReq, encodedFile, cb);
});
+ it('returns a controlled error for malformed URI encoding', (done) => {
+ const malformedFile = { ...mockFile, originalname: '%.json' };
+
+ storage.getFilename(mockReq, malformedFile, (err, filename) => {
+ expect(err).toMatchObject({
+ statusCode: 400,
+ body: { message: 'Invalid filename encoding' },
+ });
+ expect(filename).toBeUndefined();
+ done();
+ });
+ });
+
it('should call real sanitizeFilename with properly encoded filename', (done) => {
// Test with a properly URI-encoded filename that needs sanitization
const unsafeFile = {
@@ -573,15 +591,63 @@ describe('Multer Configuration', () => {
}).not.toThrow();
});
- it('should handle file system errors when directory creation fails', () => {
- // Test with a non-existent parent directory to simulate fs issues
- const invalidPath = '/nonexistent/path/that/should/not/exist';
- mockReq.config.paths.uploads = invalidPath;
+ it('should report file system errors through the storage callback', (done) => {
+ const loggerError = jest.spyOn(logger, 'error').mockImplementation();
+ const filesystemError = new Error('permission denied');
+ const mkdir = jest.spyOn(fs, 'mkdirSync').mockImplementationOnce(() => {
+ throw filesystemError;
+ });
- // The current implementation doesn't catch errors, so they're thrown synchronously
- expect(() => {
- storage.getDestination(mockReq, mockFile, jest.fn());
- }).toThrow();
+ storage.getDestination(mockReq, mockFile, (err, destination) => {
+ expect(err).toMatchObject({
+ statusCode: 500,
+ body: { message: 'Failed to prepare upload directory' },
+ cause: filesystemError,
+ });
+ expect(destination).toBeUndefined();
+ expect(loggerError).toHaveBeenCalledWith(
+ 'Failed to prepare upload directory: permission denied',
+ );
+ mkdir.mockRestore();
+ loggerError.mockRestore();
+ done();
+ });
+ });
+
+ it('keeps the upload server alive after rejecting a malformed filename', async () => {
+ const app = express();
+ const upload = multer({ storage });
+ app.use((req, res, next) => {
+ req.user = mockReq.user;
+ req.config = mockReq.config;
+ next();
+ });
+ app.post('/upload', upload.single('file'), (req, res) => {
+ res.status(201).json({
+ originalname: req.file.originalname,
+ filename: req.file.filename,
+ });
+ });
+ app.use(ErrorController);
+
+ const malformed = await request(app).post('/upload').attach('file', Buffer.from('{}'), {
+ filename: '%.json',
+ contentType: 'application/json',
+ });
+
+ expect(malformed.status).toBe(400);
+ expect(malformed.body).toEqual({ message: 'Invalid filename encoding' });
+ const outputPath = path.join(tempDir, 'temp', 'test-user-123');
+ expect(fs.readdirSync(outputPath)).toEqual([]);
+
+ const healthy = await request(app).post('/upload').attach('file', Buffer.from('{}'), {
+ filename: 'healthy%20upload.json',
+ contentType: 'application/json',
+ });
+
+ expect(healthy.status).toBe(201);
+ expect(healthy.body.originalname).toBe('healthy upload.json');
+ expect(fs.existsSync(path.join(outputPath, healthy.body.filename))).toBe(true);
});
it('should handle malformed filenames with real sanitization', (done) => {
diff --git a/api/server/routes/share.js b/api/server/routes/share.js
index 95298114a0..9ff04aba33 100644
--- a/api/server/routes/share.js
+++ b/api/server/routes/share.js
@@ -5,6 +5,7 @@ const {
createShareContentPreflight,
isEnabled,
isContentFilterError,
+ isConversationImportError,
generateCheckAccess,
grantCreationPermissions,
ensureLinkPermissions,
@@ -439,6 +440,9 @@ if (allowSharedLinks) {
if (isContentFilterError(error)) {
return res.status(error.statusCode).json(error.body);
}
+ if (isConversationImportError(error)) {
+ return res.status(error.statusCode).json(error.body);
+ }
if (error?.code !== 'SHARE_REVISION_MISMATCH') {
logger.error('Error forking shared conversation:', error);
}
diff --git a/api/server/utils/import/importBatchBuilder.js b/api/server/utils/import/importBatchBuilder.js
index 40d59ac857..dc46b991d9 100644
--- a/api/server/utils/import/importBatchBuilder.js
+++ b/api/server/utils/import/importBatchBuilder.js
@@ -1,9 +1,12 @@
const { v4: uuidv4 } = require('uuid');
const {
+ assertConversationImportWriteSize,
assertModelBoundContent,
assertConversationImportContentAllowed,
+ executeConversationImportWrites,
} = require('@librechat/api');
const {
+ getTenantId,
logger,
createFallbackRetentionDate,
createTempChatExpirationDate,
@@ -14,7 +17,14 @@ const {
RetentionMode,
openAISettings,
} = require('librechat-data-provider');
-const { bulkIncrementTagCounts, bulkSaveConvos, bulkSaveMessages, getFiles } = require('~/models');
+const {
+ bulkIncrementTagCounts,
+ bulkSaveConvos,
+ bulkSaveMessages,
+ deleteImportedConversations,
+ deleteImportedMessages,
+ getFiles,
+} = require('~/models');
const { FALLBACK_MODEL_BY_ENDPOINT } = require('./defaults');
/**
@@ -177,6 +187,13 @@ class ImportBatchBuilder {
* @throws {Error} If there is an error saving the batch.
*/
async saveBatch() {
+ const tenantId = getTenantId();
+ assertConversationImportWriteSize({
+ conversations: this.conversations,
+ messages: this.messages,
+ ...(tenantId == null ? {} : { tenantId }),
+ });
+
await assertConversationContentAllowed(
this.filters,
{
@@ -190,17 +207,26 @@ class ImportBatchBuilder {
},
);
+ const conversationIds = this.conversations.map((convo) => convo.conversationId);
+ const cleanupScope = {
+ user: this.requestUserId,
+ conversationIds,
+ ...(tenantId == null ? {} : { tenantId }),
+ };
+ const tags = this.conversations.flatMap((convo) => convo.tags);
+
try {
- const promises = [];
- promises.push(bulkSaveConvos(this.conversations));
- promises.push(bulkSaveMessages(this.messages, true));
- promises.push(
- bulkIncrementTagCounts(
- this.requestUserId,
- this.conversations.flatMap((convo) => convo.tags),
- ),
- );
- await Promise.all(promises);
+ await executeConversationImportWrites({
+ saveConversations: () => bulkSaveConvos(this.conversations),
+ saveMessages: () => bulkSaveMessages(this.messages, true),
+ updateTagCounts: () => bulkIncrementTagCounts(this.requestUserId, tags),
+ deleteMessages: () => deleteImportedMessages(cleanupScope),
+ deleteConversations: () => deleteImportedConversations(cleanupScope),
+ onTagCountError: (error) =>
+ logger.error(`Error updating imported tag counts: ${error.message}`),
+ onCleanupError: (error, resource) =>
+ logger.error(`Error cleaning imported ${resource}: ${error.message}`),
+ });
logger.debug(
`user: ${this.requestUserId} | Added ${this.conversations.length} conversations and ${this.messages.length} messages to the DB.`,
);
diff --git a/api/server/utils/import/importBatchBuilder.spec.js b/api/server/utils/import/importBatchBuilder.spec.js
index 27ae83ca09..f14ad5fd49 100644
--- a/api/server/utils/import/importBatchBuilder.spec.js
+++ b/api/server/utils/import/importBatchBuilder.spec.js
@@ -10,18 +10,28 @@ jest.mock('@librechat/api', () => ({
const {
ContentFilterError,
+ MAX_CONVERSATION_IMPORT_DOCUMENT_BYTES,
contentFilterBlockResponse,
extractConversationImportContent,
inspectContent,
} = require('@librechat/api');
const { EModelEndpoint } = require('librechat-data-provider');
-const { bulkIncrementTagCounts, bulkSaveConvos, bulkSaveMessages, getFiles } = require('~/models');
+const {
+ bulkIncrementTagCounts,
+ bulkSaveConvos,
+ bulkSaveMessages,
+ deleteImportedConversations,
+ deleteImportedMessages,
+ getFiles,
+} = require('~/models');
const { ImportBatchBuilder } = require('./importBatchBuilder');
jest.mock('~/models', () => ({
bulkIncrementTagCounts: jest.fn(),
bulkSaveConvos: jest.fn(),
bulkSaveMessages: jest.fn(),
+ deleteImportedConversations: jest.fn(),
+ deleteImportedMessages: jest.fn(),
getFiles: jest.fn(),
}));
@@ -70,6 +80,8 @@ describe('ImportBatchBuilder content filtering', () => {
bulkIncrementTagCounts.mockResolvedValue();
bulkSaveConvos.mockResolvedValue();
bulkSaveMessages.mockResolvedValue();
+ deleteImportedConversations.mockResolvedValue();
+ deleteImportedMessages.mockResolvedValue();
getFiles.mockResolvedValue([]);
});
@@ -257,6 +269,38 @@ describe('ImportBatchBuilder content filtering', () => {
expect(bulkIncrementTagCounts).toHaveBeenCalledTimes(1);
});
+ it('rejects an oversized conversation before starting any bulk write', async () => {
+ const builder = createBuilder(undefined);
+ builder.conversations[0].title = 'x'.repeat(16 * 1024 * 1024);
+
+ await expect(builder.saveBatch()).rejects.toThrow(
+ `at most ${MAX_CONVERSATION_IMPORT_DOCUMENT_BYTES} bytes`,
+ );
+
+ expect(bulkSaveConvos).not.toHaveBeenCalled();
+ expect(bulkSaveMessages).not.toHaveBeenCalled();
+ expect(bulkIncrementTagCounts).not.toHaveBeenCalled();
+ });
+
+ it('cleans only the generated owner scope when a message write fails', async () => {
+ const builder = createBuilder(undefined);
+ const writeError = new Error('message write failed');
+ bulkSaveMessages.mockRejectedValueOnce(writeError);
+
+ await expect(builder.saveBatch()).rejects.toBe(writeError);
+
+ const scope = {
+ user: 'user-123',
+ conversationIds: [builder.conversations[0].conversationId],
+ };
+ expect(deleteImportedMessages).toHaveBeenCalledWith(scope);
+ expect(deleteImportedConversations).toHaveBeenCalledWith(scope);
+ expect(bulkSaveConvos.mock.invocationCallOrder[0]).toBeLessThan(
+ bulkSaveMessages.mock.invocationCallOrder[0],
+ );
+ expect(bulkIncrementTagCounts).not.toHaveBeenCalled();
+ });
+
it('blocks opaque imported content before starting any bulk write', async () => {
const opaqueValue = 'data:image/png;base64,IMPORT-OPAQUE-DO-NOT-ECHO';
const builder = createBuilder(
diff --git a/api/server/utils/import/importConversations.database.spec.js b/api/server/utils/import/importConversations.database.spec.js
new file mode 100644
index 0000000000..833a0c935b
--- /dev/null
+++ b/api/server/utils/import/importConversations.database.spec.js
@@ -0,0 +1,123 @@
+const fs = require('fs').promises;
+const os = require('os');
+const path = require('path');
+const mongoose = require('mongoose');
+const { MongoMemoryServer } = require('mongodb-memory-server');
+const { createModels, runAsSystem, tenantStorage } = require('@librechat/data-schemas');
+const {
+ MAX_CONVERSATION_IMPORT_BSON_BYTES,
+ MAX_CONVERSATION_IMPORT_DOCUMENT_BYTES,
+} = require('@librechat/api');
+const { Constants, EModelEndpoint } = require('librechat-data-provider');
+
+jest.mock('~/server/services/Config', () => ({
+ getEndpointsConfig: jest.fn().mockResolvedValue({
+ openAI: { userProvide: false },
+ }),
+}));
+
+jest.mock('~/server/controllers/ModelController', () => ({
+ getModelsConfig: jest.fn().mockResolvedValue({
+ openAI: ['gpt-4o'],
+ }),
+}));
+
+createModels(mongoose);
+const importConversations = require('./importConversations');
+
+describe('importConversations database hardening', () => {
+ let mongoServer;
+ let tempDir;
+
+ beforeAll(async () => {
+ mongoServer = await MongoMemoryServer.create();
+ await mongoose.connect(mongoServer.getUri());
+ });
+
+ beforeEach(async () => {
+ tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'librechat-import-database-'));
+ await mongoose.connection.dropDatabase();
+ });
+
+ afterEach(async () => {
+ if (tempDir) {
+ await fs.rm(tempDir, { recursive: true, force: true });
+ }
+ });
+
+ afterAll(async () => {
+ await mongoose.disconnect();
+ if (mongoServer) {
+ await mongoServer.stop();
+ }
+ });
+
+ it('round-trips an existing browser export for its owner and tenant', async () => {
+ const filepath = path.join(tempDir, 'browser-export.json');
+ const fixture = path.join(__dirname, '__data__', 'librechat-export.json');
+ const owner = 'browser-import-user';
+ const tenantId = 'browser-tenant';
+ await fs.copyFile(fixture, filepath);
+
+ await tenantStorage.run({ tenantId, userId: owner }, async () => {
+ await importConversations({ filepath, requestUserId: owner, userRole: 'USER' });
+ });
+
+ await expect(fs.stat(filepath)).rejects.toMatchObject({ code: 'ENOENT' });
+ const persisted = await runAsSystem(async () => {
+ const conversations = await mongoose.models.Conversation.find({ user: owner }).lean();
+ const messages = await mongoose.models.Message.find({ user: owner }).lean();
+ return { conversations, messages };
+ });
+ expect(persisted.conversations).toHaveLength(1);
+ expect(persisted.conversations[0]).toMatchObject({
+ user: owner,
+ tenantId,
+ title: 'Conversation 1. Web Search',
+ });
+ expect(persisted.messages).toHaveLength(6);
+ expect(persisted.messages.every((message) => message.tenantId === tenantId)).toBe(true);
+ });
+
+ it('rejects an oversized BSON record before persisting any part of a browser import', async () => {
+ const filepath = path.join(tempDir, 'oversized-conversation.json');
+ const owner = 'browser-import-user';
+ const tenantId = 'browser-tenant';
+ await fs.writeFile(
+ filepath,
+ JSON.stringify({
+ conversationId: 'source-conversation',
+ endpoint: EModelEndpoint.openAI,
+ title: 'x'.repeat(MAX_CONVERSATION_IMPORT_BSON_BYTES),
+ options: { endpoint: EModelEndpoint.openAI, model: 'gpt-4o' },
+ messages: [
+ {
+ messageId: 'source-message',
+ conversationId: 'source-conversation',
+ parentMessageId: Constants.NO_PARENT,
+ sender: 'User',
+ text: 'Hello',
+ isCreatedByUser: true,
+ },
+ ],
+ }),
+ 'utf8',
+ );
+
+ await expect(
+ tenantStorage.run({ tenantId, userId: owner }, async () =>
+ importConversations({ filepath, requestUserId: owner, userRole: 'USER' }),
+ ),
+ ).rejects.toThrow(`at most ${MAX_CONVERSATION_IMPORT_DOCUMENT_BYTES} bytes`);
+
+ await new Promise((resolve) => setTimeout(resolve, 100));
+ await expect(fs.stat(filepath)).rejects.toMatchObject({ code: 'ENOENT' });
+ const persisted = await runAsSystem(async () => {
+ const conversations = await mongoose.models.Conversation.find({ user: owner }).lean();
+ const messages = await mongoose.models.Message.find({ user: owner }).lean();
+ return { conversations, messages };
+ });
+ expect(persisted.conversations).toEqual([]);
+ expect(persisted.messages).toEqual([]);
+ });
+});
diff --git a/packages/api/src/conversations/import.spec.ts b/packages/api/src/conversations/import.spec.ts
new file mode 100644
index 0000000000..4d0bfc70f6
--- /dev/null
+++ b/packages/api/src/conversations/import.spec.ts
@@ -0,0 +1,172 @@
+import {
+ MAX_CONVERSATION_IMPORT_BSON_BYTES,
+ MAX_CONVERSATION_IMPORT_DOCUMENT_BYTES,
+ ConversationImportError,
+ assertConversationImportWriteSize,
+ executeConversationImportWrites,
+ isConversationImportError,
+} from './import';
+
+describe('conversation import writes', () => {
+ it('rejects a document too close to the MongoDB BSON limit before writes begin', () => {
+ let thrown: Error | undefined;
+ try {
+ assertConversationImportWriteSize({
+ conversations: [
+ {
+ user: 'authenticated-user',
+ conversationId: 'generated-conversation',
+ title: 'x'.repeat(MAX_CONVERSATION_IMPORT_BSON_BYTES),
+ },
+ ],
+ messages: [],
+ tenantId: 'tenant-a',
+ });
+ } catch (error) {
+ if (error instanceof Error) {
+ thrown = error;
+ }
+ }
+ expect(thrown).toBeInstanceOf(ConversationImportError);
+ expect(thrown).toMatchObject({
+ code: 'invalid_request',
+ statusCode: 413,
+ message: `Each imported conversation or message must be at most ${MAX_CONVERSATION_IMPORT_DOCUMENT_BYTES} bytes`,
+ body: {
+ error: 'invalid_request',
+ message: `Each imported conversation or message must be at most ${MAX_CONVERSATION_IMPORT_DOCUMENT_BYTES} bytes`,
+ },
+ });
+ expect(isConversationImportError(thrown)).toBe(true);
+
+ expect(() =>
+ assertConversationImportWriteSize({
+ conversations: [{ conversationId: 'generated-conversation', title: 'Imported' }],
+ messages: [{ conversationId: 'generated-conversation', text: 'Hello' }],
+ }),
+ ).not.toThrow();
+ });
+
+ it('compensates a partial conversation write before rethrowing its error', async () => {
+ const order: string[] = [];
+ const writeError = new Error('conversation write failed');
+
+ await expect(
+ executeConversationImportWrites({
+ saveConversations: jest.fn(async () => {
+ order.push('save conversations');
+ throw writeError;
+ }),
+ saveMessages: jest.fn(async () => {
+ order.push('save messages');
+ }),
+ updateTagCounts: jest.fn(async () => {
+ order.push('update tags');
+ }),
+ deleteMessages: jest.fn(async () => {
+ order.push('delete messages');
+ }),
+ deleteConversations: jest.fn(async () => {
+ order.push('delete conversations');
+ }),
+ }),
+ ).rejects.toBe(writeError);
+
+ expect(order).toEqual(['save conversations', 'delete messages', 'delete conversations']);
+ });
+
+ it('compensates partial messages before removing their conversation', async () => {
+ const order: string[] = [];
+ const writeError = new Error('message write failed');
+
+ await expect(
+ executeConversationImportWrites({
+ saveConversations: jest.fn(async () => {
+ order.push('save conversations');
+ }),
+ saveMessages: jest.fn(async () => {
+ order.push('save messages');
+ throw writeError;
+ }),
+ updateTagCounts: jest.fn(async () => {
+ order.push('update tags');
+ }),
+ deleteMessages: jest.fn(async () => {
+ order.push('delete messages');
+ }),
+ deleteConversations: jest.fn(async () => {
+ order.push('delete conversations');
+ }),
+ }),
+ ).rejects.toBe(writeError);
+
+ expect(order).toEqual([
+ 'save conversations',
+ 'save messages',
+ 'delete messages',
+ 'delete conversations',
+ ]);
+ });
+
+ it('keeps the conversation discoverable when message cleanup fails', async () => {
+ const writeError = new Error('message write failed');
+ const cleanupError = new Error('message cleanup failed');
+ const deleteConversations = jest.fn().mockResolvedValue(undefined);
+ const onCleanupError = jest.fn();
+
+ await expect(
+ executeConversationImportWrites({
+ saveConversations: jest.fn().mockResolvedValue(undefined),
+ saveMessages: jest.fn().mockRejectedValue(writeError),
+ updateTagCounts: jest.fn().mockResolvedValue(undefined),
+ deleteMessages: jest.fn().mockRejectedValue(cleanupError),
+ deleteConversations,
+ onCleanupError,
+ }),
+ ).rejects.toBe(writeError);
+
+ expect(deleteConversations).not.toHaveBeenCalled();
+ expect(onCleanupError).toHaveBeenCalledWith(cleanupError, 'messages');
+ });
+
+ it('reports failed conversation cleanup without replacing the write error', async () => {
+ const writeError = new Error('message write failed');
+ const cleanupError = new Error('conversation cleanup failed');
+ const onCleanupError = jest.fn();
+
+ await expect(
+ executeConversationImportWrites({
+ saveConversations: jest.fn().mockResolvedValue(undefined),
+ saveMessages: jest.fn().mockRejectedValue(writeError),
+ updateTagCounts: jest.fn().mockResolvedValue(undefined),
+ deleteMessages: jest.fn().mockResolvedValue(undefined),
+ deleteConversations: jest.fn().mockRejectedValue(cleanupError),
+ onCleanupError,
+ }),
+ ).rejects.toBe(writeError);
+
+ expect(onCleanupError).toHaveBeenCalledWith(cleanupError, 'conversations');
+ });
+
+ it('keeps the completed import when derived tag count refresh fails', async () => {
+ const tagError = new Error('tag count failed');
+ const onTagCountError = jest.fn();
+ const deleteMessages = jest.fn().mockResolvedValue(undefined);
+ const deleteConversations = jest.fn().mockResolvedValue(undefined);
+
+ await expect(
+ executeConversationImportWrites({
+ saveConversations: jest.fn().mockResolvedValue(undefined),
+ saveMessages: jest.fn().mockResolvedValue(undefined),
+ updateTagCounts: jest.fn().mockRejectedValue(tagError),
+ deleteMessages,
+ deleteConversations,
+ onTagCountError,
+ }),
+ ).resolves.toBeUndefined();
+
+ expect(deleteMessages).not.toHaveBeenCalled();
+ expect(deleteConversations).not.toHaveBeenCalled();
+ expect(onTagCountError).toHaveBeenCalledWith(tagError);
+ });
+});
diff --git a/packages/api/src/conversations/import.ts b/packages/api/src/conversations/import.ts
new file mode 100644
index 0000000000..ebfef1ea97
--- /dev/null
+++ b/packages/api/src/conversations/import.ts
@@ -0,0 +1,122 @@
+import { BSON, ObjectId } from 'mongodb';
+
+import type { Document } from 'mongodb';
+
+export const MAX_CONVERSATION_IMPORT_BSON_BYTES: number = 16 * 1024 * 1024;
+export const CONVERSATION_IMPORT_BSON_HEADROOM_BYTES: number = 64 * 1024;
+export const MAX_CONVERSATION_IMPORT_DOCUMENT_BYTES: number =
+ MAX_CONVERSATION_IMPORT_BSON_BYTES - CONVERSATION_IMPORT_BSON_HEADROOM_BYTES;
+
+export interface ConversationImportWriteBatch {
+ conversations: readonly Document[];
+ messages: readonly Document[];
+ tenantId?: string;
+}
+
+export interface ConversationImportWriteOperations {
+ saveConversations: () => Promise<void>;
+ saveMessages: () => Promise<void>;
+ updateTagCounts: () => Promise<void>;
+ deleteMessages: () => Promise<void>;
+ deleteConversations: () => Promise<void>;
+ onTagCountError?: (error: Error) => void;
+ onCleanupError?: (error: Error, resource: 'messages' | 'conversations') => void;
+}
+
+export class ConversationImportError extends Error {
+ readonly code = 'invalid_request';
+ readonly statusCode: number;
+ readonly body: { error: 'invalid_request'; message: string };
+
+ constructor(message: string, statusCode: number, options?: ErrorOptions) {
+ super(message, options);
+ this.name = 'ConversationImportError';
+ this.statusCode = statusCode;
+ this.body = { error: 'invalid_request', message };
+ }
+}
+
+function importWriteError(
+ message: string,
+ statusCode: number,
+ cause?: unknown,
+): ConversationImportError {
+ return new ConversationImportError(
+ message,
+ statusCode,
+ cause === undefined ? undefined : { cause },
+ );
+}
+
+export function isConversationImportError(error: unknown): error is ConversationImportError {
+ return error instanceof ConversationImportError;
+}
+
+export function assertConversationImportWriteSize(batch: ConversationImportWriteBatch): void {
+ const assertDocumentSize = (document: Document): void => {
+ let size: number;
+ try {
+ size = BSON.calculateObjectSize({
+ ...document,
+ _id: new ObjectId(),
+ __v: 0,
+ ...(batch.tenantId == null ? {} : { tenantId: batch.tenantId }),
+ });
+ } catch (error) {
+ throw importWriteError('An imported conversation or message cannot be stored', 400, error);
+ }
+ if (size > MAX_CONVERSATION_IMPORT_DOCUMENT_BYTES) {
+ throw importWriteError(
+ `Each imported conversation or message must be at most ${MAX_CONVERSATION_IMPORT_DOCUMENT_BYTES} bytes`,
+ 413,
+ );
+ }
+ };
+ for (const conversation of batch.conversations) {
+ assertDocumentSize(conversation);
+ }
+ for (const message of batch.messages) {
+ assertDocumentSize(message);
+ }
+}
+
+export async function executeConversationImportWrites(
+ operations: ConversationImportWriteOperations,
+): Promise<void> {
+ try {
+ await operations.saveConversations();
+ await operations.saveMessages();
+ } catch (error) {
+ try {
+ await operations.deleteMessages();
+ } catch (cleanupError) {
+ operations.onCleanupError?.(
+ cleanupError instanceof Error
+ ? cleanupError
+ : new Error('Failed to clean imported messages'),
+ 'messages',
+ );
+ throw error;
+ }
+
+ try {
+ await operations.deleteConversations();
+ } catch (cleanupError) {
+ operations.onCleanupError?.(
+ cleanupError instanceof Error
+ ? cleanupError
+ : new Error('Failed to clean imported conversations'),
+ 'conversations',
+ );
+ }
+ throw error;
+ }
+
+ try {
+ await operations.updateTagCounts();
+ } catch (error) {
+ operations.onTagCountError?.(
+ error instanceof Error ? error : new Error('Failed to update imported tag counts'),
+ );
+ }
+}
diff --git a/packages/api/src/conversations/index.ts b/packages/api/src/conversations/index.ts
index 993afe633e..0795f87e5d 100644
--- a/packages/api/src/conversations/index.ts
+++ b/packages/api/src/conversations/index.ts
@@ -1 +1,2 @@
export * from './archive';
+export * from './import';
diff --git a/packages/data-schemas/src/methods/import.spec.ts b/packages/data-schemas/src/methods/import.spec.ts
new file mode 100644
index 0000000000..b83f25bbb8
--- /dev/null
+++ b/packages/data-schemas/src/methods/import.spec.ts
@@ -0,0 +1,190 @@
+import mongoose from 'mongoose';
+import { MongoMemoryServer } from 'mongodb-memory-server';
+import { CONVERSATION_IMPORT_CLEANUP_CHUNK_SIZE, createConversationImportMethods } from './import';
+import { runAsSystem, tenantStorage } from '~/config/tenantContext';
+import { createModels } from '~/models';
+import { createMethods } from './index';
+
+createModels(mongoose);
+
+describe('conversation import cleanup methods', () => {
+ let mongoServer: MongoMemoryServer;
+
+ beforeAll(async () => {
+ mongoServer = await MongoMemoryServer.create();
+ await mongoose.connect(mongoServer.getUri());
+ });
+
+ beforeEach(async () => {
+ await mongoose.connection.dropDatabase();
+ });
+
+ afterAll(async () => {
+ await mongoose.disconnect();
+ await mongoServer.stop();
+ });
+
+ it('removes only the generated IDs for the authenticated owner and tenant', async () => {
+ const methods = createMethods(mongoose);
+ const project = await tenantStorage.run({ tenantId: 'tenant-a', userId: 'owner-a' }, async () =>
+ methods.createChatProject('owner-a', { name: 'Imported chats' }),
+ );
+ const chatProjectId = project._id!.toString();
+ const target = {
+ user: 'owner-a',
+ conversationId: 'generated-target',
+ tenantId: 'tenant-a',
+ chatProjectId,
+ };
+ const records = [
+ target,
+ { ...target, conversationId: 'untouched-id' },
+ { ...target, user: 'owner-b' },
+ { ...target, tenantId: 'tenant-b' },
+ ];
+
+ await runAsSystem(async () => {
+ await mongoose.models.Conversation.insertMany(
+ records.map((record) => ({
+ ...record,
+ endpoint: 'openAI',
+ title: record.conversationId,
+ createdAt: new Date(
+ record.conversationId === target.conversationId
+ ? '2026-02-01T00:00:00.000Z'
+ : '2026-01-01T00:00:00.000Z',
+ ),
+ updatedAt: new Date(
+ record.conversationId === target.conversationId
+ ? '2026-02-01T00:00:00.000Z'
+ : '2026-01-01T00:00:00.000Z',
+ ),
+ })),
+ );
+ await mongoose.models.Message.insertMany(
+ records.map((record, index) => ({
+ ...record,
+ messageId: `message-${index}`,
+ parentMessageId: '00000000-0000-0000-0000-000000000000',
+ text: record.conversationId,
+ })),
+ );
+ await mongoose.models.ChatProject.updateOne(
+ { _id: project._id },
+ {
+ $set: {
+ conversationCount: 2,
+ lastConversationAt: new Date('2026-02-01T00:00:00.000Z'),
+ lastConversationId: target.conversationId,
+ },
+ },
+ );
+ });
+
+ await tenantStorage.run({ tenantId: target.tenantId, userId: target.user }, async () => {
+ const scope = {
+ user: target.user,
+ conversationIds: [target.conversationId],
+ tenantId: target.tenantId,
+ };
+ await methods.deleteImportedMessages(scope);
+ await methods.deleteImportedConversations(scope);
+ });
+
+ const remaining = await runAsSystem(async () => {
+ const conversations = await mongoose.models.Conversation.find({}).lean();
+ const messages = await mongoose.models.Message.find({}).lean();
+ const refreshedProject = await mongoose.models.ChatProject.findById(project._id).lean();
+ return { conversations, messages, refreshedProject };
+ });
+ expect(remaining.conversations).toHaveLength(3);
+ expect(remaining.messages).toHaveLength(3);
+ expect(
+ remaining.conversations.some(
+ (record) =>
+ record.user === target.user &&
+ record.tenantId === target.tenantId &&
+ record.conversationId === target.conversationId,
+ ),
+ ).toBe(false);
+ expect(
+ remaining.messages.some(
+ (record) =>
+ record.user === target.user &&
+ record.tenantId === target.tenantId &&
+ record.conversationId === target.conversationId,
+ ),
+ ).toBe(false);
+ expect(remaining.refreshedProject).toMatchObject({
+ conversationCount: 1,
+ lastConversationId: 'untouched-id',
+ });
+ });
+
+ it('requires an absent tenant field for tenantless cleanup', async () => {
+ const methods = createMethods(mongoose);
+ const base = { user: 'owner-a', conversationId: 'generated-target' };
+ await runAsSystem(async () => {
+ await mongoose.models.Conversation.insertMany([
+ { ...base, endpoint: 'openAI', title: 'tenantless' },
+ { ...base, endpoint: 'openAI', tenantId: 'tenant-a', title: 'tenant' },
+ ]);
+ await mongoose.models.Message.insertMany([
+ { ...base, messageId: 'tenantless-message', text: 'tenantless' },
+ { ...base, tenantId: 'tenant-a', messageId: 'tenant-message', text: 'tenant' },
+ ]);
+ });
+
+ await methods.deleteImportedMessages({
+ user: base.user,
+ conversationIds: [base.conversationId],
+ });
+ await methods.deleteImportedConversations({
+ user: base.user,
+ conversationIds: [base.conversationId],
+ });
+
+ const remaining = await runAsSystem(async () => ({
+ conversations: await mongoose.models.Conversation.find({}).lean(),
+ messages: await mongoose.models.Message.find({}).lean(),
+ }));
+ expect(remaining.conversations).toHaveLength(1);
+ expect(remaining.conversations[0].tenantId).toBe('tenant-a');
+ expect(remaining.messages).toHaveLength(1);
+ expect(remaining.messages[0].tenantId).toBe('tenant-a');
+ });
+
+ it('chunks every cleanup query while retaining its exact owner and tenant scope', async () => {
+ const deleteMessages = jest.fn().mockResolvedValue(undefined);
+ const findProjects = jest.fn().mockResolvedValue([]);
+ const deleteConversations = jest.fn().mockResolvedValue(undefined);
+ const cleanupMongoose = {
+ models: {
+ Message: { deleteMany: deleteMessages },
+ Conversation: { distinct: findProjects, deleteMany: deleteConversations },
+ },
+ } as unknown as typeof mongoose;
+ const methods = createConversationImportMethods(cleanupMongoose);
+ const conversationIds = Array.from(
+ { length: CONVERSATION_IMPORT_CLEANUP_CHUNK_SIZE * 2 + 1 },
+ (_, index) => `generated-${index}`,
+ );
+ const scope = { user: 'owner-a', tenantId: 'tenant-a', conversationIds };
+
+ await methods.deleteImportedMessages(scope);
+ await methods.deleteImportedConversations(scope);
+
+ for (const cleanupMock of [deleteMessages, findProjects, deleteConversations]) {
+ expect(cleanupMock).toHaveBeenCalledTimes(3);
+ const filters = cleanupMock.mock.calls.map((call) => call.at(-1));
+ expect(filters.flatMap((filter) => filter.conversationId.$in)).toEqual(conversationIds);
+ expect(filters.every((filter) => filter.user === scope.user)).toBe(true);
+ expect(filters.every((filter) => filter.tenantId === scope.tenantId)).toBe(true);
+ expect(
+ filters.every(
+ (filter) => filter.conversationId.$in.length <= CONVERSATION_IMPORT_CLEANUP_CHUNK_SIZE,
+ ),
+ ).toBe(true);
+ }
+ });
+});
diff --git a/packages/data-schemas/src/methods/import.ts b/packages/data-schemas/src/methods/import.ts
new file mode 100644
index 0000000000..7f2b6c4cad
--- /dev/null
+++ b/packages/data-schemas/src/methods/import.ts
@@ -0,0 +1,91 @@
+import type { FilterQuery, Model } from 'mongoose';
+import type { IConversation, IMessage } from '~/types';
+import { runAsSystem, tenantStorage } from '~/config/tenantContext';
+import { refreshChatProjectStatsForUser } from './chatProject';
+
+export interface ConversationImportCleanupScope {
+ user: string;
+ conversationIds: readonly string[];
+ tenantId?: string;
+}
+
+export interface ConversationImportMethods {
+ deleteImportedMessages(scope: ConversationImportCleanupScope): Promise<void>;
+ deleteImportedConversations(scope: ConversationImportCleanupScope): Promise<void>;
+}
+
+/** Keeps generated UUID arrays well below MongoDB's 16 MiB command limit. */
+export const CONVERSATION_IMPORT_CLEANUP_CHUNK_SIZE = 10_000;
+
+function createImportCleanupFilter<T>(
+ scope: ConversationImportCleanupScope,
+ conversationIds: readonly string[],
+): FilterQuery<T> {
+ return {
+ user: scope.user,
+ conversationId: { $in: conversationIds },
+ ...(scope.tenantId == null ? { tenantId: { $exists: false } } : { tenantId: scope.tenantId }),
+ };
+}
+
+function chunkConversationIds(conversationIds: readonly string[]): string[][] {
+ const chunks: string[][] = [];
+ for (
+ let index = 0;
+ index < conversationIds.length;
+ index += CONVERSATION_IMPORT_CLEANUP_CHUNK_SIZE
+ ) {
+ chunks.push(conversationIds.slice(index, index + CONVERSATION_IMPORT_CLEANUP_CHUNK_SIZE));
+ }
+ return chunks;
+}
+
+export function createConversationImportMethods(
+ mongoose: typeof import('mongoose'),
+): ConversationImportMethods {
+ async function deleteImportedMessages(scope: ConversationImportCleanupScope): Promise<void> {
+ if (scope.conversationIds.length === 0) {
+ return;
+ }
+ const Message = mongoose.models.Message as Model<IMessage>;
+ await runAsSystem(async () => {
+ for (const conversationIds of chunkConversationIds(scope.conversationIds)) {
+ await Message.deleteMany(createImportCleanupFilter<IMessage>(scope, conversationIds));
+ }
+ });
+ }
+
+ async function deleteImportedConversations(scope: ConversationImportCleanupScope): Promise<void> {
+ if (scope.conversationIds.length === 0) {
+ return;
+ }
+ const Conversation = mongoose.models.Conversation as Model<IConversation>;
+ const projectIds = await runAsSystem(async () => {
+ const affectedProjectIds = new Set<string>();
+ for (const conversationIds of chunkConversationIds(scope.conversationIds)) {
+ const filter = createImportCleanupFilter<IConversation>(scope, conversationIds);
+ const affectedProjects = await Conversation.distinct('chatProjectId', filter);
+ for (const projectId of affectedProjects) {
+ if (projectId) {
+ affectedProjectIds.add(String(projectId));
+ }
+ }
+ await Conversation.deleteMany(filter);
+ }
+ return [...affectedProjectIds];
+ });
+ const context = tenantStorage.getStore();
+ await tenantStorage.run(
+ { ...context, tenantId: scope.tenantId, userId: scope.user },
+ async () => {
+ await Promise.all(
+ projectIds.map((projectId) =>
+ refreshChatProjectStatsForUser(mongoose, scope.user, projectId),
+ ),
+ );
+ },
+ );
+ }
+
+ return { deleteImportedMessages, deleteImportedConversations };
+}
diff --git a/packages/data-schemas/src/methods/index.ts b/packages/data-schemas/src/methods/index.ts
index c1bf4e35e3..1bf484ed40 100644
--- a/packages/data-schemas/src/methods/index.ts
+++ b/packages/data-schemas/src/methods/index.ts
@@ -58,6 +58,7 @@ import { createCategoriesMethods, type CategoriesMethods } from './categories';
import { createPresetMethods, type PresetMethods } from './preset';
/* Tier 2 — Moderate (service deps injected) */
import { createConversationTagMethods, type ConversationTagMethods } from './conversationTag';
+import { createConversationImportMethods, type ConversationImportMethods } from './import';
import {
createMessageMethods,
CLIENT_MESSAGE_SELECT,
@@ -232,6 +233,7 @@ export type AllMethods = UserMethods &
CategoriesMethods &
PresetMethods &
ConversationTagMethods &
+ ConversationImportMethods &
MessageMethods &
ConversationMethods &
ChatProjectMethods &
@@ -454,6 +456,7 @@ export function createMethods(
...createPresetMethods(mongoose),
/* Tier 2 */
...createConversationTagMethods(mongoose),
+ ...createConversationImportMethods(mongoose),
...messageMethods,
...conversationMethods,
...createChatProjectMethods(mongoose),
@@ -508,6 +511,7 @@ export type {
CategoriesMethods,
PresetMethods,
ConversationTagMethods,
+ ConversationImportMethods,
MessageMethods,
ParentSubagentTaskRecord,
ParentSubagentThreadRecord,