/** * Unit tests for Open Responses API controller * Tests that recordCollectedUsage is called correctly for token spending */ const { ErrorTypes, ResourceType, ContentTypes } = require('librechat-data-provider'); const mockSpendTokens = jest.fn().mockResolvedValue({}); const mockSpendStructuredTokens = jest.fn().mockResolvedValue({}); const mockRecordCollectedUsage = jest .fn() .mockResolvedValue({ input_tokens: 100, output_tokens: 50 }); const mockGetBalanceConfig = jest.fn().mockReturnValue({ enabled: true }); const mockGetTransactionsConfig = jest.fn().mockReturnValue({ enabled: true }); const mockResolveMemoryAvailability = jest.fn().mockResolvedValue(true); const mockInitialSessions = new Map([['execute_code', { session_id: 'seeded' }]]); const mockInspectContent = jest.fn().mockReturnValue(null); const mockResolveConversationTitle = jest.fn(({ filters, candidate, fallback = 'New Chat' }) => { const resolveAllowedTitle = (value) => { if (typeof value !== 'string' || value.trim() === '') { return null; } const finding = mockInspectContent( [{ source: 'conversation_title', field: 'title', text: value }], { filters }, ); return finding == null ? value : null; }; return ( resolveAllowedTitle(candidate) ?? (fallback === candidate ? null : resolveAllowedTitle(fallback)) ); }); const mockHasActivePiiPatterns = (config) => config != null && (config.starterPatterns == null || config.starterPatterns.length > 0 || (config.customPatterns?.length ?? 0) > 0); const mockHasModelBoundContentProtection = (filters, legacyPii) => { const sourcePolicies = [ legacyPii, filters?.messages?.pii, filters?.agentInstructions?.pii, filters?.conversationStarters?.pii, filters?.skills?.pii, filters?.memories?.pii, filters?.files?.pii, filters?.toolArguments?.pii, filters?.modelParameters?.pii, filters?.actionMetadata?.pii, ]; if (sourcePolicies.some(mockHasActivePiiPatterns)) { return true; } const filePolicy = filters?.files?.pii; return ( filePolicy?.uninspectable === 'block' && (filePolicy.fields == null || filePolicy.fields.some((field) => ['content', 'extracted_text', 'transcript'].includes(field), )) ); }; class MockAgentRunEnvelopeError extends TypeError { constructor(message) { super(message); this.name = 'AgentRunEnvelopeError'; } } const mockCreateAgentRunEnvelope = jest.fn( ({ protocol, requestId, receivedAt, principal, payload }) => ({ version: 1, protocol, requestId, receivedAt, principal: { userId: principal.id, ...(principal.role != null && { role: principal.role }), ...(principal.tenantId != null && { tenantId: principal.tenantId }), }, payload: JSON.parse(JSON.stringify(payload)), }), ); const mockGetSafeErrorMetadata = jest.fn((error) => { const status = error?.status ?? error?.statusCode ?? error?.response?.status; return { type: error instanceof Error ? 'Error' : 'UnknownError', ...(Number.isInteger(status) && status >= 100 && status <= 599 && { status }), }; }); const mockBuildSkillPrimedIdsByName = jest.fn((manualSkillPrimes, alwaysApplySkillPrimes) => { const primed = {}; for (const skill of alwaysApplySkillPrimes ?? []) { primed[skill.name] = skill._id.toString(); } for (const skill of manualSkillPrimes ?? []) { primed[skill.name] = skill._id.toString(); } return Object.keys(primed).length > 0 ? primed : undefined; }); const mockEnrichWithSkillConfigurable = jest.fn((result) => result); const mockBuildAgentToolContext = jest.fn(({ agent, config }) => ({ agent, endpointTokenConfig: config.endpointTokenConfig, toolRegistry: config.toolRegistry, userMCPAuthMap: config.userMCPAuthMap, tool_resources: config.tool_resources, actionsEnabled: config.actionsEnabled, accessibleSkillIds: config.accessibleSkillIds, activeSkillNames: config.activeSkillNames, codeEnvAvailable: config.codeEnvAvailable, skillAuthoringAvailable: config.skillAuthoringAvailable, fileAuthoringToolNames: config.fileAuthoringToolNames, skillPrimedIdsByName: mockBuildSkillPrimedIdsByName(config.manualSkillPrimes, config.alwaysApplySkillPrimes) ?? {}, })); const mockEnrichLoadedToolsWithAgentContext = jest.fn(({ result, req, ctx }) => mockEnrichWithSkillConfigurable({ result, context: { req, accessibleSkillIds: ctx.accessibleSkillIds, codeEnvAvailable: ctx.codeEnvAvailable === true, skillPrimedIdsByName: ctx.skillPrimedIdsByName, activeSkillNames: ctx.activeSkillNames, skillAuthoringAvailable: ctx.skillAuthoringAvailable === true, fileAuthoringToolNames: ctx.fileAuthoringToolNames, }, }), ); const mockCanAuthorSkillFiles = jest.fn( ({ scopedEditableSkillIds = [], skillCreateAllowed }) => scopedEditableSkillIds.length > 0 || skillCreateAllowed === true, ); const mockGetSkillToolDeps = jest.fn(() => ({})); const mockBuildAgentScopedContext = jest.fn().mockResolvedValue(new Map()); const mockBuildAgentContextAttachmentsByAgentId = jest.fn().mockReturnValue(new Map()); const mockBuildInlineMemoryContext = jest.fn().mockResolvedValue(''); const mockApplyContextToAgent = jest.fn().mockResolvedValue(undefined); const mockResponsesUsage = { input_tokens: 125, output_tokens: 50, total_tokens: 175, input_tokens_details: { cached_tokens: 0 }, output_tokens_details: { reasoning_tokens: 0 }, primary: { input_tokens: 100, output_tokens: 40, total_tokens: 140 }, subagent: { input_tokens: 25, output_tokens: 10, total_tokens: 35 }, }; const mockBuildResponsesUsage = jest.fn().mockReturnValue(mockResponsesUsage); const mockEnrollAgentExecution = jest.fn(); let mockExecution; let mockRealExecutionManager; function resetMockExecution() { const controller = new AbortController(); const writes = []; mockExecution = { signal: controller.signal, terminalOutcome: 'complete', abort: jest.fn((reason) => controller.abort(reason)), track: jest.fn((promise) => { writes.push(promise); return promise; }), beginProviderExecution: jest.fn(async () => { if (controller.signal.aborted) { throw Object.assign(new Error('request disconnected'), { code: 'RUN_REPLACED', status: 409, }); } }), settle: jest.fn(async () => { await Promise.all(writes); }), }; mockEnrollAgentExecution.mockResolvedValue(mockExecution); } jest.mock('nanoid', () => ({ nanoid: jest.fn(() => 'mock-nanoid-123'), })); jest.mock('uuid', () => ({ v4: jest.fn(() => 'mock-uuid-456'), })); jest.mock('@librechat/data-schemas', () => ({ ...jest.requireActual('@librechat/data-schemas'), logger: { debug: jest.fn(), info: jest.fn(), error: jest.fn(), warn: jest.fn(), }, })); jest.mock('@librechat/agents', () => ({ ...jest.requireActual('@librechat/agents'), Callback: { TOOL_ERROR: 'TOOL_ERROR' }, ToolEndHandler: jest.fn(), formatAgentMessages: jest.fn().mockReturnValue({ messages: [], indexTokenCountMap: {}, }), })); jest.mock('@librechat/api', () => ({ createApiModelCallbacks: (...args) => jest.requireActual('@librechat/api').createApiModelCallbacks(...args), captureResponseAccountingUsage: (...args) => jest.requireActual('@librechat/api').captureResponseAccountingUsage(...args), resolveResponseContinuation: (...args) => jest.requireActual('@librechat/api').resolveResponseContinuation(...args), buildResponseInputChain: (...args) => jest.requireActual('@librechat/api').buildResponseInputChain(...args), loadForegroundResponseHistory: (...args) => jest.requireActual('@librechat/api').loadForegroundResponseHistory(...args), projectStoredResponseMessage: (...args) => jest.requireActual('@librechat/api').projectStoredResponseMessage(...args), requireResponseStorageWrite: (...args) => jest.requireActual('@librechat/api').requireResponseStorageWrite(...args), saveForegroundResponseInputs: (...args) => jest.requireActual('@librechat/api').saveForegroundResponseInputs(...args), createResponseTurn: (...args) => jest.requireActual('@librechat/api').createResponseTurn(...args), createStoredForegroundResponseReader: (...args) => jest.requireActual('@librechat/api').createStoredForegroundResponseReader(...args), createResponseAccountingSnapshot: (...args) => jest.requireActual('@librechat/api').createResponseAccountingSnapshot(...args), withResponsePersistenceErrors: (...args) => jest.requireActual('@librechat/api').withResponsePersistenceErrors(...args), createFileProvisionRecovery: () => jest.requireActual('@librechat/api').createFileProvisionRecovery(), ...jest.requireActual('../../../../../packages/api/src/agents/responses/persistence'), createResponseExecutionRuntime: (...args) => jest.requireActual('@librechat/api').createResponseExecutionRuntime(...args), GenerationJobManager: jest.requireActual('@librechat/api').GenerationJobManager, getPluginHookSource: () => jest.requireActual('@librechat/api').getPluginHookSource(), getAgentErrorMetadata: (...args) => jest.requireActual('@librechat/api').getAgentErrorMetadata(...args), loadSkillAccess: (...args) => jest.requireActual('@librechat/api').loadSkillAccess(...args), getConversationWriteContext: (...args) => jest.requireActual('@librechat/api').getConversationWriteContext(...args), isTemporaryTurn: (...args) => jest.requireActual('@librechat/api').isTemporaryTurn(...args), getModelEndUsage: (...args) => jest.requireActual('@librechat/api').getModelEndUsage(...args), announceReply: jest.fn().mockResolvedValue(undefined), /* Provisioning moved into this package; the controllers build the callback from it. */ createProvisionFilesCallback: () => async () => {}, createAgentExecutionContext: (context) => context, resolveApiConversationProject: jest.fn((...args) => jest.requireActual('@librechat/api').resolveApiConversationProject(...args), ), /** Grants both by default; the capability set is what these specs vary. */ resolveToolRoleGrants: jest.fn(async () => ({ runCode: true, fileSearch: true, webSearch: true, })), SAFE_CONVERSATION_TITLE: 'New Chat', resolveConversationTitle: (...args) => mockResolveConversationTitle(...args), /** Pass-through: the controller strips UI-only activity-label parts * before SDK formatting; the mock must expose it like any other used * export or the call throws before the assertions run. */ stripActivityLabelParts: jest.fn((payload) => payload), /** Pass-through by default; the history-strip test swaps in its own result * to prove the formatter receives what this returns. */ stripUnusableSummaryParts: jest.fn((payload) => payload), createOwnedToolEndHandler: jest.fn( (...args) => new (require('@librechat/agents').ToolEndHandler)(...args), ), collectReachableAgents: (roots) => { const agents = []; const pending = [...roots]; const visited = new Set(); for (let index = 0; index < pending.length; index++) { const agent = pending[index]; if (!agent || visited.has(agent)) { continue; } visited.add(agent); agents.push(agent); pending.push(...(agent.subagentAgentConfigs ?? [])); } return agents; }, createRun: jest.fn().mockResolvedValue({ processStream: jest.fn().mockResolvedValue(undefined), }), createTerminalRunErrorObserver: (...args) => jest.requireActual('@librechat/api').createTerminalRunErrorObserver(...args), buildInitialToolSessions: jest.fn().mockReturnValue(mockInitialSessions), applyContextToAgent: (...args) => mockApplyContextToAgent(...args), buildRunToolSet: jest.fn().mockReturnValue(new Set()), /** No fixture declares a caller-executed tool, so the handoff stays inert. */ createClientToolHandoff: jest.fn(({ agentDefinitions }) => ({ toolDefinitions: agentDefinitions, appliedTools: [], wrapRunStep: (delegate) => delegate, wrapToolExecute: (delegate) => delegate, })), AgentRunEnvelopeError: MockAgentRunEnvelopeError, createAgentRunEnvelope: (...args) => mockCreateAgentRunEnvelope(...args), createRemoteExecutionContext: jest.fn((...args) => jest.requireActual('@librechat/api').createRemoteExecutionContext(...args), ), resolveAdmittedCodeEnvironmentDecision: (...args) => jest.requireActual('@librechat/api').resolveAdmittedCodeEnvironmentDecision(...args), resolvePersistableCodeEnvironmentDecision: (...args) => jest.requireActual('@librechat/api').resolvePersistableCodeEnvironmentDecision(...args), createMCPRuntimeRequestBody: ({ messageId, conversationId, parentMessageId, codeEnvironmentMode, codeWorkspaces, }) => ({ messageId, conversationId, ...(codeEnvironmentMode !== undefined && { codeEnvironmentMode }), ...(codeWorkspaces !== undefined && { codeWorkspaces }), ...(parentMessageId !== undefined && { parentMessageId: parentMessageId ?? '00000000-0000-0000-0000-000000000000', }), }), buildAgentScopedContext: (...args) => mockBuildAgentScopedContext(...args), buildInlineMemoryContext: (...args) => mockBuildInlineMemoryContext(...args), buildAgentContextAttachmentsByAgentId: (...args) => mockBuildAgentContextAttachmentsByAgentId(...args), scopeSkillIds: jest.fn().mockImplementation((ids) => ids), resolveAgentScopedSkillIds: jest .fn() .mockImplementation(({ accessibleSkillIds }) => accessibleSkillIds), loadSkillStates: jest.fn().mockResolvedValue({ skillStates: {}, defaultActiveOnShare: false }), createSafeUser: jest.fn().mockReturnValue({ id: 'user-123' }), initializeAgent: jest.fn().mockResolvedValue({ id: 'agent-123', model: 'claude-3', model_parameters: {}, toolRegistry: {}, edges: [], agentContextAttachments: [], }), discoverConnectedAgents: jest.fn().mockImplementation(async (computedParams, deps) => { // Call onAgentInitialized for each agent config if provided by the mock setup if (deps?.onAgentInitialized && mockGlobalDiscoveredAgentConfigs) { for (const [agentId, config] of mockGlobalDiscoveredAgentConfigs) { deps.onAgentInitialized(agentId, config, config); } } return { agentConfigs: mockGlobalDiscoveredAgentConfigs ?? new Map(), edges: [], skippedAgentIds: new Set(), userMCPAuthMap: undefined, }; }), resolveSubagentGraphs: jest.fn().mockResolvedValue(undefined), getBalanceConfig: mockGetBalanceConfig, getTransactionsConfig: mockGetTransactionsConfig, recordCollectedUsage: mockRecordCollectedUsage, createSubagentUsageSink: jest.fn().mockReturnValue(jest.fn()), CHILD_THREAD_READ_ONLY_ERROR: 'This subagent thread is view-only. Continue it from its parent agent or create a separate chat.', getLangfuseTraceMessageFields: jest.fn().mockResolvedValue({ langfuseSampled: true, langfuseDestinationIds: ['destination-1'], }), resolveAgentTokenConfig: jest.fn(({ agentId, byAgentId, fallback }) => agentId != null && byAgentId?.has(agentId) ? byAgentId.get(agentId) : fallback, ), extractManualSkills: jest.fn().mockReturnValue(undefined), injectSkillPrimes: jest.fn().mockReturnValue({ initialMessages: [], indexTokenCountMap: {}, inserted: 0, insertIdx: -1, alwaysApplyDropped: 0, alwaysApplyDedupedFromManual: 0, }), createToolExecuteHandler: jest.fn().mockReturnValue({ handle: jest.fn() }), resolveRecursionLimit: jest.fn().mockReturnValue(50), // Responses API writeDone: jest.fn(), buildResponse: jest.fn().mockReturnValue({ id: 'resp_mock-123', output: [] }), generateResponseId: jest.fn().mockReturnValue('resp_mock-123'), isValidationFailure: jest.fn().mockReturnValue(false), inspectContent: mockInspectContent, extractConversationTitleContent: jest.fn(({ title }) => [ { source: 'conversation_title', field: 'title', text: title }, ]), extractAgentContent: jest.fn().mockReturnValue([]), extractFileContent: jest.fn().mockReturnValue([]), extractResponseInputFileContent: jest.fn().mockReturnValue([]), extractMessageContent: jest.fn().mockReturnValue([]), extractModelParameterContent: jest.fn().mockReturnValue([]), extractSkillContent: jest.fn().mockReturnValue([]), extractToolArgumentContent: jest.fn().mockReturnValue([]), getBlockedOpaqueFileField: jest.fn().mockReturnValue(null), getContentTraversalFragments: jest.fn().mockReturnValue([]), isContentTraversalProtected: jest.fn().mockReturnValue(true), isContentTraversalLimitError: jest.fn((error) => error?.code === 'content_filter_uninspectable'), prependContentTraversalFragments: jest.fn(), assertModelBoundContent: jest.fn(), hasModelBoundContentProtection: mockHasModelBoundContentProtection, isContentFilterError: jest.fn((error) => error?.code === 'content_filter_block'), getSafeErrorMetadata: mockGetSafeErrorMetadata, /** Mirrors the real helper's contract: generic copy under content protection, otherwise the * provider's own message. Stripping of LangChain's docs URL is covered in its own unit test. */ getUserFacingProviderError: (error, protectionEnabled) => { if (protectionEnabled) { return 'An error occurred while processing the request'; } return error instanceof Error ? error.message : 'An error occurred'; }, contentFilterBlockResponse: jest.fn().mockReturnValue({ error: 'content_filter_block', message: 'Submitted content was blocked.', }), contentFilterUninspectableResponse: jest.fn().mockReturnValue({ error: 'content_filter_uninspectable', message: 'Submitted file content could not be inspected before processing.', source: 'file', field: 'content', }), emitResponseCreated: jest.fn(), createResponseContext: jest.fn().mockReturnValue({ responseId: 'resp_123' }), createResponseTracker: jest.fn().mockReturnValue({ usage: { inputTokens: 100, outputTokens: 50, reasoningTokens: 0, cachedTokens: 0 }, }), setupStreamingResponse: jest.fn(), emitResponseInProgress: jest.fn(), convertInputToMessages: jest.fn().mockReturnValue([]), validateResponseRequest: jest.fn().mockReturnValue({ request: { model: 'agent-123', input: 'Hello', stream: false }, }), buildAggregatedResponse: jest.fn().mockReturnValue({ id: 'resp_mock-123', status: 'completed', output: [], usage: { input_tokens: 100, output_tokens: 50, total_tokens: 150 }, }), buildResponsesUsage: mockBuildResponsesUsage, createResponseAccountingCollector: jest.fn().mockImplementation(() => ({ record: jest.fn(), snapshot: () => ({ status: 'unavailable', currency: 'USD', coverage: 'none', reason: 'usage_unavailable', calls: [], }), })), createApplicationBillingQuote: jest.fn(), createResponseAggregator: jest.fn().mockReturnValue({ usage: { inputTokens: 100, outputTokens: 50, reasoningTokens: 0, cachedTokens: 0 }, }), sendResponsesErrorResponse: jest.fn(), createResponsesEventHandlers: jest.fn().mockReturnValue({ handlers: { on_message_delta: { handle: jest.fn() }, on_reasoning_delta: { handle: jest.fn() }, on_run_step: { handle: jest.fn() }, on_run_step_delta: { handle: jest.fn() }, on_run_step_completed: { handle: jest.fn() }, on_chat_model_end: { handle: jest.fn() }, }, finalizeStream: jest.fn(), failStream: jest.fn(), prepareStreamResponse: jest.fn((usage, accounting) => ({ id: 'resp_mock-123', usage, accounting, object: 'response', output: [], model: 'agent-123', status: 'completed', store: false, })), }), createAggregatorEventHandlers: jest.fn().mockReturnValue({ on_message_delta: { handle: jest.fn() }, on_reasoning_delta: { handle: jest.fn() }, on_run_step: { handle: jest.fn() }, on_run_step_delta: { handle: jest.fn() }, on_run_step_completed: { handle: jest.fn() }, on_chat_model_end: { handle: jest.fn() }, }), executeAgentRun: async (params) => { if (mockRealExecutionManager) return jest .requireActual('@librechat/api') .executeAgentRun(params, { manager: mockRealExecutionManager }); const { envelope, runId, conversationId, connection, isPrincipalActive, execute, handleExecutionError, beforeSettle, afterSettle, } = params; let execution; let executionError; let closed = connection?.isClosed() ?? false; const removeCloseListener = connection?.onClose(() => { closed = true; execution?.abort(); }) ?? (() => undefined); try { execution = await mockEnrollAgentExecution({ runId, userId: envelope.principal.userId, conversationId, agentId: envelope.payload.model, protocol: envelope.protocol, isPrincipalActive, }); if (closed || connection?.isClosed() === true) execution.abort(); await execution.beginProviderExecution(); return await execute(execution); } catch (error) { executionError = error; if (handleExecutionError) return await handleExecutionError(error, execution?.signal); throw error; } finally { removeCloseListener(); if (execution) { await beforeSettle?.(execution, executionError); await execution.settle(executionError); await afterSettle?.(execution, executionError); } } }, waitForAgentExecutionWrites: async (writes) => { const results = await Promise.allSettled(writes); const failure = results.find((result) => result.status === 'rejected'); if (failure?.status === 'rejected') throw failure.reason; }, })); jest.mock('~/server/services/ToolService', () => ({ loadAgentTools: jest.fn().mockResolvedValue([]), loadToolsForExecution: jest.fn().mockResolvedValue([]), isFatalAgentInitializationError: jest.fn((error) => ['AGENT_EXPECTED_MCP_TOOLS_UNAVAILABLE', 'resource_recovery_required'].includes(error?.code), ), })); const mockGetMultiplier = jest.fn().mockReturnValue(1); const mockGetCacheMultiplier = jest.fn().mockReturnValue(null); jest.mock('~/server/controllers/agents/callbacks', () => { const noop = { handle: jest.fn() }; return { createToolEndCallback: jest.fn().mockReturnValue(jest.fn()), createResponsesToolEndCallback: jest.fn().mockReturnValue(jest.fn()), contextualizeModelUsage: jest.fn().mockImplementation((usage) => usage), agentLogHandlerObj: noop, buildSummarizationHandlers: jest.fn().mockReturnValue({ on_summarize_start: noop, on_summarize_delta: noop, on_summarize_complete: noop, }), }; }); jest.mock('~/server/services/PermissionService', () => ({ findAccessibleResources: jest.fn().mockResolvedValue([]), checkPermission: jest.fn().mockResolvedValue(true), })); jest.mock('~/server/controllers/ModelController', () => ({ getEndpointModelsConfig: jest.fn().mockResolvedValue({}), })); jest.mock('~/server/services/MCP', () => ({ resolveConfigServers: jest.fn().mockResolvedValue({}), })); jest.mock('~/config', () => ({ getMCPManager: jest.fn().mockReturnValue({}), })); jest.mock('~/server/services/Files/permissions', () => ({ filterFilesByAgentAccess: jest.fn(), })); jest.mock('~/server/services/Endpoints/agents/skillDeps', () => ({ getSkillToolDeps: mockGetSkillToolDeps, getSkillDbMethods: jest.fn(() => ({})), canAuthorSkillFiles: mockCanAuthorSkillFiles, withDeploymentSkillIds: jest.fn((ids = []) => ids), buildAgentToolContext: mockBuildAgentToolContext, resolveMemoryAvailability: mockResolveMemoryAvailability, enrichLoadedToolsWithAgentContext: mockEnrichLoadedToolsWithAgentContext, })); const mockResolveLinkedInstructions = jest.fn(); jest.mock('~/server/services/Endpoints/agents/linkedInstructions', () => ({ getLinkedInstructionsResolver: jest.fn(() => mockResolveLinkedInstructions), })); jest.mock('~/cache', () => ({ logViolation: jest.fn(), })); jest.mock('~/server/services/Files/process', () => ({ saveBase64Image: jest.fn() })); jest.mock('~/server/services/Files/strategies', () => ({ getStrategyFunctions: jest.fn().mockReturnValue({}), })); jest.mock('~/server/services/Files/Code/crud', () => ({ batchUploadCodeEnvFiles: jest.fn().mockResolvedValue({ session_id: '', files: [] }), })); jest.mock('~/server/services/Files/Code/process', () => ({ getSessionInfo: jest.fn().mockResolvedValue(null), checkIfActive: jest.fn().mockReturnValue(false), })); const mockUpdateBalance = jest.fn().mockResolvedValue({}); const mockBulkInsertTransactions = jest.fn().mockResolvedValue(undefined); jest.mock('~/models', () => ({ getAgent: jest.fn().mockResolvedValue({ id: 'agent-123', name: 'Test Agent' }), getProjectFiles: jest.fn(), getFiles: jest.fn(), getMessages: jest.fn().mockResolvedValue([]), getMessage: jest.fn().mockResolvedValue(null), saveMessage: jest.fn().mockImplementation(async (_context, message) => ({ ...message })), updateFilesUsage: jest.fn(), getUserKeyValues: jest.fn(), getUserCodeFiles: jest.fn(), getToolFilesByIds: jest.fn(), getCodeGeneratedFiles: jest.fn(), updateBalance: mockUpdateBalance, bulkInsertTransactions: mockBulkInsertTransactions, spendTokens: mockSpendTokens, spendStructuredTokens: mockSpendStructuredTokens, getMultiplier: mockGetMultiplier, getCacheMultiplier: mockGetCacheMultiplier, getConvoFiles: jest.fn().mockResolvedValue([]), getFormattedMemories: jest.fn().mockResolvedValue({ withKeys: '', withoutKeys: '' }), saveConvo: jest.fn().mockImplementation(async (_context, conversation) => ({ ...conversation })), getConvo: jest.fn().mockResolvedValue(null), readAdmittedConvoCodeEnvironmentDecision: jest.fn().mockResolvedValue(null), isSubagentOwnerAdmissible: jest.fn().mockResolvedValue(true), })); let mockGlobalDiscoveredAgentConfigs = null; describe('createResponse controller', () => { let createResponse; let req, res; beforeEach(() => { jest.clearAllMocks(); resetMockExecution(); mockGlobalDiscoveredAgentConfigs = null; require('@librechat/api').inspectContent.mockReset().mockReturnValue(null); const controller = require('../responses'); createResponse = controller.createResponse; req = { body: { model: 'agent-123', input: 'Hello', stream: false, }, user: { id: 'user-123' }, config: { endpoints: { agents: { allowedProviders: ['anthropic'] }, }, }, once: jest.fn(), off: jest.fn(), }; res = { status: jest.fn().mockReturnThis(), json: jest.fn(), setHeader: jest.fn(), flushHeaders: jest.fn(), end: jest.fn(), write: jest.fn(), once: jest.fn(), off: jest.fn(), }; }); it.each([ [false, false], [true, false], [false, true], [true, true], ])( 'passes explicit or owner-loaded workspace selections to runtime: continuation=%s moves=%s', async (continuation, movesEnabled) => { const api = require('@librechat/api'); const selections = [{ environmentId: 'machine', workspaceId: 'project' }]; req.config.endpoints.agents.statefulCodeSessions = { conversationMoves: { enabled: movesEnabled }, }; const request = { model: 'agent-123', input: 'Hello', stream: false, ...(continuation ? { previous_response_id: 'previous' } : { code_workspaces: selections }), }; api.validateResponseRequest.mockReturnValueOnce({ request }); if (continuation) require('~/models').getConvo.mockResolvedValueOnce({ conversationId: 'previous', codeWorkspaces: selections, }); if (continuation && movesEnabled) require('~/models').readAdmittedConvoCodeEnvironmentDecision.mockResolvedValueOnce({ conversationId: 'previous', codeWorkspaces: selections, }); await createResponse(req, res); expect(api.sendResponsesErrorResponse.mock.calls).toEqual([]); const fencedRead = require('~/models').readAdmittedConvoCodeEnvironmentDecision; if (movesEnabled) expect(fencedRead).toHaveBeenCalledTimes(1); else expect(fencedRead).not.toHaveBeenCalled(); expect(api.initializeAgent).toHaveBeenCalledWith( expect.objectContaining({ requestBody: expect.objectContaining({ codeWorkspaces: selections }), }), expect.anything(), ); if (continuation) expect(require('~/models').getConvo).toHaveBeenCalledWith('user-123', 'previous'); }, ); /** The SDK formatter takes the last summary part carrying text as the history * boundary, so a stored summary whose round failed would replace the turns it * never finished summarizing. The formatter must see the stripped history. */ it('formats continued history only after unusable summaries are stripped', async () => { const api = require('@librechat/api'); const db = require('~/models'); const { formatAgentMessages } = require('@librechat/agents'); const storedContent = [ { type: 'text', text: 'Earlier answer' }, { type: 'summary', content: [{ type: 'text', text: 'Partial summ' }], failed: true }, ]; const stripped = [{ role: 'assistant', content: [{ type: 'text', text: 'Earlier answer' }] }]; api.validateResponseRequest.mockReturnValueOnce({ request: { model: 'agent-123', input: 'Hello', stream: false, previous_response_id: 'previous', }, }); db.getConvo.mockResolvedValueOnce({ conversationId: 'previous', user: 'user-123' }); db.getMessages.mockResolvedValueOnce([ { messageId: 'stored-assistant', isCreatedByUser: false, content: storedContent }, ]); api.stripUnusableSummaryParts.mockReturnValueOnce(stripped); await createResponse(req, res); expect(api.stripUnusableSummaryParts).toHaveBeenCalledWith( expect.arrayContaining([ expect.objectContaining({ messageId: 'stored-assistant', content: storedContent }), ]), ); expect(formatAgentMessages).toHaveBeenCalledWith(stripped, {}, expect.anything()); }); it.each([false, true])( 'persists the normalized no-attached decision atomically: stream=%s', async (stream) => { const api = require('@librechat/api'); const db = require('~/models'); api.validateResponseRequest.mockReturnValueOnce({ request: { model: 'agent-123', input: 'Hello', stream, store: true, code_environment_mode: 'without_attached', }, }); await createResponse(req, res); expect(db.saveConvo).toHaveBeenCalledWith( expect.anything(), expect.objectContaining({ codeEnvironmentMode: 'without_attached', }), expect.anything(), ); expect(db.saveConvo.mock.calls.at(-1)[1]).not.toHaveProperty('codeWorkspaces'); }, ); it('keeps the stored decision when a continued conversation is saved', async () => { const api = require('@librechat/api'); const db = require('~/models'); api.validateResponseRequest.mockReturnValueOnce({ request: { model: 'agent-123', input: 'Hello', stream: false, store: true, previous_response_id: 'previous', }, }); db.getConvo.mockResolvedValueOnce({ conversationId: 'previous', codeEnvironmentMode: 'attached', codeWorkspaces: [{ environmentId: 'vm', workspaceId: 'projects' }], }); await createResponse(req, res); const saved = db.saveConvo.mock.calls.at(-1)[1]; expect(saved).toEqual(expect.objectContaining({ conversationId: 'previous' })); expect(saved).not.toHaveProperty('codeEnvironmentMode'); expect(saved).not.toHaveProperty('codeWorkspaces'); }); it('enrolls, starts, and settles the remote execution lifecycle', async () => { await createResponse(req, res); expect(mockEnrollAgentExecution).toHaveBeenCalledWith( expect.objectContaining({ runId: 'resp_mock-123', userId: 'user-123', agentId: 'agent-123', protocol: 'responses', }), ); const { createRun } = require('@librechat/api'); const processStream = await createRun.mock.results.at(-1).value; expect(mockExecution.beginProviderExecution).toHaveBeenCalledTimes(1); expect(mockExecution.beginProviderExecution.mock.invocationCallOrder[0]).toBeLessThan( require('@librechat/api').initializeAgent.mock.invocationCallOrder[0], ); expect(mockExecution.beginProviderExecution.mock.invocationCallOrder[0]).toBeLessThan( processStream.processStream.mock.invocationCallOrder[0], ); expect(mockExecution.settle).toHaveBeenCalledWith(undefined); expect(res.once).toHaveBeenCalledWith('close', expect.any(Function)); expect(res.off).toHaveBeenCalledWith('close', expect.any(Function)); }); it('covers artifact writes when provider execution fails', async () => { const providerError = new Error('provider aborted'); const artifactWrite = Promise.resolve(null); const processStream = jest.fn().mockRejectedValue(providerError); const { createRun } = require('@librechat/api'); const { createToolEndCallback } = require('~/server/controllers/agents/callbacks'); createRun.mockResolvedValueOnce({ processStream }); createToolEndCallback.mockImplementationOnce(({ artifactPromises }) => { artifactPromises.push(artifactWrite); return jest.fn(); }); await createResponse(req, res); expect(mockExecution.track).toHaveBeenCalledWith(expect.any(Promise)); expect(mockExecution.track.mock.invocationCallOrder[0]).toBeLessThan( mockExecution.settle.mock.invocationCallOrder[0], ); expect(mockExecution.settle).toHaveBeenCalledWith(providerError); }); it('does not initialize a provider after disconnecting during enrollment', async () => { let enteredEnrollment; const enrollmentReady = new Promise((resolve) => { enteredEnrollment = resolve; }); let finishEnrollment; mockEnrollAgentExecution.mockImplementationOnce( () => new Promise((resolve) => { finishEnrollment = resolve; enteredEnrollment(); }), ); const request = createResponse(req, res); await enrollmentReady; res.once.mock.calls[0][1](); finishEnrollment(mockExecution); await request; expect(mockExecution.abort).toHaveBeenCalledTimes(1); expect(mockExecution.beginProviderExecution).toHaveBeenCalledTimes(1); expect(require('@librechat/api').initializeAgent).not.toHaveBeenCalled(); expect(mockExecution.settle).toHaveBeenCalledWith( expect.objectContaining({ code: 'RUN_REPLACED' }), ); }); it('does not treat a consumed request stream as a response disconnect', async () => { req.destroyed = true; await createResponse(req, res); expect(mockExecution.abort).not.toHaveBeenCalled(); expect(mockExecution.beginProviderExecution).toHaveBeenCalledTimes(1); }); it('includes persistent-memory guidance in an inline agent with no saved memories', async () => { const api = require('@librechat/api'); const { memoryInstructions, buildInlineMemoryContext } = jest.requireActual('@librechat/api'); const agent = { id: 'agent-123', model: 'claude-3', model_parameters: {}, toolRegistry: {}, edges: [], memoryToolsRegistered: true, }; api.initializeAgent.mockResolvedValueOnce(agent); mockBuildInlineMemoryContext.mockImplementationOnce(buildInlineMemoryContext); await createResponse(req, res); expect(mockApplyContextToAgent).toHaveBeenCalledWith( expect.objectContaining({ agent, sharedRunContext: expect.stringContaining(memoryInstructions), }), ); expect(require('~/models').getFormattedMemories).toHaveBeenCalledWith({ userId: 'user-123', agentId: undefined, }); }); it('resolves saved graph subagents for remote Responses API runs', async () => { const { initializeAgent, resolveSubagentGraphs } = require('@librechat/api'); const primaryConfig = { id: 'agent-123', model: 'claude-3', endpointTokenConfig: { 'claude-3': { prompt: 1 } }, model_parameters: {}, toolRegistry: {}, edges: [], agentContextAttachments: [], subagents: { enabled: true, graphs: [{ type: 'team', agent_ids: ['agent-123'], edges: [] }], }, }; initializeAgent.mockResolvedValueOnce(primaryConfig); const memberConfig = { id: 'agent-graph-member', endpointTokenConfig: { 'custom-model': { prompt: 7 } }, agentContextAttachments: [{ file_id: 'member-file' }], }; resolveSubagentGraphs.mockImplementationOnce(async ({ rootConfigs }, deps) => { rootConfigs[0].subagentGraphConfigs = [ { definition: { type: 'team' }, memberConfigs: [memberConfig] }, ]; deps.onAgentInitialized(memberConfig.id, memberConfig, memberConfig); }); req.config.endpoints.agents.capabilities = ['subagents']; await createResponse(req, res); expect(resolveSubagentGraphs).toHaveBeenCalledWith( expect.objectContaining({ primaryConfig, rootConfigs: [primaryConfig], signal: mockExecution.signal, resourceType: ResourceType.REMOTE_AGENT, memoryAvailable: true, }), expect.objectContaining({ getAgent: expect.any(Function) }), ); expect(mockBuildAgentContextAttachmentsByAgentId).toHaveBeenCalledWith([ primaryConfig, memberConfig, ]); expect(mockBuildAgentScopedContext).toHaveBeenCalledWith( expect.objectContaining({ agentIds: ['agent-123', 'agent-graph-member'] }), ); expect(mockApplyContextToAgent).toHaveBeenCalledWith( expect.objectContaining({ agent: memberConfig, agentId: 'agent-graph-member' }), ); expect(mockBuildInlineMemoryContext).toHaveBeenCalledWith( expect.objectContaining({ agent: memberConfig, memoryAvailable: true }), ); const usageParams = mockRecordCollectedUsage.mock.calls[0][1]; expect(usageParams.endpointTokenConfig).toBe(primaryConfig.endpointTokenConfig); expect(usageParams.resolveEndpointTokenConfig({ agentId: memberConfig.id })).toBe( memberConfig.endpointTokenConfig, ); expect(mockResolveMemoryAvailability).toHaveBeenCalledWith( expect.objectContaining({ enabledCapabilities: expect.any(Set), user: req.user }), ); const { createRun } = require('@librechat/api'); expect(createRun).toHaveBeenCalledWith( expect.objectContaining({ initialSessions: mockInitialSessions, user: expect.objectContaining({ id: 'user-123' }), traceContext: { endpoint: 'agents' }, }), ); }); it.each([false, true])( 'excludes caller-executed tools from eager execution: stream=%s', async (stream) => { const api = require('@librechat/api'); const clientToolNames = new Set(['submit_sql']); api.validateResponseRequest.mockReturnValueOnce({ request: { model: 'agent-123', input: 'Hello', stream }, }); api.createClientToolHandoff.mockImplementationOnce(({ agentDefinitions }) => ({ toolDefinitions: agentDefinitions, appliedTools: [], clientToolNames, wrapRunStep: (delegate) => delegate, wrapToolExecute: (delegate) => delegate, })); await createResponse(req, res); expect(api.createRun).toHaveBeenCalledWith(expect.objectContaining({ clientToolNames })); }, ); it('invokes the graph with the resolved recursion limit rather than the SDK default', async () => { const api = require('@librechat/api'); const processStream = jest.fn().mockResolvedValue(undefined); api.createRun.mockResolvedValueOnce({ processStream }); api.resolveRecursionLimit.mockReturnValueOnce(123); await createResponse(req, res); expect(processStream).toHaveBeenCalledWith( expect.anything(), expect.objectContaining({ recursionLimit: 123 }), expect.anything(), ); }); it('returns 503 when an agent expects MCP tools but resolves none', async () => { const { initializeAgent, sendResponsesErrorResponse } = require('@librechat/api'); const { loadAgentTools } = require('~/server/services/ToolService'); const toolError = Object.assign(new Error('Expected MCP tools are unavailable'), { code: 'AGENT_EXPECTED_MCP_TOOLS_UNAVAILABLE', status: 503, statusCode: 503, }); loadAgentTools.mockRejectedValueOnce(toolError); initializeAgent.mockImplementationOnce(async ({ req, res, loadTools, agent }) => { await loadTools({ req, res, tools: ['run_query_mcp_warehouse'], model: agent.model, agentId: agent.id, provider: agent.provider, }); }); await createResponse(req, res); expect(sendResponsesErrorResponse).toHaveBeenCalledWith( res, 503, 'Expected MCP tools are unavailable', 'server_error', 'AGENT_EXPECTED_MCP_TOOLS_UNAVAILABLE', ); expect( require('~/server/services/ToolService').isFatalAgentInitializationError, ).toHaveBeenCalledWith(toolError, { signal: loadAgentTools.mock.calls.at(-1)[0].signal }); }); it('returns the resource recovery status and code before model invocation', async () => { const { initializeAgent, sendResponsesErrorResponse } = require('@librechat/api'); const { loadAgentTools } = require('~/server/services/ToolService'); const toolError = Object.assign(new Error('resource recovery required'), { code: ErrorTypes.RESOURCE_RECOVERY_REQUIRED, status: 409, statusCode: 409, }); loadAgentTools.mockRejectedValueOnce(toolError); initializeAgent.mockImplementationOnce(async ({ req, res, loadTools, agent }) => { await loadTools({ req, res, tools: ['execute_code'], model: agent.model, agentId: agent.id, provider: agent.provider, }); }); await createResponse(req, res); expect(sendResponsesErrorResponse).toHaveBeenCalledWith( res, 409, 'resource recovery required', 'invalid_request', ErrorTypes.RESOURCE_RECOVERY_REQUIRED, ); }); it('stores Langfuse trace markers with a persisted response', async () => { const api = require('@librechat/api'); const { saveMessage } = require('~/models'); api.validateResponseRequest.mockReturnValueOnce({ request: { ...req.body, store: true }, }); await createResponse(req, res); expect(api.getLangfuseTraceMessageFields).toHaveBeenCalledWith(req.config, 'resp_mock-123', { isTemporary: false, }); expect(saveMessage).toHaveBeenCalledWith( expect.objectContaining({ userId: 'user-123' }), expect.objectContaining({ messageId: 'resp_mock-123', isCreatedByUser: false, langfuseSampled: true, langfuseDestinationIds: ['destination-1'], tokenCount: 50, }), { context: 'Responses API - save assistant response' }, ); }); it('stores a connected user-to-assistant message tree and reports storage success', async () => { const api = require('@librechat/api'); const db = require('~/models'); api.validateResponseRequest.mockReturnValueOnce({ request: { ...req.body, store: true } }); api.convertInputToMessages.mockReturnValueOnce([ { role: 'user', content: 'Hello', messageId: 'input-chain' }, ]); await createResponse(req, res); expect(db.saveMessage).toHaveBeenCalledWith( expect.anything(), expect.objectContaining({ messageId: 'input-chain', parentMessageId: '00000000-0000-0000-0000-000000000000', }), expect.anything(), ); expect(db.saveMessage).toHaveBeenCalledWith( expect.anything(), expect.objectContaining({ messageId: 'resp_mock-123', parentMessageId: 'input-chain', }), expect.anything(), ); expect(res.json).toHaveBeenCalledWith(expect.objectContaining({ store: true })); }); it('continues a stored response ID in its owner-scoped conversation', async () => { const api = require('@librechat/api'); const db = require('~/models'); api.validateResponseRequest.mockReturnValueOnce({ request: { ...req.body, previous_response_id: 'resp_first' }, }); db.getMessage.mockResolvedValueOnce({ messageId: 'resp_first', conversationId: 'thread-conversation', isCreatedByUser: false, }); db.getConvo.mockResolvedValueOnce({ conversationId: 'thread-conversation' }); db.getMessages.mockResolvedValueOnce([ { messageId: 'first-input', isCreatedByUser: true, parentMessageId: '00000000-0000-0000-0000-000000000000', text: 'first question', }, { messageId: 'resp_first', parentMessageId: 'first-input', text: 'first answer' }, { messageId: 'later-input', isCreatedByUser: true, parentMessageId: 'resp_first', text: 'later question', }, { messageId: 'resp_later', parentMessageId: 'later-input', text: 'later answer' }, ]); await createResponse(req, res); expect(db.getMessage).toHaveBeenCalledWith({ user: 'user-123', messageId: 'resp_first' }); expect(db.getConvo).toHaveBeenCalledWith('user-123', 'thread-conversation'); const [history] = require('@librechat/agents').formatAgentMessages.mock.calls[0]; expect(history.slice(0, 2).map((message) => message.messageId)).toEqual([ 'first-input', 'resp_first', ]); expect(history.some((message) => message.messageId === 'resp_later')).toBe(false); }); it('reports unsuccessful optional storage without exposing database details', async () => { const api = require('@librechat/api'); const db = require('~/models'); api.validateResponseRequest.mockReturnValueOnce({ request: { ...req.body, store: true } }); db.saveConvo.mockRejectedValueOnce(new Error('database contains sensitive diagnostics')); await createResponse(req, res); expect(res.json).toHaveBeenCalledWith(expect.objectContaining({ store: false })); expect(api.sendResponsesErrorResponse).not.toHaveBeenCalled(); expect(JSON.stringify(res.json.mock.calls)).not.toContain('sensitive diagnostics'); }); it('retrieves the selected stored reply by its returned ID, without later replies', async () => { const db = require('~/models'); req.params = { id: 'resp_first' }; db.getMessage.mockResolvedValueOnce({ messageId: 'resp_first', conversationId: 'thread-conversation', isCreatedByUser: false, text: 'first answer', }); db.getConvo.mockResolvedValueOnce({ conversationId: 'thread-conversation', agent_id: 'agent-123', }); await require('../responses').getResponse(req, res); expect(db.getConvo).toHaveBeenCalledWith('user-123', 'thread-conversation'); expect(db.getMessages).not.toHaveBeenCalled(); expect(res.json).toHaveBeenCalledWith( expect.objectContaining({ id: 'resp_first', model: 'agent-123', store: true, output: [ expect.objectContaining({ id: 'msg_resp_first', content: [expect.objectContaining({ text: 'first answer' })], }), ], }), ); }); it('does not retrieve another owner’s stored response', async () => { const db = require('~/models'); req.params = { id: 'resp_foreign' }; db.getMessage.mockResolvedValueOnce(null); db.getConvo.mockResolvedValueOnce(null); await require('../responses').getResponse(req, res); expect(db.getMessage).toHaveBeenCalledWith({ user: 'user-123', messageId: 'resp_foreign' }); expect(res.status).toHaveBeenCalledWith(404); expect(res.json).toHaveBeenCalledWith({ error: expect.objectContaining({ type: 'not_found', code: 'response_not_found', }), }); }); it.each([false, true])( 'runs and records a forced-temporary turn as temporary for Langfuse: stream=%s', async (stream) => { const api = require('@librechat/api'); req.config.interfaceConfig = { retentionMode: 'ephemeral', temporaryChatRetention: 1 }; api.validateResponseRequest.mockReturnValueOnce({ request: { ...req.body, stream, store: true }, }); await createResponse(req, res); expect(api.createRun).toHaveBeenCalledWith(expect.objectContaining({ isTemporary: true })); expect(api.getLangfuseTraceMessageFields).toHaveBeenCalledWith(req.config, 'resp_mock-123', { isTemporary: true, }); }, ); it.each([false, true])( 'stores input and output under the retention write context: stream=%s', async (stream) => { const api = require('@librechat/api'); const db = require('~/models'); req.config.interfaceConfig = { retentionMode: 'ephemeral', temporaryChatRetention: 1 }; req.body.isTemporary = false; api.validateResponseRequest.mockReturnValueOnce({ request: { ...req.body, stream, store: true }, }); api.convertInputToMessages.mockReturnValueOnce([ { role: 'user', content: 'Hello', messageId: 'input-123' }, ]); const savedResponse = { messageId: 'resp_mock-123', isTemporary: true }; db.saveMessage.mockImplementationOnce(async (_context, message) => ({ ...message })); db.saveMessage.mockImplementationOnce(async (_context, message) => Object.assign(savedResponse, { conversationId: message.conversationId }), ); await createResponse(req, res); expect(db.saveMessage).toHaveBeenCalledTimes(2); for (const [context] of db.saveMessage.mock.calls) { expect(context).toEqual({ userId: 'user-123', isTemporary: false, expiredAt: undefined, interfaceConfig: req.config.interfaceConfig, }); } expect(api.announceReply).toHaveBeenCalledWith( db, expect.objectContaining({ reply: savedResponse }), ); }, ); describe('execution envelope', () => { it('creates the portable run input before agent initialization', async () => { req.user = { id: 'user-123', role: 'USER', tenantId: 'stale-user-tenant', federatedTokens: { access_token: 'secret' }, }; req.tenantId = 'request-tenant'; const requestBody = { ...req.body, ephemeralAgent: { skills: true }, manualSkills: ['review-code'], timezone: 'America/New_York', isTemporary: true, }; req.body = requestBody; const { validateResponseRequest, initializeAgent } = require('@librechat/api'); validateResponseRequest.mockReturnValueOnce({ request: requestBody }); await createResponse(req, res); expect(mockCreateAgentRunEnvelope).toHaveBeenCalledWith( expect.objectContaining({ protocol: 'responses', principal: { ...req.user, tenantId: 'request-tenant', }, payload: requestBody, requestId: expect.any(String), receivedAt: expect.any(Number), }), ); expect(mockCreateAgentRunEnvelope.mock.invocationCallOrder[0]).toBeLessThan( initializeAgent.mock.invocationCallOrder[0], ); expect(initializeAgent).toHaveBeenCalledWith( expect.objectContaining({ runtime: expect.objectContaining({ turnStartedAt: mockCreateAgentRunEnvelope.mock.results[0].value.receivedAt, }), requestBody: { messageId: 'resp_mock-123', conversationId: expect.any(String), codeEnvironmentMode: 'without_attached', }, }), expect.anything(), ); expect(req.turnStartedAt).toBe(mockCreateAgentRunEnvelope.mock.results[0].value.receivedAt); expect(req.body).not.toBe(requestBody); expect(req.body).toEqual(requestBody); expect(JSON.stringify(mockCreateAgentRunEnvelope.mock.results[0].value)).not.toContain( 'secret', ); }); it('returns a protocol 400 when the envelope rejects a non-JSON payload', async () => { const message = 'payload.max_output_tokens must contain only finite numbers'; const { sendResponsesErrorResponse, initializeAgent } = require('@librechat/api'); mockCreateAgentRunEnvelope.mockImplementationOnce(() => { throw new MockAgentRunEnvelopeError(message); }); await createResponse(req, res); expect(sendResponsesErrorResponse).toHaveBeenCalledWith(res, 400, message, 'invalid_request'); expect(initializeAgent).not.toHaveBeenCalled(); }); }); describe('content filtering', () => { it.each([ { description: 'data:application/pdf;base64,c2VjcmV0' }, { parameters: { type: 'object', properties: { payload: { description: 'data:application/pdf;base64,c2VjcmV0' } }, }, }, { parameters: { type: 'object', properties: { payload: { type: 'input_file', file_id: 'unresolved' } }, }, }, ])('rejects opaque caller tools in the final post-merge file check: %j', async (fields) => { const api = require('@librechat/api'); const real = jest.requireActual('@librechat/api'); req.config.filters = { files: { pii: { starterPatterns: [], fields: ['content', 'extracted_text'], uninspectable: 'block', }, }, }; const primary = { id: 'agent-123', model: 'claude-3', model_parameters: {}, toolRegistry: {}, deliveryRouting: real.resolveTurnDeliveryRouting({ agent: { provider: 'anthropic' } }), requestAttachments: [ { file_id: 'file-context', type: 'text/plain', text: 'safe file text', llmDeliveryPath: 'text', }, ], }; api.initializeAgent.mockResolvedValueOnce(primary); api.validateResponseRequest.mockReturnValueOnce({ request: { model: 'agent-123', input: 'Hello', stream: false, tools: [{ type: 'function', name: 'caller', ...fields }], }, }); api.createClientToolHandoff.mockImplementationOnce(real.createClientToolHandoff); api.assertModelBoundContent.mockImplementation(real.assertModelBoundContent); api.isContentFilterError.mockImplementation(real.isContentFilterError); try { await createResponse(req, res); expect(primary.toolDefinitions).toEqual([expect.objectContaining({ name: 'caller' })]); expect(api.assertModelBoundContent).toHaveBeenLastCalledWith( expect.objectContaining({ agents: [primary] }), ); expect(api.createRun).not.toHaveBeenCalled(); expect(api.sendResponsesErrorResponse).toHaveBeenCalledWith( res, 400, expect.any(String), 'invalid_request', 'content_filter_uninspectable', ); } finally { api.assertModelBoundContent.mockReset(); api.isContentFilterError.mockImplementation( (error) => error?.code === 'content_filter_block', ); } }); it('replaces a blocked agent-derived conversation title before persistence', async () => { const api = require('@librechat/api'); const db = require('~/models'); api.validateResponseRequest.mockReturnValueOnce({ request: { model: 'agent-123', input: 'Hello', stream: false, store: true, }, }); api.inspectContent.mockImplementation((fragments) => fragments[0]?.source === 'conversation_title' && fragments[0]?.text === 'BLOCKED-AGENT' ? { detectorId: 'pii-pattern' } : null, ); db.getAgent.mockResolvedValueOnce({ id: 'agent-123', name: 'BLOCKED-AGENT', model: 'claude-3', provider: 'anthropic', }); req.config.filters = { conversationTitles: { pii: { starterPatterns: [], customPatterns: [{ id: 'blocked', label: 'blocked', regex: 'BLOCKED' }], }, }, }; await createResponse(req, res); expect(db.saveConvo).toHaveBeenCalledWith( expect.anything(), expect.objectContaining({ title: 'New Chat', }), expect.anything(), ); }); it('blocks opaque response input before conversion or agent loading', async () => { const api = require('@librechat/api'); const db = require('~/models'); const input = [ { type: 'message', role: 'user', content: [{ type: 'input_file', file_data: 'do-not-echo' }], }, ]; api.validateResponseRequest.mockReturnValueOnce({ request: { model: 'agent-123', input, stream: false }, }); api.getBlockedOpaqueFileField.mockReturnValueOnce('extracted_text'); api.contentFilterUninspectableResponse.mockReturnValueOnce({ error: 'content_filter_uninspectable', message: 'Submitted file content could not be inspected before processing.', source: 'file', field: 'extracted_text', }); await createResponse(req, res); expect(api.getBlockedOpaqueFileField).toHaveBeenCalledWith(req.config.filters, input); expect(api.convertInputToMessages).not.toHaveBeenCalled(); expect(db.getAgent).not.toHaveBeenCalled(); expect(api.sendResponsesErrorResponse).toHaveBeenCalledWith( res, 400, 'Submitted file content could not be inspected before processing.', 'invalid_request', 'content_filter_uninspectable', ); expect(JSON.stringify(api.sendResponsesErrorResponse.mock.calls)).not.toContain( 'do-not-echo', ); }); it('returns a raw-free error when nested response input exhausts its budget', async () => { const api = require('@librechat/api'); const db = require('~/models'); req.config.filters = { messages: { pii: { starterPatterns: [] } } }; api.extractMessageContent.mockImplementationOnce(() => { throw { code: 'content_filter_uninspectable', statusCode: 400, body: { error: 'content_filter_uninspectable', message: 'Submitted content could not be completely inspected before processing.', source: 'message', field: 'content_part', }, }; }); await createResponse(req, res); expect(db.getAgent).not.toHaveBeenCalled(); expect(api.sendResponsesErrorResponse).toHaveBeenCalledWith( res, 400, 'Submitted content could not be completely inspected before processing.', 'invalid_request', 'content_filter_uninspectable', ); }); it('continues when exhausted response parameters are outside the active policy', async () => { const api = require('@librechat/api'); const db = require('~/models'); api.extractModelParameterContent.mockImplementationOnce(() => { throw { code: 'content_filter_uninspectable', statusCode: 400, body: { error: 'content_filter_uninspectable', message: 'Submitted content could not be completely inspected before processing.', source: 'model_parameter', field: 'request_fields', }, }; }); api.isContentTraversalProtected.mockReturnValueOnce(false); await createResponse(req, res); expect(db.getAgent).toHaveBeenCalled(); expect(api.sendResponsesErrorResponse).not.toHaveBeenCalledWith( res, 400, expect.anything(), 'invalid_request', 'content_filter_uninspectable', ); }); it('retains earlier request fragments when a function schema exhausts traversal', async () => { const api = require('@librechat/api'); const db = require('~/models'); const instructionFragment = { id: 'agent.instructions', path: '/instructions', text: 'PRIVATE-INSTRUCTION', source: 'agent_instruction', field: 'instructions', }; const partialToolFragment = { id: 'tool.arguments.partial', path: '/arguments/safe', text: 'safe', source: 'tool_argument', field: 'arguments', }; const traversalError = Object.assign(new Error('Traversal limit exceeded'), { code: 'content_filter_uninspectable', statusCode: 400, body: { error: 'content_filter_uninspectable', message: 'Submitted content could not be completely inspected before processing.', source: 'tool_argument', field: 'arguments', }, }); api.validateResponseRequest.mockReturnValueOnce({ request: { model: 'agent-123', input: 'Hello', instructions: 'PRIVATE-INSTRUCTION', tools: [{ type: 'function', name: 'lookup', parameters: { safe: true } }], stream: false, }, }); api.extractAgentContent.mockReturnValueOnce([instructionFragment]); api.extractToolArgumentContent.mockImplementationOnce(() => { throw traversalError; }); api.getContentTraversalFragments.mockReturnValueOnce([ instructionFragment, partialToolFragment, ]); api.inspectContent.mockReturnValueOnce({ detectorId: 'pii-pattern', ruleId: 'private', label: 'private value', source: 'agent_instruction', field: 'instructions', }); req.config.filters = { agentInstructions: { pii: { fields: ['instructions'], starterPatterns: [], customPatterns: [{ id: 'private', label: 'private value', regex: 'PRIVATE' }], }, }, }; await createResponse(req, res); expect(api.prependContentTraversalFragments).toHaveBeenCalledWith( traversalError, expect.arrayContaining([instructionFragment]), ); expect(api.inspectContent).toHaveBeenCalledWith( expect.arrayContaining([instructionFragment, partialToolFragment]), expect.anything(), ); expect(db.getAgent).not.toHaveBeenCalled(); expect(api.sendResponsesErrorResponse).toHaveBeenCalledWith( res, 400, 'Submitted content was blocked.', 'invalid_request', 'content_filter_block', ); }); it('blocks instructions and input before loading the agent', async () => { const api = require('@librechat/api'); const db = require('~/models'); api.validateResponseRequest.mockReturnValueOnce({ request: { model: 'agent-123', input: 'Hello', stream: false, metadata: { label: 'submitted metadata' }, text: { format: { type: 'json_schema', json_schema: { description: 'submitted response schema' }, }, }, }, }); api.inspectContent.mockReturnValueOnce({ detectorId: 'pii-pattern', ruleId: 'sk_prefix', label: 'sk- prefix token', source: 'agent_instruction', field: 'instructions', }); await createResponse(req, res); expect(api.extractAgentContent).toHaveBeenCalled(); expect(api.extractMessageContent).toHaveBeenCalled(); expect(api.extractModelParameterContent).toHaveBeenCalledWith( expect.objectContaining({ metadata: { label: 'submitted metadata' }, response_format: { type: 'json_schema', json_schema: { description: 'submitted response schema' }, }, }), ); expect(db.getAgent).not.toHaveBeenCalled(); expect(api.sendResponsesErrorResponse).toHaveBeenCalledWith( res, 400, 'Submitted content was blocked.', 'invalid_request', 'content_filter_block', ); }); it('blocks manually selected skill names before resolving the skill', async () => { const api = require('@librechat/api'); const db = require('~/models'); req.body.manualSkills = ['PRIVATE-SKILL']; api.extractManualSkills.mockReturnValueOnce(['PRIVATE-SKILL']); api.inspectContent.mockReturnValueOnce({ detectorId: 'pii-pattern', ruleId: 'private', label: 'private value', source: 'skill', field: 'name', }); await createResponse(req, res); expect(api.extractSkillContent).toHaveBeenCalledWith({ name: 'PRIVATE-SKILL' }); expect(db.getAgent).not.toHaveBeenCalled(); expect(api.sendResponsesErrorResponse).toHaveBeenCalledWith( res, 400, 'Submitted content was blocked.', 'invalid_request', 'content_filter_block', ); }); it('blocks previously stored model-bound content before provider invocation', async () => { const api = require('@librechat/api'); const blockedError = Object.assign( new Error('Submitted content contains a private value. Remove it and try again.'), { code: 'content_filter_block', statusCode: 400, body: { error: 'content_filter_block', message: 'Submitted content contains a private value. Remove it and try again.', source: 'message', field: 'text', }, }, ); api.assertModelBoundContent.mockImplementationOnce(() => { throw blockedError; }); await createResponse(req, res); expect(api.assertModelBoundContent).toHaveBeenCalled(); expect(api.createRun).not.toHaveBeenCalled(); expect(api.sendResponsesErrorResponse).toHaveBeenCalledWith( res, 400, blockedError.body.message, 'invalid_request', 'content_filter_block', ); }); it('preserves imported whole-assistant provenance and blocks its stored text', async () => { const api = require('@librechat/api'); const db = require('~/models'); const storedMessage = { messageId: 'imported-assistant', isCreatedByUser: false, isUserSubmitted: true, text: 'sk-imported-secret', }; const blockedError = Object.assign(new Error('Submitted content was blocked.'), { code: 'content_filter_block', statusCode: 400, body: { error: 'content_filter_block', message: 'Submitted content was blocked.', source: 'message', field: 'text', }, }); api.validateResponseRequest.mockReturnValueOnce({ request: { model: 'agent-123', input: 'Hello', stream: false, previous_response_id: 'resp_imported', }, }); db.getConvo.mockResolvedValueOnce({ conversationId: 'resp_imported', user: 'user-123' }); db.getMessages.mockResolvedValueOnce([storedMessage]); api.assertModelBoundContent.mockImplementationOnce(({ storedMessages }) => { expect(storedMessages).toEqual([ expect.objectContaining({ messageId: 'imported-assistant', isCreatedByUser: false, isUserSubmitted: true, text: 'sk-imported-secret', content: 'sk-imported-secret', }), ]); throw blockedError; }); await createResponse(req, res); expect(api.initializeAgent).not.toHaveBeenCalled(); expect(api.discoverConnectedAgents).not.toHaveBeenCalled(); expect(mockBuildAgentScopedContext).not.toHaveBeenCalled(); expect(mockApplyContextToAgent).not.toHaveBeenCalled(); expect(db.updateFilesUsage).not.toHaveBeenCalled(); expect(api.createRun).not.toHaveBeenCalled(); expect(api.sendResponsesErrorResponse).toHaveBeenCalledWith( res, 400, blockedError.body.message, 'invalid_request', 'content_filter_block', ); }); it('preserves path-marked assistant content and blocks only the submitted block', async () => { const api = require('@librechat/api'); const db = require('~/models'); const content = [ { type: 'text', text: 'neighboring model prose' }, { type: 'text', text: 'sk-path-secret' }, ]; const blockedError = Object.assign(new Error('Submitted content was blocked.'), { code: 'content_filter_block', statusCode: 400, body: { error: 'content_filter_block', message: 'Submitted content was blocked.', source: 'message', field: 'content_part', }, }); api.validateResponseRequest.mockReturnValueOnce({ request: { model: 'agent-123', input: 'Hello', stream: false, previous_response_id: 'resp_path_marked', }, }); db.getConvo.mockResolvedValueOnce({ conversationId: 'resp_path_marked', user: 'user-123', }); db.getMessages.mockResolvedValueOnce([ { messageId: 'mixed-assistant', isCreatedByUser: false, text: 'assistant summary text', content, userSubmittedPaths: ['/content/1/text'], userSubmittedMessageFieldPaths: [{ path: '/content/1/text', field: 'decision_response' }], }, ]); api.assertModelBoundContent.mockImplementationOnce(({ storedMessages }) => { expect(storedMessages).toEqual([ expect.objectContaining({ text: 'assistant summary text', content, userSubmittedPaths: ['/content/1/text'], userSubmittedMessageFieldPaths: [ { path: '/content/1/text', field: 'decision_response' }, ], }), ]); throw blockedError; }); await createResponse(req, res); expect(api.initializeAgent).not.toHaveBeenCalled(); expect(api.createRun).not.toHaveBeenCalled(); expect(api.sendResponsesErrorResponse).toHaveBeenCalledWith( res, 400, blockedError.body.message, 'invalid_request', 'content_filter_block', ); }); it('allows neighboring unmarked assistant prose when marked content is safe', async () => { const api = require('@librechat/api'); const db = require('~/models'); const content = [ { type: 'text', text: 'sk-model-generated-prose' }, { type: 'text', text: 'safe submitted correction' }, ]; api.validateResponseRequest.mockReturnValueOnce({ request: { model: 'agent-123', input: 'Hello', stream: false, previous_response_id: 'resp_neighboring_model_output', }, }); db.getConvo.mockResolvedValueOnce({ conversationId: 'resp_neighboring_model_output', user: 'user-123', }); db.getMessages.mockResolvedValueOnce([ { messageId: 'mixed-assistant', isCreatedByUser: false, content, userSubmittedPaths: ['/content/1/text'], }, ]); api.assertModelBoundContent.mockImplementationOnce(({ storedMessages }) => { const [message] = storedMessages; expect(message.content).toEqual(content); expect(message.userSubmittedPaths).toEqual(['/content/1/text']); expect(message.content[1].text).toBe('safe submitted correction'); }); await createResponse(req, res); expect(api.createRun).toHaveBeenCalledTimes(1); expect(api.sendResponsesErrorResponse).not.toHaveBeenCalledWith( res, 400, expect.anything(), 'invalid_request', 'content_filter_block', ); }); it('preflights request and context attachments from every run agent under a files-only policy', async () => { const api = require('@librechat/api'); const primaryRequestFile = { filename: 'primary-request.txt', content: 'primary request' }; const primaryContextFile = { filename: 'primary-context.txt', content: 'primary context' }; const handoffRequestFile = { filename: 'handoff-request.txt', content: 'handoff request' }; const handoffContextFile = { filename: 'handoff-context.txt', content: 'sk-handoff-context', }; const blockedError = Object.assign(new Error('Submitted file content was blocked.'), { code: 'content_filter_block', statusCode: 400, body: { error: 'content_filter_block', message: 'Submitted file content was blocked.', source: 'file', field: 'content', }, }); req.config.filters = { files: { pii: { fields: ['content'], starterPatterns: ['sk-'] } }, }; api.validateResponseRequest.mockReturnValueOnce({ request: { model: 'agent-123', input: 'Hello', stream: true }, }); api.initializeAgent.mockResolvedValueOnce({ id: 'agent-123', model: 'claude-3', model_parameters: {}, toolRegistry: {}, edges: [{ source: 'agent-123', target: 'agent-handoff' }], requestAttachments: [primaryRequestFile], agentContextAttachments: [primaryContextFile], }); mockGlobalDiscoveredAgentConfigs = new Map([ [ 'agent-handoff', { id: 'agent-handoff', model: 'claude-3', model_parameters: {}, requestAttachments: [handoffRequestFile], agentContextAttachments: [handoffContextFile], }, ], ]); api.assertModelBoundContent .mockImplementationOnce(() => undefined) .mockImplementationOnce(({ filters, files }) => { expect(filters).toEqual(req.config.filters); expect(files).toEqual([ primaryRequestFile, primaryContextFile, handoffRequestFile, handoffContextFile, ]); throw blockedError; }); await createResponse(req, res); expect(api.createRun).not.toHaveBeenCalled(); expect(api.setupStreamingResponse).not.toHaveBeenCalled(); expect(api.sendResponsesErrorResponse).toHaveBeenCalledWith( res, 400, blockedError.body.message, 'invalid_request', 'content_filter_block', ); }); it('preflights each exact synthesized dynamic tool context as file content', async () => { const api = require('@librechat/api'); const nestedPureSubagent = { id: 'agent-nested-pure', model: 'claude-3', model_parameters: {}, toolDefinitions: [ { name: 'nested_lookup', description: 'late-loaded nested tool definition', parameters: { type: 'object' }, }, ], dynamicToolContextMap: { nested_lookup: 'sk-nested-dynamic-context', }, }; const blockedError = Object.assign(new Error('Submitted file content was blocked.'), { code: 'content_filter_block', statusCode: 400, body: { error: 'content_filter_block', message: 'Submitted file content was blocked.', source: 'file', field: 'content', }, }); req.config.filters = { files: { pii: { fields: ['content'], starterPatterns: ['sk-'] } }, }; api.validateResponseRequest.mockReturnValueOnce({ request: { model: 'agent-123', input: 'Hello', stream: true }, }); api.initializeAgent.mockResolvedValueOnce({ id: 'agent-123', model: 'claude-3', model_parameters: {}, toolRegistry: {}, edges: [{ source: 'agent-123', target: 'agent-handoff' }], dynamicToolContextMap: { execute_code: ' primary safe context', ignored_empty: '', file_search: 'primary context ', ignored_non_string: 42, }, subagentAgentConfigs: [ { id: 'agent-pure', model: 'claude-3', model_parameters: {}, subagentAgentConfigs: [nestedPureSubagent], }, ], }); mockGlobalDiscoveredAgentConfigs = new Map([ [ 'agent-handoff', { id: 'agent-handoff', model: 'claude-3', model_parameters: {}, dynamicToolContextMap: { execute_code: 'handoff safe context', file_search: 'sk-handoff-dynamic-context', }, }, ], ]); api.assertModelBoundContent .mockImplementationOnce(() => undefined) .mockImplementationOnce(({ filters, agents, files }) => { expect(filters).toEqual(req.config.filters); expect(agents.map(({ id }) => id)).toEqual([ 'agent-123', 'agent-handoff', 'agent-pure', 'agent-nested-pure', ]); expect(files).toEqual([ { content: 'primary safe context\nprimary context' }, { content: 'handoff safe context\nsk-handoff-dynamic-context' }, { content: 'sk-nested-dynamic-context' }, ]); throw blockedError; }); await createResponse(req, res); expect(api.createRun).not.toHaveBeenCalled(); expect(api.setupStreamingResponse).not.toHaveBeenCalled(); expect(api.sendResponsesErrorResponse).toHaveBeenCalledWith( res, 400, blockedError.body.message, 'invalid_request', 'content_filter_block', ); }); it('re-inspects agents after dynamic context is applied', async () => { const api = require('@librechat/api'); const blockedError = Object.assign(new Error('Submitted content was blocked.'), { code: 'content_filter_block', statusCode: 400, body: { error: 'content_filter_block', message: 'Submitted content was blocked.', source: 'agent_instruction', field: 'instructions', }, }); mockApplyContextToAgent.mockImplementationOnce(async ({ agent }) => { agent.instructions = 'PRIVATE-DYNAMIC-INSTRUCTION'; }); api.assertModelBoundContent .mockImplementationOnce(() => undefined) .mockImplementationOnce(({ agents }) => { if (agents?.some((agent) => agent.instructions === 'PRIVATE-DYNAMIC-INSTRUCTION')) { throw blockedError; } }); await createResponse(req, res); expect(api.assertModelBoundContent).toHaveBeenLastCalledWith( expect.objectContaining({ agents: [expect.objectContaining({ instructions: 'PRIVATE-DYNAMIC-INSTRUCTION' })], }), ); expect(api.createRun).not.toHaveBeenCalled(); expect(api.sendResponsesErrorResponse).toHaveBeenCalledWith( res, 400, blockedError.body.message, 'invalid_request', 'content_filter_block', ); }); }); describe('safe error logging', () => { const credentialCases = () => { const { OpenIDReauthRequiredError, MCPAuthenticationRejectedError, MCPAuthenticationRefreshError, OboTokenResolutionError, } = jest.requireActual('@librechat/api'); return [ [new OpenIDReauthRequiredError('Please sign in again'), 401, undefined], [ new MCPAuthenticationRejectedError('private-mcp', false), 403, 'MCP_AUTHENTICATION_REJECTED', ], [ new MCPAuthenticationRefreshError(new Error('temporary failure')), 503, 'MCP_AUTHENTICATION_REFRESH_FAILED', ], [ new OboTokenResolutionError('session_refresh_failed', 'Please sign in again', false), 403, 'MCP_AUTHENTICATION_REJECTED', ], [ new OboTokenResolutionError('exchange_failed', 'Temporary exchange failure', true), 503, 'MCP_AUTHENTICATION_REFRESH_FAILED', ], ]; }; it.each(credentialCases())( 'preserves remote Responses credential metadata: %s', async (error, status, code) => { const api = require('@librechat/api'); api.initializeAgent.mockRejectedValueOnce(error); await createResponse(req, res); expect(api.sendResponsesErrorResponse).toHaveBeenCalledWith( res, status, error.message, status < 500 ? 'invalid_request' : 'server_error', ...(code ? [code] : []), ); }, ); it('does not classify a client disconnect as an upstream model error', async () => { const api = require('@librechat/api'); const { logger } = require('@librechat/data-schemas'); const abortError = Object.assign(new Error('request aborted'), { name: 'AbortError' }); api.createRun.mockImplementationOnce(async (options) => ({ processStream: jest.fn(async () => { options.modelCallbacks .find(({ name }) => name === 'librechat-upstream-model-error-tracker') .handleLLMError(abortError); res.once.mock.calls.find(([event]) => event === 'close')[1](); throw abortError; }), })); await createResponse(req, res); expect(mockExecution.signal.aborted).toBe(true); expect(logger.error).not.toHaveBeenCalledWith( '[Responses API] Upstream model error', expect.anything(), ); }); it('logs bounded metadata and returns a raw-free provider error', async () => { const api = require('@librechat/api'); const { logger } = require('@librechat/data-schemas'); const rawValue = 'PRIVATE-RESPONSES-PROVIDER-PAYLOAD'; const providerError = Object.assign(new Error(`Provider echoed ${rawValue}`), { code: 'ERR_REMOTE', response: { status: 502, headers: { authorization: rawValue }, data: { prompt: rawValue }, }, }); req.config.filters = { messages: { pii: {} } }; api.createRun.mockRejectedValueOnce(providerError); await createResponse(req, res); const errorLog = logger.error.mock.calls.find( ([message]) => message === '[Responses API] Error:', ); expect(errorLog).toEqual(['[Responses API] Error:', { type: 'Error', status: 502 }]); expect(JSON.stringify(errorLog)).not.toContain(rawValue); expect(api.sendResponsesErrorResponse).toHaveBeenCalledWith( res, 500, 'An error occurred while processing the request', 'server_error', ); expect(JSON.stringify(api.sendResponsesErrorResponse.mock.calls)).not.toContain(rawValue); }); it.each([false, true])( 'classifies a terminal model callback failure and correlates its trace: stream=%s', async (stream) => { const api = require('@librechat/api'); const { logger } = require('@librechat/data-schemas'); const rawValue = 'PRIVATE-RESPONSES-UPSTREAM-PAYLOAD'; const providerError = Object.assign(new Error(`Provider echoed ${rawValue}`), { code: 'ERR_REMOTE', response: { status: 503, data: { prompt: rawValue } }, }); req.config.filters = { messages: { pii: {} } }; api.validateResponseRequest.mockReturnValueOnce({ request: { model: 'agent-123', input: 'Hello', stream }, }); api.createRun.mockImplementationOnce(async (options) => ({ processStream: jest.fn(async () => { options.modelCallbacks .find(({ name }) => name === 'librechat-upstream-model-error-tracker') .handleLLMError(providerError); throw new Error('graph failed', { cause: providerError }); }), })); await createResponse(req, res); const errorLog = logger.error.mock.calls.find( ([message]) => message === '[Responses API] Upstream model error', ); expect(errorLog).toEqual([ '[Responses API] Upstream model error', { type: 'Error', status: 503, errorCode: 'UPSTREAM_MODEL_ERROR', errorOrigin: 'model_provider', errorType: '503', traceId: 'da34f2d846b1b1b770afe89e670770d5', }, ]); expect(JSON.stringify(errorLog)).not.toContain(rawValue); expect(JSON.stringify(errorLog)).not.toContain('ERR_REMOTE'); }, ); it('preserves the legacy provider error when protection is inactive', async () => { const api = require('@librechat/api'); const rawValue = 'LEGACY-RESPONSES-PROVIDER-ERROR'; api.createRun.mockRejectedValueOnce( Object.assign(new Error(rawValue), { code: 'ERR_LEGACY_REMOTE' }), ); await createResponse(req, res); expect(api.sendResponsesErrorResponse).toHaveBeenCalledWith( res, 500, rawValue, 'server_error', 'ERR_LEGACY_REMOTE', ); }); it.each([ ['a management-only prompt', { prompts: { pii: {} } }], ['an inert message', { messages: { pii: { starterPatterns: [] } } }], ])('preserves the legacy provider error for %s policy', async (_policy, filters) => { const api = require('@librechat/api'); const rawValue = 'LEGACY-RESPONSES-CONFIGURED-PROVIDER-ERROR'; req.config.filters = filters; api.createRun.mockRejectedValueOnce(new Error(rawValue)); await createResponse(req, res); expect(api.sendResponsesErrorResponse).toHaveBeenCalledWith( res, 500, rawValue, 'server_error', ); }); it('logs bounded metadata for tool callback failures', async () => { const api = require('@librechat/api'); const { logger } = require('@librechat/data-schemas'); const rawValue = 'PRIVATE-RESPONSES-TOOL-PAYLOAD'; const toolError = Object.assign(new Error(`Tool echoed ${rawValue}`), { code: 'ERR_TOOL', response: { status: 422, data: { output: rawValue } }, }); api.createRun.mockResolvedValueOnce({ processStream: jest.fn().mockImplementation(async (_input, _config, options) => { options.callbacks.TOOL_ERROR({}, toolError, 'file_search'); }), }); await createResponse(req, res); expect(mockGetSafeErrorMetadata).toHaveBeenCalledWith(toolError); const errorLog = logger.error.mock.calls.find(([message]) => message.includes('Tool Error "file_search"'), ); expect(errorLog).toEqual([ '[Responses API] Tool Error "file_search"', { type: 'Error', status: 422 }, ]); expect(JSON.stringify(errorLog)).not.toContain(rawValue); }); }); describe('conversation ownership validation', () => { it('should skip ownership check when previous_response_id is not provided', async () => { const { getConvo } = require('~/models'); await createResponse(req, res); expect(getConvo).not.toHaveBeenCalled(); }); it('should return 400 when previous_response_id is not a string', async () => { const { validateResponseRequest, sendResponsesErrorResponse } = require('@librechat/api'); validateResponseRequest.mockReturnValueOnce({ request: { model: 'agent-123', input: 'Hello', stream: false, previous_response_id: { $gt: '' }, }, }); await createResponse(req, res); expect(sendResponsesErrorResponse).toHaveBeenCalledWith( res, 400, 'previous_response_id must be a string', 'invalid_request', ); }); it('should return 404 when conversation is not owned by user', async () => { const { validateResponseRequest, sendResponsesErrorResponse } = require('@librechat/api'); const { getConvo, getAgent } = require('~/models'); validateResponseRequest.mockReturnValueOnce({ request: { model: 'agent-123', input: 'Hello', stream: false, previous_response_id: 'resp_abc', }, }); getConvo.mockResolvedValueOnce(null); getAgent.mockRejectedValueOnce(new Error('speculative agent lookup failed')); await createResponse(req, res); expect(getConvo).toHaveBeenCalledWith('user-123', 'resp_abc'); expect(sendResponsesErrorResponse).toHaveBeenCalledWith( res, 404, 'Conversation not found', 'not_found', ); }); it('starts the agent read while owner-scoped conversation validation is in flight', async () => { const api = require('@librechat/api'); const models = require('~/models'); models.getConvo.mockResolvedValueOnce({ conversationId: 'resp_abc', user: 'user-123' }); let resolveAgent; models.getAgent.mockImplementationOnce( () => new Promise((resolve) => { resolveAgent = resolve; }), ); api.resolveApiConversationProject.mockImplementationOnce(async (...args) => { expect(models.getAgent).toHaveBeenCalledWith({ id: 'agent-123' }); resolveAgent({ id: 'agent-123', name: 'Test Agent' }); return jest.requireActual('@librechat/api').resolveApiConversationProject(...args); }); api.validateResponseRequest.mockReturnValueOnce({ request: { model: 'agent-123', input: 'Hello', stream: false, previous_response_id: 'resp_abc', }, }); await createResponse(req, res); expect(models.getAgent.mock.invocationCallOrder[0]).toBeLessThan( models.getConvo.mock.invocationCallOrder[0], ); expect(api.initializeAgent).toHaveBeenCalled(); }); it('keeps Project-unavailable errors as Responses not-found responses', async () => { const api = require('@librechat/api'); const models = require('~/models'); api.validateResponseRequest.mockReturnValueOnce({ request: { model: 'agent-123', input: 'Hello', stream: false, previous_response_id: 'resp_abc', }, }); models.getAgent.mockRejectedValueOnce(new Error('speculative agent lookup failed')); api.resolveApiConversationProject.mockResolvedValueOnce({ ok: false, status: 404, reason: 'unavailable', message: 'Conversation context unavailable', }); await createResponse(req, res); const errorCall = api.sendResponsesErrorResponse.mock.calls.at(-1); expect(errorCall[1]).toBe(404); expect(errorCall[3]).toBe('not_found'); expect(api.initializeAgent).not.toHaveBeenCalled(); }); it('rechecks conversation existence after enrollment before provider or persistence work', async () => { const api = require('@librechat/api'); const models = require('~/models'); api.validateResponseRequest.mockReturnValueOnce({ request: { model: 'agent-123', input: 'Hello', stream: false, store: true, previous_response_id: 'resp_abc', }, }); let deleted = false; models.getConvo.mockImplementation(async () => deleted ? null : { conversationId: 'resp_abc', user: 'user-123' }, ); mockEnrollAgentExecution.mockImplementationOnce(async () => { deleted = true; return mockExecution; }); await createResponse(req, res); expect(mockEnrollAgentExecution).toHaveBeenCalledTimes(1); expect(api.initializeAgent).not.toHaveBeenCalled(); expect(api.createRun).not.toHaveBeenCalled(); expect(models.saveConvo).not.toHaveBeenCalled(); expect(models.saveMessage).not.toHaveBeenCalled(); }); it('should proceed when conversation is owned by user', async () => { const { validateResponseRequest, sendResponsesErrorResponse } = require('@librechat/api'); const { getConvo } = require('~/models'); validateResponseRequest.mockReturnValueOnce({ request: { model: 'agent-123', input: 'Hello', stream: false, previous_response_id: 'resp_abc', }, }); getConvo.mockResolvedValueOnce({ conversationId: 'resp_abc', user: 'user-123' }); await createResponse(req, res); expect(getConvo).toHaveBeenCalledWith('user-123', 'resp_abc'); expect(sendResponsesErrorResponse).not.toHaveBeenCalledWith( res, 404, expect.any(String), expect.any(String), ); }); it('rejects a remote response continuation of a view-only subagent thread', async () => { const { validateResponseRequest, sendResponsesErrorResponse, CHILD_THREAD_READ_ONLY_ERROR, } = require('@librechat/api'); const { getConvo, saveConvo, saveMessage } = require('~/models'); validateResponseRequest.mockReturnValueOnce({ request: { model: 'agent-123', input: 'Mutate the child.', stream: false, store: true, previous_response_id: 'child-thread', }, }); getConvo.mockResolvedValueOnce({ conversationId: 'child-thread', user: 'user-123', subagentThread: { parentConversationId: 'parent-thread' }, }); await createResponse(req, res); expect(sendResponsesErrorResponse).toHaveBeenCalledWith( res, 409, CHILD_THREAD_READ_ONLY_ERROR, 'invalid_request', 'conversation_read_only', ); expect(saveConvo).not.toHaveBeenCalled(); expect(saveMessage).not.toHaveBeenCalled(); }); it('should return 500 when getConvo throws a DB error', async () => { const { validateResponseRequest, sendResponsesErrorResponse } = require('@librechat/api'); const { getConvo } = require('~/models'); validateResponseRequest.mockReturnValueOnce({ request: { model: 'agent-123', input: 'Hello', stream: false, previous_response_id: 'resp_abc', }, }); getConvo.mockRejectedValueOnce(new Error('DB connection failed')); await createResponse(req, res); expect(sendResponsesErrorResponse).toHaveBeenCalledWith( res, 500, expect.any(String), expect.any(String), ); expect(sendResponsesErrorResponse.mock.calls.at(-1)[3]).toBe('server_error'); }); }); describe('remote-agent file authorization', () => { it.each([false, true])( 'persists completed server tool results for continued history (stream=%s)', async (stream) => { const api = require('@librechat/api'); api.validateResponseRequest.mockReturnValueOnce({ request: { ...req.body, stream, store: true }, }); const response = { id: 'resp_mock-123', status: 'completed', output: [ { type: 'function_call', id: 'fc_1', call_id: 'call-a', name: 'lookup', arguments: '{}', status: 'completed', }, { type: 'function_call_output', id: 'fco_1', call_id: 'call-a', output: 'actual protected result', status: 'completed', }, ], }; if (stream) { const handlers = api.createResponsesEventHandlers.getMockImplementation()(); api.createResponsesEventHandlers.mockReturnValueOnce({ ...handlers, prepareStreamResponse: jest.fn(() => response), }); } else api.buildAggregatedResponse.mockReturnValueOnce(response); await createResponse(req, res); expect(require('~/models').saveMessage).toHaveBeenCalledWith( expect.anything(), expect.objectContaining({ messageId: 'resp_mock-123', isCreatedByUser: false, content: [ { type: ContentTypes.TOOL_CALL, tool_call: { id: 'call-a', name: 'lookup', args: '{}', output: 'actual protected result', }, }, ], }), expect.anything(), ); }, ); it.each([false, true])( 'preserves canonical tool completion and artifact callbacks (stream=%s)', async (stream) => { const api = require('@librechat/api'); req.body.stream = stream; api.validateResponseRequest.mockReturnValueOnce({ request: { ...req.body } }); await createResponse(req, res); const { customHandlers } = api.createRun.mock.calls.at(-1)[0]; const handlers = stream ? api.createResponsesEventHandlers.mock.results.at(-1).value.handlers : api.createAggregatorEventHandlers.mock.results.at(-1).value; expect(customHandlers.on_run_step_completed).toBe(handlers.on_run_step_completed); expect(customHandlers.on_run_step_completed.handle).toEqual(expect.any(Function)); expect(api.createOwnedToolEndHandler).toHaveBeenCalled(); }, ); it('passes on what the execution context says about attendance, not an answer of its own', async () => { const { initializeAgent, createRemoteExecutionContext } = require('@librechat/api'); const { loadAgentTools } = require('~/server/services/ToolService'); createRemoteExecutionContext.mockReturnValueOnce({ principal: { userId: 'user-123' }, agentId: 'agent-123', source: { type: 'remote_api', protocol: 'responses', background: true }, unattended: false, }); await createResponse(req, res); const [initializeParams] = initializeAgent.mock.calls.at(-1); await initializeParams.loadTools({ agentId: 'agent-123', tools: ['file_search'], provider: 'anthropic', model: 'claude-3', }); expect(loadAgentTools).toHaveBeenLastCalledWith( expect.objectContaining({ unattended: false }), ); }); it.each([false, true])( 'threads the remote-agent permission boundary through initialization and tool loading (stream=%s)', async (stream) => { const { initializeAgent, createToolExecuteHandler } = require('@librechat/api'); const { loadAgentTools, loadToolsForExecution } = require('~/server/services/ToolService'); const { filterFilesByAgentAccess } = require('~/server/services/Files/permissions'); req.config.endpoints.agents.backgroundTasks = { ordinaryToolCancellation: true, completionResultMaxChars: 4096, }; req.body.stream = stream; require('@librechat/api').validateResponseRequest.mockReturnValueOnce({ request: { ...req.body }, }); await createResponse(req, res); const [initializeParams, dbMethods] = initializeAgent.mock.calls.at(-1); const filterParams = { files: [{ file_id: 'owner-file', user: 'agent-owner' }], userId: 'user-123', role: 'USER', agentId: 'agent-123', }; await dbMethods.filterFilesByAgentAccess(filterParams); expect(filterFilesByAgentAccess).toHaveBeenLastCalledWith({ ...filterParams, resourceType: ResourceType.REMOTE_AGENT, }); await initializeParams.loadTools({ agentId: 'agent-123', tools: ['file_search'], provider: 'anthropic', model: 'claude-3', tool_resources: { file_search: { file_ids: ['owner-file'] } }, }); /** A foreground response answers an API client, so tool loading must not prompt. */ expect(loadAgentTools).toHaveBeenLastCalledWith( expect.objectContaining({ agentResourceType: ResourceType.REMOTE_AGENT, unattended: true, }), ); const toolExecuteOptions = createToolExecuteHandler.mock.calls.at(-1)[0]; expect(toolExecuteOptions.ordinaryToolCancellation).toBe(true); expect(toolExecuteOptions.backgroundCompletionResultMaxChars).toBe(4096); expect(toolExecuteOptions.runSignal).toBe(mockExecution.signal); expect(toolExecuteOptions.foregroundRunId).toBe(initializeParams.requestBody.messageId); const effectiveSignal = new AbortController().signal; await toolExecuteOptions.loadTools( ['file_search'], 'agent-123', undefined, undefined, effectiveSignal, ); expect(loadToolsForExecution).toHaveBeenLastCalledWith( expect.objectContaining({ agentResourceType: ResourceType.REMOTE_AGENT, requestBody: initializeParams.requestBody, signal: effectiveSignal, unattended: true, }), ); mockExecution.abort(); await toolExecuteOptions.loadTools( ['file_search'], 'agent-123', undefined, undefined, undefined, ); expect(loadToolsForExecution).toHaveBeenLastCalledWith( expect.objectContaining({ signal: undefined }), ); }, ); }); describe('token usage recording - non-streaming', () => { it('should call recordCollectedUsage after successful non-streaming completion', async () => { await createResponse(req, res); expect(mockRecordCollectedUsage).toHaveBeenCalledTimes(1); expect(mockRecordCollectedUsage).toHaveBeenCalledWith( { spendTokens: mockSpendTokens, spendStructuredTokens: mockSpendStructuredTokens, pricing: { getMultiplier: mockGetMultiplier, getCacheMultiplier: mockGetCacheMultiplier }, bulkWriteOps: { insertMany: mockBulkInsertTransactions, updateBalance: mockUpdateBalance, }, }, expect.objectContaining({ user: 'user-123', conversationId: expect.any(String), collectedUsage: expect.any(Array), context: 'message', }), ); }); it('should pass balance and transactions config to recordCollectedUsage', async () => { mockGetBalanceConfig.mockReturnValue({ enabled: true, startBalance: 2000 }); mockGetTransactionsConfig.mockReturnValue({ enabled: true }); await createResponse(req, res); expect(mockRecordCollectedUsage).toHaveBeenCalledWith( expect.any(Object), expect.objectContaining({ balance: { enabled: true, startBalance: 2000 }, transactions: { enabled: true }, }), ); }); it('should pass spendTokens, spendStructuredTokens, pricing, and bulkWriteOps as dependencies', async () => { await createResponse(req, res); const [deps] = mockRecordCollectedUsage.mock.calls[0]; expect(deps).toHaveProperty('spendTokens', mockSpendTokens); expect(deps).toHaveProperty('spendStructuredTokens', mockSpendStructuredTokens); expect(deps).toHaveProperty('pricing'); expect(deps.pricing).toHaveProperty('getMultiplier', mockGetMultiplier); expect(deps.pricing).toHaveProperty('getCacheMultiplier', mockGetCacheMultiplier); expect(deps).toHaveProperty('bulkWriteOps'); expect(deps.bulkWriteOps).toHaveProperty('insertMany', mockBulkInsertTransactions); expect(deps.bulkWriteOps).toHaveProperty('updateBalance', mockUpdateBalance); }); it('should include model from primaryConfig in recordCollectedUsage params', async () => { await createResponse(req, res); expect(mockRecordCollectedUsage).toHaveBeenCalledWith( expect.any(Object), expect.objectContaining({ model: 'claude-3', }), ); }); }); describe('agent context parity with UI path', () => { it('applies agent-scoped attachment context before createRun', async () => { const api = require('@librechat/api'); api.initializeAgent.mockResolvedValueOnce({ id: 'agent-123', model: 'claude-3', model_parameters: {}, toolRegistry: {}, edges: [], agentContextAttachments: [{ file_id: 'file-1', filename: 'ocr_file.pdf' }], }); mockBuildAgentContextAttachmentsByAgentId.mockReturnValueOnce( new Map([['agent-123', [{ file_id: 'file-1', filename: 'ocr_file.pdf' }]]]), ); mockBuildAgentScopedContext.mockResolvedValueOnce( new Map([['agent-123', 'PDF context: ocr_file.pdf']]), ); await createResponse(req, res); expect(mockBuildAgentContextAttachmentsByAgentId).toHaveBeenCalledWith([ expect.objectContaining({ id: 'agent-123' }), ]); expect(mockBuildAgentScopedContext).toHaveBeenCalledWith( expect.objectContaining({ agentIds: ['agent-123'], attachmentsByAgentId: expect.any(Map), req, }), ); expect(mockApplyContextToAgent).toHaveBeenCalledWith( expect.objectContaining({ agent: expect.objectContaining({ id: 'agent-123' }), agentId: 'agent-123', sharedRunContext: 'PDF context: ocr_file.pdf', }), ); }); it('applies context to primary and discovered handoff agents', async () => { const api = require('@librechat/api'); const handoffConfig = { id: 'agent-handoff', model: 'claude-3', model_parameters: {}, toolRegistry: {}, edges: [], agentContextAttachments: [{ file_id: 'file-2', filename: 'handoff_context.pdf' }], }; // Set primary agent to have edges pointing to handoff agent api.initializeAgent.mockResolvedValueOnce({ id: 'agent-123', model: 'claude-3', model_parameters: {}, toolRegistry: {}, edges: [{ source: 'agent-123', target: 'agent-handoff' }], agentContextAttachments: [{ file_id: 'file-1', filename: 'primary_context.pdf' }], }); // Set global config so discoverConnectedAgents mock can invoke onAgentInitialized mockGlobalDiscoveredAgentConfigs = new Map([['agent-handoff', handoffConfig]]); mockBuildAgentScopedContext.mockResolvedValueOnce( new Map([ ['agent-123', 'Primary context'], ['agent-handoff', 'Handoff context'], ]), ); await createResponse(req, res); const appliedAgentIds = mockApplyContextToAgent.mock.calls.map((call) => call[0].agentId); expect(appliedAgentIds).toEqual(expect.arrayContaining(['agent-123', 'agent-handoff'])); expect(mockApplyContextToAgent).toHaveBeenCalledWith( expect.objectContaining({ agentId: 'agent-handoff', sharedRunContext: 'Handoff context', }), ); }); }); describe('token usage recording - streaming', () => { beforeEach(() => { req.body.stream = true; const api = require('@librechat/api'); api.validateResponseRequest.mockReturnValue({ request: { model: 'agent-123', input: 'Hello', stream: true }, }); }); it('should call recordCollectedUsage after successful streaming completion', async () => { await createResponse(req, res); expect(mockRecordCollectedUsage).toHaveBeenCalledTimes(1); expect(mockRecordCollectedUsage).toHaveBeenCalledWith( { spendTokens: mockSpendTokens, spendStructuredTokens: mockSpendStructuredTokens, pricing: { getMultiplier: mockGetMultiplier, getCacheMultiplier: mockGetCacheMultiplier }, bulkWriteOps: { insertMany: mockBulkInsertTransactions, updateBalance: mockUpdateBalance, }, }, expect.objectContaining({ user: 'user-123', context: 'message', }), ); }); }); describe('collectedUsage population', () => { it('should collect usage from on_chat_model_end events', async () => { const api = require('@librechat/api'); api.createRun.mockImplementation(async ({ customHandlers }) => { return { processStream: jest.fn().mockImplementation(async () => { customHandlers.on_chat_model_end.handle('on_chat_model_end', { output: { usage_metadata: { input_tokens: 150, output_tokens: 75, model: 'claude-3', }, }, }); }), }; }); await createResponse(req, res); expect(mockRecordCollectedUsage).toHaveBeenCalledWith( expect.any(Object), expect.objectContaining({ collectedUsage: expect.arrayContaining([ expect.objectContaining({ input_tokens: 150, output_tokens: 75, }), ]), }), ); }); it('uses collected usage for the non-streaming response', async () => { const api = require('@librechat/api'); api.validateResponseRequest.mockReturnValueOnce({ request: { model: 'agent-123', input: 'Hello', stream: false }, }); await createResponse(req, res); const collectedUsage = mockRecordCollectedUsage.mock.calls.at(-1)[1].collectedUsage; expect(mockBuildResponsesUsage).toHaveBeenCalledWith(collectedUsage); expect(api.buildAggregatedResponse).toHaveBeenCalledWith( expect.anything(), expect.anything(), mockResponsesUsage, expect.objectContaining({ status: 'unavailable', calls: expect.any(Array) }), ); }); it('uses collected usage for the completed streaming event', async () => { const api = require('@librechat/api'); api.validateResponseRequest.mockReturnValueOnce({ request: { model: 'agent-123', input: 'Hello', stream: true }, }); await createResponse(req, res); const finalizeStream = api.createResponsesEventHandlers.mock.results.at(-1).value.finalizeStream; expect(finalizeStream).toHaveBeenCalledWith( mockResponsesUsage, expect.objectContaining({ calls: expect.any(Array) }), expect.objectContaining({ store: false }), ); }); }); describe('foreground production composition', () => { const names = [ 'createSafeUser', 'createResponseContext', 'createResponseTracker', 'createResponseAggregator', 'createResponsesEventHandlers', 'createAggregatorEventHandlers', 'buildAggregatedResponse', 'buildResponsesUsage', 'convertInputToMessages', 'setupStreamingResponse', 'emitResponseCreated', 'emitResponseInProgress', 'createOwnedToolEndHandler', 'sendResponsesErrorResponse', ]; let originals; let originalRun; let originalContextualize; let originalToolEnd; beforeEach(() => { const api = require('@librechat/api'); const actual = jest.requireActual('@librechat/api'); originals = new Map(names.map((name) => [name, api[name].getMockImplementation()])); for (const name of names) api[name].mockImplementation(actual[name]); const sdk = require('@librechat/agents'); originalToolEnd = sdk.ToolEndHandler.getMockImplementation(); sdk.ToolEndHandler.mockImplementation( (...args) => new (jest.requireActual('@librechat/agents').ToolEndHandler)(...args), ); originalRun = api.createRun.getMockImplementation(); const callbacks = require('~/server/controllers/agents/callbacks'); originalContextualize = callbacks.contextualizeModelUsage.getMockImplementation(); callbacks.contextualizeModelUsage.mockImplementation( jest.requireActual('~/server/controllers/agents/callbacks').contextualizeModelUsage, ); mockRealExecutionManager = new actual.GenerationJobManagerClass(); mockRealExecutionManager.configure({ jobStore: new actual.InMemoryJobStore(), eventTransport: new actual.InMemoryEventTransport(), }); mockRealExecutionManager.initialize(); jest.spyOn(mockRealExecutionManager, 'createJob'); api.createRun.mockImplementation(async ({ customHandlers }) => ({ processStream: async () => { customHandlers.on_run_step.handle('on_run_step', { id: 'step-tool', type: 'tool_calls', index: 0, stepDetails: { type: 'tool_calls', tool_calls: [{ id: 'call', name: 'lookup', args: '{}' }], }, }); customHandlers.on_run_step_completed.handle('on_run_step_completed', { result: { id: 'step-tool', index: 0, tool_call: { id: 'call', name: 'lookup', args: '{}', output: 'retained-tool-result', type: 'tool_call', }, }, }); await customHandlers.on_tool_end.handle( 'on_tool_end', { output: new (require('@librechat/agents/langchain/messages').ToolMessage)({ content: 'retained-tool-result', tool_call_id: 'call', }), }, {}, { toolCallStepIds: new Map([['call', 'step-tool']]) }, ); customHandlers.on_message_delta.handle('on_message_delta', { delta: { content: [{ type: 'text', text: 'Answer' }] }, }); customHandlers.on_chat_model_end.handle( 'on_chat_model_end', { output: { usage_metadata: { input_tokens: 2, output_tokens: 1 } } }, {}, { getAgentContext: () => ({ clientOptions: { model: 'configured-provider-model' }, provider: 'openAI', }), }, ); }, })); }); afterEach(async () => { await mockRealExecutionManager?.destroy(); mockRealExecutionManager = undefined; const api = require('@librechat/api'); for (const [name, implementation] of originals) api[name].mockImplementation(implementation); api.createRun.mockImplementation(originalRun); require('@librechat/agents').ToolEndHandler.mockImplementation(originalToolEnd); require('~/server/controllers/agents/callbacks').contextualizeModelUsage.mockImplementation( originalContextualize, ); }); const completed = (res, stream) => { if (!stream) return res.json.mock.calls.at(-1)?.[0]; return res.write.mock.calls .map(([chunk]) => chunk) .filter((chunk) => chunk.startsWith('data: {')) .map((chunk) => JSON.parse(chunk.slice(6).trim())) .find((event) => event.type === 'response.completed')?.response; }; it.each([ [false, false, false], [true, false, false], [false, true, false], [true, true, false], [false, false, true], [true, false, true], [false, true, true], [true, true, true], ])( 'enforces native input policy through the remote bridge: stream=%s blocked=%s continuation=%s', async (stream, blocked, continuation) => { const { createRemotePolicyFixture } = require('~/test/helpers/remotePolicy'); const fixture = await createRemotePolicyFixture({ blocked }); const api = require('@librechat/api'); const actual = jest.requireActual('@librechat/api'); const db = require('~/models'); fixture.configure(req); require('@librechat/agents').formatAgentMessages.mockImplementationOnce( jest.requireActual('@librechat/agents').formatAgentMessages, ); api.initializeAgent.mockResolvedValueOnce(fixture.agent); api.createRun.mockImplementation(actual.createRun); api.validateResponseRequest.mockReturnValueOnce({ request: { model: 'agent-123', input: 'Hello', stream, store: true, ...(continuation && { previous_response_id: 'previous' }), }, }); if (continuation) { db.getConvo.mockResolvedValueOnce({ conversationId: 'previous' }); db.getMessages.mockResolvedValueOnce([ { messageId: 'prior-input', parentMessageId: '00000000-0000-0000-0000-000000000000', isCreatedByUser: true, text: 'Previous question', }, { messageId: 'prior-answer', parentMessageId: 'prior-input', isCreatedByUser: false, text: 'Previous answer', }, ]); } try { await createResponse(req, res); expect(fixture.factory).toHaveBeenCalledTimes(1); if (!blocked) expect(fixture.errors.map(({ code, stack }) => ({ code, stack }))).toEqual([]); if (blocked) expect(fixture.provider.mock.calls).toEqual([]); expect(fixture.provider).toHaveBeenCalledTimes(blocked ? 0 : 1); if (blocked) { if (!stream) expect(res.status).toHaveBeenCalledWith(400); expect(completed(res, stream)?.status).not.toBe('completed'); expect(db.saveMessage).not.toHaveBeenCalled(); expect(db.saveConvo).not.toHaveBeenCalled(); expect(JSON.stringify([res.json.mock.calls, res.write.mock.calls])).not.toContain( 'RUNTIME-PRIVATE-CANARY', ); } else { expect(api.sendResponsesErrorResponse.mock.calls).toEqual([]); expect(completed(res, stream)?.status).toBe('completed'); expect(db.saveMessage).toHaveBeenCalled(); } expect(fixture.sdkModelHost.snapshot().calls).toBe(0); } finally { await fixture.close(); } }, ); it.each([false, true])( 'cancels protected remote provider work without persisting late output: stream=%s', async (stream) => { let started; let release; const entered = new Promise((resolve) => { started = resolve; }); const pending = new Promise((resolve) => { release = resolve; }); const { createRemotePolicyFixture } = require('~/test/helpers/remotePolicy'); const fixture = await createRemotePolicyFixture({ beforeProvider: async () => { started(); await pending; }, }); const api = require('@librechat/api'); const db = require('~/models'); fixture.configure(req); api.initializeAgent.mockResolvedValueOnce(fixture.agent); api.createRun.mockImplementation(jest.requireActual('@librechat/api').createRun); api.validateResponseRequest.mockReturnValueOnce({ request: { model: 'agent-123', input: 'Hello', stream, store: true }, }); require('@librechat/agents').formatAgentMessages.mockImplementationOnce( jest.requireActual('@librechat/agents').formatAgentMessages, ); const request = createResponse(req, res); try { await entered; const job = await mockRealExecutionManager.getJob('resp_mock-123'); await mockRealExecutionManager.abortJob('resp_mock-123', { expectedCreatedAt: job.createdAt, awaitProviderDrain: false, }); release(); await request; expect(completed(res, stream)?.status).not.toBe('completed'); expect(db.saveMessage).not.toHaveBeenCalled(); expect(db.saveConvo).not.toHaveBeenCalled(); expect(fixture.provider).toHaveBeenCalledTimes(1); expect(JSON.stringify([res.json.mock.calls, res.write.mock.calls])).not.toContain( 'Approved answer', ); } finally { release(); await request; await fixture.close(); } }, ); it.each([false, true])( 'publishes tool results, accounting and successful storage after real host drain: stream=%s', async (stream) => { const api = require('@librechat/api'); const db = require('~/models'); api.validateResponseRequest.mockReturnValueOnce({ request: { model: 'agent-123', input: 'Hello', stream, store: true }, }); const writers = [db.saveMessage, db.saveConvo, api.announceReply]; const implementations = writers.map((writer) => writer.getMockImplementation()); writers.forEach((writer, index) => { writer.mockImplementation(async (...args) => { const job = await mockRealExecutionManager.getJob('resp_mock-123'); expect(job.metadata.providerDrained).toBe(false); expect( await mockRealExecutionManager.getCleanupBlockingJobIdsForUser(req.user.id), ).toContain('resp_mock-123'); return implementations[index](...args); }); }); try { await createResponse(req, res); } finally { writers.forEach((writer, index) => writer.mockImplementation(implementations[index])); } expect(api.sendResponsesErrorResponse.mock.calls).toEqual([]); const response = completed(res, stream); expect(response).toMatchObject({ id: 'resp_mock-123', store: true, accounting: { calls: [ expect.objectContaining({ model: 'configured-provider-model', modelSource: 'configured', inputTokens: 2, outputTokens: 1, }), ], }, }); expect(response.output).toEqual( expect.arrayContaining([ expect.objectContaining({ type: 'function_call_output', call_id: 'call', output: 'retained-tool-result', }), ]), ); const message = db.saveMessage.mock.calls.find(([, value]) => !value.isCreatedByUser)?.[1]; expect(message).toMatchObject({ parentMessageId: expect.any(String), content: expect.arrayContaining([ expect.objectContaining({ tool_call: expect.objectContaining({ output: 'retained-tool-result' }), }), ]), metadata: { responseReceipt: { accounting: response.accounting, usage: response.usage } }, }); expect( require('~/server/controllers/agents/callbacks')[ stream ? 'createResponsesToolEndCallback' : 'createToolEndCallback' ], ).toHaveBeenCalled(); const callbacks = require('~/server/controllers/agents/callbacks'); const artifactCallback = callbacks[ stream ? 'createResponsesToolEndCallback' : 'createToolEndCallback' ].mock.results.at(-1).value; expect(artifactCallback).toHaveBeenCalledWith( expect.objectContaining({ output: expect.objectContaining({ tool_call_id: 'call' }) }), expect.objectContaining({ stepId: 'step-tool' }), ); expect( response.output.filter( (item) => item.type === 'function_call_output' && item.call_id === 'call', ), ).toHaveLength(1); expect(mockRecordCollectedUsage).toHaveBeenCalledTimes(1); }, ); it.each([false, true])( 'retains provider output with store false on resolved conversation save failure: stream=%s', async (stream) => { const api = require('@librechat/api'); const db = require('~/models'); api.validateResponseRequest.mockReturnValueOnce({ request: { model: 'agent-123', input: 'Hello', stream, store: true }, }); db.saveConvo.mockResolvedValueOnce({ message: 'private database failure' }); await createResponse(req, res); expect(completed(res, stream)).toMatchObject({ store: false, output: expect.arrayContaining([ expect.objectContaining({ type: 'function_call_output', output: 'retained-tool-result', }), ]), }); expect(db.saveMessage).not.toHaveBeenCalled(); }, ); it.each([false, true])( 'closes canonical cancellation without emitting success or persisting output: stream=%s', async (stream) => { const api = require('@librechat/api'); const db = require('~/models'); const provider = api.createRun.getMockImplementation(); api.validateResponseRequest.mockReturnValueOnce({ request: { model: 'agent-123', input: 'Hello', stream, store: true }, }); api.createRun.mockImplementationOnce(async (options) => { const run = await provider(options); return { ...run, processStream: async (...args) => { await run.processStream(...args); const job = await mockRealExecutionManager.getJob('resp_mock-123'); await mockRealExecutionManager.abortJob('resp_mock-123', { expectedCreatedAt: job.createdAt, awaitProviderDrain: false, }); }, }; }); await createResponse(req, res); expect(db.saveMessage).not.toHaveBeenCalled(); if (stream) { expect(completed(res, true)).toBeUndefined(); expect(res.write.mock.calls.map(([value]) => value).join('')).toContain( 'response_execution_cancelled', ); expect(res.end).toHaveBeenCalled(); } else { expect(res.status).toHaveBeenCalledWith(409); expect(res.json).toHaveBeenCalledWith({ error: expect.objectContaining({ code: 'response_execution_cancelled' }), }); } }, ); it.each([false, true])( 'closes outcome readback failure with a safe error after provider drain: stream=%s', async (stream) => { const api = require('@librechat/api'); const db = require('~/models'); api.validateResponseRequest.mockReturnValueOnce({ request: { model: 'agent-123', input: 'Hello', stream, store: true }, }); const complete = mockRealExecutionManager.completeJob.bind(mockRealExecutionManager); jest .spyOn(mockRealExecutionManager, 'completeJob') .mockImplementationOnce(async (...args) => { const result = await complete(...args); jest .spyOn(mockRealExecutionManager, 'getJob') .mockRejectedValueOnce(new Error('private-outage-secret')); return result; }); await expect(createResponse(req, res)).rejects.toThrow('private-outage-secret'); expect(db.saveMessage).toHaveBeenCalledTimes(2); const body = stream ? res.write.mock.calls.map(([value]) => value).join('') : JSON.stringify(res.json.mock.calls); expect(body).toContain('response_execution_unavailable'); expect(body).not.toContain('private-outage-secret'); expect(completed(res, stream)?.store).not.toBe(true); expect(await mockRealExecutionManager.getCleanupBlockingJobIdsForUser(req.user.id)).toEqual( [], ); }, ); it('resolves a returned response ID before real host conversation admission and links its next input', async () => { const api = require('@librechat/api'); const db = require('~/models'); const priorConversation = '6834b9eb-9939-40d2-847a-ac9ad95fd88d'; api.validateResponseRequest.mockReturnValueOnce({ request: { model: 'agent-123', input: 'Next', stream: false, store: true, previous_response_id: 'resp_prior', }, }); db.getMessage.mockResolvedValueOnce({ messageId: 'resp_prior', conversationId: priorConversation, isCreatedByUser: false, }); db.getConvo.mockResolvedValueOnce({ conversationId: priorConversation, user: req.user.id }); db.getMessages.mockResolvedValueOnce([ { messageId: 'resp_prior', conversationId: priorConversation, parentMessageId: null, text: 'Earlier answer', isCreatedByUser: false, }, ]); await createResponse(req, res); expect(api.sendResponsesErrorResponse.mock.calls).toEqual([]); expect(db.getConvo).toHaveBeenCalledWith(req.user.id, priorConversation); expect( db.saveMessage.mock.calls.find(([, message]) => message.isCreatedByUser)?.[1], ).toMatchObject({ conversationId: priorConversation, parentMessageId: 'resp_prior' }); expect(mockRealExecutionManager.createJob.mock.calls[0][2]).toBe(priorConversation); expect(await mockRealExecutionManager.getJob('resp_mock-123')).toBeUndefined(); }); }); describe('handoff model validation', () => { it('validates handoff agents through a loader that reads only their own provider models', async () => { const { initializeAgent, discoverConnectedAgents } = require('@librechat/api'); const { getEndpointModelsConfig } = require('~/server/controllers/ModelController'); initializeAgent.mockResolvedValueOnce({ id: 'agent-123', model: 'claude-3', model_parameters: {}, toolRegistry: new Map(), edges: [{ source: 'agent-123', target: 'agent-handoff' }], }); await createResponse(req, res); const [params] = discoverConnectedAgents.mock.calls.at(-1); expect(params).not.toHaveProperty('modelsConfig'); expect(getEndpointModelsConfig).not.toHaveBeenCalled(); await params.getEndpointModels('anthropic'); expect(getEndpointModelsConfig).toHaveBeenCalledTimes(1); expect(getEndpointModelsConfig).toHaveBeenCalledWith(req, 'anthropic'); }); }); describe('sub-agent skill priming', () => { it('passes the sub-agent primed skill IDs into non-streaming tool execution', async () => { const { initializeAgent, discoverConnectedAgents, createToolExecuteHandler, } = require('@librechat/api'); const { loadToolsForExecution } = require('~/server/services/ToolService'); const subAgent = { id: 'agent-sub', name: 'Sub Agent' }; const subConfig = { id: 'agent-sub', model: 'claude-3', model_parameters: {}, toolRegistry: new Map(), userMCPAuthMap: { sub: { token: 'sub-token' } }, tool_resources: { code_interpreter: { file_ids: ['sub-file'] } }, actionsEnabled: true, accessibleSkillIds: ['sub-skill-id'], activeSkillNames: ['sub-hidden-skill'], codeEnvAvailable: true, skillAuthoringAvailable: true, fileAuthoringToolNames: ['create_file', 'edit_file'], manualSkillPrimes: [{ name: 'sub-hidden-skill', _id: { toString: () => 'sub-manual-id' } }], alwaysApplySkillPrimes: [ { name: 'sub-always-skill', _id: { toString: () => 'sub-always-id' } }, ], }; initializeAgent.mockResolvedValueOnce({ id: 'agent-123', model: 'claude-3', model_parameters: {}, toolRegistry: new Map(), edges: [{ source: 'agent-123', target: 'agent-sub' }], accessibleSkillIds: ['primary-skill-id'], activeSkillNames: ['primary-skill'], codeEnvAvailable: false, skillAuthoringAvailable: false, fileAuthoringToolNames: [], manualSkillPrimes: [{ name: 'primary-skill', _id: { toString: () => 'primary-skill-id' } }], }); discoverConnectedAgents.mockImplementationOnce(async (_params, deps) => { deps.onAgentInitialized('agent-sub', subAgent, subConfig); return { agentConfigs: new Map([['agent-sub', subConfig]]), edges: [], skippedAgentIds: new Set(), userMCPAuthMap: undefined, }; }); await createResponse(req, res); const toolExecuteOptions = createToolExecuteHandler.mock.calls.at(-1)[0]; await toolExecuteOptions.loadTools(['read_file'], 'agent-sub'); expect(loadToolsForExecution).toHaveBeenLastCalledWith( expect.objectContaining({ agent: subAgent, toolRegistry: subConfig.toolRegistry, userMCPAuthMap: subConfig.userMCPAuthMap, tool_resources: subConfig.tool_resources, actionsEnabled: true, }), ); expect(mockEnrichWithSkillConfigurable).toHaveBeenLastCalledWith({ result: expect.anything(), context: { req, accessibleSkillIds: ['sub-skill-id'], codeEnvAvailable: true, skillPrimedIdsByName: { 'sub-always-skill': 'sub-always-id', 'sub-hidden-skill': 'sub-manual-id', }, activeSkillNames: ['sub-hidden-skill'], skillAuthoringAvailable: true, fileAuthoringToolNames: ['create_file', 'edit_file'], }, }); }); }); describe('file search role gating', () => { const setCapabilities = (capabilities) => { req.config.endpoints.agents.capabilities = capabilities; }; it('reports file search available when the capability and the grant agree', async () => { const { initializeAgent } = require('@librechat/api'); setCapabilities(['file_search']); await createResponse(req, res); expect(initializeAgent).toHaveBeenCalledWith( expect.objectContaining({ fileSearchAvailable: true }), expect.anything(), ); }); /** `initializeAgent` re-hydrates prior-turn `file_search` files from this * flag, so a denied role must reach it — dropping the tool downstream still * leaves the files read, their usage bumped and their resources primed. */ it('withholds it when the role is denied FILE_SEARCH', async () => { const { initializeAgent, resolveToolRoleGrants } = require('@librechat/api'); resolveToolRoleGrants.mockResolvedValueOnce({ runCode: true, fileSearch: false }); setCapabilities(['file_search']); await createResponse(req, res); expect(initializeAgent).toHaveBeenCalledWith( expect.objectContaining({ fileSearchAvailable: false }), expect.anything(), ); }); /** Both flags are false without their capability, so the role read would be * pure load on every request. */ it('reads no role at all when neither capability is enabled', async () => { const { initializeAgent, resolveToolRoleGrants } = require('@librechat/api'); setCapabilities([]); await createResponse(req, res); expect(resolveToolRoleGrants).not.toHaveBeenCalled(); expect(initializeAgent).toHaveBeenCalledWith( expect.objectContaining({ fileSearchAvailable: false, codeEnvAvailable: false }), expect.anything(), ); }); /** One lookup answers both grants, so enabling either capability pays for * the other's pairing too. */ it('pairs both flags from a single role read', async () => { const { initializeAgent, resolveToolRoleGrants } = require('@librechat/api'); setCapabilities(['file_search', 'execute_code']); await createResponse(req, res); expect(resolveToolRoleGrants).toHaveBeenCalledTimes(1); expect(initializeAgent).toHaveBeenCalledWith( expect.objectContaining({ fileSearchAvailable: true, codeEnvAvailable: true }), expect.anything(), ); }); }); describe('web search role gating', () => { const setCapabilities = (capabilities) => { req.config.endpoints.agents.capabilities = capabilities; }; const passedResolver = () => { const { initializeAgent } = require('@librechat/api'); return initializeAgent.mock.calls[0][0].resolveWebSearchGrant; }; /** Provider-native search is a model parameter with no capability of its own, * so the resolver is handed over whatever the capabilities — but it reads * nothing until the initializer finds native search in the built config. */ it('hands initializeAgent a grant resolver without reading the role', async () => { const { resolveToolRoleGrants } = require('@librechat/api'); setCapabilities([]); await createResponse(req, res); expect(passedResolver()).toEqual(expect.any(Function)); expect(resolveToolRoleGrants).not.toHaveBeenCalled(); }); it('resolves the WEB_SEARCH grant against this request when called', async () => { const { resolveToolRoleGrants } = require('@librechat/api'); resolveToolRoleGrants.mockResolvedValueOnce({ runCode: true, fileSearch: true, webSearch: false, }); setCapabilities([]); await createResponse(req, res); await expect(passedResolver()()).resolves.toBe(false); expect(resolveToolRoleGrants).toHaveBeenCalledWith(expect.objectContaining({ req })); }); }); });