const { Constants, ContentTypes, EModelEndpoint } = require('librechat-data-provider'); const BaseClientClass = require('../BaseClient'); const { ContentFilterError, createPrivateTextIngress, createModelBoundChatModelCallback, getPrivateTextAdmission, getPrivateTextInspectionTokens, assertModelBoundContent, resolveTurnDeliveryRouting, buildSteerMedia, Tokenizer, } = require('@librechat/api'); const { FakeClient, initializeFakeClient } = require('./FakeClient'); function deferred() { let resolve; let reject; const promise = new Promise((resolvePromise, rejectPromise) => { resolve = resolvePromise; reject = rejectPromise; }); return { promise, reject, resolve }; } jest.mock('~/db/connect'); jest.mock('~/server/services/Config', () => ({ getAppConfig: jest.fn().mockResolvedValue({ // Default app config for tests paths: { uploads: '/tmp' }, fileStrategy: 'local', memory: { disabled: false }, }), })); jest.mock('~/models', () => ({ User: jest.fn(), Key: jest.fn(), Session: jest.fn(), Balance: jest.fn(), Transaction: jest.fn(), getMessages: jest.fn().mockResolvedValue([]), saveMessage: jest.fn(), updateMessage: jest.fn(), deleteMessagesSince: jest.fn(), deleteMessages: jest.fn(), getConvoTitle: jest.fn(), getConvo: jest.fn(), saveConvo: jest.fn(), stampConvoLastResponse: jest.fn(), deleteConvos: jest.fn(), getPreset: jest.fn(), getPresets: jest.fn(), savePreset: jest.fn(), deletePresets: jest.fn(), findFileById: jest.fn(), createFile: jest.fn(), updateFile: jest.fn(), deleteFile: jest.fn(), deleteFiles: jest.fn(), getFiles: jest.fn(), updateFileUsage: jest.fn(), getMultiplier: jest.fn(), reserveBalance: jest.fn(), renewBalanceReservation: jest.fn(), releaseBalanceReservation: jest.fn(), })); const { releaseBalanceReservation, reserveBalance, getMultiplier, saveMessage, getMessages, saveConvo, getFiles, getConvo, stampConvoLastResponse, } = require('~/models'); jest.mock('@librechat/agents', () => { const actual = jest.requireActual('@librechat/agents'); return { ...actual, ChatOpenAI: jest.fn().mockImplementation(() => { return {}; }), }; }); let parentMessageId; let conversationId; const fakeMessages = []; const userMessage = 'Hello, ChatGPT!'; const apiKey = 'fake-api-key'; const messageHistory = [ { role: 'user', isCreatedByUser: true, text: 'Hello', messageId: '1' }, { role: 'assistant', isCreatedByUser: false, text: 'Hi', messageId: '2', parentMessageId: '1' }, { role: 'user', isCreatedByUser: true, text: "What's up", messageId: '3', parentMessageId: '2', }, ]; describe('BaseClient', () => { let TestClient; const options = { // debug: true, modelOptions: { model: 'gpt-4o-mini', temperature: 0, }, }; beforeEach(() => { TestClient = initializeFakeClient(apiKey, options, fakeMessages); TestClient.summarizeMessages = jest.fn().mockResolvedValue({ summaryMessage: { role: 'system', content: 'Refined answer', }, summaryTokenCount: 5, }); }); test('persists only the host-authored external event display projection on the user turn', () => { const projection = { version: 1, eventType: 'chess.turn.ready', sourceType: 'speed-chess', occurredAt: new Date('2026-08-21T12:00:00.000Z'), expectedActionToolName: 'submit_move', }; TestClient.options.req = { _agentEventTriggerProjection: projection }; expect( TestClient.createUserMessage({ messageId: 'event:user', parentMessageId: 'parent', conversationId: 'event-thread', text: 'Private event payload', }), ).toEqual(expect.objectContaining({ subagentTriggerProjection: projection })); }); test('returns the input messages without instructions when addInstructions() is called with empty instructions', () => { const messages = [{ content: 'Hello' }, { content: 'How are you?' }, { content: 'Goodbye' }]; const instructions = ''; const result = TestClient.addInstructions(messages, instructions); expect(result).toEqual(messages); }); test('returns the input messages with instructions properly added when addInstructions() is called with non-empty instructions', () => { const messages = [{ content: 'Hello' }, { content: 'How are you?' }, { content: 'Goodbye' }]; const instructions = { content: 'Please respond to the question.' }; const result = TestClient.addInstructions(messages, instructions); const expected = [ { content: 'Please respond to the question.' }, { content: 'Hello' }, { content: 'How are you?' }, { content: 'Goodbye' }, ]; expect(result).toEqual(expected); }); test('returns the input messages with instructions properly added when addInstructions() with legacy flag', () => { const messages = [{ content: 'Hello' }, { content: 'How are you?' }, { content: 'Goodbye' }]; const instructions = { content: 'Please respond to the question.' }; const result = TestClient.addInstructions(messages, instructions, true); const expected = [ { content: 'Hello' }, { content: 'How are you?' }, { content: 'Please respond to the question.' }, { content: 'Goodbye' }, ]; expect(result).toEqual(expected); }); test('concats messages correctly in concatenateMessages()', () => { const messages = [ { name: 'User', content: 'Hello' }, { name: 'Assistant', content: 'How can I help you?' }, { name: 'User', content: 'I have a question.' }, ]; const result = TestClient.concatenateMessages(messages); const expected = 'User:\nHello\n\nAssistant:\nHow can I help you?\n\nUser:\nI have a question.\n\n'; expect(result).toBe(expected); }); test('refines messages correctly in summarizeMessages()', async () => { const messagesToRefine = [ { role: 'user', content: 'Hello', tokenCount: 10 }, { role: 'assistant', content: 'How can I help you?', tokenCount: 20 }, ]; const remainingContextTokens = 100; const expectedRefinedMessage = { role: 'system', content: 'Refined answer', }; const result = await TestClient.summarizeMessages({ messagesToRefine, remainingContextTokens }); expect(result.summaryMessage).toEqual(expectedRefinedMessage); }); test('gets messages within token limit (under limit) correctly in getMessagesWithinTokenLimit()', async () => { TestClient.maxContextTokens = 100; TestClient.shouldSummarize = true; const messages = [ { role: 'user', content: 'Hello', tokenCount: 5 }, { role: 'assistant', content: 'How can I help you?', tokenCount: 19 }, { role: 'user', content: 'I have a question.', tokenCount: 18 }, ]; const expectedContext = [ { role: 'user', content: 'Hello', tokenCount: 5 }, // 'Hello'.length { role: 'assistant', content: 'How can I help you?', tokenCount: 19 }, { role: 'user', content: 'I have a question.', tokenCount: 18 }, ]; // Subtract 3 tokens for Assistant Label priming after all messages have been counted. const expectedRemainingContextTokens = 58 - 3; // (100 - 5 - 19 - 18) - 3 const expectedMessagesToRefine = []; const lastExpectedMessage = expectedMessagesToRefine?.[expectedMessagesToRefine.length - 1] ?? {}; const expectedIndex = messages.findIndex((msg) => msg.content === lastExpectedMessage?.content); const result = await TestClient.getMessagesWithinTokenLimit({ messages }); expect(result.context).toEqual(expectedContext); expect(result.messagesToRefine.length - 1).toEqual(expectedIndex); expect(result.remainingContextTokens).toBe(expectedRemainingContextTokens); expect(result.messagesToRefine).toEqual(expectedMessagesToRefine); }); test('gets result over token limit correctly in getMessagesWithinTokenLimit()', async () => { TestClient.maxContextTokens = 50; // Set a lower limit TestClient.shouldSummarize = true; const messages = [ { role: 'user', content: 'Hello', tokenCount: 30 }, { role: 'assistant', content: 'How can I help you?', tokenCount: 30 }, { role: 'user', content: 'I have a question.', tokenCount: 5 }, { role: 'user', content: 'I need a coffee, stat!', tokenCount: 19 }, { role: 'assistant', content: 'Sure, I can help with that.', tokenCount: 18 }, ]; // Subtract 3 tokens for Assistant Label priming after all messages have been counted. const expectedRemainingContextTokens = 5; // (50 - 18 - 19 - 5) - 3 const expectedMessagesToRefine = [ { role: 'user', content: 'Hello', tokenCount: 30 }, { role: 'assistant', content: 'How can I help you?', tokenCount: 30 }, ]; const expectedContext = [ { role: 'user', content: 'I have a question.', tokenCount: 5 }, { role: 'user', content: 'I need a coffee, stat!', tokenCount: 19 }, { role: 'assistant', content: 'Sure, I can help with that.', tokenCount: 18 }, ]; const lastExpectedMessage = expectedMessagesToRefine?.[expectedMessagesToRefine.length - 1] ?? {}; const expectedIndex = messages.findIndex((msg) => msg.content === lastExpectedMessage?.content); const result = await TestClient.getMessagesWithinTokenLimit({ messages }); expect(result.context).toEqual(expectedContext); expect(result.messagesToRefine.length - 1).toEqual(expectedIndex); expect(result.remainingContextTokens).toBe(expectedRemainingContextTokens); expect(result.messagesToRefine).toEqual(expectedMessagesToRefine); }); describe('loadHistory', () => { const receiver = Object.assign(Object.create(BaseClientClass.prototype), { user: 'user-1', getMessageMapMethod: null, shouldSummarize: false, addPreviousAttachments: async (messages) => messages, }); const loadHistory = (parentMessageId) => receiver.loadHistory('convo-1', parentMessageId); beforeEach(() => { getMessages.mockClear(); }); test('skips the database when the parent is the root sentinel: no message can match it', async () => { const result = await loadHistory(Constants.NO_PARENT); expect(result).toEqual([]); expect(getMessages).not.toHaveBeenCalled(); }); test('still loads and walks the chain for a real parent', async () => { getMessages.mockResolvedValueOnce([ { messageId: 'root', parentMessageId: Constants.NO_PARENT, text: 'a' }, { messageId: 'reply', parentMessageId: 'root', text: 'b' }, ]); const result = await loadHistory('reply'); expect(getMessages).toHaveBeenCalledTimes(1); expect(result.map((m) => m.messageId)).toEqual(['root', 'reply']); }); test('prunes pre-summary history before hydrating attachments', async () => { const addPreviousAttachments = jest.fn(async (messages) => messages); receiver.shouldSummarize = true; receiver.addPreviousAttachments = addPreviousAttachments; getMessages.mockResolvedValueOnce([ { messageId: 'pre-summary', parentMessageId: Constants.NO_PARENT, files: [{ file_id: 'old-file' }], }, { messageId: 'summary', parentMessageId: 'pre-summary', summary: 'Earlier context', summaryTokenCount: 10, }, { messageId: 'latest', parentMessageId: 'summary', text: 'Continue' }, ]); const result = await loadHistory('latest'); expect(result.map((message) => message.messageId)).toEqual(['summary', 'latest']); expect(addPreviousAttachments).toHaveBeenCalledWith( expect.not.arrayContaining([expect.objectContaining({ messageId: 'pre-summary' })]), ); receiver.shouldSummarize = false; receiver.addPreviousAttachments = async (messages) => messages; receiver.previous_summary = undefined; }); }); describe('getMessagesForConversation', () => { it('should return an empty array if the parentMessageId does not exist', () => { const result = TestClient.constructor.getMessagesForConversation({ messages: unorderedMessages, parentMessageId: '999', }); expect(result).toEqual([]); }); it('should handle messages with messageId property', () => { const messagesWithMessageId = [ { messageId: '1', parentMessageId: null, text: 'Message 1' }, { messageId: '2', parentMessageId: '1', text: 'Message 2' }, ]; const result = TestClient.constructor.getMessagesForConversation({ messages: messagesWithMessageId, parentMessageId: '2', }); expect(result).toEqual([ { messageId: '1', parentMessageId: null, text: 'Message 1' }, { messageId: '2', parentMessageId: '1', text: 'Message 2' }, ]); }); const messagesWithNullParent = [ { id: '1', parentMessageId: null, text: 'Message 1' }, { id: '2', parentMessageId: null, text: 'Message 2' }, ]; it('should handle messages with null parentMessageId that are not root', () => { const result = TestClient.constructor.getMessagesForConversation({ messages: messagesWithNullParent, parentMessageId: '2', }); expect(result).toEqual([{ id: '2', parentMessageId: null, text: 'Message 2' }]); }); const cyclicMessages = [ { id: '3', parentMessageId: '2', text: 'Message 3' }, { id: '1', parentMessageId: '3', text: 'Message 1' }, { id: '2', parentMessageId: '1', text: 'Message 2' }, ]; it('should handle cyclic references without going into an infinite loop', () => { const result = TestClient.constructor.getMessagesForConversation({ messages: cyclicMessages, parentMessageId: '3', }); expect(result).toEqual([ { id: '1', parentMessageId: '3', text: 'Message 1' }, { id: '2', parentMessageId: '1', text: 'Message 2' }, { id: '3', parentMessageId: '2', text: 'Message 3' }, ]); }); const unorderedMessages = [ { id: '3', parentMessageId: '2', text: 'Message 3' }, { id: '2', parentMessageId: '1', text: 'Message 2' }, { id: '1', parentMessageId: Constants.NO_PARENT, text: 'Message 1' }, ]; it('should return ordered messages based on parentMessageId', () => { const result = TestClient.constructor.getMessagesForConversation({ messages: unorderedMessages, parentMessageId: '3', }); expect(result).toEqual([ { id: '1', parentMessageId: Constants.NO_PARENT, text: 'Message 1' }, { id: '2', parentMessageId: '1', text: 'Message 2' }, { id: '3', parentMessageId: '2', text: 'Message 3' }, ]); }); const unorderedBranchedMessages = [ { id: '4', parentMessageId: '2', text: 'Message 4', summary: 'Summary for Message 4' }, { id: '10', parentMessageId: '7', text: 'Message 10' }, { id: '1', parentMessageId: null, text: 'Message 1' }, { id: '6', parentMessageId: '5', text: 'Message 7' }, { id: '7', parentMessageId: '5', text: 'Message 7' }, { id: '2', parentMessageId: '1', text: 'Message 2' }, { id: '8', parentMessageId: '6', text: 'Message 8' }, { id: '5', parentMessageId: '3', text: 'Message 5' }, { id: '3', parentMessageId: '1', text: 'Message 3' }, { id: '6', parentMessageId: '4', text: 'Message 6' }, { id: '8', parentMessageId: '7', text: 'Message 9' }, { id: '9', parentMessageId: '7', text: 'Message 9' }, { id: '11', parentMessageId: '2', text: 'Message 11', summary: 'Summary for Message 11' }, ]; it('should return ordered messages from a branched array based on parentMessageId', () => { const result = TestClient.constructor.getMessagesForConversation({ messages: unorderedBranchedMessages, parentMessageId: '10', summary: true, }); expect(result).toEqual([ { id: '1', parentMessageId: null, text: 'Message 1' }, { id: '3', parentMessageId: '1', text: 'Message 3' }, { id: '5', parentMessageId: '3', text: 'Message 5' }, { id: '7', parentMessageId: '5', text: 'Message 7' }, { id: '10', parentMessageId: '7', text: 'Message 10' }, ]); }); it('should return an empty array if no messages are provided', () => { const result = TestClient.constructor.getMessagesForConversation({ messages: [], parentMessageId: '3', }); expect(result).toEqual([]); }); it('should map over the ordered messages if mapMethod is provided', () => { const mapMethod = (msg) => msg.text; const result = TestClient.constructor.getMessagesForConversation({ messages: unorderedMessages, parentMessageId: '3', mapMethod, }); expect(result).toEqual(['Message 1', 'Message 2', 'Message 3']); }); let unorderedMessagesWithSummary = [ { id: '4', parentMessageId: '3', text: 'Message 4' }, { id: '2', parentMessageId: '1', text: 'Message 2', summary: 'Summary for Message 2' }, { id: '3', parentMessageId: '2', text: 'Message 3', summary: 'Summary for Message 3' }, { id: '1', parentMessageId: null, text: 'Message 1' }, ]; it('should start with the message that has a summary property and continue until the specified parentMessageId', () => { const result = TestClient.constructor.getMessagesForConversation({ messages: unorderedMessagesWithSummary, parentMessageId: '4', summary: true, }); expect(result).toEqual([ { id: '3', parentMessageId: '2', role: 'system', text: 'Message 3', content: [{ type: 'text', text: 'Summary for Message 3' }], summary: 'Summary for Message 3', }, { id: '4', parentMessageId: '3', text: 'Message 4' }, ]); }); it('should handle multiple summaries and return the branch from the latest to the parentMessageId', () => { unorderedMessagesWithSummary = [ { id: '5', parentMessageId: '4', text: 'Message 5' }, { id: '2', parentMessageId: '1', text: 'Message 2', summary: 'Summary for Message 2' }, { id: '3', parentMessageId: '2', text: 'Message 3', summary: 'Summary for Message 3' }, { id: '4', parentMessageId: '3', text: 'Message 4', summary: 'Summary for Message 4' }, { id: '1', parentMessageId: null, text: 'Message 1' }, ]; const result = TestClient.constructor.getMessagesForConversation({ messages: unorderedMessagesWithSummary, parentMessageId: '5', summary: true, }); expect(result).toEqual([ { id: '4', parentMessageId: '3', role: 'system', text: 'Message 4', content: [{ type: 'text', text: 'Summary for Message 4' }], summary: 'Summary for Message 4', }, { id: '5', parentMessageId: '4', text: 'Message 5' }, ]); }); it('should handle summary at root edge case and continue until the parentMessageId', () => { unorderedMessagesWithSummary = [ { id: '5', parentMessageId: '4', text: 'Message 5' }, { id: '1', parentMessageId: null, text: 'Message 1', summary: 'Summary for Message 1' }, { id: '4', parentMessageId: '3', text: 'Message 4', summary: 'Summary for Message 4' }, { id: '2', parentMessageId: '1', text: 'Message 2', summary: 'Summary for Message 2' }, { id: '3', parentMessageId: '2', text: 'Message 3', summary: 'Summary for Message 3' }, ]; const result = TestClient.constructor.getMessagesForConversation({ messages: unorderedMessagesWithSummary, parentMessageId: '5', summary: true, }); expect(result).toEqual([ { id: '4', parentMessageId: '3', role: 'system', text: 'Message 4', content: [{ type: 'text', text: 'Summary for Message 4' }], summary: 'Summary for Message 4', }, { id: '5', parentMessageId: '4', text: 'Message 5' }, ]); }); it('should detect summary content block and use it over legacy fields (summary mode)', () => { const messagesWithContentBlock = [ { id: '3', parentMessageId: '2', text: 'Message 3' }, { id: '2', parentMessageId: '1', text: 'Message 2', content: [ { type: 'text', text: 'Original text' }, { type: 'summary', text: 'Content block summary', tokenCount: 42 }, ], }, { id: '1', parentMessageId: null, text: 'Message 1' }, ]; const result = TestClient.constructor.getMessagesForConversation({ messages: messagesWithContentBlock, parentMessageId: '3', summary: true, }); expect(result).toHaveLength(2); expect(result[0].role).toBeUndefined(); expect(result[0].content).toEqual([ { type: 'summary', text: 'Content block summary', tokenCount: 42 }, ]); }); it('should prefer content block summary over legacy summary field', () => { const messagesWithBoth = [ { id: '2', parentMessageId: '1', text: 'Message 2' }, { id: '1', parentMessageId: null, text: 'Message 1', summary: 'Legacy summary', summaryTokenCount: 10, content: [{ type: 'summary', text: 'Content block summary', tokenCount: 20 }], }, ]; const result = TestClient.constructor.getMessagesForConversation({ messages: messagesWithBoth, parentMessageId: '2', summary: true, }); expect(result).toHaveLength(2); expect(result[0].content).toEqual([ { type: 'summary', text: 'Content block summary', tokenCount: 20 }, ]); }); it('should fallback to legacy summary when no content block exists', () => { const messagesWithLegacy = [ { id: '2', parentMessageId: '1', text: 'Message 2' }, { id: '1', parentMessageId: null, text: 'Message 1', summary: 'Legacy summary only', summaryTokenCount: 15, }, ]; const result = TestClient.constructor.getMessagesForConversation({ messages: messagesWithLegacy, parentMessageId: '2', summary: true, }); expect(result).toHaveLength(2); expect(result[0].content).toEqual([{ type: 'text', text: 'Legacy summary only' }]); expect(result[0].tokenCount).toBe(15); }); it('keeps the parts a response produced after its summary (summary mode)', () => { const trailingText = { type: 'text', text: 'Answer after summarizing' }; const messagesWithTrailingParts = [ { id: '1', parentMessageId: null, text: 'Message 1' }, { id: '2', parentMessageId: '1', text: 'Before summarizing', content: [ { type: 'text', text: 'Before summarizing' }, { type: 'summary', text: 'Earlier context', tokenCount: 6 }, trailingText, ], }, { id: '3', parentMessageId: '2', text: 'Message 3' }, ]; const result = TestClient.constructor.getMessagesForConversation({ messages: messagesWithTrailingParts, parentMessageId: '3', summary: true, }); expect(result.map((message) => message.id)).toEqual(['2', '3']); expect(result[0].content).toEqual([ { type: 'summary', text: 'Earlier context', tokenCount: 6 }, trailingText, ]); }); it('should not stop traversal at a failed summary, keeping the prior history', () => { /** A summarize round that errored keeps the deltas it streamed, so its * text is a truncated prefix; treating it as the checkpoint would send * it in place of the history it never finished summarizing. */ const messagesWithFailedSummary = [ { id: '1', parentMessageId: null, text: 'Message 1' }, { id: '2', parentMessageId: '1', text: 'Message 2' }, { id: '3', parentMessageId: '2', text: '', content: [{ type: 'summary', text: 'Partial sum', tokenCount: 5, failed: true }], }, { id: '4', parentMessageId: '3', text: 'Message 4' }, ]; const result = TestClient.constructor.getMessagesForConversation({ messages: messagesWithFailedSummary, parentMessageId: '4', summary: true, }); expect(result.map((message) => message.id)).toEqual(['1', '2', '3', '4']); expect(result.every((message) => message.role !== 'system')).toBe(true); }); }); describe('sendMessage', () => { test('sendMessage should return a response message', async () => { const expectedResult = expect.objectContaining({ sender: TestClient.sender, text: expect.any(String), isCreatedByUser: false, messageId: expect.any(String), parentMessageId: expect.any(String), conversationId: expect.any(String), }); const response = await TestClient.sendMessage(userMessage); parentMessageId = response.messageId; conversationId = response.conversationId; expect(response).toEqual(expectedResult); }); test('persists exact provenance paths for edited and steered assistant content', async () => { const history = [ { role: 'user', isCreatedByUser: true, text: 'Original question', messageId: 'user-message', parentMessageId: Constants.NO_PARENT, }, { role: 'assistant', isCreatedByUser: false, messageId: 'assistant-message', parentMessageId: 'user-message', userSubmittedPaths: ['/content/1/think'], userSubmittedMessageFieldPaths: [ { path: '/content/0/tool_call/output', field: 'answer' }, ], content: [ { type: ContentTypes.TOOL_CALL, tool_call: { name: 'ask_user_question', output: 'Prior answer' }, }, { type: ContentTypes.THINK, [ContentTypes.THINK]: 'Prior user-edited reasoning' }, { type: ContentTypes.TEXT, [ContentTypes.TEXT]: 'Original model response' }, ], }, ]; TestClient = initializeFakeClient(apiKey, options, history); TestClient.clientName = 'agents'; TestClient.sendCompletion.mockResolvedValue({ completion: [ { type: ContentTypes.TEXT, [ContentTypes.TEXT]: ' model continuation' }, { type: ContentTypes.STEER, [ContentTypes.STEER]: 'User steer' }, ], metadata: undefined, }); const response = await TestClient.sendMessage('ignored during edit', { conversationId: 'conversation-1', parentMessageId: 'assistant-message', responseMessageId: 'assistant-message', isEdited: true, isContinued: true, editedContent: { index: 2, text: 'User replacement', type: ContentTypes.TEXT, }, }); const modelBoundEditedMessage = TestClient.buildMessages.mock.calls[0][0].at(-1); expect(modelBoundEditedMessage.userSubmittedPaths).toEqual([ '/content/1/think', '/content/2/text', ]); expect(response.content).toEqual([ { type: ContentTypes.TOOL_CALL, tool_call: { name: 'ask_user_question', output: 'Prior answer' }, }, { type: ContentTypes.THINK, [ContentTypes.THINK]: 'Prior user-edited reasoning' }, { type: ContentTypes.TEXT, [ContentTypes.TEXT]: 'User replacement model continuation', }, { type: ContentTypes.STEER, [ContentTypes.STEER]: 'User steer' }, ]); expect(response.userSubmittedPaths).toEqual([ '/content/3', '/content/1/think', '/content/2/text', ]); expect(response.userSubmittedMessageFieldPaths).toEqual([ { path: '/content/0/tool_call/output', field: 'answer' }, ]); expect(response).not.toHaveProperty('isUserSubmitted'); }); test('should replace responseMessageId with new UUID when isRegenerate is true and messageId ends with underscore', async () => { const mockCrypto = require('crypto'); const newUUID = 'new-uuid-1234'; jest.spyOn(mockCrypto, 'randomUUID').mockReturnValue(newUUID); const opts = { isRegenerate: true, responseMessageId: 'existing-message-id_', }; await TestClient.setMessageOptions(opts); expect(TestClient.responseMessageId).toBe(newUUID); expect(TestClient.responseMessageId).not.toBe('existing-message-id_'); mockCrypto.randomUUID.mockRestore(); }); test('should not replace responseMessageId when isRegenerate is false', async () => { const opts = { isRegenerate: false, responseMessageId: 'existing-message-id_', }; await TestClient.setMessageOptions(opts); expect(TestClient.responseMessageId).toBe('existing-message-id_'); }); test('should not replace responseMessageId when it does not end with underscore', async () => { const opts = { isRegenerate: true, responseMessageId: 'existing-message-id', }; await TestClient.setMessageOptions(opts); expect(TestClient.responseMessageId).toBe('existing-message-id'); }); test('sendMessage should work with provided conversationId and parentMessageId', async () => { const userMessage = 'Second message in the conversation'; const opts = { conversationId, parentMessageId, getReqData: jest.fn(), onStart: jest.fn(), }; const expectedResult = expect.objectContaining({ sender: TestClient.sender, text: expect.any(String), isCreatedByUser: false, messageId: expect.any(String), parentMessageId: expect.any(String), conversationId: opts.conversationId, }); const response = await TestClient.sendMessage(userMessage, opts); parentMessageId = response.messageId; expect(response.conversationId).toEqual(conversationId); expect(response).toEqual(expectedResult); expect(opts.getReqData).toHaveBeenCalled(); expect(opts.onStart).toHaveBeenCalled(); expect(TestClient.getBuildMessagesOptions).toHaveBeenCalled(); expect(TestClient.getSaveOptions).toHaveBeenCalled(); }); test('runs the restored-history guard before building model input', async () => { const policyError = Object.assign(new Error('Blocked restored history'), { code: 'content_filter_block', }); TestClient.assertStoredModelBoundContent = jest.fn(() => { throw policyError; }); await expect(TestClient.sendMessage('Safe new message')).rejects.toBe(policyError); expect(TestClient.assertStoredModelBoundContent).toHaveBeenCalledTimes(1); expect(TestClient.buildMessages).not.toHaveBeenCalled(); expect(TestClient.sendCompletion).not.toHaveBeenCalled(); }); test('cancels a deferred user-message write when the model boundary rejects content', async () => { saveMessage.mockClear(); saveConvo.mockClear(); const policyError = new ContentFilterError({ source: 'message', field: 'text' }); const getReqData = jest.fn(); const abortController = new AbortController(); TestClient.shouldDeferUserMessagePersistence = jest.fn(() => true); TestClient.sendCompletion.mockRejectedValue(policyError); await expect( TestClient.sendMessage('Safe new message', { abortController, getReqData }), ).rejects.toBe(policyError); /** Policy cancellation removes the Stop listener and remains final. */ abortController.abort(); expect(saveMessage).not.toHaveBeenCalled(); expect(saveConvo).not.toHaveBeenCalled(); const persistenceCall = getReqData.mock.calls.find(([data]) => data.userMessagePromise); await expect(persistenceCall[0].userMessagePromise).resolves.toEqual({}); }); test('starts a deferred user-message write after a safe no-model completion', async () => { saveMessage.mockClear(); saveConvo.mockClear(); TestClient.shouldDeferUserMessagePersistence = jest.fn(() => true); TestClient.sendCompletion.mockImplementation(async () => { expect(saveMessage).not.toHaveBeenCalled(); return { completion: 'Safe response', metadata: undefined }; }); await TestClient.sendMessage('Safe new message'); expect(saveMessage.mock.calls.some(([, message]) => message.isCreatedByUser === true)).toBe( true, ); }); describe('seeding the conversation for a deferred user message', () => { const seedContext = 'api/app/clients/BaseClient.js - sendMessage #seedConversation'; const flush = () => new Promise((resolve) => setImmediate(resolve)); const savedUserMessage = () => saveMessage.mock.calls.some(([, message]) => message.isCreatedByUser === true); beforeEach(() => { saveMessage.mockReset(); saveConvo.mockReset().mockImplementation(async (_ctx, fields) => ({ ...fields })); getConvo.mockReset().mockResolvedValue(null); /** A fresh options object: the suite-level one is shared by reference across clients. */ TestClient.options = { ...TestClient.options, req: { user: { id: 'seed-user' }, body: {} }, }; TestClient.shouldDeferUserMessagePersistence = jest.fn(() => true); TestClient.shouldSeedDeferredConversation = jest.fn(() => true); }); afterEach(() => { saveMessage.mockReset(); saveConvo.mockReset(); getConvo.mockReset(); }); test('creates a new conversation row while the message itself waits for admission', async () => { TestClient.sendCompletion.mockImplementation(async () => { await flush(); expect(savedUserMessage()).toBe(false); expect(saveConvo).toHaveBeenCalledTimes(1); const [, fields, seedOptions] = saveConvo.mock.calls[0]; expect(fields).toEqual(expect.objectContaining({ conversationId: expect.any(String) })); expect(seedOptions).toEqual(expect.objectContaining({ context: seedContext })); /** An empty append set spares `saveConvo` the read of a message list the seed lacks. */ expect(seedOptions).toEqual(expect.objectContaining({ appendMessageIds: [] })); return { completion: 'Safe response', metadata: undefined }; }); await TestClient.sendMessage('Message with an attachment'); expect(savedUserMessage()).toBe(true); /** The message save reuses the seeded row instead of looking the conversation up again. */ expect(getConvo).toHaveBeenCalledTimes(1); }); test('leaves an existing conversation to the deferred message write', async () => { getConvo.mockResolvedValue({ conversationId: 'existing-convo', endpoint: 'openAI' }); TestClient.sendCompletion.mockImplementation(async () => { await flush(); expect(saveConvo).not.toHaveBeenCalled(); return { completion: 'Safe response', metadata: undefined }; }); await TestClient.sendMessage('Message with an attachment'); expect(savedUserMessage()).toBe(true); expect(saveConvo.mock.calls.every(([, , opts]) => opts.context !== seedContext)).toBe(true); }); test('holds the deferred message write until an in-flight seed lands', async () => { const seedWrite = deferred(); saveConvo.mockImplementationOnce(() => seedWrite.promise); const completionStarted = deferred(); const completionResult = deferred(); const abortController = new AbortController(); TestClient.sendCompletion.mockImplementation(() => { completionStarted.resolve(); return completionResult.promise; }); const sendPromise = TestClient.sendMessage('Message with an attachment', { abortController, }); await completionStarted.promise; await flush(); expect(saveConvo).toHaveBeenCalledTimes(1); abortController.abort(); await flush(); expect(savedUserMessage()).toBe(false); seedWrite.resolve({ conversationId: 'seeded-convo' }); await flush(); expect(savedUserMessage()).toBe(true); completionResult.resolve({ completion: 'Partial response', metadata: undefined }); await sendPromise; }); test('keeps the deferral cancellable after seeding when the model boundary rejects content', async () => { const policyError = new ContentFilterError({ source: 'message', field: 'text' }); TestClient.sendCompletion.mockImplementation(async () => { await flush(); throw policyError; }); await expect(TestClient.sendMessage('Message with an attachment')).rejects.toBe( policyError, ); expect(savedUserMessage()).toBe(false); expect(saveConvo).toHaveBeenCalledTimes(1); }); test('does not seed when the client holds back every write', async () => { TestClient.shouldSeedDeferredConversation = jest.fn(() => false); TestClient.sendCompletion.mockImplementation(async () => { await flush(); expect(saveConvo).not.toHaveBeenCalled(); return { completion: 'Safe response', metadata: undefined }; }); await TestClient.sendMessage('Message with an attachment'); expect(savedUserMessage()).toBe(true); }); }); test('preserves eager user-message persistence for non-policy provider failures', async () => { saveMessage.mockClear(); saveConvo.mockClear(); const providerError = new Error('Provider unavailable'); TestClient.shouldDeferUserMessagePersistence = jest.fn(() => true); TestClient.sendCompletion.mockRejectedValue(providerError); await expect(TestClient.sendMessage('Safe new message')).rejects.toBe(providerError); expect(saveMessage.mock.calls.some(([, message]) => message.isCreatedByUser === true)).toBe( true, ); }); test('starts a deferred user-message write when Stop aborts an in-flight completion', async () => { saveMessage.mockClear(); saveConvo.mockClear(); const completionStarted = deferred(); const completionResult = deferred(); const abortController = new AbortController(); TestClient.shouldDeferUserMessagePersistence = jest.fn(() => true); TestClient.sendCompletion.mockImplementation(() => { completionStarted.resolve(); return completionResult.promise; }); const sendPromise = TestClient.sendMessage('Safe new message', { abortController }); await completionStarted.promise; expect(saveMessage).not.toHaveBeenCalled(); abortController.abort(); expect(saveMessage.mock.calls.some(([, message]) => message.isCreatedByUser === true)).toBe( true, ); completionResult.resolve({ completion: 'Partial response', metadata: undefined }); await sendPromise; }); test('keeps an abort-started write when a late policy error loses the settlement race', async () => { saveMessage.mockClear(); saveConvo.mockClear(); const completionStarted = deferred(); const completionResult = deferred(); const policyError = new ContentFilterError({ source: 'message', field: 'text' }); const abortController = new AbortController(); TestClient.shouldDeferUserMessagePersistence = jest.fn(() => true); TestClient.sendCompletion.mockImplementation(() => { completionStarted.resolve(); return completionResult.promise; }); const sendPromise = TestClient.sendMessage('Safe new message', { abortController }); await completionStarted.promise; abortController.abort(); completionResult.reject(policyError); await expect(sendPromise).rejects.toBe(policyError); expect(saveMessage.mock.calls.some(([, message]) => message.isCreatedByUser === true)).toBe( true, ); }); test('blocks persisted user text selected by the built model payload', async () => { const secret = 'PRIVATE-HISTORICAL-VALUE'; const history = [ { role: 'user', isCreatedByUser: true, text: `Previously stored ${secret}`, messageId: 'persisted-user', parentMessageId: Constants.NO_PARENT, }, { role: 'assistant', isCreatedByUser: false, text: 'Safe model response', messageId: 'persisted-assistant', parentMessageId: 'persisted-user', }, ]; TestClient = initializeFakeClient( apiKey, { ...options, req: { config: { filters: { messages: { pii: { fields: ['text'], starterPatterns: [], customPatterns: [ { id: 'historical-private', label: 'historical private value', regex: 'PRIVATE-HISTORICAL-[A-Z]+', }, ], }, }, }, }, }, }, history, ); let error; try { await TestClient.sendMessage('Safe new message', { conversationId: 'persisted-conversation', parentMessageId: 'persisted-assistant', }); } catch (caughtError) { error = caughtError; } expect(error).toMatchObject({ code: 'content_filter_block', body: { error: 'content_filter_block', source: 'message', field: 'text', }, }); expect(JSON.stringify({ message: error.message, body: error.body })).not.toContain(secret); expect(TestClient.buildMessages).toHaveBeenCalledTimes(1); expect(TestClient.sendCompletion).not.toHaveBeenCalled(); }); test('allows persisted user text that the built model payload prunes out', async () => { const secret = 'PRIVATE-PRUNED-HISTORICAL-VALUE'; TestClient = initializeFakeClient( apiKey, { ...options, req: { config: { filters: { messages: { pii: { fields: ['text'], starterPatterns: [], customPatterns: [ { id: 'pruned-private', label: 'pruned private value', regex: 'PRIVATE-PRUNED-HISTORICAL-[A-Z]+', }, ], }, }, }, }, }, }, [ { role: 'user', isCreatedByUser: true, text: `Old ${secret}`, messageId: 'pruned-user', parentMessageId: Constants.NO_PARENT, }, { role: 'assistant', isCreatedByUser: false, text: 'Safe response', messageId: 'safe-assistant', parentMessageId: 'pruned-user', }, ], ); TestClient.buildMessages.mockResolvedValue({ prompt: [{ role: 'user', content: 'Safe new message' }], tokenCountMap: null, }); await expect( TestClient.sendMessage('Safe new message', { conversationId: 'pruned-conversation', parentMessageId: 'safe-assistant', }), ).resolves.toEqual(expect.objectContaining({ isCreatedByUser: false })); expect(TestClient.buildMessages).toHaveBeenCalledTimes(1); expect(TestClient.sendCompletion).toHaveBeenCalledTimes(1); }); test('blocks historical tool arguments without classifying assistant prose as user input', async () => { const filters = { messages: { pii: { fields: ['text'], starterPatterns: [], customPatterns: [ { id: 'assistant-prose', label: 'assistant prose value', regex: 'PRIVATE-PROSE', }, ], }, }, toolArguments: { pii: { fields: ['arguments'], starterPatterns: [], customPatterns: [ { id: 'historical-tool', label: 'historical tool value', regex: 'PRIVATE-TOOL', }, ], }, }, }; const safeUserMessage = { role: 'user', isCreatedByUser: true, text: 'Safe historical question', messageId: 'safe-user', parentMessageId: Constants.NO_PARENT, }; const assistantMessage = { role: 'assistant', isCreatedByUser: false, text: 'Model generated PRIVATE-PROSE', content: [ { type: 'tool_call', tool_call: { name: 'lookup', args: { query: 'PRIVATE-TOOL' }, }, }, ], messageId: 'assistant-with-tool', parentMessageId: 'safe-user', }; const clientOptions = { ...options, req: { config: { filters } }, }; TestClient = initializeFakeClient(apiKey, clientOptions, [safeUserMessage, assistantMessage]); await expect( TestClient.sendMessage('Safe new message', { conversationId: 'tool-conversation', parentMessageId: 'assistant-with-tool', }), ).rejects.toMatchObject({ code: 'content_filter_block', body: { source: 'tool_argument', field: 'arguments', }, }); expect(TestClient.buildMessages).toHaveBeenCalledTimes(1); expect(TestClient.sendCompletion).not.toHaveBeenCalled(); const proseOnlyClient = initializeFakeClient(apiKey, clientOptions, [ safeUserMessage, { ...assistantMessage, content: undefined, }, ]); await expect( proseOnlyClient.sendMessage('Safe new message', { conversationId: 'prose-conversation', parentMessageId: 'assistant-with-tool', }), ).resolves.toEqual(expect.objectContaining({ isCreatedByUser: false })); expect(proseOnlyClient.buildMessages).toHaveBeenCalledTimes(1); expect(proseOnlyClient.sendCompletion).toHaveBeenCalledTimes(1); }); test('resolves and inspects owner-scoped historical files before building messages', async () => { const historicalMessage = { role: 'user', isCreatedByUser: true, text: 'Use my file', files: [{ file_id: 'owned-file' }], messageId: 'historical-file-message', parentMessageId: Constants.NO_PARENT, }; getFiles.mockReset(); getFiles.mockResolvedValueOnce([ { file_id: 'owned-file', filename: 'owned.txt', filepath: '/uploads/owned.txt', text: 'safe canonical file content', user: 'user-1', }, ]); TestClient = initializeFakeClient( apiKey, { ...options, req: { user: { id: 'user-1', tenantId: 'tenant-a' }, config: { filters: { files: { pii: { fields: ['extracted_text'], starterPatterns: [], uninspectable: 'block', }, }, }, }, }, }, [historicalMessage], ); await expect( TestClient.sendMessage('Safe new message', { conversationId: 'historical-file-conversation', parentMessageId: 'historical-file-message', }), ).resolves.toBeDefined(); expect(getFiles).toHaveBeenCalledWith( { file_id: { $in: ['owned-file'] }, user: 'user-1', tenantId: 'tenant-a', }, {}, {}, ); expect(TestClient.buildMessages).toHaveBeenCalled(); }); test('keeps the turn view of historical files that projection and steer replay read', async () => { const routedCsv = { file_id: 'csv-file', filename: 'sales.csv', filepath: '/uploads/sales.csv', type: 'text/csv', text: 'region,total', llmDeliveryPath: 'none', metadata: { destinationChosen: false }, user: 'user-1', }; getFiles.mockReset(); getFiles.mockResolvedValueOnce([routedCsv]); TestClient = initializeFakeClient( apiKey, { ...options, agent: { provider: EModelEndpoint.openAI, fileConsumers: { executeCode: false, fileSearch: false }, }, req: { user: { id: 'user-1', tenantId: 'tenant-a' }, config: { fileConfig: { endpoints: { [EModelEndpoint.openAI]: { defaultLLMDeliveryPath: { overrides: { 'text/csv': 'none' } }, textFallbackWithoutTools: true, }, }, }, }, }, }, [ { role: 'user', isCreatedByUser: true, text: 'Summarize my sheet', files: [{ file_id: 'csv-file' }], messageId: 'historical-csv-message', parentMessageId: Constants.NO_PARENT, }, ], ); TestClient.options.agent.deliveryRouting = resolveTurnDeliveryRouting({ agent: TestClient.options.agent, config: TestClient.options.req.config, }); await TestClient.sendMessage('And the totals?', { conversationId: 'historical-csv-conversation', parentMessageId: 'historical-csv-message', }); expect(TestClient.authorizedHistoricalFiles.get('csv-file')).toEqual({ ...routedCsv, llmDeliveryPath: 'text', }); expect(routedCsv.llmDeliveryPath).toBe('none'); }); test('does not block a missing historical file omitted from the final payload', async () => { getFiles.mockReset(); getFiles.mockResolvedValueOnce([]); TestClient = initializeFakeClient( apiKey, { ...options, req: { user: { id: 'user-1', tenantId: 'tenant-a' }, config: { filters: { files: { pii: { fields: ['extracted_text'], starterPatterns: [], uninspectable: 'block', }, }, }, }, }, }, [ { role: 'user', isCreatedByUser: true, text: 'Use a foreign file', files: [{ file_id: 'foreign-file' }], messageId: 'foreign-file-message', parentMessageId: Constants.NO_PARENT, }, ], ); await expect( TestClient.sendMessage('Safe new message', { conversationId: 'foreign-file-conversation', parentMessageId: 'foreign-file-message', }), ).resolves.toEqual(expect.objectContaining({ isCreatedByUser: false })); expect(TestClient.buildMessages).toHaveBeenCalledTimes(1); expect(TestClient.sendCompletion).toHaveBeenCalledTimes(1); }); test('surfaces historical file lookup failures instead of silently dropping context', async () => { getFiles.mockReset(); getFiles.mockRejectedValueOnce(new Error('historical file lookup unavailable')); TestClient = initializeFakeClient( apiKey, { ...options, req: { user: { id: 'user-1', tenantId: 'tenant-a' }, config: {} }, }, [ { role: 'user', isCreatedByUser: true, text: 'Use my historical file', files: [{ file_id: 'historical-file' }], messageId: 'historical-file-message', parentMessageId: Constants.NO_PARENT, }, ], ); await expect( TestClient.sendMessage('Safe new message', { conversationId: 'historical-file-error-conversation', parentMessageId: 'historical-file-message', }), ).rejects.toThrow('historical file lookup unavailable'); expect(TestClient.buildMessages).not.toHaveBeenCalled(); expect(TestClient.sendCompletion).not.toHaveBeenCalled(); }); test('ignores historical file refs when the endpoint does not resend files', async () => { getFiles.mockReset(); TestClient = initializeFakeClient( apiKey, { ...options, resendFiles: false, req: { user: { id: 'user-1', tenantId: 'tenant-a' }, config: { filters: { files: { pii: { fields: ['extracted_text'], starterPatterns: [], uninspectable: 'block', }, }, }, }, }, }, [ { role: 'user', isCreatedByUser: true, text: 'A prior turn referenced a file.', files: [{ file_id: 'deleted-historical-file' }], content: [ { type: 'input_file', files: [{ file_id: 'part-file' }], image_file: { file_id: 'image-file' }, file_id: 'direct-file', file: { file_id: 'nested-file' }, }, ], messageId: 'historical-file-message', parentMessageId: Constants.NO_PARENT, }, ], ); await expect( TestClient.sendMessage('Safe text-only continuation', { conversationId: 'no-file-replay-conversation', parentMessageId: 'historical-file-message', }), ).resolves.toBeDefined(); expect(getFiles).not.toHaveBeenCalled(); expect(TestClient.buildMessages).toHaveBeenCalled(); const [modelMessages] = TestClient.buildMessages.mock.calls[0]; expect(modelMessages[0]).not.toHaveProperty('files'); expect(modelMessages[0].content[0]).toEqual({ type: 'input_file' }); expect(TestClient.sendCompletion).toHaveBeenCalled(); }); test('keeps a materialized current attachment inspectable when historical replay is disabled', () => { const currentFile = { file_id: 'current-file', filename: 'safe.txt', text: 'Safe current attachment content', }; TestClient = initializeFakeClient(apiKey, { ...options, resendFiles: false, attachments: [currentFile], req: { config: { filters: { files: { pii: { fields: ['extracted_text'], starterPatterns: [], uninspectable: 'block', }, }, }, }, }, }); TestClient.message_file_map = { 'current-source': [currentFile] }; TestClient.setModelBoundStoredMessages([ { messageId: 'current-source', role: 'user', isCreatedByUser: true, text: 'Use the current file', }, ]); expect(() => TestClient.assertBuiltModelBoundContent([ { role: 'user', content: 'Use the current file', additional_kwargs: { sourceMessageId: 'current-source' }, }, ]), ).not.toThrow(); }); test('should return chat history', async () => { TestClient = initializeFakeClient(apiKey, options, messageHistory); const chatMessages = await TestClient.loadHistory(conversationId, '2'); expect(TestClient.currentMessages).toHaveLength(2); expect(chatMessages[0].text).toEqual('Hello'); const chatMessages2 = await TestClient.loadHistory(conversationId, '3'); expect(TestClient.currentMessages).toHaveLength(3); expect(chatMessages2[chatMessages2.length - 1].text).toEqual("What's up"); }); test('loadHistory should scope database reads to the current user', async () => { const user = 'user-123'; TestClient = new FakeClient(apiKey, options); TestClient.user = user; getMessages.mockResolvedValueOnce([ { role: 'user', isCreatedByUser: true, text: 'Hello', messageId: '1', conversationId, }, ]); const chatMessages = await TestClient.loadHistory(conversationId, '1'); expect(getMessages).toHaveBeenCalledWith({ conversationId, user }, '+privateTextTokens'); expect(chatMessages).toHaveLength(1); expect(chatMessages[0].text).toBe('Hello'); }); /* Most of the new sendMessage logic revolving around edited/continued AI messages * can be summarized by the following test. The condition will load the entire history up to * the message that is being edited, which will trigger the AI API to 'continue' the response. * The 'userMessage' is only passed by convention and is not necessary for the generation. */ it('should not push userMessage to currentMessages when isEdited is true and vice versa', async () => { const overrideParentMessageId = 'user-message-id'; const responseMessageId = 'response-message-id'; const newHistory = messageHistory.slice(); newHistory.push({ role: 'assistant', isCreatedByUser: false, text: 'test message', messageId: responseMessageId, parentMessageId: '3', }); TestClient = initializeFakeClient(apiKey, options, newHistory); const sendMessageOptions = { isEdited: true, overrideParentMessageId, parentMessageId: '3', responseMessageId, }; await TestClient.sendMessage('test message', sendMessageOptions); const currentMessages = TestClient.currentMessages; expect(currentMessages[currentMessages.length - 1].messageId).not.toEqual( overrideParentMessageId, ); // Test the opposite case sendMessageOptions.isEdited = false; await TestClient.sendMessage('test message', sendMessageOptions); const currentMessages2 = TestClient.currentMessages; expect(currentMessages2[currentMessages2.length - 1].messageId).toEqual( overrideParentMessageId, ); }); it('honors response and user message IDs preallocated before initialization', async () => { TestClient = initializeFakeClient(apiKey, options, messageHistory); const result = await TestClient.handleStartMethods('request-scoped MCP', { conversationId, parentMessageId: '3', preallocatedUserMessageId: 'preallocated-user', preallocatedResponseMessageId: 'preallocated-response', }); expect(result.userMessage.messageId).toBe('preallocated-user'); expect(result.responseMessageId).toBe('preallocated-response'); expect(TestClient.responseMessageId).toBe('preallocated-response'); }); it('applies edited reasoning content from its typed payload before regeneration', async () => { const responseMessageId = 'response-with-reasoning'; const newHistory = [ ...messageHistory, { role: 'assistant', isCreatedByUser: false, messageId: responseMessageId, parentMessageId: '3', content: [ { type: ContentTypes.THINK, think: 'Original reasoning', phase: 'analysis', reasoning_label: 'Inspecting the original path', reasoning_label_step_id: 'old-step', reasoning_label_attempts: 2, reasoning_label_submitted_chars: 18, reasoning_label_revision: 2, reasoning_label_status: 'complete', }, { type: ContentTypes.TEXT, text: 'Original response' }, ], }, ]; TestClient = initializeFakeClient(apiKey, options, newHistory); await TestClient.sendMessage('test message', { isEdited: true, overrideParentMessageId: 'user-message-id', parentMessageId: '3', responseMessageId, editedContent: { index: 0, type: ContentTypes.THINK, [ContentTypes.THINK]: 'Updated reasoning', }, }); const editedResponse = TestClient.currentMessages[TestClient.currentMessages.length - 1]; expect(editedResponse.content[0]).toEqual({ type: ContentTypes.THINK, think: 'Updated reasoning', phase: 'analysis', }); }); test('setOptions is called with the correct arguments only when replaceOptions is set to true', async () => { TestClient.setOptions = jest.fn(); const opts = { conversationId: '123', parentMessageId: '456', replaceOptions: true }; await TestClient.sendMessage('Hello, world!', opts); expect(TestClient.setOptions).toHaveBeenCalledWith(opts); TestClient.setOptions.mockClear(); }); test('loadHistory is called with the correct arguments', async () => { const opts = { conversationId: '123', parentMessageId: '456' }; await TestClient.sendMessage('Hello, world!', opts); expect(TestClient.loadHistory).toHaveBeenCalledWith( opts.conversationId, opts.parentMessageId, ); }); test('getReqData is called with the correct arguments', async () => { const getReqData = jest.fn(); const opts = { getReqData }; const response = await TestClient.sendMessage('Hello, world!', opts); expect(getReqData).toHaveBeenCalledWith( expect.objectContaining({ userMessage: expect.objectContaining({ text: 'Hello, world!' }), conversationId: response.conversationId, responseMessageId: response.messageId, }), ); }); function protectedClient(history = [], legacyPii) { const filters = { messages: { pii: { action: 'redact', fields: ['text'], starterPatterns: [], customPatterns: [ { id: 'email', label: 'Email', regex: 'alice@example\\.com', category: 'email' }, ], }, }, }; const req = { user: { id: 'owner' }, path: '/', body: { text: 'alice@example.com', clientRequestId: 'created-privacy' }, config: { filters, messageFilter: { pii: legacyPii } }, }; const next = jest.fn(); createPrivateTextIngress({ getFilters: () => filters, getLegacyPii: () => legacyPii, getKey: () => 'ab'.repeat(32), })(req, { status: jest.fn().mockReturnThis(), json: jest.fn() }, next); expect(next).toHaveBeenCalledTimes(1); const client = initializeFakeClient(apiKey, { ...options, req }, history); client.shouldDeferUserMessagePersistence = () => true; client.assertStoredModelBoundContent = () => assertModelBoundContent({ legacyPii, storedMessages: client.modelBoundStoredMessages, }); client.assertBuiltModelBoundContent = () => {}; client.saveMessageToDatabase = jest.fn(async (message) => ({ message })); const provider = jest.fn(); client.sendCompletion = jest.fn(async (payload) => { const callback = createModelBoundChatModelCallback( { filters, legacyPii, storedMessages: client.modelBoundStoredMessages, privateTextTokens: getPrivateTextInspectionTokens(client.modelBoundStoredMessages), }, { onContentRejected: client.modelBoundUserMessagePersistence?.cancel, onContentAllowed: getPrivateTextAdmission( req, client.modelBoundUserMessagePersistence?.start, client.privateTextStart, ), }, ); await callback.handleChatModelStart(undefined, [payload]); provider(); return { completion: 'Safe reply' }; }); return { client, req, provider }; } test('protected startup remains deferred until exact admission and the atomic write finishes', async () => { const { client, req, provider } = protectedClient(); const committed = deferred(); let written; client.saveMessageToDatabase.mockImplementationOnce((message) => { written = message; return committed.promise; }); const onStart = jest.fn(); const sent = client.sendMessage(req.body.text, { onStart }); // Wait for the admission callback to begin the real deferred write. for (let i = 0; i < 30 && !written; i++) { await Promise.resolve(); } expect(written).toBeDefined(); expect(onStart).not.toHaveBeenCalled(); expect(provider).not.toHaveBeenCalled(); committed.resolve({ message: written }); await sent; expect(onStart).toHaveBeenCalledTimes(1); expect(provider).toHaveBeenCalledTimes(1); expect(onStart.mock.invocationCallOrder[0]).toBeLessThan( provider.mock.invocationCallOrder[0], ); }); test('protected write failure prevents created and the provider call', async () => { const { client, req, provider } = protectedClient(); client.saveMessageToDatabase.mockResolvedValueOnce({}); const onStart = jest.fn(); await expect(client.sendMessage(req.body.text, { onStart })).rejects.toThrow(); expect(onStart).not.toHaveBeenCalled(); expect(provider).not.toHaveBeenCalled(); }); test.each([false, true])( 'cancels protected Stop before native admission, pre-aborted: %s', async (preAborted) => { const { client, req, provider } = protectedClient(); const controller = new AbortController(); if (preAborted) { controller.abort(); } const ready = deferred(); const completion = deferred(); const onStart = jest.fn(); client.sendCompletion = jest.fn(async () => { ready.resolve(); return completion.promise; }); const sent = client.sendMessage(req.body.text, { abortController: controller, onStart }); const observed = sent.catch((error) => error); await ready.promise; if (!preAborted) { controller.abort(); } completion.resolve({ completion: 'Stopped before model' }); expect(await observed).toEqual(expect.objectContaining({ code: 'content_filter_block' })); expect(client.saveMessageToDatabase).not.toHaveBeenCalled(); expect(onStart).not.toHaveBeenCalled(); expect(provider).not.toHaveBeenCalled(); }, ); test.each(['user-id', 'user-id__1', 'user-id__invalid'])( 'rejects a protected persistence-skipping override %s before model invocation', async (overrideUserMessageId) => { const { client, req, provider } = protectedClient(); req.body.overrideUserMessageId = overrideUserMessageId; const onStart = jest.fn(); await expect(client.sendMessage(req.body.text, { onStart })).rejects.toMatchObject({ code: 'content_filter_block', }); expect(client.skipSaveUserMessage).toBe(true); expect(client.saveMessageToDatabase).not.toHaveBeenCalled(); expect(onStart).not.toHaveBeenCalled(); expect(provider).not.toHaveBeenCalled(); }, ); test('retains protected admission for the normal browser override with writer index zero', async () => { const { client, req, provider } = protectedClient(); req.body.overrideUserMessageId = 'normal-user-id__0'; const onStart = jest.fn(); await expect(client.sendMessage(req.body.text, { onStart })).resolves.toBeDefined(); expect(client.skipSaveUserMessage).toBe(false); expect(onStart).toHaveBeenCalledWith( expect.objectContaining({ messageId: 'normal-user-id', privacyRevision: expect.any(String), }), expect.any(String), true, ); expect(provider).toHaveBeenCalledTimes(1); }); test('a legacy history rejection leaves a transformed turn and conversation unsaved', async () => { const history = [{ messageId: 'prior', text: 'LEGACY-SECRET', isCreatedByUser: true }]; const { client, req, provider } = protectedClient(history, { starterPatterns: [], customPatterns: [{ id: 'legacy', label: 'Legacy', regex: 'LEGACY-SECRET' }], }); const onStart = jest.fn(); await expect( client.sendMessage(req.body.text, { conversationId: 'conversation', parentMessageId: 'prior', onStart, }), ).rejects.toThrow(); expect(client.saveMessageToDatabase).not.toHaveBeenCalled(); expect(onStart).not.toHaveBeenCalled(); expect(provider).not.toHaveBeenCalled(); }); test('an exact model-input rejection cancels the protected deferred write before created', async () => { const { client, req, provider } = protectedClient(); const onStart = jest.fn(); client.buildMessages.mockResolvedValueOnce({ prompt: [{ role: 'user', content: 'alice@example.com' }], }); await expect(client.sendMessage(req.body.text, { onStart })).rejects.toThrow(); expect(client.saveMessageToDatabase).not.toHaveBeenCalled(); expect(onStart).not.toHaveBeenCalled(); expect(provider).not.toHaveBeenCalled(); expect(client.modelBoundUserMessagePersistence.isPending()).toBe(false); }); test('onStart is called with the correct arguments', async () => { const onStart = jest.fn(); const opts = { onStart }; await TestClient.sendMessage('Hello, world!', opts); expect(onStart).toHaveBeenCalledWith( expect.objectContaining({ text: 'Hello, world!' }), expect.any(String), /** `isNewConvo` */ true, ); }); test('saveMessageToDatabase is called with the correct arguments', async () => { const saveOptions = TestClient.getSaveOptions(); const user = {}; const opts = { user }; const saveSpy = jest.spyOn(TestClient, 'saveMessageToDatabase'); await TestClient.sendMessage('Hello, world!', opts); expect(saveSpy).toHaveBeenCalledWith( expect.objectContaining({ sender: expect.any(String), text: expect.any(String), isCreatedByUser: expect.any(Boolean), messageId: expect.any(String), parentMessageId: expect.any(String), conversationId: expect.any(String), }), saveOptions, user, ); }); test('asks saveConvo to stamp the assistant reply but never the user turn', async () => { /* The timestamp itself is assigned inside `saveConvo`, past its own awaited reads, so a catch-up recorded while one of them is in flight cannot outrank the reply. */ saveMessage.mockImplementation(async (_ctx, message) => message); const saveOptions = TestClient.getSaveOptions(); TestClient.skipSaveConvo = false; saveConvo.mockClear(); await TestClient.saveMessageToDatabase( { conversationId: 'convo-unseen', messageId: 'm1', isCreatedByUser: true, text: 'hi' }, saveOptions, TestClient.user, ); await TestClient.saveMessageToDatabase( { conversationId: 'convo-unseen', messageId: 'm2', isCreatedByUser: false, text: 'hello' }, saveOptions, TestClient.user, ); const [userTurn, reply] = saveConvo.mock.calls; /* A user turn stamping this would light the unseen dot the moment they press Enter. */ expect(userTurn[1].lastResponseAt).toBeUndefined(); expect(userTurn[2].stampReply).toBeUndefined(); expect(reply[2].stampReply).toBe(true); expect(reply[2].replyMessageId).toBe('m2'); }); test('never stamps a reply whose message write resolved empty', async () => { /* Duplicate-key recovery that cannot re-read the row leaves no message to open, so an indicator would point at a reply that is not in the history. */ saveMessage.mockResolvedValueOnce(undefined); const saveOptions = TestClient.getSaveOptions(); TestClient.skipSaveConvo = false; saveConvo.mockClear(); await TestClient.saveMessageToDatabase( { conversationId: 'convo-unseen', messageId: 'm7', isCreatedByUser: false, text: 'hello' }, saveOptions, TestClient.user, ); expect(saveConvo.mock.calls[0][2].stampReply).toBeUndefined(); }); test('stamps the reply of a response that skips the conversation save', async () => { /* The secondary response of an override pair persists its message and returns before the conversation-field save. Without its own stamp, a reply that finishes after the primary one, or is the only one that persisted, would never light an indicator. */ saveMessage.mockImplementation(async (_ctx, message) => message); const saveOptions = TestClient.getSaveOptions(); TestClient.skipSaveConvo = true; saveConvo.mockClear(); stampConvoLastResponse.mockClear(); await TestClient.saveMessageToDatabase( { conversationId: 'convo-override', messageId: 'm4', isCreatedByUser: true, text: 'hi' }, saveOptions, 'user-override', ); await TestClient.saveMessageToDatabase( { conversationId: 'convo-override', messageId: 'm5', isCreatedByUser: false, text: 'yo' }, saveOptions, 'user-override', ); TestClient.skipSaveConvo = false; expect(saveConvo).not.toHaveBeenCalled(); expect(stampConvoLastResponse).toHaveBeenCalledTimes(1); expect(stampConvoLastResponse).toHaveBeenCalledWith('user-override', 'convo-override', 'm5'); }); test('never fails a persisted reply because its indicator stamp failed', async () => { saveMessage.mockImplementation(async (_ctx, message) => message); const saveOptions = TestClient.getSaveOptions(); TestClient.skipSaveConvo = true; stampConvoLastResponse.mockClear(); stampConvoLastResponse.mockRejectedValueOnce(new Error('mongo is down')); await expect( TestClient.saveMessageToDatabase( { conversationId: 'convo-override', messageId: 'm6', isCreatedByUser: false, text: 'yo' }, saveOptions, 'user-override', ), ).resolves.toBeDefined(); expect(stampConvoLastResponse).toHaveBeenCalledTimes(1); TestClient.skipSaveConvo = false; }); test('keeps the unseen timestamps out of the user turn’s unsetFields', async () => { /* The real wipe threat: a user turn whose endpointOptions omit these fields builds an unsetFields list from the fetched conversation. excludedKeys must keep them out. */ getConvo.mockResolvedValue({ conversationId: 'convo-unseen', endpoint: 'openai', model: 'gpt-3.5-turbo', lastResponseAt: new Date(), lastResponseMessageId: 'reply-unseen', lastSeenAt: new Date(), }); const saveOptions = TestClient.getSaveOptions(); TestClient.skipSaveConvo = false; saveConvo.mockClear(); await TestClient.saveMessageToDatabase( { conversationId: 'convo-unseen', messageId: 'm3', isCreatedByUser: true, text: 'again' }, saveOptions, TestClient.user, ); const [, , convoOptions] = saveConvo.mock.calls[0]; expect(convoOptions.unsetFields).not.toHaveProperty('lastResponseAt'); expect(convoOptions.unsetFields).not.toHaveProperty('lastSeenAt'); expect(convoOptions.unsetFields).not.toHaveProperty('lastResponseMessageId'); }); test('does not start the completed response write when terminal ownership is denied', async () => { const hookStarted = deferred(); const terminalDecision = deferred(); const beforeResponsePersistence = jest.fn(() => { hookStarted.resolve(); return terminalDecision.promise; }); const saveSpy = jest.spyOn(TestClient, 'saveMessageToDatabase'); const responsePromise = TestClient.sendMessage('Race Stop against completion.', { user: {}, beforeResponsePersistence, }); await hookStarted.promise; expect(beforeResponsePersistence).toHaveBeenCalledTimes(1); expect( saveSpy.mock.calls.filter(([message]) => message?.isCreatedByUser === false), ).toHaveLength(0); terminalDecision.resolve(false); const response = await responsePromise; expect(beforeResponsePersistence).toHaveBeenCalledWith(response); expect( saveSpy.mock.calls.filter(([message]) => message?.isCreatedByUser === false), ).toHaveLength(0); expect(TestClient.savedMessageIds.has(response.messageId)).toBe(false); await expect(response.databasePromise).resolves.toEqual({ persistenceSkipped: true }); }); test('starts the completed response write only after terminal ownership is granted', async () => { const hookStarted = deferred(); const terminalDecision = deferred(); const beforeResponsePersistence = jest.fn(() => { hookStarted.resolve(); return terminalDecision.promise; }); const saveSpy = jest.spyOn(TestClient, 'saveMessageToDatabase'); const responsePromise = TestClient.sendMessage('Complete after winning ownership.', { user: {}, beforeResponsePersistence, }); await hookStarted.promise; expect( saveSpy.mock.calls.filter(([message]) => message?.isCreatedByUser === false), ).toHaveLength(0); terminalDecision.resolve(true); const response = await responsePromise; expect( saveSpy.mock.calls.filter(([message]) => message?.isCreatedByUser === false), ).toHaveLength(1); await expect(response.databasePromise).resolves.toEqual(expect.any(Object)); }); test('persists the generation-time Langfuse sampling decision for agent responses', async () => { const previousSampleRate = process.env.LANGFUSE_SAMPLE_RATE; process.env.LANGFUSE_SAMPLE_RATE = '0'; TestClient.options.endpoint = 'agents'; const saveSpy = jest.spyOn(TestClient, 'saveMessageToDatabase'); try { const response = await TestClient.sendMessage('Hello, world!', { user: {} }); expect(response.langfuseSampled).toBe(false); expect(response.langfuseDestinationIds).toEqual([]); expect(saveSpy).toHaveBeenCalledWith( expect.objectContaining({ langfuseSampled: false, langfuseDestinationIds: [], }), expect.any(Object), expect.any(Object), ); } finally { if (previousSampleRate == null) { delete process.env.LANGFUSE_SAMPLE_RATE; } else { process.env.LANGFUSE_SAMPLE_RATE = previousSampleRate; } } }); test('persists the Langfuse sampling decision for agent clients using a provider endpoint', async () => { const previousSampleRate = process.env.LANGFUSE_SAMPLE_RATE; const previousClientName = TestClient.clientName; const previousEndpoint = TestClient.options.endpoint; process.env.LANGFUSE_SAMPLE_RATE = '0'; TestClient.clientName = 'agents'; TestClient.options.endpoint = 'bedrock'; const saveSpy = jest.spyOn(TestClient, 'saveMessageToDatabase'); try { const response = await TestClient.sendMessage('Hello, world!', { user: {} }); expect(response.langfuseSampled).toBe(false); expect(response.langfuseDestinationIds).toEqual([]); expect(saveSpy).toHaveBeenCalledWith( expect.objectContaining({ endpoint: 'bedrock', langfuseSampled: false, langfuseDestinationIds: [], }), expect.any(Object), expect.any(Object), ); } finally { if (previousSampleRate == null) { delete process.env.LANGFUSE_SAMPLE_RATE; } else { process.env.LANGFUSE_SAMPLE_RATE = previousSampleRate; } TestClient.clientName = previousClientName; TestClient.options.endpoint = previousEndpoint; } }); test('persists no Langfuse destination when a sampled trace has no configured export', async () => { const envKeys = [ 'LANGFUSE_PUBLIC_KEY', 'LANGFUSE_SECRET_KEY', 'LANGFUSE_FANOUT_ENABLED', 'LANGFUSE_FANOUT_COLLECTOR_URL', 'TENANT_ISOLATION_STRICT', ]; const previousEnv = Object.fromEntries(envKeys.map((key) => [key, process.env[key]])); const previousSampleRate = process.env.LANGFUSE_SAMPLE_RATE; envKeys.forEach((key) => delete process.env[key]); process.env.LANGFUSE_SAMPLE_RATE = '1'; TestClient.options.endpoint = 'agents'; const saveSpy = jest.spyOn(TestClient, 'saveMessageToDatabase'); try { const response = await TestClient.sendMessage('Hello, world!', { user: {} }); expect(response.langfuseSampled).toBe(true); expect(response.langfuseDestinationIds).toEqual([]); expect(saveSpy).toHaveBeenCalledWith( expect.objectContaining({ langfuseSampled: true, langfuseDestinationIds: [], }), expect.any(Object), expect.any(Object), ); } finally { for (const [key, value] of Object.entries(previousEnv)) { if (value == null) { delete process.env[key]; } else { process.env[key] = value; } } if (previousSampleRate == null) { delete process.env.LANGFUSE_SAMPLE_RATE; } else { process.env.LANGFUSE_SAMPLE_RATE = previousSampleRate; } } }); test('should handle existing conversation when getConvo retrieves one', async () => { const existingConvo = { conversationId: 'existing-convo-id', endpoint: 'openai', endpointType: 'openai', model: 'gpt-3.5-turbo', messages: [ { role: 'user', content: 'Existing message 1' }, { role: 'assistant', content: 'Existing response 1' }, ], temperature: 1, }; const { temperature: _temp, ...newConvo } = existingConvo; const user = { id: 'user-id', }; getConvo.mockResolvedValue(existingConvo); saveConvo.mockResolvedValue(newConvo); TestClient = initializeFakeClient( apiKey, { ...options, req: { user, }, }, [], ); const saveSpy = jest.spyOn(TestClient, 'saveMessageToDatabase'); const newMessage = 'New message in existing conversation'; const response = await TestClient.sendMessage(newMessage, { user, conversationId: existingConvo.conversationId, }); expect(getConvo).toHaveBeenCalledWith(user.id, existingConvo.conversationId); expect(TestClient.conversationId).toBe(existingConvo.conversationId); expect(response.conversationId).toBe(existingConvo.conversationId); expect(TestClient.fetchedConvo).toBe(true); expect(saveSpy).toHaveBeenCalledWith( expect.objectContaining({ conversationId: existingConvo.conversationId, text: newMessage, }), expect.any(Object), expect.any(Object), ); expect(saveConvo).toHaveBeenCalledTimes(2); expect(saveConvo).toHaveBeenCalledWith( expect.any(Object), expect.objectContaining({ conversationId: existingConvo.conversationId, }), expect.objectContaining({ context: 'api/app/clients/BaseClient.js - saveMessageToDatabase #saveConvo', unsetFields: { temperature: 1, }, }), ); await TestClient.sendMessage('Another message', { conversationId: existingConvo.conversationId, }); expect(getConvo).toHaveBeenCalledTimes(1); }); test('should correctly handle existing conversation and unset fields appropriately', async () => { const existingConvo = { conversationId: 'existing-convo-id', endpoint: 'openai', endpointType: 'openai', model: 'gpt-3.5-turbo', messages: [ { role: 'user', content: 'Existing message 1' }, { role: 'assistant', content: 'Existing response 1' }, ], title: 'Existing Conversation', someExistingField: 'existingValue', anotherExistingField: 'anotherValue', temperature: 0.7, modelLabel: 'GPT-3.5', pinned: true, subagentThread: { rootConversationId: 'root-conversation', parentConversationId: 'parent-conversation', parentMessageId: 'parent-message', parentToolCallId: 'parent-tool-call', subagentType: 'researcher', subagentKind: 'agent', depth: 1, }, }; getConvo.mockResolvedValue(existingConvo); saveConvo.mockResolvedValue(existingConvo); TestClient = initializeFakeClient( apiKey, { ...options, modelOptions: { model: 'gpt-4', temperature: 0.5, }, }, [], ); const newMessage = 'New message in existing conversation'; await TestClient.sendMessage(newMessage, { conversationId: existingConvo.conversationId, }); expect(saveConvo).toHaveBeenCalledTimes(2); const saveConvoCall = saveConvo.mock.calls[0]; const [, savedFields, saveOptions] = saveConvoCall; // Instead of checking all excludedKeys, we'll just check specific fields // that we know should be excluded expect(savedFields).not.toHaveProperty('messages'); expect(savedFields).not.toHaveProperty('title'); // Only check that someExistingField is in unsetFields expect(saveOptions.unsetFields).toHaveProperty('someExistingField', 1); expect(saveOptions.unsetFields).not.toHaveProperty('subagentThread'); // Sidebar metadata is never part of endpointOptions, so sweeping it would // unpin a chat every time it received a message. expect(saveOptions.unsetFields).not.toHaveProperty('pinned'); // Mock saveConvo to return the expected fields saveConvo.mockImplementation((req, fields) => { return Promise.resolve({ ...fields, endpoint: 'openai', endpointType: 'openai', model: 'gpt-4', temperature: 0.5, }); }); // Only check the conversationId since that's the only field we can be sure about expect(savedFields).toHaveProperty('conversationId', 'existing-convo-id'); expect(TestClient.fetchedConvo).toBe(true); await TestClient.sendMessage('Another message', { conversationId: existingConvo.conversationId, }); expect(getConvo).toHaveBeenCalledTimes(1); const secondSaveConvoCall = saveConvo.mock.calls[1]; expect(secondSaveConvoCall[2]).toHaveProperty('unsetFields', {}); }); test('sendCompletion is called with the correct arguments', async () => { const payload = {}; // Mock payload TestClient.buildMessages.mockReturnValue({ prompt: payload, tokenCountMap: null }); const opts = {}; await TestClient.sendMessage('Hello, world!', opts); expect(TestClient.sendCompletion).toHaveBeenCalledWith(payload, opts); }); test('records history and message-build startup milestones', async () => { const startupTelemetry = { mark: jest.fn() }; TestClient.options.startupTelemetry = startupTelemetry; await TestClient.sendMessage('Hello, world!', {}); expect(startupTelemetry.mark.mock.calls.map(([milestone]) => milestone)).toEqual([ 'history_loaded', 'messages_built', ]); }); test('getTokenCount for response is called with the correct arguments', async () => { const tokenCountMap = {}; // Mock tokenCountMap TestClient.buildMessages.mockReturnValue({ prompt: [], tokenCountMap }); TestClient.getTokenCountForResponse = jest.fn(); const response = await TestClient.sendMessage('Hello, world!', {}); expect(TestClient.getTokenCountForResponse).toHaveBeenCalledWith(response); }); test('returns an object with the correct shape', async () => { const response = await TestClient.sendMessage('Hello, world!', {}); expect(response).toEqual( expect.objectContaining({ sender: expect.any(String), text: expect.any(String), isCreatedByUser: expect.any(Boolean), messageId: expect.any(String), parentMessageId: expect.any(String), conversationId: expect.any(String), }), ); }); test('saveMessageToDatabase appends the saved message id instead of rebuilding the array', async () => { const savedId = new (require('mongoose').Types.ObjectId)(); saveMessage.mockResolvedValueOnce({ _id: savedId, messageId: 'saved-1' }); saveConvo.mockResolvedValueOnce({ conversationId }); await TestClient.saveMessageToDatabase( { messageId: 'saved-1', conversationId, text: 'hi' }, TestClient.getSaveOptions(), ); expect(saveConvo).toHaveBeenCalledWith( expect.anything(), expect.anything(), expect.objectContaining({ appendMessageIds: [savedId] }), ); }); test('saveMessageToDatabase rebuilds the array when the saved message has no _id', async () => { saveMessage.mockResolvedValueOnce({ messageId: 'saved-2' }); saveConvo.mockResolvedValueOnce({ conversationId }); await TestClient.saveMessageToDatabase( { messageId: 'saved-2', conversationId, text: 'hi' }, TestClient.getSaveOptions(), ); const metadata = saveConvo.mock.calls[saveConvo.mock.calls.length - 1][2]; expect(metadata).not.toHaveProperty('appendMessageIds'); }); test('saveMessageToDatabase returns early when this.options is null (client disposed)', async () => { const savedOptions = TestClient.options; TestClient.options = null; saveMessage.mockClear(); const result = await TestClient.saveMessageToDatabase( { messageId: 'msg-1', conversationId: 'conv-1', isCreatedByUser: true, text: 'hi' }, {}, null, ); expect(result).toEqual({}); expect(saveMessage).not.toHaveBeenCalled(); TestClient.options = savedOptions; }); test('saveMessageToDatabase uses snapshot of options, immune to mid-await disposal', async () => { const savedOptions = TestClient.options; TestClient.options = { ...savedOptions, endpoint: 'agents', agent: { id: 'agent_persisted' }, }; saveMessage.mockClear(); saveConvo.mockClear(); // Make db.saveMessage yield, simulating I/O suspension during which disposal occurs saveMessage.mockImplementation(async (_reqCtx, msgData) => { // Simulate disposeClient nullifying client.options while awaiting TestClient.options = null; return msgData; }); saveConvo.mockResolvedValue({ conversationId: 'conv-1' }); const result = await TestClient.saveMessageToDatabase( { messageId: 'msg-1', conversationId: 'conv-1', isCreatedByUser: true, text: 'hi' }, { endpoint: 'agents', agent_id: 'agent_persisted' }, null, ); // Should complete without TypeError, using the snapshotted options expect(result).toHaveProperty('message'); expect(result).toHaveProperty('conversation'); expect(saveMessage).toHaveBeenCalled(); expect(saveConvo).toHaveBeenCalledWith( expect.anything(), expect.anything(), expect.objectContaining({ initialAgentId: 'agent_persisted' }), ); TestClient.options = savedOptions; saveMessage.mockReset(); saveConvo.mockReset(); }); test('saveMessageToDatabase reuses conversation resolved on the request', async () => { const existingConvo = { conversationId: 'cached-convo-id', endpoint: 'openai', endpointType: 'openai', temperature: 0.7, isTemporary: true, expiredAt: new Date('2030-01-01T00:00:00.000Z'), }; const user = { id: 'user-id' }; const req = { user, body: { isTemporary: false }, resolvedConversation: existingConvo }; getConvo.mockClear(); saveMessage.mockResolvedValue({ messageId: 'msg-1' }); saveConvo.mockResolvedValue(existingConvo); TestClient = initializeFakeClient(apiKey, { ...options, endpoint: 'openai', req }, []); await TestClient.saveMessageToDatabase( { messageId: 'msg-1', conversationId: existingConvo.conversationId, isCreatedByUser: true, text: 'hi', }, { endpoint: 'openai' }, user, ); expect(getConvo).not.toHaveBeenCalled(); expect(saveMessage).toHaveBeenCalledWith( expect.objectContaining({ isTemporary: true, expiredAt: existingConvo.expiredAt, }), expect.any(Object), expect.any(Object), ); expect(req.resolvedConversation).toBe(existingConvo); expect(TestClient.fetchedConvo).toBe(true); expect(saveConvo).toHaveBeenCalledWith( expect.any(Object), expect.objectContaining({ conversationId: existingConvo.conversationId }), expect.objectContaining({ unsetFields: expect.objectContaining({ temperature: 1 }), }), ); await TestClient.saveMessageToDatabase( { messageId: 'response-1', conversationId: existingConvo.conversationId, text: 'reply' }, { endpoint: 'openai' }, user, ); for (const save of [saveMessage, saveConvo]) { expect(save).toHaveBeenLastCalledWith( expect.objectContaining({ isTemporary: true, expiredAt: existingConvo.expiredAt }), expect.any(Object), expect.any(Object), ); } expect(getConvo).not.toHaveBeenCalled(); }); test('userMessagePromise is awaited before saving response message', async () => { // Mock the saveMessageToDatabase method TestClient.saveMessageToDatabase = jest.fn().mockImplementation(() => { return new Promise((resolve) => setTimeout(resolve, 100)); // Simulate a delay }); // Send a message const messagePromise = TestClient.sendMessage('Hello, world!'); // Wait a short time to ensure the user message save has started await new Promise((resolve) => setTimeout(resolve, 50)); // Check that saveMessageToDatabase has been called once (for the user message) expect(TestClient.saveMessageToDatabase).toHaveBeenCalledTimes(1); // Wait for the message to be fully processed await messagePromise; // Check that saveMessageToDatabase has been called twice (once for user message, once for response) expect(TestClient.saveMessageToDatabase).toHaveBeenCalledTimes(2); // Check the order of calls const calls = TestClient.saveMessageToDatabase.mock.calls; expect(calls[0][0].isCreatedByUser).toBe(true); // First call should be for user message expect(calls[1][0].isCreatedByUser).toBe(false); // Second call should be for response message }); }); describe('recordTokenUsage model assignment', () => { test('should pass this.model to recordTokenUsage, not the agent ID from responseMessage.model', async () => { const actualModel = 'claude-opus-4-5'; const agentId = 'agent_p5Z_IU6EIxBoqn1BoqLBp'; TestClient.model = actualModel; TestClient.options.endpoint = 'agents'; TestClient.options.agent = { id: agentId }; TestClient.getTokenCountForResponse = jest.fn().mockReturnValue(50); TestClient.recordTokenUsage = jest.fn().mockResolvedValue(undefined); TestClient.buildMessages.mockReturnValue({ prompt: [], tokenCountMap: { res: 50 }, }); await TestClient.sendMessage('Hello', {}); expect(TestClient.recordTokenUsage).toHaveBeenCalledWith( expect.objectContaining({ model: actualModel, }), ); const callArgs = TestClient.recordTokenUsage.mock.calls[0][0]; expect(callArgs.model).not.toBe(agentId); }); test('should pass this.model even when this.model differs from modelOptions.model', async () => { const instanceModel = 'gpt-4o'; TestClient.model = instanceModel; TestClient.modelOptions = { model: 'gpt-4o-mini' }; TestClient.getTokenCountForResponse = jest.fn().mockReturnValue(50); TestClient.recordTokenUsage = jest.fn().mockResolvedValue(undefined); TestClient.buildMessages.mockReturnValue({ prompt: [], tokenCountMap: { res: 50 }, }); await TestClient.sendMessage('Hello', {}); expect(TestClient.recordTokenUsage).toHaveBeenCalledWith( expect.objectContaining({ model: instanceModel, }), ); }); }); /** * The `transactions.enabled` guard lives in `createTransaction`, which reads it off * the object it is handed. Dropping the config anywhere between here and there * silently re-enables the writes rather than failing, so pin the wiring itself. */ describe('recordTokenUsage transactions config', () => { let priorEndpoint; let priorEndpointType; const arrangeFallbackPath = () => { TestClient.getTokenCountForResponse = jest.fn().mockReturnValue(50); TestClient.recordTokenUsage = jest.fn().mockResolvedValue(undefined); TestClient.buildMessages.mockReturnValue({ prompt: [], tokenCountMap: { res: 50 }, }); }; /** `options` is shared across this file's tests, so an endpoint left behind by an earlier * case would route the balance-enabled arrangement into `checkBalance`. */ beforeEach(() => { priorEndpoint = TestClient.options.endpoint; priorEndpointType = TestClient.options.endpointType; delete TestClient.options.endpoint; delete TestClient.options.endpointType; }); afterEach(() => { delete TestClient.options.req; TestClient.options.endpoint = priorEndpoint; TestClient.options.endpointType = priorEndpointType; }); test('should forward the resolved transactions config to recordTokenUsage', async () => { TestClient.options.req = { config: { transactions: { enabled: false } } }; arrangeFallbackPath(); await TestClient.sendMessage('Hello', {}); expect(TestClient.recordTokenUsage).toHaveBeenCalledWith( expect.objectContaining({ transactions: { enabled: false }, }), ); }); test('should default to enabled transactions when no app config is present', async () => { arrangeFallbackPath(); await TestClient.sendMessage('Hello', {}); expect(TestClient.recordTokenUsage).toHaveBeenCalledWith( expect.objectContaining({ transactions: { enabled: true }, }), ); }); test('should forward transactions as enabled when balance tracking overrides the setting', async () => { TestClient.options.req = { config: { transactions: { enabled: false }, balance: { enabled: true } }, }; arrangeFallbackPath(); await TestClient.sendMessage('Hello', {}); expect(TestClient.recordTokenUsage).toHaveBeenCalledWith( expect.objectContaining({ transactions: { enabled: true }, }), ); }); }); describe('balance reservation lifecycle', () => { let priorEndpoint; let priorEndpointType; let events; beforeEach(() => { priorEndpoint = TestClient.options.endpoint; priorEndpointType = TestClient.options.endpointType; TestClient.options.endpoint = EModelEndpoint.openAI; delete TestClient.options.endpointType; TestClient.options.req = { config: { balance: { enabled: true } } }; events = []; getMultiplier.mockReturnValue(1); reserveBalance.mockImplementation(async () => { events.push('reserve'); return { reserved: true, balance: 1000 }; }); releaseBalanceReservation.mockImplementation(async () => { events.push('release'); }); TestClient.sendCompletion.mockImplementation(async () => { events.push('completion'); return { completion: 'Mock response text', metadata: undefined }; }); TestClient.getTokenCountForResponse = jest.fn().mockReturnValue(50); TestClient.recordTokenUsage = jest.fn(async () => { events.push('usage'); }); TestClient.buildMessages.mockReturnValue({ prompt: [], tokenCountMap: { res: 50 }, }); }); afterEach(() => { delete TestClient.options.req; TestClient.options.endpoint = priorEndpoint; TestClient.options.endpointType = priorEndpointType; }); test('releases the reservation once the response usage is recorded, before persistence', async () => { const beforeResponsePersistence = jest.fn(async () => { events.push('persist'); return true; }); await TestClient.sendMessage('Hello', { beforeResponsePersistence }); expect(events).toEqual(['reserve', 'completion', 'usage', 'release', 'persist']); const [{ reservationId, amount }] = reserveBalance.mock.calls[0]; expect(releaseBalanceReservation).toHaveBeenCalledTimes(1); expect(releaseBalanceReservation).toHaveBeenCalledWith({ user: TestClient.user, reservationId, amount, }); }); test('releases the reservation when the completion fails', async () => { TestClient.sendCompletion.mockRejectedValue(new Error('provider unavailable')); await expect(TestClient.sendMessage('Hello', {})).rejects.toThrow('provider unavailable'); expect(events).toEqual(['reserve', 'release']); }); test('releases the reservation when work after the completion fails', async () => { TestClient.recordTokenUsage.mockRejectedValue(new Error('usage write failed')); await expect(TestClient.sendMessage('Hello', {})).rejects.toThrow('usage write failed'); expect(events).toEqual(['reserve', 'completion', 'release']); }); test('takes no reservation when the balance check refuses the request', async () => { reserveBalance.mockResolvedValue({ reserved: false, balance: 0 }); await expect(TestClient.sendMessage('Hello', {})).rejects.toThrow(); expect(TestClient.sendCompletion).not.toHaveBeenCalled(); expect(releaseBalanceReservation).not.toHaveBeenCalled(); }); }); describe('getMessagesWithinTokenLimit with instructions', () => { test('should always include instructions when present', async () => { TestClient.maxContextTokens = 50; const instructions = { role: 'system', content: 'System instructions', tokenCount: 20, }; const messages = [ instructions, { role: 'user', content: 'Hello', tokenCount: 10 }, { role: 'assistant', content: 'Hi there', tokenCount: 15 }, ]; const result = await TestClient.getMessagesWithinTokenLimit({ messages, instructions, }); expect(result.context[0]).toBe(instructions); expect(result.remainingContextTokens).toBe(2); }); test('should handle case when messages exceed limit but instructions must be preserved', async () => { TestClient.maxContextTokens = 30; const instructions = { role: 'system', content: 'System instructions', tokenCount: 20, }; const messages = [ instructions, { role: 'user', content: 'Hello', tokenCount: 10 }, { role: 'assistant', content: 'Hi there', tokenCount: 15 }, ]; const result = await TestClient.getMessagesWithinTokenLimit({ messages, instructions, }); // Should only include instructions and the last message that fits expect(result.context).toHaveLength(1); expect(result.context[0].content).toBe(instructions.content); expect(result.messagesToRefine).toHaveLength(2); expect(result.remainingContextTokens).toBe(7); // 30 - 20 - 3 (assistant label) }); test('should work correctly without instructions (1/2)', async () => { TestClient.maxContextTokens = 50; const messages = [ { role: 'user', content: 'Hello', tokenCount: 10 }, { role: 'assistant', content: 'Hi there', tokenCount: 15 }, ]; const result = await TestClient.getMessagesWithinTokenLimit({ messages, }); expect(result.context).toHaveLength(2); expect(result.remainingContextTokens).toBe(22); // 50 - 10 - 15 - 3(assistant label) expect(result.messagesToRefine).toHaveLength(0); }); test('should work correctly without instructions (2/2)', async () => { TestClient.maxContextTokens = 30; const messages = [ { role: 'user', content: 'Hello', tokenCount: 10 }, { role: 'assistant', content: 'Hi there', tokenCount: 20 }, ]; const result = await TestClient.getMessagesWithinTokenLimit({ messages, }); expect(result.context).toHaveLength(1); expect(result.remainingContextTokens).toBe(7); expect(result.messagesToRefine).toHaveLength(1); }); test('should handle case when only instructions fit within limit', async () => { TestClient.maxContextTokens = 25; const instructions = { role: 'system', content: 'System instructions', tokenCount: 20, }; const messages = [ instructions, { role: 'user', content: 'Hello', tokenCount: 10 }, { role: 'assistant', content: 'Hi there', tokenCount: 15 }, ]; const result = await TestClient.getMessagesWithinTokenLimit({ messages, instructions, }); expect(result.context).toHaveLength(1); expect(result.context[0]).toBe(instructions); expect(result.messagesToRefine).toHaveLength(2); expect(result.remainingContextTokens).toBe(2); // 25 - 20 - 3(assistant label) }); }); describe('sendMessage file population', () => { const attachment = { file_id: 'file-abc', filename: 'image.png', filepath: '/uploads/image.png', type: 'image/png', bytes: 1024, object: 'file', user: 'user-1', embedded: false, usage: 0, text: 'large ocr blob that should be stripped', _id: 'mongo-id-1', }; beforeEach(() => { TestClient.options.req = { body: { files: [{ file_id: 'file-abc' }] } }; TestClient.options.attachments = [attachment]; }); test('populates userMessage.files before saveMessageToDatabase is called', async () => { TestClient.saveMessageToDatabase = jest.fn().mockImplementation((msg) => { return Promise.resolve({ message: msg }); }); await TestClient.sendMessage('Hello'); const userSave = TestClient.saveMessageToDatabase.mock.calls.find( ([msg]) => msg.isCreatedByUser, ); expect(userSave).toBeDefined(); expect(userSave[0].files).toBeDefined(); expect(userSave[0].files).toHaveLength(1); expect(userSave[0].files[0].file_id).toBe('file-abc'); }); test('strips text and _id from files before saving', async () => { TestClient.saveMessageToDatabase = jest.fn().mockResolvedValue({ message: {} }); await TestClient.sendMessage('Hello'); const userSave = TestClient.saveMessageToDatabase.mock.calls.find( ([msg]) => msg.isCreatedByUser, ); expect(userSave[0].files[0].text).toBeUndefined(); expect(userSave[0].files[0]._id).toBeUndefined(); expect(userSave[0].files[0].filename).toBe('image.png'); }); test('deletes image_urls from userMessage when files are present', async () => { TestClient.saveMessageToDatabase = jest.fn().mockResolvedValue({ message: {} }); TestClient.options.attachments = [ { ...attachment, image_urls: ['data:image/png;base64,...'] }, ]; await TestClient.sendMessage('Hello'); const userSave = TestClient.saveMessageToDatabase.mock.calls.find( ([msg]) => msg.isCreatedByUser, ); expect(userSave[0].image_urls).toBeUndefined(); }); test('does not set files when no attachments match request file IDs', async () => { TestClient.options.req = { body: { files: [{ file_id: 'file-nomatch' }] } }; TestClient.saveMessageToDatabase = jest.fn().mockResolvedValue({ message: {} }); await TestClient.sendMessage('Hello'); const userSave = TestClient.saveMessageToDatabase.mock.calls.find( ([msg]) => msg.isCreatedByUser, ); expect(userSave[0].files).toBeUndefined(); }); test('skips file population when attachments is not an array (Promise case)', async () => { TestClient.options.attachments = Promise.resolve([attachment]); TestClient.saveMessageToDatabase = jest.fn().mockResolvedValue({ message: {} }); await TestClient.sendMessage('Hello'); const userSave = TestClient.saveMessageToDatabase.mock.calls.find( ([msg]) => msg.isCreatedByUser, ); expect(userSave[0].files).toBeUndefined(); }); test('skips file population when skipSaveUserMessage is true', async () => { TestClient.skipSaveUserMessage = true; TestClient.saveMessageToDatabase = jest.fn().mockResolvedValue({ message: {} }); await TestClient.sendMessage('Hello'); const userSave = TestClient.saveMessageToDatabase.mock.calls.find( ([msg]) => msg?.isCreatedByUser, ); expect(userSave).toBeUndefined(); }); test('ignores file_id: undefined entries in req.body.files (no set poisoning)', async () => { TestClient.options.req = { body: { files: [{ file_id: undefined }, { file_id: 'file-abc' }] }, }; TestClient.options.attachments = [ { ...attachment, file_id: undefined }, { ...attachment, file_id: 'file-abc' }, ]; TestClient.saveMessageToDatabase = jest.fn().mockResolvedValue({ message: {} }); await TestClient.sendMessage('Hello'); const userSave = TestClient.saveMessageToDatabase.mock.calls.find( ([msg]) => msg.isCreatedByUser, ); expect(userSave[0].files).toHaveLength(1); expect(userSave[0].files[0].file_id).toBe('file-abc'); }); }); describe('addPreviousAttachments authorization', () => { const ownerFile = { file_id: 'owner-file', filename: 'owner.txt', filepath: '/uploads/owner.txt', source: 'local', type: 'text/plain', bytes: 100, object: 'file', user: 'user-1', embedded: false, usage: 0, text: 'authorized owner text', _id: 'owner-mongo-id', metadata: { codeEnvRef: { kind: 'user', id: 'user-1', storage_session_id: 'owner-session', file_id: 'owner-code-file', }, }, }; beforeEach(() => { getFiles.mockReset(); TestClient.options.resendFiles = true; TestClient.options.attachments = undefined; TestClient.options.req = { user: { id: 'user-1', tenantId: 'tenant-a', }, }; TestClient.addFileContextToMessage = jest.fn(async (message, files) => { const text = files .map((file) => file.text) .filter(Boolean) .join('\n'); if (text) { message.fileContext = text; } }); TestClient.processAttachments = jest.fn(async (_message, files) => files); TestClient.assertHistoricalAttachmentLimits = undefined; TestClient.checkVisionRequest = jest.fn(); }); describe('tool-routed files on a later turn', () => { const routedCsv = { file_id: 'csv-file', filename: 'sales.csv', filepath: '/uploads/sales.csv', source: 'local', type: 'text/csv', user: 'user-1', text: 'region,total', llmDeliveryPath: 'none', metadata: { destinationChosen: false }, }; /** A tool serves a file only once it holds it, so a record left to the sandbox needs the * reference provisioning writes for that tool to count as its reader. */ const sandboxCsv = { ...routedCsv, metadata: { destinationChosen: false, codeEnvRef: { kind: 'user', id: 'user-1', storage_session_id: 'session-1', file_id: 'sandbox-csv-file', }, }, }; const replayCsv = async ( fileConsumers, endpointConfig = { defaultLLMDeliveryPath: { overrides: { 'text/csv': 'none' } }, textFallbackWithoutTools: true, }, file = routedCsv, ) => { getFiles.mockResolvedValueOnce([file]); TestClient.options.req.config = { fileConfig: { endpoints: { [EModelEndpoint.openAI]: endpointConfig } }, }; TestClient.options.agent = { provider: EModelEndpoint.openAI, fileConsumers }; TestClient.options.agent.deliveryRouting = resolveTurnDeliveryRouting({ agent: TestClient.options.agent, config: TestClient.options.req?.config, }); TestClient.assertHistoricalAttachmentLimits = jest.fn(async (files) => files); const [message] = await TestClient.addPreviousAttachments([ { messageId: 'msg-csv', text: 'Summarize it', files: [{ file_id: 'csv-file' }] }, ]); return message; }; test('replays the stored text when this turn runs no tool that can read the file', async () => { const message = await replayCsv({ executeCode: false, fileSearch: false }); const replayed = { ...routedCsv, llmDeliveryPath: 'text' }; expect(TestClient.assertHistoricalAttachmentLimits).toHaveBeenCalledWith([replayed]); expect(TestClient.addFileContextToMessage).toHaveBeenCalledWith(message, [replayed]); expect(TestClient.authorizedHistoricalFiles.get('csv-file')).toEqual(replayed); expect(message.fileContext).toBe('region,total'); expect(routedCsv.llmDeliveryPath).toBe('none'); }); test('replays the stored text once the endpoint routes the type to text', async () => { const message = await replayCsv( { executeCode: true, fileSearch: false }, { defaultLLMDeliveryPath: { overrides: { 'text/csv': 'text' } } }, ); const replayed = { ...routedCsv, llmDeliveryPath: 'text' }; expect(TestClient.assertHistoricalAttachmentLimits).toHaveBeenCalledWith([replayed]); expect(TestClient.addFileContextToMessage).toHaveBeenCalledWith(message, [replayed]); expect(message.fileContext).toBe('region,total'); }); test('admits a historical tool-routed file this turn sends to the provider', async () => { const routedImage = { file_id: 'image-file', filename: 'chart.png', filepath: '/uploads/chart.png', source: 'local', type: 'image/png', user: 'user-1', llmDeliveryPath: 'none', metadata: { destinationChosen: false }, }; getFiles.mockResolvedValueOnce([routedImage]); TestClient.options.req.config = { fileConfig: { endpoints: {} } }; TestClient.options.agent = { provider: EModelEndpoint.openAI, fileConsumers: { executeCode: false, fileSearch: false }, }; TestClient.options.agent.deliveryRouting = resolveTurnDeliveryRouting({ agent: TestClient.options.agent, config: TestClient.options.req?.config, }); TestClient.assertHistoricalAttachmentLimits = jest.fn(async (files) => files); await TestClient.addPreviousAttachments([ { messageId: 'msg-image', text: 'What does it show?', files: [{ file_id: 'image-file' }], }, ]); expect(TestClient.assertHistoricalAttachmentLimits).toHaveBeenCalledWith([ { ...routedImage, llmDeliveryPath: 'provider' }, ]); }); test('keeps the file off the prompt when the sandbox running it holds the file', async () => { const message = await replayCsv( { executeCode: true, fileSearch: false }, undefined, sandboxCsv, ); expect(TestClient.assertHistoricalAttachmentLimits).toHaveBeenCalledWith([]); expect(TestClient.addFileContextToMessage).not.toHaveBeenCalled(); expect(message.fileContext).toBeUndefined(); }); test('replays the stored text when file search never received the file', async () => { /* An earlier turn's upload that named no destination was filed under no tool, so the * vector store holds nothing to search. Withholding the text for the enabled tool left * the file unreadable on every later turn as well as the one it arrived on. */ const message = await replayCsv({ executeCode: false, fileSearch: true }); const replayed = { ...routedCsv, llmDeliveryPath: 'text' }; expect(TestClient.assertHistoricalAttachmentLimits).toHaveBeenCalledWith([replayed]); expect(TestClient.addFileContextToMessage).toHaveBeenCalledWith(message, [replayed]); expect(message.fileContext).toBe('region,total'); expect(routedCsv.llmDeliveryPath).toBe('none'); }); }); test('rehydrates historical file refs from owner-scoped DB rows only', async () => { getFiles.mockResolvedValueOnce([ownerFile]); const [message] = await TestClient.addPreviousAttachments([ { messageId: 'msg-1', text: 'Use the attachment', files: [ { file_id: 'owner-file', filename: 'attacker-controlled-owner-name.txt', filepath: '/forged/owner.txt', text: 'forged owner text', }, { file_id: 'victim-file', filename: 'victim.txt', filepath: '/victim/private.txt', text: 'victim private text', }, ], attachments: [ { file_id: 'victim-file', filename: 'victim-output.csv', text: 'victim output text', }, ], fileContext: 'stale victim private text', }, ]); expect(getFiles).toHaveBeenCalledWith( { file_id: { $in: ['owner-file', 'victim-file'] }, user: 'user-1', tenantId: 'tenant-a', }, {}, {}, ); expect(TestClient.addFileContextToMessage).toHaveBeenCalledWith(message, [ownerFile]); expect(TestClient.processAttachments).toHaveBeenCalledWith(message, [ownerFile]); expect(message.fileContext).toBe('authorized owner text'); expect(message.files).toEqual([ expect.objectContaining({ file_id: 'owner-file', filename: 'owner.txt', filepath: '/uploads/owner.txt', source: 'local', metadata: ownerFile.metadata, }), ]); expect(message.files[0].text).toBeUndefined(); expect(message.files[0]._id).toBeUndefined(); expect(message.attachments).toBeUndefined(); expect(JSON.stringify(message)).not.toContain('victim'); expect(JSON.stringify(message)).not.toContain('forged owner text'); }); test('hydrates files referenced by non-steer provider content parts', async () => { getFiles.mockResolvedValueOnce([ownerFile]); const [message] = await TestClient.addPreviousAttachments([ { messageId: 'msg-content-file', isCreatedByUser: true, content: [ { type: 'input_file', files: [{ file_id: 'owner-file' }], }, ], }, ]); expect(getFiles).toHaveBeenCalledWith( { file_id: { $in: ['owner-file'] }, user: 'user-1', tenantId: 'tenant-a', }, {}, {}, ); expect(TestClient.authorizedHistoricalFiles.get('owner-file')).toEqual(ownerFile); expect(message.content[0].files).toEqual([{ file_id: 'owner-file' }]); }); test('hydrates nested provider file references', async () => { getFiles.mockResolvedValueOnce([ownerFile]); const [message] = await TestClient.addPreviousAttachments([ { messageId: 'msg-nested-content-file', isCreatedByUser: true, content: [ { type: 'input_file', file: { file_id: 'owner-file' }, }, ], }, ]); expect(getFiles).toHaveBeenCalledWith( { file_id: { $in: ['owner-file'] }, user: 'user-1', tenantId: 'tenant-a', }, {}, {}, ); expect(TestClient.authorizedHistoricalFiles.get('owner-file')).toEqual(ownerFile); expect(message.content[0].file).toEqual({ file_id: 'owner-file' }); }); test('preserves owner-scoped historical attachments when file patterns are inactive', async () => { TestClient.options.req.config = { filters: { files: { pii: { starterPatterns: [], customPatterns: [], }, }, }, }; getFiles.mockResolvedValueOnce([ownerFile]); const [message] = await TestClient.addPreviousAttachments([ { messageId: 'msg-inactive-file-policy', files: [{ file_id: 'owner-file', filename: 'forged-input.txt' }], attachments: [{ file_id: 'owner-file', filename: 'forged-output.txt' }], }, ]); expect(getFiles).toHaveBeenCalledWith( { file_id: { $in: ['owner-file'] }, user: 'user-1', tenantId: 'tenant-a', }, {}, {}, ); expect(message.files).toEqual([ expect.objectContaining({ file_id: 'owner-file', filename: 'owner.txt' }), ]); expect(message.attachments).toEqual([ expect.objectContaining({ file_id: 'owner-file', filename: 'owner.txt' }), ]); }); test('strips an unresolved historical file reference without pre-pruning enforcement', async () => { TestClient.options.req.config = { filters: { files: { pii: { fields: ['extracted_text'], starterPatterns: [], uninspectable: 'block', }, }, }, }; getFiles.mockResolvedValueOnce([]); const [message] = await TestClient.addPreviousAttachments([ { messageId: 'msg-unresolved', isCreatedByUser: true, files: [{ file_id: 'foreign-file' }], }, ]); expect(message).toEqual(expect.objectContaining({ messageId: 'msg-unresolved' })); expect(message).not.toHaveProperty('files'); expect(TestClient.addFileContextToMessage).not.toHaveBeenCalled(); expect(TestClient.processAttachments).not.toHaveBeenCalled(); }); test('strips historical file context when no authenticated owner scope is available', async () => { TestClient.options.req = {}; const [message] = await TestClient.addPreviousAttachments([ { messageId: 'msg-2', files: [{ file_id: 'victim-file', filename: 'victim.txt' }], fileContext: 'stale victim private text', }, ]); expect(getFiles).not.toHaveBeenCalled(); expect(message.files).toBeUndefined(); expect(message.fileContext).toBeUndefined(); }); test('preserves repeated owner-authorized historical file refs after the first context use', async () => { getFiles.mockResolvedValueOnce([ownerFile]); const [firstMessage, secondMessage] = await TestClient.addPreviousAttachments([ { messageId: 'msg-repeat-1', files: [{ file_id: 'owner-file', filename: 'first-forged.txt' }], }, { messageId: 'msg-repeat-2', files: [{ file_id: 'owner-file', filename: 'second-forged.txt' }], }, ]); expect(getFiles).toHaveBeenCalledTimes(1); expect(getFiles).toHaveBeenCalledWith( { file_id: { $in: ['owner-file'] }, user: 'user-1', tenantId: 'tenant-a', }, {}, {}, ); expect(TestClient.addFileContextToMessage).toHaveBeenCalledTimes(1); expect(TestClient.addFileContextToMessage).toHaveBeenCalledWith(firstMessage, [ownerFile]); expect(secondMessage.fileContext).toBeUndefined(); expect(firstMessage.files).toEqual([ expect.objectContaining({ file_id: 'owner-file', filename: 'owner.txt' }), ]); expect(secondMessage.files).toEqual([ expect.objectContaining({ file_id: 'owner-file', filename: 'owner.txt' }), ]); expect(JSON.stringify(secondMessage)).not.toContain('second-forged'); }); test('extracts historical file context while encoding provider attachments', async () => { getFiles.mockResolvedValueOnce([ownerFile]); const fileContext = deferred(); const providerAttachments = deferred(); let completed = false; TestClient.addFileContextToMessage.mockImplementation(async (message) => { await fileContext.promise; message.fileContext = 'authorized owner text'; }); TestClient.processAttachments.mockImplementation(() => providerAttachments.promise); const messagesPromise = TestClient.addPreviousAttachments([ { messageId: 'msg-concurrent-file-work', files: [{ file_id: 'owner-file', filename: 'owner.txt' }], }, ]).then((messages) => { completed = true; return messages; }); await Promise.resolve(); await Promise.resolve(); expect(TestClient.addFileContextToMessage).toHaveBeenCalledTimes(1); expect(TestClient.processAttachments).toHaveBeenCalledTimes(1); providerAttachments.resolve([ownerFile]); await Promise.resolve(); expect(completed).toBe(false); fileContext.resolve(); const [message] = await messagesPromise; expect(message.fileContext).toBe('authorized owner text'); expect(TestClient.message_file_map['msg-concurrent-file-work']).toEqual([]); }); test('preserves download-only historical attachments without trusting file fields', async () => { const [message] = await TestClient.addPreviousAttachments([ { messageId: 'msg-download-only', attachments: [ { filename: 'report.csv', filepath: '/api/files/code/download/session/file', expiresAt: 123456, conversationId: 'conversation-1', messageId: 'assistant-message', toolCallId: 'tool-call-1', text: 'untrusted text should not survive', source: 'forged-source', metadata: { codeEnvRef: { id: 'victim' } }, }, ], fileContext: 'stale context', }, ]); expect(getFiles).not.toHaveBeenCalled(); expect(message.fileContext).toBeUndefined(); expect(message.attachments).toEqual([ { filename: 'report.csv', filepath: '/api/files/code/download/session/file', expiresAt: 123456, conversationId: 'conversation-1', messageId: 'assistant-message', toolCallId: 'tool-call-1', }, ]); expect(JSON.stringify(message)).not.toContain('untrusted text'); expect(JSON.stringify(message)).not.toContain('forged-source'); expect(JSON.stringify(message)).not.toContain('victim'); }); test('processes only historical files admitted by the runtime endpoint policy', async () => { const modelFile = { ...ownerFile, metadata: undefined }; getFiles.mockResolvedValueOnce([modelFile]); TestClient.assertHistoricalAttachmentLimits = jest.fn(async () => []); const [message] = await TestClient.addPreviousAttachments([ { messageId: 'msg-1', text: 'Use the attachment', files: [{ file_id: modelFile.file_id }], }, ]); expect(TestClient.assertHistoricalAttachmentLimits).toHaveBeenCalledWith([modelFile]); expect(TestClient.addFileContextToMessage).not.toHaveBeenCalled(); expect(TestClient.processAttachments).not.toHaveBeenCalled(); expect(message.files).toEqual([expect.objectContaining({ file_id: modelFile.file_id })]); }); test('includes nested steer file references in historical admission', async () => { const modelFile = { ...ownerFile, metadata: undefined }; getFiles.mockResolvedValueOnce([modelFile]); TestClient.assertHistoricalAttachmentLimits = jest.fn(async (files) => files); await TestClient.addPreviousAttachments([ { messageId: 'msg-steer', content: [ { type: 'steer', steer: 'Use the attachment', files: [{ file_id: modelFile.file_id }], }, ], }, ]); expect(TestClient.assertHistoricalAttachmentLimits).toHaveBeenCalledWith([modelFile]); expect(TestClient.authorizedHistoricalReplayFiles.get(modelFile.file_id)).toEqual(modelFile); }); test('preserves repeated steer file injections in historical admission', async () => { const modelFile = { ...ownerFile, metadata: undefined }; getFiles.mockResolvedValueOnce([modelFile]); TestClient.assertHistoricalAttachmentLimits = jest.fn(async (files) => files); await TestClient.addPreviousAttachments([ { messageId: 'msg-steer-repeat', content: [ { type: 'steer', steer: 'Use the attachment once.', files: [{ file_id: modelFile.file_id }], }, { type: 'steer', steer: 'Use the attachment again.', files: [{ file_id: modelFile.file_id }], }, ], }, ]); expect(TestClient.assertHistoricalAttachmentLimits).toHaveBeenCalledWith([ modelFile, modelFile, ]); expect(TestClient.modelBoundHistoricalSteerFiles).toEqual([modelFile, modelFile]); }); test('keeps canonical byte metadata for processed historical survivors', async () => { const modelFile = { ...ownerFile, metadata: undefined, bytes: 120 * 1024 * 1024 }; getFiles.mockResolvedValueOnce([modelFile]); TestClient.processAttachments.mockResolvedValue([{ file_id: modelFile.file_id }]); await TestClient.addPreviousAttachments([ { messageId: 'msg-canonical-bytes', files: [{ file_id: modelFile.file_id }], }, ]); expect(TestClient.message_file_map['msg-canonical-bytes']).toEqual([modelFile]); }); test('merges safe per-message metadata onto authorized DB-backed attachments', async () => { getFiles.mockResolvedValueOnce([ownerFile]); const [message] = await TestClient.addPreviousAttachments([ { messageId: 'msg-artifact', attachments: [ { file_id: 'owner-file', filename: 'forged-artifact.csv', filepath: '/forged/artifact.csv', source: 'forged-source', metadata: { codeEnvRef: { id: 'victim' } }, text: 'forged artifact text', messageId: 'assistant-message', toolCallId: 'tool-call-2', }, ], }, ]); expect(message.attachments).toEqual([ expect.objectContaining({ file_id: 'owner-file', filename: 'owner.txt', filepath: '/uploads/owner.txt', source: 'local', metadata: ownerFile.metadata, messageId: 'assistant-message', toolCallId: 'tool-call-2', }), ]); expect(message.attachments[0].text).toBeUndefined(); expect(message.attachments[0]._id).toBeUndefined(); expect(JSON.stringify(message)).not.toContain('forged-artifact'); expect(JSON.stringify(message)).not.toContain('forged artifact text'); }); }); describe('sendMessage quote references', () => { // The blockquote merge itself lives in AgentClient.buildMessages / prependQuotes // (covered by packages/api specs). BaseClient's job is to attach the normalized // quotes onto the user message early and keep the stored text clean. test('attaches normalized quotes before getReqData fires and keeps stored text clean', async () => { TestClient.options.req = { body: { quotes: [' the selected text ', '', 42] } }; TestClient.saveMessageToDatabase = jest.fn().mockResolvedValue({ message: {} }); let captured; await TestClient.sendMessage('What does this mean?', { getReqData: (data) => { if (data.userMessage) { captured = { text: data.userMessage.text, quotes: data.userMessage.quotes }; } }, }); // Quotes are present (trimmed, non-strings dropped) at getReqData time, and // the user text is never mutated by the merge. expect(captured).toBeDefined(); expect(captured.quotes).toEqual(['the selected text']); expect(captured.text).toBe('What does this mean?'); const userSave = TestClient.saveMessageToDatabase.mock.calls.find( ([msg]) => msg.isCreatedByUser, ); expect(userSave[0].text).toBe('What does this mean?'); expect(userSave[0].quotes).toEqual(['the selected text']); }); test('persists multiple quotes in order on the saved message', async () => { TestClient.options.req = { body: { quotes: ['first excerpt', 'second excerpt'] } }; TestClient.saveMessageToDatabase = jest.fn().mockResolvedValue({ message: {} }); await TestClient.sendMessage('Compare these'); const userSave = TestClient.saveMessageToDatabase.mock.calls.find( ([msg]) => msg.isCreatedByUser, ); expect(userSave[0].text).toBe('Compare these'); expect(userSave[0].quotes).toEqual(['first excerpt', 'second excerpt']); }); test('leaves the message untouched when no quotes are provided', async () => { TestClient.options.req = { body: {} }; TestClient.saveMessageToDatabase = jest.fn().mockResolvedValue({ message: {} }); await TestClient.sendMessage('Just a question'); const userSave = TestClient.saveMessageToDatabase.mock.calls.find( ([msg]) => msg.isCreatedByUser, ); expect(userSave[0].text).toBe('Just a question'); expect(userSave[0].quotes).toBeUndefined(); expect(userSave[0].reasoningOverride).toBeUndefined(); }); test('persists only a validated request-scoped reasoning override on the user turn', async () => { TestClient.options.req = { body: { reasoningOverride: { key: 'reasoning_effort', value: 'high' } }, }; TestClient.saveMessageToDatabase = jest.fn().mockResolvedValue({ message: {} }); await TestClient.sendMessage('Think carefully'); const userSave = TestClient.saveMessageToDatabase.mock.calls.find( ([message]) => message.isCreatedByUser === true, ); expect(userSave[0].reasoningOverride).toEqual({ key: 'reasoning_effort', value: 'high', }); }); test('drops an invalid request-scoped reasoning override from message metadata', async () => { TestClient.options.req = { body: { reasoningOverride: { key: 'model', value: 'secret-model' } }, }; TestClient.saveMessageToDatabase = jest.fn().mockResolvedValue({ message: {} }); await TestClient.sendMessage('Do not trust this'); const userSave = TestClient.saveMessageToDatabase.mock.calls.find( ([message]) => message.isCreatedByUser === true, ); expect(userSave[0].reasoningOverride).toBeUndefined(); }); test('does not add a request-scoped reasoning override to a rerun turn', async () => { const rerunClient = initializeFakeClient(apiKey, options, [ ...messageHistory, { role: 'assistant', isCreatedByUser: false, text: 'Previous response', messageId: 'response-0', parentMessageId: '3', }, ]); rerunClient.options.req = { body: { reasoningOverride: { key: 'reasoning_effort', value: 'high' } }, }; const result = await rerunClient.handleStartMethods('Rerun this', { conversationId: 'conversation-1', parentMessageId: '3', responseMessageId: 'response-0', isEdited: true, isContinued: true, }); expect(result.userMessage.reasoningOverride).toBeUndefined(); }); }); describe('mergeEditedContent phase boundaries', () => { test('carries the new reasoning label when adjacent THINK parts merge', () => { const existing = [ { type: ContentTypes.THINK, think: 'Retained reasoning. ', reasoning_label: 'Inspecting the old path', reasoning_label_step_id: 'old-step', reasoning_label_attempts: 1, reasoning_label_submitted_chars: 18, reasoning_label_revision: 1, reasoning_label_status: 'complete', }, ]; const completion = [ { type: ContentTypes.THINK, think: 'Continued reasoning.', reasoning_label: 'Tracing the regenerated path', reasoning_label_step_id: 'new-step', reasoning_label_attempts: 3, reasoning_label_submitted_chars: 20, reasoning_label_revision: 2, reasoning_label_status: 'streaming', }, ]; expect(TestClient.mergeEditedContent(existing, completion, ContentTypes.THINK)).toEqual([ { ...completion[0], think: 'Retained reasoning. Continued reasoning.', }, ]); }); test('clears a retained reasoning label when the merged THINK has no label', () => { const existing = [ { type: ContentTypes.THINK, think: 'Retained reasoning. ', agentId: 'agent-1', reasoning_label: 'Inspecting the old path', reasoning_label_step_id: 'old-step', reasoning_label_attempts: 3, reasoning_label_submitted_chars: 18, reasoning_label_revision: 2, reasoning_label_status: 'complete', }, ]; const completion = [ { type: ContentTypes.THINK, think: 'Continued without a generated title.', agentId: 'agent-1', }, ]; expect(TestClient.mergeEditedContent(existing, completion, ContentTypes.THINK)).toEqual([ { type: ContentTypes.THINK, think: 'Retained reasoning. Continued without a generated title.', agentId: 'agent-1', }, ]); }); test('does not merge commentary into a final answer', () => { const existing = [ { type: ContentTypes.TEXT, text: 'Checked the deployment. ', phase: 'commentary' }, ]; const completion = [ { type: ContentTypes.TEXT, text: 'Everything is healthy.', phase: 'final_answer' }, { type: ContentTypes.ACTIVITY_LABEL, activity_label_type: 'phase', activity_start_index: 0, activity_end_index: 1, activity_label: 'Verified deployment health', }, ]; expect(TestClient.mergeEditedContent(existing, completion, ContentTypes.TEXT)).toEqual([ existing[0], completion[0], { ...completion[1], activity_start_index: 1, activity_end_index: 2 }, ]); }); test.each([ [undefined, 'commentary'], ['commentary', undefined], ])('does not merge phased and unphased text (%s → %s)', (existingPhase, completionPhase) => { const existing = [ { type: ContentTypes.TEXT, text: 'Retained text. ', ...(existingPhase != null && { phase: existingPhase }), }, ]; const completion = [ { type: ContentTypes.TEXT, text: 'New text.', ...(completionPhase != null && { phase: completionPhase }), }, ]; expect(TestClient.mergeEditedContent(existing, completion, ContentTypes.TEXT)).toEqual([ existing[0], completion[0], ]); }); }); describe('processAttachments llmDeliveryPath handling', () => { beforeEach(() => { TestClient.options = { endpoint: EModelEndpoint.openAI, }; TestClient.addImageURLs = jest.fn(async (message, files) => { message.image_urls = ['encoded-image']; return files; }); TestClient.addDocuments = jest.fn(async (message, files) => { message.documents = [{ type: 'file' }]; return files; }); TestClient.addVideos = jest.fn(async (_message, files) => files); TestClient.modelOptions = undefined; TestClient.addAudios = jest.fn(async (_message, files) => files); }); /** The routing initialization settles for an agent, from the request config it reads. */ const routedAgent = (agent) => ({ ...agent, deliveryRouting: resolveTurnDeliveryRouting({ agent, config: TestClient.options.req?.config, }), }); /* The stored path is an upload-time inference, so delivery resolves it again by the * routing settled for the agent running the turn. A test asserting a route has to * configure that route rather than rely on the stored value alone. */ const routeTo = (path, mimeTypes, endpointConfig = {}) => { TestClient.options.req = { config: { fileConfig: { endpoints: { [EModelEndpoint.openAI]: { ...endpointConfig, defaultLLMDeliveryPath: { overrides: Object.fromEntries(mimeTypes.map((mime) => [mime, path])), }, }, }, }, }, }; TestClient.options.agent = routedAgent({ provider: EModelEndpoint.openAI, endpoint: EModelEndpoint.openAI, }); }; test('keeps a none image in returned files without adding image URLs', async () => { routeTo('none', ['image/*']); const message = {}; const file = { user: 'user1', file_id: 'none-image', filename: 'image.png', filepath: '/uploads/image.png', type: 'image/png', bytes: 100, source: 'local', llmDeliveryPath: 'none', }; const result = await TestClient.processAttachments(message, [file]); expect(result).toEqual([file]); expect(message.image_urls).toBeUndefined(); expect(TestClient.addImageURLs).not.toHaveBeenCalled(); }); test('does not inject extracted text after the current provider resolves none', () => { routeTo('none', ['application/pdf']); const file = { file_id: 'none-pdf', filename: 'report.pdf', type: 'application/pdf', llmDeliveryPath: 'text', metadata: { destinationChosen: false }, }; expect(TestClient.getTextContextAttachments([file])).toEqual([]); }); const routeCsvToTools = ({ textFallbackWithoutTools = true } = {}) => { routeTo('none', ['text/csv'], { textFallbackWithoutTools }); }; test('injects the text stored for a tool-routed file when this turn runs no reader', () => { routeCsvToTools(); TestClient.options.agent = { provider: EModelEndpoint.openAI, fileConsumers: { executeCode: false, fileSearch: false }, }; TestClient.options.agent.deliveryRouting = resolveTurnDeliveryRouting({ agent: TestClient.options.agent, config: TestClient.options.req?.config, }); /* Agent initialization marks the copy it hands this client, so the stored route reads * `text` while the configured route stays `none`. */ const file = { file_id: 'fallback-csv', filename: 'sales.csv', type: 'text/csv', text: 'region,total', llmDeliveryPath: 'text', metadata: { destinationChosen: false }, }; expect(TestClient.getAttachmentDeliveryPath(file)).toBe('text'); expect(TestClient.getTextContextAttachments([file])).toEqual([file]); }); test('delivers a late steer through fallback even when the initialized agent has file tools', async () => { routeCsvToTools(); TestClient.options.agent = routedAgent({ provider: EModelEndpoint.openAI, fileConsumers: { executeCode: true, fileSearch: true }, }); const file = { file_id: 'late-csv', filename: 'late.csv', type: 'text/csv', source: 'local', text: 'region,total', llmDeliveryPath: 'none', metadata: { destinationChosen: false }, }; const assertFilesAllowed = jest.fn(); const initEncoding = jest.spyOn(Tokenizer, 'initEncoding').mockResolvedValue(undefined); const getTokenCount = jest.spyOn(Tokenizer, 'getTokenCount').mockReturnValue(4); let result; try { result = await buildSteerMedia({ client: { resolveTurnAttachments: TestClient.resolveTurnAttachments.bind(TestClient), addFileContextToMessage: BaseClientClass.prototype.addFileContextToMessage.bind(TestClient), processAttachments: BaseClientClass.prototype.processAttachments.bind(TestClient), }, user: { id: 'user-1' }, item: { steerId: 'late', text: 'Read this file', files: [{ file_id: file.file_id }] }, getFiles: jest.fn().mockResolvedValue([file]), assertFilesAllowed, }); } finally { initEncoding.mockRestore(); getTokenCount.mockRestore(); } expect(assertFilesAllowed).toHaveBeenCalledWith([{ ...file, llmDeliveryPath: 'text' }]); expect(JSON.stringify(result.content)).toContain('region,total'); expect(file.llmDeliveryPath).toBe('none'); expect(TestClient.options.agent.fileConsumers).toEqual({ executeCode: true, fileSearch: true, }); }); test('keeps a tool-routed file off the prompt when the sandbox running it holds the file', () => { routeCsvToTools(); TestClient.options.agent = { provider: EModelEndpoint.openAI, fileConsumers: { executeCode: true, fileSearch: false }, }; TestClient.options.agent.deliveryRouting = resolveTurnDeliveryRouting({ agent: TestClient.options.agent, config: TestClient.options.req?.config, }); const file = { file_id: 'code-csv', filename: 'sales.csv', type: 'text/csv', text: 'region,total', llmDeliveryPath: 'none', metadata: { destinationChosen: false, codeEnvRef: { kind: 'user', id: 'user-1', storage_session_id: 'session-1', file_id: 'sandbox-code-csv', }, }, }; expect(TestClient.getAttachmentDeliveryPath(file)).toBe('none'); expect(TestClient.getTextContextAttachments([file])).toEqual([]); }); test('delivers the text when File Search has yet to receive the file', () => { /* An upload that named no destination is filed under no tool, so an enabled search tool * alone cannot serve it and withholding the text left it readable by nothing. */ routeCsvToTools(); TestClient.options.agent = { provider: EModelEndpoint.openAI, fileConsumers: { executeCode: false, fileSearch: true }, }; TestClient.options.agent.deliveryRouting = resolveTurnDeliveryRouting({ agent: TestClient.options.agent, config: TestClient.options.req?.config, }); const file = { file_id: 'unprovisioned-csv', filename: 'sales.csv', type: 'text/csv', text: 'region,total', llmDeliveryPath: 'none', metadata: { destinationChosen: false }, }; expect(TestClient.getAttachmentDeliveryPath(file)).toBe('text'); /* The filter selects records by the route this turn resolves, so it returns the record as * stored; marking the copy admission reads is `resolveTurnAttachments`. */ expect(TestClient.getTextContextAttachments([file])).toEqual([file]); expect(TestClient.resolveTurnAttachments([file])).toEqual([ { ...file, llmDeliveryPath: 'text' }, ]); }); test('leaves a file Run Code can read with Run Code before the sandbox holds it', () => { /* Run Code uploads the file on its first call, so the text stays off the prompt, where it * would otherwise count toward the history limits until that call. */ routeCsvToTools(); TestClient.options.agent = { provider: EModelEndpoint.openAI, fileConsumers: { executeCode: true, fileSearch: true }, }; TestClient.options.agent.deliveryRouting = resolveTurnDeliveryRouting({ agent: TestClient.options.agent, config: TestClient.options.req?.config, }); const file = { file_id: 'unprovisioned-csv', filename: 'sales.csv', type: 'text/csv', text: 'region,total', llmDeliveryPath: 'none', metadata: { destinationChosen: false }, }; expect(TestClient.getAttachmentDeliveryPath(file)).toBe('none'); expect(TestClient.getTextContextAttachments([file])).toEqual([]); expect(TestClient.resolveTurnAttachments([file])).toEqual([file]); }); test('does not fall back on an endpoint that has not enabled it', () => { routeCsvToTools({ textFallbackWithoutTools: false }); TestClient.options.agent = { provider: EModelEndpoint.openAI, fileConsumers: { executeCode: false, fileSearch: false }, }; TestClient.options.agent.deliveryRouting = resolveTurnDeliveryRouting({ agent: TestClient.options.agent, config: TestClient.options.req?.config, }); const file = { file_id: 'disabled-csv', filename: 'sales.csv', type: 'text/csv', text: 'region,total', llmDeliveryPath: 'text', metadata: { destinationChosen: false }, }; expect(TestClient.getAttachmentDeliveryPath(file)).toBe('none'); expect(TestClient.getTextContextAttachments([file])).toEqual([]); }); test('does not fall back when the turn tools are unknown', () => { routeCsvToTools(); TestClient.options.agent = { provider: EModelEndpoint.openAI }; const file = { file_id: 'unknown-csv', filename: 'sales.csv', type: 'text/csv', text: 'region,total', llmDeliveryPath: 'none', metadata: { destinationChosen: false }, }; expect(TestClient.getTextContextAttachments([file])).toEqual([]); }); test('does not inject extracted text when the current provider resolves native delivery', () => { routeTo('provider', ['application/pdf']); const file = { file_id: 'provider-pdf', filename: 'report.pdf', type: 'application/pdf', llmDeliveryPath: 'text', metadata: { destinationChosen: false }, }; expect(TestClient.getTextContextAttachments([file])).toEqual([]); }); test('re-resolves a path stored under a different provider', async () => { /* Audio uploaded under Google stores `provider`, and the OpenAI encoder emits no * audio payload for it, so the inference is not this endpoint's to honor. * * What this does not do is produce a transcript: the record holds raw media and no * extracted text, and extraction at delivery is Phase 2 work. So the model receives * nothing here either way, which the assertions state rather than imply, and the * change is limited to not downloading and encoding a file to no purpose. */ routeTo('text', ['audio/*']); const message = {}; const file = { user: 'user1', file_id: 'foreign-audio', filename: 'note.mp3', filepath: '/uploads/note.mp3', type: 'audio/mpeg', bytes: 100, source: 'local', llmDeliveryPath: 'provider', }; const result = await TestClient.processAttachments(message, [file]); expect(result).toEqual([file]); expect(TestClient.addAudios).not.toHaveBeenCalled(); expect(message.audios).toBeUndefined(); expect(file.text).toBeUndefined(); }); test('re-resolves a converted image against the type it was routed on', async () => { /* Conversion rewrote the stored type, so resolving against that asks about a format * the administrator never configured a route for and delivers what they excluded. */ routeTo('none', ['image/png']); const message = {}; const file = { user: 'user1', file_id: 'converted-image', filename: 'photo.png', filepath: '/uploads/photo.webp', type: 'image/webp', bytes: 100, source: 'local', llmDeliveryPath: 'none', metadata: { routingMimeType: 'image/png' }, }; const result = await TestClient.processAttachments(message, [file]); expect(result).toEqual([file]); expect(TestClient.addImageURLs).not.toHaveBeenCalled(); }); test('reads the Responses setting the turn runs on from the settled routing', async () => { /* Azure sends a PDF natively only under the Responses API. The routing carries the * decision initialization made, so a record stored as `provider` is not resolved * again to text it has none of, which would leave the model with nothing. */ TestClient.options = { endpoint: EModelEndpoint.agents, req: { config: { fileConfig: undefined } }, }; TestClient.options.agent = routedAgent({ provider: EModelEndpoint.azureOpenAI, endpoint: EModelEndpoint.azureOpenAI, model_parameters: { useResponsesApi: true }, }); const message = {}; const file = { user: 'user1', file_id: 'azure-pdf', filename: 'doc.pdf', filepath: '/uploads/doc.pdf', type: 'application/pdf', bytes: 100, source: 'local', llmDeliveryPath: 'provider', }; await TestClient.processAttachments(message, [file]); expect(TestClient.addDocuments).toHaveBeenCalled(); }); test('resolves a custom endpoint policy by the name the admin configured', async () => { /* `initializeAgent` rewrites `agent.provider` to the client family a custom endpoint * runs on, so resolving by it looks up `openAI` and silently loses every override * written against the endpoint's own name. Upload routed under that name, and * delivery has to agree or the file is stored and never sent. */ TestClient.options = { endpoint: EModelEndpoint.agents, endpointType: EModelEndpoint.agents, agent: { provider: EModelEndpoint.openAI, endpoint: 'Mock Provider B' }, req: { config: { fileConfig: { endpoints: { 'Mock Provider B': { defaultLLMDeliveryPath: { overrides: { 'image/*': 'none' } }, }, }, }, }, }, }; TestClient.options.agent = routedAgent(TestClient.options.agent); const message = {}; const file = { user: 'user1', file_id: 'custom-image', filename: 'photo.png', filepath: '/uploads/photo.png', type: 'image/png', bytes: 100, source: 'local', llmDeliveryPath: 'provider', }; const result = await TestClient.processAttachments(message, [file]); expect(result).toEqual([file]); expect(TestClient.addImageURLs).not.toHaveBeenCalled(); }); test('resolves an agent policy by its own endpoint, not the agents container', async () => { /* getEndpointFileConfig prefers endpointType, and an agents chat carries `agents`, * so supplying it answers with the generic entry rather than the agent's. * `initializeAgent` sets `agent.endpoint` from the agent's provider, so it names a * configurable entry and never the container. */ TestClient.options = { endpoint: EModelEndpoint.agents, endpointType: EModelEndpoint.agents, agent: { provider: EModelEndpoint.openAI, endpoint: EModelEndpoint.openAI }, req: { config: { fileConfig: { endpoints: { [EModelEndpoint.openAI]: { defaultLLMDeliveryPath: { overrides: { 'image/*': 'none' } }, }, }, }, }, }, }; TestClient.options.agent = routedAgent(TestClient.options.agent); const message = {}; const file = { user: 'user1', file_id: 'agent-image', filename: 'photo.png', filepath: '/uploads/photo.png', type: 'image/png', bytes: 100, source: 'local', llmDeliveryPath: 'provider', }; const result = await TestClient.processAttachments(message, [file]); expect(result).toEqual([file]); expect(TestClient.addImageURLs).not.toHaveBeenCalled(); }); test('keeps an explicitly named destination even under a different provider', async () => { /* The user named this one, through the chooser or by requesting a tool resource, * and that decision is not this endpoint's to re-derive. */ routeTo('text', ['audio/*']); const message = {}; const file = { user: 'user1', file_id: 'chosen-audio', filename: 'note.mp3', filepath: '/uploads/note.mp3', type: 'audio/mpeg', bytes: 100, source: 'local', llmDeliveryPath: 'provider', metadata: { destinationChosen: true }, }; await TestClient.processAttachments(message, [file]); expect(TestClient.addAudios).toHaveBeenCalled(); }); test('keeps a none PDF in returned files without adding documents', async () => { routeTo('none', ['application/pdf']); const message = {}; const file = { user: 'user1', file_id: 'none-pdf', filename: 'document.pdf', filepath: '/uploads/document.pdf', type: 'application/pdf', bytes: 100, source: 'local', llmDeliveryPath: 'none', }; const result = await TestClient.processAttachments(message, [file]); expect(result).toEqual([file]); expect(message.documents).toBeUndefined(); expect(TestClient.addDocuments).not.toHaveBeenCalled(); }); test('keeps a text-delivery markdown file in returned files without adding documents', async () => { const message = {}; const file = { user: 'user1', file_id: 'text-markdown', filename: 'notes.md', filepath: '/uploads/notes.md', type: 'text/markdown', bytes: 100, source: 'local', text: 'extracted markdown', llmDeliveryPath: 'text', }; const result = await TestClient.processAttachments(message, [file]); expect(result).toEqual([file]); expect(message.documents).toBeUndefined(); expect(TestClient.addDocuments).not.toHaveBeenCalled(); }); test('still delivers a provider PDF that lazy provisioning marked embedded', async () => { const message = {}; const file = { user: 'user1', file_id: 'provisioned-pdf', filename: 'report.pdf', filepath: '/uploads/report.pdf', type: 'application/pdf', bytes: 100, source: 'local', embedded: true, llmDeliveryPath: 'provider', }; await TestClient.processAttachments(message, [file]); expect(TestClient.addDocuments).toHaveBeenCalled(); expect(message.documents).toEqual([{ type: 'file' }]); }); test('still delivers a provider image that carries a codeEnvRef', async () => { const message = {}; const file = { user: 'user1', file_id: 'provisioned-image', filename: 'chart.png', filepath: '/uploads/chart.png', type: 'image/png', bytes: 100, source: 'local', llmDeliveryPath: 'provider', metadata: { codeEnvRef: { kind: 'user', id: 'u1' } }, }; await TestClient.processAttachments(message, [file]); expect(TestClient.addImageURLs).toHaveBeenCalled(); expect(message.image_urls).toEqual(['encoded-image']); }); test('keeps a code output out of the prompt once its expired sandbox reference is cleared', async () => { /* Priming clears a dead sandbox reference on the turn's copy of the record so the file * is re-provisioned. The output still belongs to the sandbox that wrote it. */ const message = {}; const file = { user: 'user1', file_id: 'code-output-chart', filename: 'chart.png', filepath: '/uploads/chart.png', type: 'image/png', bytes: 100, source: 'local', context: 'execute_code', metadata: {}, }; const result = await TestClient.processAttachments(message, [file]); expect(result).toEqual([file]); expect(TestClient.addImageURLs).not.toHaveBeenCalled(); expect(message.image_urls).toBeUndefined(); }); test('keeps excluding embedded legacy files that have no delivery path', async () => { const message = {}; const file = { user: 'user1', file_id: 'legacy-embedded', filename: 'legacy.pdf', filepath: '/uploads/legacy.pdf', type: 'application/pdf', bytes: 100, source: 'local', embedded: true, }; const result = await TestClient.processAttachments(message, [file]); expect(result).toEqual([file]); expect(TestClient.addDocuments).not.toHaveBeenCalled(); }); test('routes legacy files without llmDeliveryPath normally', async () => { const message = {}; const file = { user: 'user1', file_id: 'legacy-pdf', filename: 'document.pdf', filepath: '/uploads/document.pdf', type: 'application/pdf', bytes: 100, source: 'local', }; const result = await TestClient.processAttachments(message, [file]); expect(result).toEqual([file]); expect(message.documents).toEqual([{ type: 'file' }]); expect(TestClient.addDocuments).toHaveBeenCalledWith(message, [file]); }); }); }); describe('BaseClient compaction turns', () => { const compactionOptions = { modelOptions: { model: 'gpt-4o-mini', temperature: 0 } }; const compactionHistory = [ { role: 'user', isCreatedByUser: true, text: 'Hello', messageId: 'u1' }, { role: 'assistant', isCreatedByUser: false, text: 'Hi', messageId: 'a1', parentMessageId: 'u1', tokenCount: 7, }, ]; let CompactClient; beforeEach(() => { jest.clearAllMocks(); CompactClient = initializeFakeClient(apiKey, compactionOptions, compactionHistory); }); test('presents the leaf as the user message and never re-saves it', async () => { CompactClient.options.req = { body: { reasoningOverride: { key: 'reasoning_effort', value: 'high' } }, }; const result = await CompactClient.handleStartMethods('', { conversationId: 'convo-compact', parentMessageId: 'a1', preallocatedUserMessageId: 'a1', isCompaction: true, }); expect(result.userMessage).toEqual({ messageId: 'a1', parentMessageId: 'u1', conversationId: undefined, isCreatedByUser: false, text: '', }); expect(CompactClient.skipSaveUserMessage).toBe(true); /** History is loaded through the leaf, and nothing is appended to it. */ expect(CompactClient.currentMessages.map((message) => message.messageId)).toEqual(['u1', 'a1']); }); test('refuses a compaction whose anchor is not the loaded leaf', async () => { await expect( CompactClient.handleStartMethods('', { conversationId: 'convo-compact', parentMessageId: 'missing', preallocatedUserMessageId: 'missing', isCompaction: true, }), ).rejects.toMatchObject({ statusCode: 404, code: 'COMPACTION_ANCHOR_NOT_FOUND' }); }); test('refuses to compact a branch whose leaf is already a finished compaction', async () => { const compacted = [ ...compactionHistory, { role: 'assistant', isCreatedByUser: false, text: '', messageId: 's1', parentMessageId: 'a1', content: [ { type: ContentTypes.SUMMARY, content: [{ type: ContentTypes.TEXT, text: 'checkpoint' }], boundary: { messageId: 'step_summary', contentIndex: 0 }, }, ], }, ]; CompactClient = initializeFakeClient(apiKey, compactionOptions, compacted); await expect( CompactClient.handleStartMethods('', { conversationId: 'convo-compact', parentMessageId: 's1', preallocatedUserMessageId: 's1', isCompaction: true, }), ).rejects.toMatchObject({ statusCode: 409, code: 'NOTHING_TO_COMPACT', message: JSON.stringify({ type: 'compaction_skipped', reason: 'nothing_to_summarize' }), }); }); test('lets an interrupted compaction be retried', async () => { const interrupted = [ ...compactionHistory, { role: 'assistant', isCreatedByUser: false, text: '', messageId: 's1', parentMessageId: 'a1', content: [{ type: ContentTypes.SUMMARY, content: [], summarizing: true }], }, ]; CompactClient = initializeFakeClient(apiKey, compactionOptions, interrupted); const result = await CompactClient.handleStartMethods('', { conversationId: 'convo-compact', parentMessageId: 's1', preallocatedUserMessageId: 's1', isCompaction: true, }); expect(result.userMessage.messageId).toBe('s1'); }); test('parents the response onto the leaf and persists only the response', async () => { const saveSpy = jest.spyOn(CompactClient, 'saveMessageToDatabase').mockResolvedValue({}); const updateSpy = jest.spyOn(CompactClient, 'updateMessageInDatabase').mockResolvedValue({}); /** A calibration ratio and a counted anchor would, on an ordinary turn, * rewrite the user message's persisted count; the leaf's must survive. */ CompactClient.contextMeta = { calibrationRatio: 0.5 }; CompactClient.buildMessages = jest.fn(async () => ({ prompt: [], tokenCountMap: { a1: 7 }, promptTokens: 7, })); const response = await CompactClient.sendMessage('', { conversationId: 'convo-compact', parentMessageId: 'a1', preallocatedUserMessageId: 'a1', isCompaction: true, }); expect(response.parentMessageId).toBe('a1'); expect(response.isCreatedByUser).toBe(false); expect(saveSpy).toHaveBeenCalledTimes(1); expect(saveSpy.mock.calls[0][0].messageId).toBe(response.messageId); expect(updateSpy).not.toHaveBeenCalled(); expect(CompactClient.currentMessages.map((message) => message.messageId)).toEqual(['u1', 'a1']); expect(compactionHistory[1].tokenCount).toBe(7); }); });