LibreChat/api/server/controllers/agents/__tests__/responses.unit.spec.js
Danny Avila dd83596e70
🚔 fix: Enforce Host Model Policies for Responses and OpenAI Callers (#18400)
* fix: enforce host model policies for API SDK callers

* refactor: share API model policy assembly in TypeScript
2026-11-18 08:31:19 -05:00

3720 lines
135 KiB
JavaScript
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/**
* 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 }));
});
});
});