const express = require('express'); const request = require('supertest'); const MOCKS = '../__test-utils__/convos-route-mocks'; jest.mock('~/server/services/Config/app', () => ({ getAppConfig: jest.fn() })); const { archiveAllHandler, generationJobManager, moderateText, moderatedTexts, messageIpLimiter, messageUserLimiter, subagentActivityHandlerInputs, checkpointRows, resetCheckpointRows, } = require(MOCKS); const priorLimitMessageIp = process.env.LIMIT_MESSAGE_IP; const priorLimitMessageUser = process.env.LIMIT_MESSAGE_USER; process.env.LIMIT_MESSAGE_IP = 'true'; process.env.LIMIT_MESSAGE_USER = 'true'; const checkpointNamespace = (id) => `${require(MOCKS).ownerPrefix('test-user-123')}00000000-0000-4000-8000-${String(id).padStart(12, '0')}`; jest.mock('@librechat/agents', () => require(MOCKS).agents()); jest.mock('@librechat/api', () => require(MOCKS).api({ createContentFilter: jest.fn((options) => (req, res, next) => { const extracted = [...options.extract(req)]; if (JSON.stringify(extracted).includes('BLOCK-CONTROL')) { return res.status(400).json({ error: 'content_filter_block' }); } next(); }), extractStoredMessageContent: jest.fn((input) => [input]), inspectContent: jest.fn(() => null), extractConversationTitleContent: jest.fn(() => []), contentFilterBlockResponse: jest.fn(), isContentFilterError: jest.fn((error) => error?.code === 'content_filter_block'), }), ); jest.mock('@librechat/data-schemas', () => require(MOCKS).dataSchemas()); jest.mock('librechat-data-provider', () => require(MOCKS).dataProvider()); jest.mock('~/models', () => require(MOCKS).sharedModels()); jest.mock('~/server/services/Config', () => require(MOCKS).appConfig()); jest.mock('~/server/middleware/requireJwtAuth', () => require(MOCKS).requireJwtAuth()); jest.mock('~/server/middleware', () => require(MOCKS).middlewarePassthrough()); jest.mock('~/server/utils/import/fork', () => require(MOCKS).forkUtils()); jest.mock('~/server/utils/import', () => require(MOCKS).importUtils()); jest.mock('~/cache/getLogStores', () => require(MOCKS).logStores()); jest.mock('~/server/routes/files/multer', () => require(MOCKS).multerSetup()); jest.mock('multer', () => require(MOCKS).multerLib()); jest.mock('~/server/services/Endpoints/azureAssistants', () => require(MOCKS).assistantEndpoint()); jest.mock('~/server/services/Endpoints/assistants', () => require(MOCKS).assistantEndpoint()); jest.mock('~/server/services/Endpoints/agents/subagentThreadStore', () => require(MOCKS).subagentThreadStore(), ); jest.mock('~/server/services/Endpoints/agents/backgroundCompletion', () => ({ pendingBackgroundToolCompletions: { list: jest.fn() }, })); describe('Convos Routes', () => { let app; let convosRouter; const { deleteToolCalls, deleteConvos, deleteMessages, getConvo, saveConvo, markConvoSeen, markConvoUnread, } = require('~/models'); const { deleteOwnedAgentCheckpoints, deleteAllSharedLinksWithCleanup, deleteConvoSharedLinksWithCleanup, } = require('@librechat/api'); const subagentThreadStore = require('~/server/services/Endpoints/agents/subagentThreadStore'); beforeAll(() => { convosRouter = require('../convos'); app = express(); app.use(express.json()); /** Mock authenticated user */ app.use((req, res, next) => { req.user = { id: 'test-user-123', role: 'USER' }; const tenantId = req.get('x-test-tenant'); if (tenantId) { req.user.tenantId = tenantId; } req.config = { messageFilter: { pii: { starterPatterns: ['sk_prefix'], }, }, filters: { messages: { pii: { fields: ['text'], starterPatterns: ['sk_prefix'], }, }, }, }; next(); }); app.use('/api/convos', convosRouter); }); afterAll(() => { if (priorLimitMessageIp == null) delete process.env.LIMIT_MESSAGE_IP; else process.env.LIMIT_MESSAGE_IP = priorLimitMessageIp; if (priorLimitMessageUser == null) delete process.env.LIMIT_MESSAGE_USER; else process.env.LIMIT_MESSAGE_USER = priorLimitMessageUser; }); beforeEach(() => { jest.clearAllMocks(); moderatedTexts.length = 0; generationJobManager.getCleanupJob.mockResolvedValue(null); generationJobManager.abortJob.mockResolvedValue({ success: true }); generationJobManager.getCleanupBlockingJobIdsForUser.mockResolvedValue([]); generationJobManager.getCleanupBlockingJobIdsForConversations.mockResolvedValue([]); resetCheckpointRows(); }); it('binds the activity subscription adapter to the subagent task store', () => { const binding = subagentActivityHandlerInputs.at(-1); const subscriber = { onEvent: jest.fn() }; binding.stream.subscribe('child-thread', 'task-1', subscriber); expect(subagentThreadStore.subscribeActivity).toHaveBeenCalledWith( 'child-thread', 'task-1', subscriber, ); }); it('filters and moderates subagent guidance as ordinary user text before control handling', async () => { const response = await request(app).post('/api/convos/parent/subagents/child/control').send({ taskId: 'task-1', invocationId: 'invocation-1', action: 'queue', message: 'Guide the child.', }); expect(response.status).toBe(200); expect(messageIpLimiter).toHaveBeenCalledTimes(1); expect(messageUserLimiter).toHaveBeenCalledTimes(1); expect(moderateText).toHaveBeenCalledTimes(1); expect(moderatedTexts).toEqual(['Guide the child.']); moderateText.mockClear(); moderatedTexts.length = 0; const blocked = await request(app).post('/api/convos/parent/subagents/child/control').send({ taskId: 'task-1', invocationId: 'invocation-2', action: 'interrupt', message: 'BLOCK-CONTROL', }); expect(blocked.status).toBe(400); expect(blocked.body).toEqual({ error: 'content_filter_block' }); expect(moderateText).not.toHaveBeenCalled(); moderateText.mockClear(); const oversized = await request(app) .post('/api/convos/parent/subagents/child/control') .send({ taskId: 'task-1', invocationId: 'invocation-3', action: 'queue', message: 'x'.repeat(4 * 1024 + 1), }); expect(oversized.status).toBe(400); expect(oversized.body).toEqual({ error: 'Invalid subagent control request' }); expect(moderateText).not.toHaveBeenCalled(); const cancelled = await request(app).post('/api/convos/parent/subagents/child/control').send({ taskId: 'task-1', invocationId: 'invocation-4', action: 'cancel', }); expect(cancelled.status).toBe(200); expect(moderateText).not.toHaveBeenCalled(); const crafted = await request(app) .post('/api/convos/parent/subagents/child/control') .send({ taskId: 'task-1', invocationId: 'invocation-5', action: 'queue', message: 'Use only this bounded guidance.', answers: ['This unrelated field must not reach moderation.'], }); expect(crafted.status).toBe(400); expect(crafted.body).toEqual({ error: 'Invalid subagent control request' }); expect(moderateText).not.toHaveBeenCalled(); }); describe('GET /:conversationId', () => { it('returns an ordinary owned conversation', async () => { getConvo.mockResolvedValue({ conversationId: 'ordinary', title: 'Ordinary' }); const response = await request(app).get('/api/convos/ordinary'); expect(response.status).toBe(200); expect(response.body).toEqual({ conversationId: 'ordinary', title: 'Ordinary' }); expect(getConvo).toHaveBeenCalledWith('test-user-123', 'ordinary'); }); it('returns the same not-found response for an owned child thread', async () => { getConvo.mockResolvedValue({ conversationId: 'child', subagentThread: { parentConversationId: 'parent' }, }); const childResponse = await request(app).get('/api/convos/child'); getConvo.mockResolvedValue(null); const missingResponse = await request(app).get('/api/convos/missing'); expect(childResponse.status).toBe(404); expect(childResponse.text).toBe(''); expect(childResponse.status).toBe(missingResponse.status); expect(childResponse.text).toBe(missingResponse.text); expect(getConvo).toHaveBeenNthCalledWith(1, 'test-user-123', 'child'); }); }); describe('GET /:conversationId/pull-request', () => { it('is registered and reaches the pull request handler', async () => { const response = await request(app).get('/api/convos/ordinary/pull-request'); expect(response.status).toBe(200); expect(response.body).toEqual({ pullRequest: null }); }); it('does not fall through to the conversation read', async () => { await request(app).get('/api/convos/ordinary/pull-request'); expect(getConvo).not.toHaveBeenCalled(); }); }); describe('POST /import', () => { const { importConversations } = require('~/server/utils/import'); it('passes source-aware filters into conversation import', async () => { importConversations.mockResolvedValue(); const response = await request(app).post('/api/convos/import'); expect(response.status).toBe(201); expect(importConversations).toHaveBeenCalledWith({ filepath: '/tmp/test-file.json', requestUserId: 'test-user-123', userRole: 'USER', interfaceConfig: undefined, filters: { messages: { pii: { fields: ['text'], starterPatterns: ['sk_prefix'], }, }, }, legacyPii: { starterPatterns: ['sk_prefix'], }, }); }); it('returns only metadata-safe filter details for a blocked import', async () => { const error = Object.assign(new Error('blocked'), { code: 'content_filter_block', statusCode: 400, body: { error: 'content_filter_block', message: 'Submitted content contains a restricted value. Remove it and try again.', source: 'message', field: 'text', }, }); importConversations.mockRejectedValue(error); const response = await request(app).post('/api/convos/import'); expect(response.status).toBe(400); expect(response.body).toEqual(error.body); expect(response.body).not.toHaveProperty('detectorId'); expect(response.body).not.toHaveProperty('ruleId'); expect(response.body).not.toHaveProperty('fragmentPath'); 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', () => { const { forkConversation } = require('~/server/utils/import/fork'); it('passes source-aware filters into the fork preflight', async () => { forkConversation.mockResolvedValue({ conversation: { conversationId: 'forked-convo' } }); const response = await request(app).post('/api/convos/fork').send({ conversationId: 'source-convo', messageId: 'source-message', }); expect(response.status).toBe(200); expect(forkConversation).toHaveBeenCalledWith( expect.objectContaining({ requestUserId: 'test-user-123', originalConvoId: 'source-convo', targetMessageId: 'source-message', filters: { messages: { pii: { fields: ['text'], starterPatterns: ['sk_prefix'], }, }, }, legacyPii: { starterPatterns: ['sk_prefix'], }, }), ); }); it('forwards excludeFiles only when it is exactly true', async () => { forkConversation.mockResolvedValue({ conversation: { conversationId: 'forked-convo' } }); await request(app).post('/api/convos/fork').send({ conversationId: 'source-convo', messageId: 'source-message', excludeFiles: true, }); await request(app).post('/api/convos/fork').send({ conversationId: 'source-convo', messageId: 'source-message', excludeFiles: 'true', }); expect(forkConversation).toHaveBeenNthCalledWith( 1, expect.objectContaining({ excludeFiles: true }), ); expect(forkConversation).toHaveBeenNthCalledWith( 2, expect.objectContaining({ excludeFiles: false }), ); }); it('returns a raw-free 400 when cloned content is blocked', async () => { const error = Object.assign(new Error('PRIVATE-SENTINEL'), { code: 'content_filter_block', statusCode: 400, body: { error: 'content_filter_block', message: 'Submitted content contains a restricted value. Remove it and try again.', source: 'message', field: 'text', }, }); forkConversation.mockRejectedValue(error); const response = await request(app).post('/api/convos/fork').send({ conversationId: 'source-convo', messageId: 'source-message', }); expect(response.status).toBe(400); 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', () => { const { duplicateConversation } = require('~/server/utils/import/fork'); it('passes source-aware filters into the duplicate preflight', async () => { duplicateConversation.mockResolvedValue({ conversation: { conversationId: 'duplicated-convo' }, }); const response = await request(app) .post('/api/convos/duplicate') .send({ conversationId: 'source-convo' }); expect(response.status).toBe(201); expect(duplicateConversation).toHaveBeenCalledWith( expect.objectContaining({ userId: 'test-user-123', conversationId: 'source-convo', filters: { messages: { pii: { fields: ['text'], starterPatterns: ['sk_prefix'], }, }, }, legacyPii: { starterPatterns: ['sk_prefix'], }, }), ); }); it('returns a raw-free 400 when cloned content is blocked', async () => { const error = Object.assign(new Error('PRIVATE-SENTINEL'), { code: 'content_filter_block', statusCode: 400, body: { error: 'content_filter_block', message: 'Submitted content contains a restricted value. Remove it and try again.', source: 'message', field: 'text', }, }); duplicateConversation.mockRejectedValue(error); const response = await request(app) .post('/api/convos/duplicate') .send({ conversationId: 'source-convo' }); expect(response.status).toBe(400); 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', () => { it('prunes the deleted conversations’ owned generation checkpoint scopes', async () => { // Generation-scoped checkpoints are removed eagerly after their ownership is proven. const conversationIds = ['conv-a', 'conv-b']; deleteConvos.mockImplementation(async (_userId, _filter, options) => { await options.beforeDelete?.(conversationIds); return { deletedCount: 2, conversationIds }; }); deleteToolCalls.mockResolvedValue({ deletedCount: 0 }); deleteAllSharedLinksWithCleanup.mockResolvedValue({ deletedCount: 0 }); generationJobManager.getCleanupJob.mockImplementation(async (conversationId) => ({ metadata: { userId: 'test-user-123', conversationId, checkpointNamespace: checkpointNamespace(conversationId === 'conv-a' ? 1 : 2), generationProtocolVersion: 2, }, status: 'complete', createdAt: Date.now(), })); const response = await request(app).delete('/api/convos/all'); expect(response.status).toBe(201); expect(deleteOwnedAgentCheckpoints).toHaveBeenCalledWith( 'test-user-123', undefined, undefined, undefined, ); /** The deletion runs inside the owner admission fence, not around it. */ expect(subagentThreadStore.withOwnerDeletionFence).toHaveBeenCalledTimes(1); const [fencedUserId, fencedTenantId] = subagentThreadStore.withOwnerDeletionFence.mock.calls[0]; expect(fencedUserId).toBe('test-user-123'); expect(fencedTenantId).toBeUndefined(); expect(subagentThreadStore.cancelAndDrainForOwner).not.toHaveBeenCalled(); }); it('drains a paused event actor after owner-wide deletion removes its conversation', async () => { const createdAt = Date.now(); generationJobManager.getCleanupBlockingJobIdsForUser.mockResolvedValue([ 'paused-event-child', ]); deleteConvos.mockResolvedValue({ deletedCount: 1, conversationIds: ['paused-event-child'], }); generationJobManager.getCleanupJob.mockImplementation(async (conversationId) => conversationId === 'paused-event-child' ? { metadata: { userId: 'test-user-123' }, status: 'requires_action', createdAt, } : null, ); const response = await request(app).delete('/api/convos/all'); expect(response.status).toBe(201); expect(generationJobManager.abortJob).toHaveBeenCalledWith('paused-event-child', { expectedCreatedAt: createdAt, awaitProviderDrain: true, }); }); it('drains every owner remote run before selecting the delete-all snapshot', async () => { const createdAt = Date.now(); generationJobManager.getCleanupBlockingJobIdsForUser.mockResolvedValue([ 'resp-new-conversation', ]); generationJobManager.getCleanupJob.mockImplementation(async (streamId) => streamId === 'resp-new-conversation' ? { conversationId: 'conversation-not-yet-persisted', metadata: { userId: 'test-user-123' }, status: 'running', createdAt, } : null, ); deleteConvos.mockResolvedValue({ deletedCount: 1, conversationIds: ['conversation-not-yet-persisted'], }); const response = await request(app).delete('/api/convos/all'); expect(response.status).toBe(201); expect(generationJobManager.getCleanupBlockingJobIdsForUser).toHaveBeenCalledWith( 'test-user-123', undefined, ); expect(generationJobManager.abortJob).toHaveBeenCalledWith('resp-new-conversation', { expectedCreatedAt: createdAt, awaitProviderDrain: true, }); expect(generationJobManager.abortJob.mock.invocationCallOrder[0]).toBeLessThan( deleteConvos.mock.invocationCallOrder[0], ); }); it('re-drains and removes persistence created during a recovered owner-fence gap', async () => { const createdAt = Date.now(); generationJobManager.getCleanupBlockingJobIdsForUser .mockResolvedValueOnce([]) .mockResolvedValueOnce(['resp-gap']); generationJobManager.getCleanupJob.mockImplementation(async (streamId) => streamId === 'resp-gap' ? { metadata: { userId: 'test-user-123', conversationId: 'gap-conversation', checkpointNamespace: checkpointNamespace(3), generationProtocolVersion: 2, }, status: 'running', createdAt, } : null, ); deleteConvos .mockResolvedValueOnce({ deletedCount: 1, conversationIds: ['original'] }) .mockImplementationOnce(async (_userId, _filter, options) => { expect(options).toEqual( expect.objectContaining({ allowEmpty: true, beforeDelete: expect.any(Function) }), ); await options.beforeDelete?.(['gap-conversation']); return { deletedCount: 1, conversationIds: ['gap-conversation'] }; }); subagentThreadStore.withOwnerDeletionFence.mockImplementationOnce( async (_userId, _tenantId, deletion, recover) => { const result = await deletion(); await recover(); return result; }, ); const response = await request(app).delete('/api/convos/all'); expect(response.status).toBe(201); expect(generationJobManager.abortJob).toHaveBeenCalledWith('resp-gap', { expectedCreatedAt: createdAt, awaitProviderDrain: true, }); expect( deleteConvos.mock.calls.filter(([, filter]) => Object.keys(filter).length === 0), ).toHaveLength(2); expect(deleteMessages).toHaveBeenCalledWith({ user: 'test-user-123' }); expect(deleteOwnedAgentCheckpoints).toHaveBeenCalledWith( 'test-user-123', undefined, undefined, undefined, ); }); it('retries owner message cleanup after conversations were already removed', async () => { deleteConvos .mockResolvedValueOnce({ deletedCount: 1, conversationIds: ['original'] }) .mockResolvedValueOnce({ deletedCount: 0, conversationIds: [] }); deleteMessages .mockRejectedValueOnce(new Error('message database unavailable')) .mockResolvedValueOnce({ deletedCount: 1 }); const first = await request(app).delete('/api/convos/all'); const retry = await request(app).delete('/api/convos/all'); expect(first.status).toBe(500); expect(retry.status).toBe(201); expect(deleteOwnedAgentCheckpoints).toHaveBeenCalledWith( 'test-user-123', undefined, undefined, undefined, ); expect(deleteConvos).toHaveBeenCalledWith( 'test-user-123', {}, expect.objectContaining({ allowEmpty: true }), ); expect(deleteMessages).toHaveBeenLastCalledWith({ user: 'test-user-123' }); }); it('should delete all conversations, tool calls, and shared links for a user', async () => { const mockDbResponse = { deletedCount: 5, message: 'All conversations deleted successfully', }; deleteConvos.mockResolvedValue(mockDbResponse); deleteToolCalls.mockResolvedValue({ deletedCount: 10 }); deleteAllSharedLinksWithCleanup.mockResolvedValue({ message: 'All shared links deleted successfully', deletedCount: 3, }); const response = await request(app).delete('/api/convos/all'); expect(response.status).toBe(201); expect(response.body).toMatchObject(mockDbResponse); /** Verify deleteConvos was called with correct userId */ expect(deleteConvos).toHaveBeenCalledWith( 'test-user-123', {}, expect.objectContaining({ beforeDelete: expect.any(Function) }), ); expect(deleteConvos).toHaveBeenCalledTimes(1); /** Verify deleteToolCalls was called with correct userId */ expect(deleteToolCalls).toHaveBeenCalledWith('test-user-123'); expect(deleteToolCalls).toHaveBeenCalledTimes(1); /** Verify deleteAllSharedLinksWithCleanup was called with correct userId */ expect(deleteAllSharedLinksWithCleanup).toHaveBeenCalledWith('test-user-123'); expect(deleteAllSharedLinksWithCleanup).toHaveBeenCalledTimes(1); }); it('should call deleteAllSharedLinksWithCleanup even when no conversations exist', async () => { const mockDbResponse = { deletedCount: 0, message: 'No conversations to delete', }; deleteConvos.mockResolvedValue(mockDbResponse); deleteToolCalls.mockResolvedValue({ deletedCount: 0 }); deleteAllSharedLinksWithCleanup.mockResolvedValue({ message: 'All shared links deleted successfully', deletedCount: 0, }); const response = await request(app).delete('/api/convos/all'); expect(response.status).toBe(201); expect(deleteAllSharedLinksWithCleanup).toHaveBeenCalledWith('test-user-123'); }); it('should return 500 if deleteConvos fails', async () => { const errorMessage = 'Database connection error'; deleteConvos.mockRejectedValue(new Error(errorMessage)); const response = await request(app).delete('/api/convos/all'); expect(response.status).toBe(500); expect(response.text).toBe('Error clearing conversations'); /** Verify error was logged */ const { logger } = require('@librechat/data-schemas'); expect(logger.error).toHaveBeenCalledWith('Error clearing conversations', expect.any(Error)); }); it('does not delete conversations when cross-replica task draining fails', async () => { /** Draining happens inside the admission fence, so its failure fails the fence. */ subagentThreadStore.withOwnerDeletionFence.mockRejectedValueOnce( new Error('task owner unavailable'), ); const response = await request(app).delete('/api/convos/all'); expect(response.status).toBe(500); expect(deleteConvos).not.toHaveBeenCalled(); expect(deleteOwnedAgentCheckpoints).not.toHaveBeenCalled(); expect(deleteToolCalls).not.toHaveBeenCalled(); expect(deleteAllSharedLinksWithCleanup).not.toHaveBeenCalled(); }); it('should return 500 if deleteToolCalls fails', async () => { deleteConvos.mockResolvedValue({ deletedCount: 5 }); deleteToolCalls.mockRejectedValue(new Error('Tool calls deletion failed')); const response = await request(app).delete('/api/convos/all'); expect(response.status).toBe(500); expect(response.text).toBe('Error clearing conversations'); }); it('should return 500 if deleteAllSharedLinksWithCleanup fails', async () => { deleteConvos.mockResolvedValue({ deletedCount: 5 }); deleteToolCalls.mockResolvedValue({ deletedCount: 10 }); deleteAllSharedLinksWithCleanup.mockRejectedValue(new Error('Shared links deletion failed')); const response = await request(app).delete('/api/convos/all'); expect(response.status).toBe(500); expect(response.text).toBe('Error clearing conversations'); }); it('should handle multiple users independently', async () => { /** First user */ deleteConvos.mockResolvedValue({ deletedCount: 3 }); deleteToolCalls.mockResolvedValue({ deletedCount: 5 }); deleteAllSharedLinksWithCleanup.mockResolvedValue({ deletedCount: 2 }); let response = await request(app).delete('/api/convos/all'); expect(response.status).toBe(201); expect(deleteAllSharedLinksWithCleanup).toHaveBeenCalledWith('test-user-123'); jest.clearAllMocks(); /** Second user (simulate different user by modifying middleware) */ const app2 = express(); app2.use(express.json()); app2.use((req, res, next) => { req.user = { id: 'test-user-456' }; next(); }); app2.use('/api/convos', require('../convos')); deleteConvos.mockResolvedValue({ deletedCount: 7 }); deleteToolCalls.mockResolvedValue({ deletedCount: 12 }); deleteAllSharedLinksWithCleanup.mockResolvedValue({ deletedCount: 4 }); response = await request(app2).delete('/api/convos/all'); expect(response.status).toBe(201); expect(deleteAllSharedLinksWithCleanup).toHaveBeenCalledWith('test-user-456'); }); it('should execute deletions in correct sequence', async () => { const executionOrder = []; deleteConvos.mockImplementation(() => { executionOrder.push('deleteConvos'); return Promise.resolve({ deletedCount: 5 }); }); deleteToolCalls.mockImplementation(() => { executionOrder.push('deleteToolCalls'); return Promise.resolve({ deletedCount: 10 }); }); deleteAllSharedLinksWithCleanup.mockImplementation(() => { executionOrder.push('deleteAllSharedLinksWithCleanup'); return Promise.resolve({ deletedCount: 3 }); }); await request(app).delete('/api/convos/all'); /** Verify all three functions were called */ expect(executionOrder).toEqual([ 'deleteConvos', 'deleteToolCalls', 'deleteAllSharedLinksWithCleanup', ]); }); it('should maintain data integrity by cleaning up shared links when conversations are deleted', async () => { /** This test ensures that orphaned shared links are prevented */ const mockConvosDeleted = { deletedCount: 10 }; const mockToolCallsDeleted = { deletedCount: 15 }; const mockSharedLinksDeleted = { message: 'All shared links deleted successfully', deletedCount: 8, }; deleteConvos.mockResolvedValue(mockConvosDeleted); deleteToolCalls.mockResolvedValue(mockToolCallsDeleted); deleteAllSharedLinksWithCleanup.mockResolvedValue(mockSharedLinksDeleted); const response = await request(app).delete('/api/convos/all'); expect(response.status).toBe(201); /** Verify that shared links cleanup was called for the same user */ expect(deleteAllSharedLinksWithCleanup).toHaveBeenCalledWith('test-user-123'); /** Verify no shared links remain for deleted conversations */ expect(deleteAllSharedLinksWithCleanup).toHaveBeenCalledAfter(deleteConvos); }); }); describe('DELETE /', () => { it('fences the owner when DELETE / is called without a conversation filter', async () => { deleteConvos.mockResolvedValue({ deletedCount: 3, conversationIds: ['a', 'b', 'c'] }); const response = await request(app) .delete('/api/convos') .send({ arg: { thread_id: 'thread-abc' } }); expect(response.status).toBe(201); /** An empty filter deletes everything, so it takes the same admission fence. */ expect(subagentThreadStore.withOwnerDeletionFence).toHaveBeenCalledTimes(1); expect(subagentThreadStore.withOwnerDeletionFence.mock.calls[0][0]).toBe('test-user-123'); expect(subagentThreadStore.cancelAndDrainForOwner).not.toHaveBeenCalled(); expect(deleteConvos).toHaveBeenCalledWith( 'test-user-123', {}, expect.objectContaining({ beforeDelete: expect.any(Function) }), ); expect(subagentThreadStore.withOwnerDeletionFence.mock.calls[0][3]).toEqual( expect.any(Function), ); }); it('drains owner remote runs before the empty-filter deletion snapshot', async () => { const createdAt = Date.now(); generationJobManager.getCleanupBlockingJobIdsForUser.mockResolvedValue(['resp-new']); generationJobManager.getCleanupJob.mockImplementation(async (streamId) => streamId === 'resp-new' ? { metadata: { userId: 'test-user-123' }, status: 'running', createdAt } : null, ); deleteConvos.mockResolvedValue({ deletedCount: 1, conversationIds: ['new-conversation'], }); const response = await request(app) .delete('/api/convos') .send({ arg: { thread_id: 'thread-abc' } }); expect(response.status).toBe(201); expect(generationJobManager.abortJob).toHaveBeenCalledWith('resp-new', { expectedCreatedAt: createdAt, awaitProviderDrain: true, }); expect(generationJobManager.abortJob.mock.invocationCallOrder[0]).toBeLessThan( deleteConvos.mock.invocationCallOrder[0], ); }); it('drains a paused event actor after an empty-filter deletion removes it', async () => { const createdAt = Date.now(); deleteConvos.mockResolvedValue({ deletedCount: 1, conversationIds: ['paused-event-child'], }); generationJobManager.getCleanupJob.mockImplementation(async (conversationId) => conversationId === 'paused-event-child' ? { metadata: { userId: 'test-user-123' }, status: 'requires_action', createdAt, } : null, ); const response = await request(app) .delete('/api/convos') .send({ arg: { thread_id: 'thread-abc' } }); expect(response.status).toBe(201); expect(generationJobManager.abortJob).toHaveBeenCalledWith('paused-event-child', { expectedCreatedAt: createdAt, awaitProviderDrain: true, }); }); it('fails closed before checkpoint pruning when generation lookup stays unavailable', async () => { deleteConvos.mockImplementation(async (_userId, _filter, options) => { await options.beforeDelete?.(['paused-event-child']); return { deletedCount: 1, conversationIds: ['paused-event-child'], }; }); generationJobManager.getCleanupJob.mockRejectedValue( new Error('generation store unavailable'), ); const response = await request(app) .delete('/api/convos') .send({ arg: { thread_id: 'thread-abc' } }); expect(response.status).toBe(500); expect(generationJobManager.getCleanupJob).toHaveBeenCalledTimes(3); expect(deleteOwnedAgentCheckpoints).not.toHaveBeenCalled(); }); it('cancels root and descendant leases and cleans every cascaded conversation', async () => { deleteConvos.mockResolvedValue({ deletedCount: 2, conversationIds: ['parent-conversation', 'child-conversation'], }); deleteToolCalls.mockResolvedValue({ deletedCount: 1 }); deleteConvoSharedLinksWithCleanup.mockResolvedValue({ deletedCount: 1 }); const response = await request(app) .delete('/api/convos') .send({ arg: { conversationId: 'parent-conversation' }, }); expect(response.status).toBe(201); /** The plan is resolved before deletion, while those rows can still be read. */ expect(subagentThreadStore.planCancellationForConversations).toHaveBeenCalledWith( 'test-user-123', ['parent-conversation'], undefined, ); expect( subagentThreadStore.planCancellationForConversations.mock.invocationCallOrder[0], ).toBeLessThan(deleteConvos.mock.invocationCallOrder[0]); /** It is applied once before deletion and replayed after with the cascade. */ expect(subagentThreadStore.cancelPlan).toHaveBeenCalledTimes(2); expect(subagentThreadStore.cancelPlan.mock.calls[0][1]).toBeUndefined(); expect(subagentThreadStore.cancelPlan.mock.calls[1][1]).toEqual([ 'parent-conversation', 'child-conversation', ]); expect(deleteToolCalls.mock.calls.map((call) => call[1])).toEqual([ 'parent-conversation', 'child-conversation', ]); expect(deleteConvoSharedLinksWithCleanup.mock.calls.map((call) => call[1])).toEqual([ 'parent-conversation', 'child-conversation', ]); }); it('drains an active child generation and removes persistence that races deletion', async () => { const createdAt = Date.now(); deleteConvos.mockResolvedValue({ deletedCount: 2, conversationIds: ['parent-conversation', 'child-conversation'], }); generationJobManager.getCleanupJob.mockImplementation(async (conversationId) => conversationId === 'child-conversation' ? { metadata: { userId: 'test-user-123' }, status: 'running', createdAt } : null, ); const response = await request(app) .delete('/api/convos') .send({ arg: { conversationId: 'parent-conversation' } }); expect(response.status).toBe(201); expect(generationJobManager.abortJob).toHaveBeenCalledWith('child-conversation', { expectedCreatedAt: createdAt, awaitProviderDrain: true, }); expect(deleteConvos).toHaveBeenNthCalledWith( 2, 'test-user-123', { conversationId: { $in: ['parent-conversation', 'child-conversation'] } }, expect.objectContaining({ allowEmpty: true }), ); expect(deleteMessages).toHaveBeenCalledWith({ user: 'test-user-123', conversationId: { $in: ['parent-conversation', 'child-conversation'] }, }); }); it('drains response-id runs indexed under a deleted conversation', async () => { const createdAt = Date.now(); generationJobManager.getCleanupBlockingJobIdsForConversations.mockResolvedValue([ 'resp_remote-run', ]); generationJobManager.getCleanupJob.mockImplementation(async (streamId) => streamId === 'resp_remote-run' ? { metadata: { userId: 'test-user-123' }, status: 'running', createdAt } : null, ); deleteConvos.mockImplementationOnce(async (_userId, _filter, options) => { await options.beforeDelete?.(['conversation-1']); return { deletedCount: 1, conversationIds: ['conversation-1'] }; }); const response = await request(app) .delete('/api/convos') .send({ arg: { conversationId: 'conversation-1' } }); expect(response.status).toBe(201); expect(generationJobManager.getCleanupBlockingJobIdsForConversations).toHaveBeenCalledWith( 'test-user-123', ['conversation-1'], undefined, ); expect(generationJobManager.abortJob).toHaveBeenCalledWith('resp_remote-run', { expectedCreatedAt: createdAt, awaitProviderDrain: true, }); }); it('preserves foreign and legacy checkpoints when conversation IDs collide', async () => { const conversationIds = ['conversation-1', 'child-conversation']; const jobs = { 'resp-owned': { metadata: { userId: 'test-user-123', conversationId: 'conversation-1', checkpointNamespace: checkpointNamespace(4), generationProtocolVersion: 2, }, }, 'task-owned-child': { metadata: { userId: 'test-user-123', conversationId: 'child-conversation', checkpointNamespace: checkpointNamespace(5), generationProtocolVersion: 2, }, }, 'resp-foreign-user': { metadata: { userId: 'foreign-user', conversationId: 'conversation-1', checkpointNamespace: 'foreign-user-generation', generationProtocolVersion: 2, }, }, 'resp-foreign-tenant': { metadata: { userId: 'test-user-123', tenantId: 'foreign-tenant', conversationId: 'conversation-1', checkpointNamespace: 'foreign-tenant-generation', generationProtocolVersion: 2, }, }, 'resp-legacy': { metadata: { userId: 'test-user-123', conversationId: 'conversation-1', checkpointNamespace: '', generationProtocolVersion: 1, }, }, }; resetCheckpointRows([ { threadId: 'conversation-1', checkpointNamespace: checkpointNamespace(4) }, { threadId: 'conversation-1', checkpointNamespace: `${checkpointNamespace(4)}|subgraph`, }, { threadId: 'child-conversation', checkpointNamespace: checkpointNamespace(5) }, { threadId: 'conversation-1', checkpointNamespace: 'foreign-user-generation' }, { threadId: 'conversation-1', checkpointNamespace: 'foreign-tenant-generation' }, { threadId: 'conversation-1', checkpointNamespace: '' }, ]); generationJobManager.getCleanupBlockingJobIdsForConversations.mockResolvedValue( Object.keys(jobs), ); generationJobManager.getCleanupJob.mockImplementation(async (streamId) => { const job = jobs[streamId]; return job == null ? null : { ...job, status: 'complete', createdAt: Date.now() }; }); deleteConvos.mockImplementationOnce(async (_userId, _filter, options) => { await options.beforeDelete?.(conversationIds); return { deletedCount: 2, conversationIds }; }); const response = await request(app) .delete('/api/convos') .send({ arg: { conversationId: 'conversation-1' } }); expect(response.status).toBe(201); expect(checkpointRows).toEqual([ { threadId: 'conversation-1', checkpointNamespace: 'foreign-user-generation' }, { threadId: 'conversation-1', checkpointNamespace: 'foreign-tenant-generation' }, { threadId: 'conversation-1', checkpointNamespace: '' }, ]); expect(deleteOwnedAgentCheckpoints).toHaveBeenCalledWith( 'test-user-123', undefined, ['conversation-1', 'child-conversation'], undefined, ); }); it('deletes an owned checkpoint after its terminal job hash expires', async () => { const scope = { threadId: 'conversation-1', checkpointNamespace: checkpointNamespace(8), }; resetCheckpointRows([scope]); deleteConvos.mockImplementationOnce(async (_userId, _filter, options) => { await options.beforeDelete?.(['conversation-1']); return { deletedCount: 1, conversationIds: ['conversation-1'] }; }); const response = await request(app) .delete('/api/convos') .send({ arg: { conversationId: 'conversation-1' } }); expect(response.status).toBe(201); expect(checkpointRows).toEqual([]); expect(deleteOwnedAgentCheckpoints).toHaveBeenCalledWith( 'test-user-123', undefined, ['conversation-1'], undefined, ); }); it('retains checkpoint payload when conversation deletion fails after its snapshot', async () => { const scope = { threadId: 'conversation-1', checkpointNamespace: checkpointNamespace(8) }; resetCheckpointRows([scope]); deleteConvos.mockImplementationOnce(async (_owner, _filter, options) => { await options.beforeDelete(['conversation-1']); throw new Error('conversation deletion failed'); }); const response = await request(app) .delete('/api/convos') .send({ arg: { conversationId: 'conversation-1' } }); expect(response.status).toBe(500); expect(deleteOwnedAgentCheckpoints).not.toHaveBeenCalled(); expect(checkpointRows).toEqual([scope]); }); it('fails closed when saver deletion fails', async () => { deleteOwnedAgentCheckpoints.mockRejectedValueOnce(new Error('checkpoint store unavailable')); deleteConvos.mockImplementationOnce(async (_userId, _filter, options) => { await options.beforeDelete?.(['conversation-1']); return { deletedCount: 1, conversationIds: ['conversation-1'] }; }); const response = await request(app) .delete('/api/convos') .send({ arg: { conversationId: 'conversation-1' } }); expect(response.status).toBe(500); }); it('retries checkpoint cleanup for descendants after all conversation records are gone', async () => { deleteOwnedAgentCheckpoints.mockRejectedValueOnce(new Error('post-delete cleanup failed')); deleteConvos .mockImplementationOnce(async (_owner, _filter, options) => { await options.beforeDelete(['conversation-1', 'child-conversation']); return { deletedCount: 2, conversationIds: ['conversation-1', 'child-conversation'] }; }) .mockResolvedValue({ deletedCount: 0, conversationIds: [] }); const first = await request(app) .delete('/api/convos') .send({ arg: { conversationId: 'conversation-1' } }); expect(first.status).toBe(500); checkpointRows.push({ threadId: 'child-conversation', checkpointNamespace: checkpointNamespace(13), }); // Restore only a late checkpoint; the deletion intent must remain from the first request. const second = await request(app) .delete('/api/convos') .send({ arg: { conversationId: 'conversation-1' } }); expect(second.status).toBe(201); expect(deleteOwnedAgentCheckpoints).toHaveBeenLastCalledWith( 'test-user-123', undefined, ['conversation-1', 'child-conversation'], undefined, ); expect(checkpointRows).toEqual([]); }); it('cleans checkpoints from every cascade wave', async () => { const jobs = { 'run-parent': { metadata: { userId: 'test-user-123', conversationId: 'parent-conversation', checkpointNamespace: checkpointNamespace(11), generationProtocolVersion: 2, }, }, 'run-child': { metadata: { userId: 'test-user-123', conversationId: 'child-conversation', checkpointNamespace: checkpointNamespace(12), generationProtocolVersion: 2, }, }, }; generationJobManager.getCleanupBlockingJobIdsForConversations.mockImplementation( async (_userId, conversationIds) => conversationIds.map((conversationId) => conversationId === 'parent-conversation' ? 'run-parent' : 'run-child', ), ); generationJobManager.getCleanupJob.mockImplementation(async (streamId) => { const job = jobs[streamId]; return job == null ? null : { ...job, status: 'complete', createdAt: Date.now() }; }); deleteConvos .mockImplementationOnce(async (_userId, _filter, options) => { await options.beforeDelete?.(['parent-conversation']); await options.beforeDelete?.(['child-conversation']); return { deletedCount: 2, conversationIds: ['parent-conversation', 'child-conversation'], }; }) .mockResolvedValueOnce({ deletedCount: 0, conversationIds: [] }); const response = await request(app) .delete('/api/convos') .send({ arg: { conversationId: 'parent-conversation' } }); expect(response.status).toBe(201); expect(deleteOwnedAgentCheckpoints).toHaveBeenCalledWith( 'test-user-123', undefined, ['parent-conversation', 'child-conversation'], undefined, ); }); it('drains a tenant user legacy generation without pruning its ambiguous namespace', async () => { const createdAt = Date.now(); generationJobManager.getCleanupBlockingJobIdsForConversations.mockResolvedValue([ 'legacy-run', ]); generationJobManager.getCleanupJob.mockImplementation(async (streamId) => streamId === 'legacy-run' ? { metadata: { userId: 'test-user-123', conversationId: 'conversation-1', checkpointNamespace: 'legacy-tenant-generation', generationProtocolVersion: 2, }, status: 'running', createdAt, } : null, ); deleteConvos .mockImplementationOnce(async (_userId, _filter, options) => { await options.beforeDelete?.(['conversation-1']); return { deletedCount: 1, conversationIds: ['conversation-1'] }; }) .mockResolvedValueOnce({ deletedCount: 0, conversationIds: [] }); const response = await request(app) .delete('/api/convos') .set('x-test-tenant', 'tenant-1') .send({ arg: { conversationId: 'conversation-1' } }); expect(response.status).toBe(201); expect(generationJobManager.abortJob).toHaveBeenCalledWith('legacy-run', { expectedCreatedAt: createdAt, awaitProviderDrain: true, }); expect(deleteOwnedAgentCheckpoints).toHaveBeenCalledWith( 'test-user-123', 'tenant-1', ['conversation-1'], undefined, ); }); it('waits for terminal response-id runs whose provider writes are undrained', async () => { const createdAt = Date.now(); generationJobManager.getCleanupBlockingJobIdsForConversations.mockResolvedValue([ 'resp_terminal-run', ]); generationJobManager.getCleanupJob.mockImplementation(async (streamId) => streamId === 'resp_terminal-run' ? { metadata: { userId: 'test-user-123', providerDrained: false }, status: 'complete', createdAt, } : null, ); deleteConvos.mockImplementationOnce(async (_userId, _filter, options) => { await options.beforeDelete?.(['conversation-1']); return { deletedCount: 1, conversationIds: ['conversation-1'] }; }); const response = await request(app) .delete('/api/convos') .send({ arg: { conversationId: 'conversation-1' } }); expect(response.status).toBe(201); expect(generationJobManager.abortJob).toHaveBeenCalledWith('resp_terminal-run', { expectedCreatedAt: createdAt, awaitProviderDrain: true, }); }); it('catches a response-id run admitted after the pre-delete snapshot', async () => { const createdAt = Date.now(); let deletionCommitted = false; generationJobManager.getCleanupBlockingJobIdsForConversations.mockImplementation(async () => deletionCommitted ? ['resp_late-run'] : [], ); generationJobManager.getCleanupJob.mockImplementation(async (streamId) => streamId === 'resp_late-run' ? { metadata: { userId: 'test-user-123' }, status: 'running', createdAt } : null, ); deleteConvos.mockImplementationOnce(async (_userId, _filter, options) => { await options.beforeDelete?.(['conversation-1']); deletionCommitted = true; return { deletedCount: 1, conversationIds: ['conversation-1'] }; }); const response = await request(app) .delete('/api/convos') .send({ arg: { conversationId: 'conversation-1' } }); expect(response.status).toBe(201); expect(generationJobManager.getCleanupBlockingJobIdsForConversations).toHaveBeenCalledTimes( 2, ); expect(generationJobManager.abortJob).toHaveBeenCalledWith('resp_late-run', { expectedCreatedAt: createdAt, awaitProviderDrain: true, }); }); it('removes persistence even when a racing response drains before post-delete discovery', async () => { deleteConvos .mockImplementationOnce(async (_userId, _filter, options) => { await options.beforeDelete?.(['conversation-1']); return { deletedCount: 1, conversationIds: ['conversation-1'] }; }) .mockResolvedValueOnce({ deletedCount: 1, conversationIds: ['conversation-1'] }); generationJobManager.getCleanupBlockingJobIdsForConversations.mockResolvedValue([]); const response = await request(app) .delete('/api/convos') .send({ arg: { conversationId: 'conversation-1' } }); expect(response.status).toBe(201); expect(generationJobManager.abortJob).not.toHaveBeenCalled(); expect(deleteConvos).toHaveBeenNthCalledWith( 2, 'test-user-123', { conversationId: { $in: ['conversation-1'] } }, expect.objectContaining({ allowEmpty: true }), ); expect(deleteMessages).toHaveBeenCalledWith({ user: 'test-user-123', conversationId: { $in: ['conversation-1'] }, }); }); it('fails closed when the idempotent remnant sweep hits a storage failure', async () => { deleteConvos .mockImplementationOnce(async (_userId, _filter, options) => { await options.beforeDelete?.(['conversation-1']); return { deletedCount: 1, conversationIds: ['conversation-1'] }; }) .mockRejectedValueOnce(new Error('remnant database unavailable')); const response = await request(app) .delete('/api/convos') .send({ arg: { conversationId: 'conversation-1' } }); expect(response.status).toBe(500); expect(response.text).toBe('Error clearing conversations'); expect(deleteOwnedAgentCheckpoints).not.toHaveBeenCalled(); }); it('fails closed when remnant message cleanup is unavailable', async () => { deleteConvos .mockImplementationOnce(async (_userId, _filter, options) => { await options.beforeDelete?.(['conversation-1']); return { deletedCount: 1, conversationIds: ['conversation-1'] }; }) .mockResolvedValueOnce({ deletedCount: 0, conversationIds: [] }); deleteMessages.mockRejectedValueOnce(new Error('message database unavailable')); const response = await request(app) .delete('/api/convos') .send({ arg: { conversationId: 'conversation-1' } }); expect(response.status).toBe(500); expect(response.text).toBe('Error clearing conversations'); expect(deleteOwnedAgentCheckpoints).not.toHaveBeenCalled(); }); it('does not prune generation persistence when provider stop is unconfirmed', async () => { const createdAt = Date.now(); let deletionCommitted = false; deleteConvos.mockImplementation(async (_userId, _filter, options) => { await options.beforeDelete?.(['child-conversation']); deletionCommitted = true; return { deletedCount: 2, conversationIds: ['parent-conversation', 'child-conversation'], }; }); generationJobManager.getCleanupJob.mockImplementation(async (conversationId) => conversationId === 'child-conversation' ? { metadata: { userId: 'test-user-123' }, status: 'running', createdAt } : null, ); generationJobManager.abortJob.mockResolvedValue({ success: false, failureReason: 'job_still_active', }); const response = await request(app) .delete('/api/convos') .send({ arg: { conversationId: 'parent-conversation' } }); expect(response.status).toBe(500); expect(deleteConvos).toHaveBeenCalledTimes(1); expect(deletionCommitted).toBe(false); expect(deleteMessages).not.toHaveBeenCalled(); }); it.each(['terminalPersistencePending', 'terminalHostActionPending'])( 'drains %s only for leases removed by this deletion', async (marker) => { const createdAt = Date.now(); deleteConvos.mockResolvedValue({ deletedCount: 2, conversationIds: ['parent-conversation', 'child-conversation'], }); subagentThreadStore.planCancellationForConversations.mockResolvedValueOnce({ userId: 'test-user-123', conversationIds: ['parent-conversation'], scopes: [], leases: [ { taskId: 'related-generation', parentConversationId: 'parent-conversation', conversationId: 'child-conversation', }, { taskId: 'unrelated-generation', parentConversationId: 'other-parent', conversationId: 'other-child', }, ], }); let relatedReads = 0; generationJobManager.getCleanupJob.mockImplementation(async (conversationId) => { if (conversationId !== 'related-generation') return null; relatedReads += 1; return { status: 'complete', createdAt, metadata: { userId: 'test-user-123', providerDrained: true, [marker]: relatedReads <= 2, }, }; }); const response = await request(app) .delete('/api/convos') .send({ arg: { conversationId: 'parent-conversation' } }); expect(response.status).toBe(201); expect(generationJobManager.abortJob).toHaveBeenCalledWith('related-generation', { expectedCreatedAt: createdAt, awaitProviderDrain: true, }); expect(relatedReads).toBeGreaterThanOrEqual(3); expect(generationJobManager.getCleanupJob).not.toHaveBeenCalledWith('unrelated-generation'); expect(deleteConvos).toHaveBeenCalledTimes(2); }, ); it('should delete a single conversation, tool calls, and associated shared links', async () => { const mockConversationId = 'conv-123'; const mockDbResponse = { deletedCount: 1, message: 'Conversation deleted successfully', }; deleteConvos.mockResolvedValue(mockDbResponse); deleteToolCalls.mockResolvedValue({ deletedCount: 3 }); deleteConvoSharedLinksWithCleanup.mockResolvedValue({ message: 'Shared links deleted successfully', deletedCount: 1, }); const response = await request(app) .delete('/api/convos') .send({ arg: { conversationId: mockConversationId, }, }); expect(response.status).toBe(201); expect(response.body).toMatchObject(mockDbResponse); /** Verify deleteConvos was called with correct parameters */ expect(deleteConvos).toHaveBeenCalledWith( 'test-user-123', { conversationId: mockConversationId }, expect.objectContaining({ beforeDelete: expect.any(Function) }), ); /** Verify deleteToolCalls was called */ expect(deleteToolCalls).toHaveBeenCalledWith('test-user-123', mockConversationId); /** Verify deleteConvoSharedLinksWithCleanup was called */ expect(deleteConvoSharedLinksWithCleanup).toHaveBeenCalledWith( 'test-user-123', mockConversationId, ); }); it('should not call deleteConvoSharedLinksWithCleanup when no conversationId provided', async () => { deleteConvos.mockResolvedValue({ deletedCount: 0 }); deleteToolCalls.mockResolvedValue({ deletedCount: 0 }); const response = await request(app) .delete('/api/convos') .send({ arg: { source: 'button', }, }); expect(response.status).toBe(200); expect(deleteConvoSharedLinksWithCleanup).not.toHaveBeenCalled(); }); it('should handle deletion of conversation without shared links', async () => { const mockConversationId = 'conv-no-shares'; deleteConvos.mockResolvedValue({ deletedCount: 1 }); deleteToolCalls.mockResolvedValue({ deletedCount: 0 }); deleteConvoSharedLinksWithCleanup.mockResolvedValue({ message: 'Shared links deleted successfully', deletedCount: 0, }); const response = await request(app) .delete('/api/convos') .send({ arg: { conversationId: mockConversationId, }, }); expect(response.status).toBe(201); expect(deleteConvoSharedLinksWithCleanup).toHaveBeenCalledWith( 'test-user-123', mockConversationId, ); }); it('should return 400 when no parameters provided', async () => { const response = await request(app).delete('/api/convos').send({ arg: {}, }); expect(response.status).toBe(400); expect(response.body).toEqual({ error: 'no parameters provided' }); expect(deleteConvos).not.toHaveBeenCalled(); expect(deleteConvoSharedLinksWithCleanup).not.toHaveBeenCalled(); }); it('should return 400 when request body is empty (DoS prevention)', async () => { const response = await request(app).delete('/api/convos').send({}); expect(response.status).toBe(400); expect(response.body).toEqual({ error: 'no parameters provided' }); expect(deleteConvos).not.toHaveBeenCalled(); }); it('should return 400 when arg is null (DoS prevention)', async () => { const response = await request(app).delete('/api/convos').send({ arg: null }); expect(response.status).toBe(400); expect(response.body).toEqual({ error: 'no parameters provided' }); expect(deleteConvos).not.toHaveBeenCalled(); }); it('should return 400 when arg is undefined (DoS prevention)', async () => { const response = await request(app).delete('/api/convos').send({ arg: undefined }); expect(response.status).toBe(400); expect(response.body).toEqual({ error: 'no parameters provided' }); expect(deleteConvos).not.toHaveBeenCalled(); }); it('should return 400 when request body is null (DoS prevention)', async () => { const response = await request(app) .delete('/api/convos') .set('Content-Type', 'application/json') .send('null'); expect(response.status).toBe(400); expect(deleteConvos).not.toHaveBeenCalled(); }); it('should return 500 if deleteConvoSharedLinksWithCleanup fails', async () => { const mockConversationId = 'conv-error'; deleteConvos.mockResolvedValue({ deletedCount: 1 }); deleteToolCalls.mockResolvedValue({ deletedCount: 2 }); deleteConvoSharedLinksWithCleanup.mockRejectedValue( new Error('Failed to delete shared links'), ); const response = await request(app) .delete('/api/convos') .send({ arg: { conversationId: mockConversationId, }, }); expect(response.status).toBe(500); expect(response.text).toBe('Error clearing conversations'); }); it('should execute deletions in correct sequence for single conversation', async () => { const mockConversationId = 'conv-sequence'; const executionOrder = []; deleteConvos.mockImplementation(() => { executionOrder.push('deleteConvos'); return Promise.resolve({ deletedCount: 1 }); }); deleteToolCalls.mockImplementation(() => { executionOrder.push('deleteToolCalls'); return Promise.resolve({ deletedCount: 2 }); }); deleteConvoSharedLinksWithCleanup.mockImplementation(() => { executionOrder.push('deleteConvoSharedLinksWithCleanup'); return Promise.resolve({ deletedCount: 1 }); }); await request(app) .delete('/api/convos') .send({ arg: { conversationId: mockConversationId, }, }); expect(executionOrder).toEqual([ 'deleteConvos', 'deleteConvos', 'deleteToolCalls', 'deleteConvoSharedLinksWithCleanup', ]); }); it('should prevent orphaned shared links when deleting single conversation', async () => { const mockConversationId = 'conv-with-shares'; deleteConvos.mockResolvedValue({ deletedCount: 1 }); deleteToolCalls.mockResolvedValue({ deletedCount: 4 }); deleteConvoSharedLinksWithCleanup.mockResolvedValue({ message: 'Shared links deleted successfully', deletedCount: 2, }); const response = await request(app) .delete('/api/convos') .send({ arg: { conversationId: mockConversationId, }, }); expect(response.status).toBe(201); /** Verify shared links were deleted for the specific conversation */ expect(deleteConvoSharedLinksWithCleanup).toHaveBeenCalledWith( 'test-user-123', mockConversationId, ); /** Verify it was called after the conversation was deleted */ expect(deleteConvoSharedLinksWithCleanup).toHaveBeenCalledAfter(deleteConvos); }); }); describe('GET / search handling', () => { const { getConvosByCursor } = require('~/models'); beforeEach(() => { getConvosByCursor.mockResolvedValue({ conversations: [], nextCursor: null }); }); /** Express already percent-decodes `req.query`, so decoding a second time in the route * threw URIError on any term containing a bare `%` and mangled `%xx`-looking text. */ it('accepts a search term containing a literal percent sign', async () => { const response = await request(app) .get('/api/convos') .query({ isArchived: 'true', search: '100% ready' }); expect(response.status).toBe(200); expect(getConvosByCursor).toHaveBeenCalledWith( 'test-user-123', expect.objectContaining({ search: '100% ready' }), ); }); it('passes percent-escape-looking text through without decoding it', async () => { const response = await request(app).get('/api/convos').query({ search: 'a%41b' }); expect(response.status).toBe(200); expect(getConvosByCursor).toHaveBeenCalledWith( 'test-user-123', expect.objectContaining({ search: 'a%41b' }), ); }); it('treats a whitespace-only search as no search', async () => { const response = await request(app).get('/api/convos').query({ search: ' ' }); expect(response.status).toBe(200); expect(getConvosByCursor).toHaveBeenCalledWith( 'test-user-123', expect.objectContaining({ search: undefined }), ); }); }); describe('GET / pinned filter', () => { const { getConvosByCursor } = require('~/models'); beforeEach(() => { getConvosByCursor.mockResolvedValue({ conversations: [], nextCursor: null }); }); it('forwards pinned=true so the sidebar section can fetch pins on their own', async () => { const response = await request(app) .get('/api/convos') .query({ pinned: 'true', limit: '100' }); expect(response.status).toBe(200); expect(getConvosByCursor).toHaveBeenCalledWith( 'test-user-123', expect.objectContaining({ pinned: true, limit: 100 }), ); }); it('leaves the list unfiltered when pinned is absent', async () => { const response = await request(app).get('/api/convos'); expect(response.status).toBe(200); expect(getConvosByCursor).toHaveBeenCalledWith( 'test-user-123', expect.objectContaining({ pinned: false }), ); }); }); describe('GET / limit clamping', () => { const { getConvosByCursor } = require('~/models'); beforeEach(() => { getConvosByCursor.mockResolvedValue({ conversations: [], nextCursor: null }); }); /** `parseInt('-1') || 25` kept the -1, and `.limit(-1 + 1)` is `.limit(0)`, which * MongoDB reads as "no limit" — one request drained the caller's whole list. */ it('clamps a negative limit instead of forwarding it', async () => { const response = await request(app).get('/api/convos').query({ limit: '-1' }); expect(response.status).toBe(200); expect(getConvosByCursor).toHaveBeenCalledWith( 'test-user-123', expect.objectContaining({ limit: 1 }), ); }); it('caps an oversized limit at the page ceiling', async () => { const response = await request(app).get('/api/convos').query({ limit: '999999999' }); expect(response.status).toBe(200); expect(getConvosByCursor).toHaveBeenCalledWith( 'test-user-123', expect.objectContaining({ limit: 100 }), ); }); it('raises a zero limit to a single row', async () => { const response = await request(app).get('/api/convos').query({ limit: '0' }); expect(response.status).toBe(200); expect(getConvosByCursor).toHaveBeenCalledWith( 'test-user-123', expect.objectContaining({ limit: 1 }), ); }); it.each([ ['absent', undefined], ['non-numeric', 'all'], ])('falls back to the default page size when the limit is %s', async (_label, limit) => { const response = await request(app) .get('/api/convos') .query(limit === undefined ? {} : { limit }); expect(response.status).toBe(200); expect(getConvosByCursor).toHaveBeenCalledWith( 'test-user-123', expect.objectContaining({ limit: 25 }), ); }); /** Express parses a repeated key into an array, which `parseInt` silently reads as * its first element's digits rather than rejecting. */ it('clamps a repeated limit parameter', async () => { const response = await request(app).get('/api/convos?limit=999999&limit=5'); expect(response.status).toBe(200); expect(getConvosByCursor).toHaveBeenCalledWith( 'test-user-123', expect.objectContaining({ limit: 100 }), ); }); }); describe('GET / list facets', () => { const { getConvosByCursor } = require('~/models'); const { getAppConfig } = require('~/server/services/Config'); beforeEach(() => { getConvosByCursor.mockResolvedValue({ conversations: [], nextCursor: null }); }); it('forwards the date cutoffs as dates', async () => { const response = await request(app) .get('/api/convos') .query({ updatedAfter: '2026-09-01T00:00:00.000Z' }); expect(response.status).toBe(200); const [, options] = getConvosByCursor.mock.calls.at(-1); expect(options.updatedAfter).toBeInstanceOf(Date); expect(options.updatedAfter.toISOString()).toBe('2026-09-01T00:00:00.000Z'); }); it('forwards repeated endpoint params as one list', async () => { const response = await request(app) .get('/api/convos') .query('endpoints=openAI&endpoints=agents'); expect(response.status).toBe(200); expect(getConvosByCursor).toHaveBeenCalledWith( 'test-user-123', expect.objectContaining({ endpoints: ['openAI', 'agents'] }), ); }); it('forwards the attachment flag only when it is on', async () => { await request(app).get('/api/convos').query({ hasFiles: 'true' }); expect(getConvosByCursor).toHaveBeenLastCalledWith( 'test-user-123', expect.objectContaining({ hasFiles: true }), ); await request(app).get('/api/convos').query({ hasFiles: 'false' }); const [, options] = getConvosByCursor.mock.calls.at(-1); expect(options.hasFiles).toBeUndefined(); }); /** Dropping a filter the caller sent would answer with conversations they asked * to exclude, which is worse than refusing the request. */ it('refuses a malformed cutoff instead of listing unfiltered', async () => { const response = await request(app) .get('/api/convos') .query({ updatedAfter: 'last tuesday' }); expect(response.status).toBe(400); expect(response.body.error).toMatch(/updatedAfter/); expect(getConvosByCursor).not.toHaveBeenCalled(); }); it('refuses a mistyped flag instead of listing unfiltered', async () => { const response = await request(app).get('/api/convos').query({ hasFiles: 'tru' }); expect(response.status).toBe(400); expect(response.body.error).toMatch(/hasFiles/); expect(getConvosByCursor).not.toHaveBeenCalled(); }); /** The limits are deployment-level, so the list reads the base config instead of * resolving the caller's merged config on every sidebar request. */ it('enforces the endpoint limit the deployment configures', async () => { const query = 'endpoints=openAI&endpoints=agents&endpoints=google'; const withinDefault = await request(app).get('/api/convos').query(query); expect(withinDefault.status).toBe(200); getAppConfig.mockResolvedValueOnce({ conversationList: { maxEndpointFilters: 2, maxEndpointNameLength: 128 }, }); const overConfigured = await request(app).get('/api/convos').query(query); expect(overConfigured.status).toBe(400); expect(overConfigured.body.error).toMatch(/at most 2 names/); }); it('answers the route error when an endpoint filter cannot read its limits', async () => { getAppConfig.mockRejectedValueOnce(new Error('config unavailable')); const response = await request(app).get('/api/convos').query({ endpoints: 'openAI' }); expect(response.status).toBe(500); expect(response.body.error).toBe('Error fetching conversations'); expect(getConvosByCursor).not.toHaveBeenCalled(); }); it('forwards the shared flag only when it is on', async () => { await request(app).get('/api/convos').query({ sharedOnly: 'true' }); expect(getConvosByCursor).toHaveBeenLastCalledWith( 'test-user-123', expect.objectContaining({ sharedOnly: true }), ); await request(app).get('/api/convos').query({ sharedOnly: 'false' }); const [, options] = getConvosByCursor.mock.calls.at(-1); expect(options.sharedOnly).toBeUndefined(); }); it('sends no facet keys when the request carries none', async () => { await request(app).get('/api/convos'); const [, options] = getConvosByCursor.mock.calls.at(-1); expect(options.updatedAfter).toBeUndefined(); expect(options.createdAfter).toBeUndefined(); expect(options.endpoints).toBeUndefined(); expect(options.hasFiles).toBeUndefined(); expect(options.sharedOnly).toBeUndefined(); }); }); describe('GET / sort normalization', () => { const { getConvosByCursor } = require('~/models'); beforeEach(() => { getConvosByCursor.mockResolvedValue({ conversations: [], nextCursor: null }); }); it('forwards a whitelisted sort field and direction', async () => { const response = await request(app) .get('/api/convos') .query({ sortBy: 'title', sortDirection: 'asc' }); expect(response.status).toBe(200); expect(getConvosByCursor).toHaveBeenCalledWith( 'test-user-123', expect.objectContaining({ sortBy: 'title', sortDirection: 'asc' }), ); }); /** An unknown field reaches `getConvosByCursor`, which throws on it, so forwarding * a stale or hand-edited value would answer 500 instead of listing anything. */ it('falls back to the default ordering for values it does not recognize', async () => { const response = await request(app) .get('/api/convos') .query({ sortBy: 'DROP TABLE', sortDirection: 'sideways' }); expect(response.status).toBe(200); expect(getConvosByCursor).toHaveBeenCalledWith( 'test-user-123', expect.objectContaining({ sortBy: 'updatedAt', sortDirection: 'desc' }), ); }); }); describe('POST /seen', () => { /* The handler's own validation and error mapping live in `packages/api` and are covered against the real implementation there; what matters here is that the route reaches it with the authenticated user. */ it('routes to the handler for the authenticated user', async () => { markConvoSeen.mockResolvedValue({ modified: true }); const response = await request(app) .post('/api/convos/seen') .send({ arg: { conversationId: 'conv-seen-1' } }); expect(response.status).toBe(200); expect(response.body).toEqual({ modified: true }); expect(markConvoSeen).toHaveBeenCalledWith('test-user-123', 'conv-seen-1'); }); }); describe('POST /unread', () => { it('routes to the handler for the authenticated user', async () => { markConvoUnread.mockResolvedValue({ modified: true }); const response = await request(app) .post('/api/convos/unread') .send({ arg: { conversationId: 'conv-unread-1' } }); expect(response.status).toBe(200); expect(response.body).toEqual({ modified: true }); expect(markConvoUnread).toHaveBeenCalledWith('test-user-123', 'conv-unread-1'); }); }); describe('POST /update running chat rename', () => { it('delegates rename semantics to the injected TypeScript handler', async () => { const { renameConversationHandler, renameHandlerInputs } = require(MOCKS); const arg = { conversationId: 'running-rename', title: 'Renamed' }; expect((await request(app).post('/api/convos/update').send({ arg })).status).toBe(204); expect(renameConversationHandler).toHaveBeenCalledWith( expect.objectContaining({ body: { arg }, user: expect.objectContaining({ id: 'test-user-123' }), }), expect.anything(), expect.anything(), ); expect(renameHandlerInputs.at(-1)).toEqual( expect.objectContaining({ saveConvo, getConvo, getActiveRunIds: expect.any(Function), logger: expect.anything(), }), ); }); }); describe('POST /archive', () => { const { configMiddleware, validateConvoAccess } = require('~/server/middleware'); const { archiveConversationHandler, archiveHandlerInputs } = require(MOCKS); const { getConvoRetention } = require('~/models'); const interfaceConfig = { retentionMode: 'ephemeral', temporaryChatRetention: 24 }; const archiveRequest = { arg: { conversationId: 'conv-retention', isArchived: true } }; const order = []; let configSeenByAccessCheck; let configSeenByHandler; /** Nothing mounts the config ahead of the convos router, so the route has to load it: * without `interfaceConfig` the retention rules in `saveConvo` never see a mode. */ beforeEach(() => { order.length = 0; configSeenByAccessCheck = undefined; configSeenByHandler = undefined; configMiddleware.mockImplementation((req, res, next) => { order.push('config'); req.config = { ...req.config, interfaceConfig }; next(); }); validateConvoAccess.mockImplementation((req, res, next) => { order.push('access'); configSeenByAccessCheck = req.config?.interfaceConfig; next(); }); archiveConversationHandler.mockImplementation((req, res) => { order.push('handler'); configSeenByHandler = req.config?.interfaceConfig; return res.status(200).json({ conversationId: 'conv-retention' }); }); }); afterEach(() => { configMiddleware.mockImplementation((req, res, next) => next()); validateConvoAccess.mockImplementation((req, res, next) => next()); archiveConversationHandler.mockImplementation((_req, res) => res.status(200).json({})); }); it('serves the archive handler with the conversation store', () => { expect(archiveHandlerInputs.at(-1)).toEqual({ saveConvo, getConvoRetention }); }); it('loads the config before the access check, which reads the retention mode from it', async () => { const response = await request(app).post('/api/convos/archive').send(archiveRequest); expect(response.status).toBe(200); expect(order).toEqual(['config', 'access', 'handler']); expect(configSeenByAccessCheck).toEqual(interfaceConfig); }); it('hands the loaded config to the handler', async () => { await request(app).post('/api/convos/archive').send(archiveRequest); expect(configSeenByHandler).toEqual(interfaceConfig); }); }); describe('POST /archive/all', () => { const { archiveAllConvos } = require('~/models'); it('delegates archive-all requests through the package API handler', async () => { archiveAllConvos.mockResolvedValue({ archivedCount: 4 }); const response = await request(app).post('/api/convos/archive/all'); expect(response.status).toBe(200); expect(response.body).toEqual({ archivedCount: 4 }); expect(archiveAllHandler).toHaveBeenCalledTimes(1); expect(archiveAllConvos).toHaveBeenCalledWith('test-user-123'); }); }); describe('POST /convos/pin', () => { const mockConversationId = 'conv-123'; const { setConvoPinned } = require('~/models'); it('should pin a conversation', async () => { const mockPinnedConvo = { conversationId: mockConversationId, pinned: true }; setConvoPinned.mockResolvedValue(mockPinnedConvo); const response = await request(app).post('/api/convos/pin').send({ arg: mockPinnedConvo }); expect(response.status).toBe(200); expect(response.body).toEqual(mockPinnedConvo); expect(setConvoPinned).toHaveBeenCalledWith('test-user-123', mockConversationId, true); }); it('should unpin a conversation', async () => { const mockUnpinnedConvo = { conversationId: mockConversationId, pinned: false }; setConvoPinned.mockResolvedValue(mockUnpinnedConvo); const response = await request(app).post('/api/convos/pin').send({ arg: mockUnpinnedConvo }); expect(response.status).toBe(200); expect(response.body).toEqual(mockUnpinnedConvo); expect(setConvoPinned).toHaveBeenCalledWith('test-user-123', mockConversationId, false); }); /** A pin is one boolean: it must not drag in `saveConvo`'s message-id refresh * and project-stats recompute, which cost an extra read and a large write. */ it('does not route a pin through the full conversation save', async () => { setConvoPinned.mockResolvedValue({ conversationId: mockConversationId, pinned: true }); await request(app) .post('/api/convos/pin') .send({ arg: { conversationId: mockConversationId, pinned: true } }); expect(setConvoPinned).toHaveBeenCalledTimes(1); expect(saveConvo).not.toHaveBeenCalled(); }); it('should return 404 when the conversation does not exist', async () => { setConvoPinned.mockResolvedValue(null); const response = await request(app) .post('/api/convos/pin') .send({ arg: { conversationId: 'missing-convo', pinned: true } }); expect(response.status).toBe(404); expect(response.body).toEqual({ error: 'Conversation not found' }); }); it('should return 400 when conversationId is missing', async () => { const response = await request(app) .post('/api/convos/pin') .send({ arg: { pinned: true } }); expect(response.status).toBe(400); expect(response.body).toEqual({ error: 'conversationId is required' }); expect(setConvoPinned).not.toHaveBeenCalled(); }); it('should return 400 when pinned is not a boolean', async () => { const response = await request(app) .post('/api/convos/pin') .send({ arg: { conversationId: mockConversationId, pinned: 'yes' } }); expect(response.status).toBe(400); expect(response.body).toEqual({ error: 'pinned must be a boolean' }); expect(setConvoPinned).not.toHaveBeenCalled(); }); it('should return 400 when pinned is missing', async () => { const response = await request(app) .post('/api/convos/pin') .send({ arg: { conversationId: mockConversationId } }); expect(response.status).toBe(400); expect(response.body).toEqual({ error: 'pinned is required' }); expect(setConvoPinned).not.toHaveBeenCalled(); }); it('should return 500 when the pin update fails', async () => { setConvoPinned.mockRejectedValue(new Error('Database error')); const response = await request(app) .post('/api/convos/pin') .send({ arg: { conversationId: mockConversationId, pinned: true } }); expect(response.status).toBe(500); }); }); }); /** * Custom Jest matcher to verify function call order */ expect.extend({ toHaveBeenCalledAfter(received, other) { const receivedCalls = received.mock.invocationCallOrder; const otherCalls = other.mock.invocationCallOrder; if (receivedCalls.length === 0) { return { pass: false, message: () => `Expected ${received.getMockName()} to have been called after ${other.getMockName()}, but ${received.getMockName()} was never called`, }; } if (otherCalls.length === 0) { return { pass: false, message: () => `Expected ${received.getMockName()} to have been called after ${other.getMockName()}, but ${other.getMockName()} was never called`, }; } const lastReceivedCall = receivedCalls[receivedCalls.length - 1]; const firstOtherCall = otherCalls[0]; const pass = lastReceivedCall > firstOtherCall; return { pass, message: () => pass ? `Expected ${received.getMockName()} not to have been called after ${other.getMockName()}` : `Expected ${received.getMockName()} to have been called after ${other.getMockName()}`, }; }, });