Enhanced ChatGPT Clone: Features Agents, MCP, Skills, DeepSeek, Anthropic, AWS, OpenAI, Responses API, Azure, Groq, o1, GPT-5, Mistral, OpenRouter, Vertex AI, Gemini, Artifacts, AI model switching, message search, Code Interpreter, langchain, DALL-E-3, OpenAPI Actions, Functions, Secure Multi-User Auth, Presets, open-source for self-hosting. Active
TypeScript aianthropicartifactsawsazurechatgptchatgpt-cloneclaudeclonedeepseekgeminigooglegpt-5librechatmcpo1openairesponses-apivisionwebui
import mongoose from 'mongoose';
import { v4 as uuidv4 } from 'uuid';
import { MongoMemoryServer } from 'mongodb-memory-server';
import { Constants, FileSources } from 'librechat-data-provider';
import { agentSchema, createMethods } from '@librechat/data-schemas';
import type {
Agent as LibreChatAgent,
AgentModelParameters,
TEphemeralAgent,
TConversation,
} from 'librechat-data-provider';
import type { AppConfig } from '@librechat/data-schemas';
import type { LoadAgentParams, LoadAgentDeps } from '../load';
import { STANDARD_MCP_CAPABILITY_PROFILE } from '~/mcp/capabilities';
import { loadAddedAgent } from '../added';
import { loadAgent } from '../load';
let Agent: mongoose.Model<unknown>;
let createAgent: ReturnType<typeof createMethods>['createAgent'];
let getAgentWithVersionCount: ReturnType<typeof createMethods>['getAgentWithVersionCount'];
const mockGetMCPServerTools = jest.fn();
const mockGetAccessibleMCPServers = jest.fn();
const deps: LoadAgentDeps = {
getAgent: (searchParameter) =>
getAgentWithVersionCount(searchParameter) as Promise<LibreChatAgent | null>,
getMCPServerTools: mockGetMCPServerTools,
getAccessibleMCPServers: mockGetAccessibleMCPServers,
};
describe('loadAgent', () => {
let mongoServer: MongoMemoryServer;
beforeAll(async () => {
mongoServer = await MongoMemoryServer.create();
const mongoUri = mongoServer.getUri();
Agent = mongoose.models.Agent || mongoose.model('Agent', agentSchema);
await mongoose.connect(mongoUri);
const methods = createMethods(mongoose);
createAgent = methods.createAgent;
getAgentWithVersionCount = methods.getAgentWithVersionCount;
}, 20000);
afterAll(async () => {
await mongoose.disconnect();
await mongoServer.stop();
});
beforeEach(async () => {
await Agent.deleteMany({});
jest.clearAllMocks();
});
test('should return null when agent_id is not provided', async () => {
const mockReq = { user: { id: 'user123' } };
const result = await loadAgent(
{
req: mockReq,
agent_id: null as unknown as string,
endpoint: 'openai',
model_parameters: { model: 'gpt-4' } as unknown as AgentModelParameters,
},
deps,
);
expect(result).toBeNull();
});
test('should return null when agent_id is empty string', async () => {
const mockReq = { user: { id: 'user123' } };
const result = await loadAgent(
{
req: mockReq,
agent_id: '',
endpoint: 'openai',
model_parameters: { model: 'gpt-4' } as unknown as AgentModelParameters,
},
deps,
);
expect(result).toBeNull();
});
test('should test ephemeral agent loading logic', async () => {
const { EPHEMERAL_AGENT_ID } = Constants;
// Mock getMCPServerTools to return tools for each server
mockGetMCPServerTools.mockImplementation(async (_userId: string, server: string) => {
if (server === 'server1') {
return { tool1_mcp_server1: {} };
} else if (server === 'server2') {
return { tool2_mcp_server2: {} };
}
return null;
});
const mockReq = {
user: { id: 'user123' },
body: {
promptPrefix: 'Test instructions',
ephemeralAgent: {
execute_code: true,
web_search: true,
mcp: ['server1', 'server2'],
},
},
};
const result = await loadAgent(
{
req: mockReq,
agent_id: EPHEMERAL_AGENT_ID as string,
endpoint: 'openai',
model_parameters: { model: 'gpt-4', temperature: 0.7 } as unknown as AgentModelParameters,
},
deps,
);
if (result) {
// Ephemeral agent ID is encoded with endpoint and model
expect(result.id).toBe('openai__gpt-4');
expect(result.instructions).toBe('Test instructions');
expect(result.provider).toBe('openai');
expect(result.model).toBe('gpt-4');
expect(result.model_parameters.temperature).toBe(0.7);
expect(result.tools).toContain('execute_code');
expect(result.tools).toContain('web_search');
expect(result.tools).toContain('tool1_mcp_server1');
expect(result.tools).toContain('tool2_mcp_server2');
} else {
expect(result).toBeNull();
}
});
test('should skip cached tools for servers made request-scoped by a config overlay', async () => {
const { EPHEMERAL_AGENT_ID } = Constants;
mockGetMCPServerTools.mockResolvedValue({ tool1_mcp_server1: {} });
const mockReq = {
user: { id: 'user123' },
config: {
mcpConfig: {
'body-scoped': {
type: 'streamable-http' as const,
url: 'https://mcp.example.com/{{LIBRECHAT_BODY_CONVERSATIONID}}/mcp',
},
},
} as unknown as AppConfig,
body: {
ephemeralAgent: {
mcp: ['body-scoped', 'server1'],
},
},
};
const result = await loadAgent(
{
req: mockReq,
agent_id: EPHEMERAL_AGENT_ID as string,
endpoint: 'openai',
model_parameters: { model: 'gpt-4' } as unknown as AgentModelParameters,
},
deps,
);
expect(mockGetMCPServerTools).toHaveBeenCalledTimes(1);
expect(mockGetMCPServerTools).toHaveBeenCalledWith(
'user123',
'server1',
undefined,
STANDARD_MCP_CAPABILITY_PROFILE,
);
expect(result?.tools).toContain(`${Constants.mcp_all}${Constants.mcp_delimiter}body-scoped`);
expect(result?.tools).toContain('tool1_mcp_server1');
});
describe('chat-selectable MCP narrowing', () => {
const { EPHEMERAL_AGENT_ID } = Constants;
const loadEphemeral = (
config: Record<string, unknown>,
body: { ephemeralAgent: { mcp: string[] } },
spec?: string,
) =>
loadAgent(
{
req: {
user: { id: 'user123', role: 'USER' },
config: config as unknown as AppConfig,
body,
},
spec,
agent_id: EPHEMERAL_AGENT_ID as string,
endpoint: 'openai',
model_parameters: { model: 'gpt-4' } as unknown as AgentModelParameters,
},
deps,
);
const selectedServerNames = () => mockGetMCPServerTools.mock.calls.map((call) => call[1]);
beforeEach(() => {
mockGetAccessibleMCPServers.mockResolvedValue({
visible: { chatMenu: true },
hidden: { chatMenu: false },
'agent-only': { consumeOnly: true },
});
mockGetMCPServerTools.mockImplementation(async (_userId: string, server: string) => ({
[`tool_mcp_${server}`]: {},
}));
});
test('drops a server the chat menu hides', async () => {
const result = await loadEphemeral(
{ mcpConfig: {} },
{
ephemeralAgent: { mcp: ['visible', 'hidden'] },
},
);
expect(selectedServerNames()).toEqual(['visible']);
expect(result?.tools).toContain('tool_mcp_visible');
expect(result?.tools).not.toContain('tool_mcp_hidden');
});
test('drops a server the user only reaches through an agent', async () => {
const result = await loadEphemeral(
{ mcpConfig: {} },
{
ephemeralAgent: { mcp: ['visible', 'agent-only'] },
},
);
expect(selectedServerNames()).toEqual(['visible']);
expect(result?.tools).not.toContain('tool_mcp_agent-only');
});
test('resolves the accessible catalog with the requesting user role', async () => {
await loadEphemeral({ mcpConfig: {} }, { ephemeralAgent: { mcp: ['visible'] } });
expect(mockGetAccessibleMCPServers).toHaveBeenCalledWith('user123', 'USER');
});
test('keeps a spec-pinned server even when the chat menu hides it', async () => {
const result = await loadEphemeral(
{
mcpConfig: {},
modelSpecs: {
list: [
{
name: 'pins-hidden',
label: 'Pins Hidden',
preset: { endpoint: 'openai', model: 'gpt-4' },
mcpServers: ['hidden'],
},
],
},
},
{ ephemeralAgent: { mcp: [] } },
'pins-hidden',
);
expect(selectedServerNames()).toEqual(['hidden']);
expect(result?.tools).toContain('tool_mcp_hidden');
});
test('keeps a request-tier server the registry cannot resolve', async () => {
const result = await loadEphemeral(
{ mcpConfig: {} },
{
ephemeralAgent: { mcp: ['body-scoped'] },
},
);
expect(selectedServerNames()).toEqual(['body-scoped']);
expect(result?.tools).toContain('tool_mcp_body-scoped');
});
test('keeps the selection when the catalog lookup fails', async () => {
mockGetAccessibleMCPServers.mockRejectedValue(new Error('registry unavailable'));
const result = await loadEphemeral(
{ mcpConfig: {} },
{
ephemeralAgent: { mcp: ['flaky'] },
},
);
expect(selectedServerNames()).toEqual(['flaky']);
expect(result?.tools).toContain('tool_mcp_flaky');
});
test('publishes the servers actually in play back onto the request body', async () => {
const body = { ephemeralAgent: { mcp: ['visible', 'hidden'] } };
await loadEphemeral(
{
mcpConfig: {},
modelSpecs: {
list: [
{
name: 'pins-hidden',
label: 'Pins Hidden',
preset: { endpoint: 'openai', model: 'gpt-4' },
mcpServers: ['hidden'],
},
],
},
},
body,
'pins-hidden',
);
/** `applyContextToAgent` reads this straight off the body and prefers it
* over the agent's tools when loading `serverInstructions`: the hidden
* pick is gone, the spec's pin stays. */
expect(body.ephemeralAgent.mcp).toEqual(['visible', 'hidden']);
});
});
test('addresses cached tools with a non-ephemeral request overlay', async () => {
const { EPHEMERAL_AGENT_ID } = Constants;
const overlayConfig = {
type: 'streamable-http' as const,
url: 'https://overlay.example.com/mcp',
};
mockGetMCPServerTools.mockResolvedValue({ overlay_tool_mcp_overlay: {} });
const result = await loadAgent(
{
req: {
user: { id: 'user123' },
config: { mcpConfig: { overlay: overlayConfig } } as unknown as AppConfig,
body: { ephemeralAgent: { mcp: ['overlay'] } },
},
agent_id: EPHEMERAL_AGENT_ID as string,
endpoint: 'openai',
model_parameters: { model: 'gpt-4' } as unknown as AgentModelParameters,
},
deps,
);
expect(mockGetMCPServerTools).toHaveBeenCalledWith(
'user123',
'overlay',
overlayConfig,
STANDARD_MCP_CAPABILITY_PROFILE,
);
expect(result?.tools).toContain('overlay_tool_mcp_overlay');
});
test('should return null for non-existent agent', async () => {
const mockReq = { user: { id: 'user123' } };
const result = await loadAgent(
{
req: mockReq,
agent_id: 'agent_non_existent',
endpoint: 'openai',
model_parameters: { model: 'gpt-4' } as unknown as AgentModelParameters,
},
deps,
);
expect(result).toBeNull();
});
test('should load agent when user is the author', async () => {
const userId = new mongoose.Types.ObjectId();
const agentId = `agent_${uuidv4()}`;
await createAgent({
id: agentId,
name: 'Test Agent',
provider: 'openai',
model: 'gpt-4',
author: userId,
description: 'Test description',
tools: ['web_search'],
});
const mockReq = { user: { id: userId.toString() } };
const result = await loadAgent(
{
req: mockReq,
agent_id: agentId,
endpoint: 'openai',
model_parameters: { model: 'gpt-4' } as unknown as AgentModelParameters,
},
deps,
);
expect(result).toBeDefined();
expect(result!.id).toBe(agentId);
expect(result!.name).toBe('Test Agent');
expect(String(result!.author)).toBe(userId.toString());
expect(result!.version).toBe(1);
});
test('should return agent even when user is not author (permissions checked at route level)', async () => {
const authorId = new mongoose.Types.ObjectId();
const userId = new mongoose.Types.ObjectId();
const agentId = `agent_${uuidv4()}`;
await createAgent({
id: agentId,
name: 'Test Agent',
provider: 'openai',
model: 'gpt-4',
author: authorId,
});
const mockReq = { user: { id: userId.toString() } };
const result = await loadAgent(
{
req: mockReq,
agent_id: agentId,
endpoint: 'openai',
model_parameters: { model: 'gpt-4' } as unknown as AgentModelParameters,
},
deps,
);
// With the new permission system, loadAgent returns the agent regardless of permissions
// Permission checks are handled at the route level via middleware
expect(result).toBeTruthy();
expect(result!.id).toBe(agentId);
expect(result!.name).toBe('Test Agent');
});
test('should handle ephemeral agent with no MCP servers', async () => {
const { EPHEMERAL_AGENT_ID } = Constants;
const mockReq = {
user: { id: 'user123' },
body: {
promptPrefix: 'Simple instructions',
ephemeralAgent: {
execute_code: false,
web_search: false,
mcp: [],
},
},
};
const result = await loadAgent(
{
req: mockReq,
agent_id: EPHEMERAL_AGENT_ID as string,
endpoint: 'openai',
model_parameters: { model: 'gpt-3.5-turbo' } as unknown as AgentModelParameters,
},
deps,
);
if (result) {
expect(result.tools).toEqual([]);
expect(result.instructions).toBe('Simple instructions');
} else {
expect(result).toBeFalsy();
}
});
test('should use parsed promptPrefix for ephemeral agent instructions', async () => {
const { EPHEMERAL_AGENT_ID } = Constants;
const result = await loadAgent(
{
req: { user: { id: 'user123' }, body: {} },
agent_id: EPHEMERAL_AGENT_ID as string,
endpoint: 'openai',
model_parameters: {
model: 'gpt-4',
promptPrefix: 'Server-side model spec instructions',
} as unknown as AgentModelParameters,
},
deps,
);
expect(result?.instructions).toBe('Server-side model spec instructions');
expect(result?.model_parameters).not.toHaveProperty('promptPrefix');
});
test('should equip ask_user_question from the ephemeralAgent request flag', async () => {
const { EPHEMERAL_AGENT_ID } = Constants;
const result = await loadAgent(
{
req: {
user: { id: 'user123' },
body: {
ephemeralAgent: { ask_user_question: true } as TEphemeralAgent,
},
},
agent_id: EPHEMERAL_AGENT_ID as string,
endpoint: 'openai',
model_parameters: { model: 'gpt-4' } as unknown as AgentModelParameters,
},
deps,
);
expect(result?.tools).toContain('ask_user_question');
});
test('should equip ask_user_question from a model spec (askUserQuestion: true)', async () => {
const { EPHEMERAL_AGENT_ID } = Constants;
const result = await loadAgent(
{
req: {
user: { id: 'user123' },
body: {},
config: {
config: {},
fileStrategy: FileSources.local,
imageOutputType: 'png',
modelSpecs: {
list: [
{
name: 'asks-questions',
label: 'Asks Questions',
preset: { endpoint: 'openai', model: 'gpt-4' },
askUserQuestion: true,
},
{
name: 'no-questions',
label: 'No Questions',
preset: { endpoint: 'openai', model: 'gpt-4' },
},
],
},
},
},
spec: 'asks-questions',
agent_id: EPHEMERAL_AGENT_ID as string,
endpoint: 'openai',
model_parameters: { model: 'gpt-4' } as unknown as AgentModelParameters,
},
deps,
);
expect(result?.tools).toContain('ask_user_question');
const withoutFlag = await loadAgent(
{
req: {
user: { id: 'user123' },
body: {},
config: {
config: {},
fileStrategy: FileSources.local,
imageOutputType: 'png',
modelSpecs: {
list: [
{
name: 'no-questions',
label: 'No Questions',
preset: { endpoint: 'openai', model: 'gpt-4' },
},
],
},
},
},
spec: 'no-questions',
agent_id: EPHEMERAL_AGENT_ID as string,
endpoint: 'openai',
model_parameters: { model: 'gpt-4' } as unknown as AgentModelParameters,
},
deps,
);
expect(withoutFlag?.tools).not.toContain('ask_user_question');
});
test('synthesizes background tool_options for eligible MCP tools from the ephemeralAgent flag', async () => {
const { EPHEMERAL_AGENT_ID } = Constants;
mockGetMCPServerTools.mockResolvedValue({ crm_lookup: { name: 'crm_lookup' } });
const result = await loadAgent(
{
req: {
user: { id: 'user123' },
body: {
ephemeralAgent: {
mcp: ['crm'],
web_search: true,
execute_code: true,
run_in_background: true,
} as TEphemeralAgent,
},
},
agent_id: EPHEMERAL_AGENT_ID as string,
endpoint: 'openai',
model_parameters: { model: 'gpt-4' } as unknown as AgentModelParameters,
},
deps,
);
// recorded as a wildcard policy; eligibility (e.g. excluding web_search)
// is enforced against the final definitions in applyBackgroundToolCalls
expect(result?.tool_options).toEqual({ '*': { run_in_background: true } });
});
test('synthesizes background tool_options from a model spec: true opts in, false is an explicit opt-out, absent is no policy', async () => {
const { EPHEMERAL_AGENT_ID } = Constants;
mockGetMCPServerTools.mockResolvedValue({ crm_lookup: { name: 'crm_lookup' } });
const buildReq = (specName: string, runInBackground?: boolean): LoadAgentParams['req'] =>
({
user: { id: 'user123' },
body: {},
config: {
config: {},
fileStrategy: FileSources.local,
imageOutputType: 'png',
modelSpecs: {
list: [
{
name: specName,
label: specName,
preset: { endpoint: 'openai', model: 'gpt-4' },
webSearch: true,
mcpServers: ['crm'],
runInBackground,
},
],
},
},
}) as unknown as LoadAgentParams['req'];
const withFlag = await loadAgent(
{
req: buildReq('bg-on', true),
spec: 'bg-on',
agent_id: EPHEMERAL_AGENT_ID as string,
endpoint: 'openai',
model_parameters: { model: 'gpt-4' } as unknown as AgentModelParameters,
},
deps,
);
expect(withFlag?.tool_options).toEqual({ '*': { run_in_background: true } });
const withoutFlag = await loadAgent(
{
req: buildReq('bg-absent', undefined),
spec: 'bg-absent',
agent_id: EPHEMERAL_AGENT_ID as string,
endpoint: 'openai',
model_parameters: { model: 'gpt-4' } as unknown as AgentModelParameters,
},
deps,
);
expect(withoutFlag?.tool_options).toBeUndefined();
/** `false` must synthesize an explicit wildcard opt-out (not stay a
* no-op): the background-native code pair would otherwise default on
* against an admin's written `runInBackground: false`. */
const withFalse = await loadAgent(
{
req: buildReq('bg-off', false),
spec: 'bg-off',
agent_id: EPHEMERAL_AGENT_ID as string,
endpoint: 'openai',
model_parameters: { model: 'gpt-4' } as unknown as AgentModelParameters,
},
deps,
);
expect(withFalse?.tool_options).toEqual({ '*': { run_in_background: false } });
});
test('should enable full skill scope for ephemeral model spec with skills true', async () => {
const { EPHEMERAL_AGENT_ID } = Constants;
const result = await loadAgent(
{
req: {
user: { id: 'user123' },
body: {
ephemeralAgent: {
subagents: { enabled: false, agent_ids: ['agent_tampered'] },
} as unknown as TEphemeralAgent,
},
config: {
config: {},
fileStrategy: FileSources.local,
imageOutputType: 'png',
modelSpecs: {
list: [
{
name: 'skills-on',
label: 'Skills On',
preset: { endpoint: 'openai', model: 'gpt-4' },
skills: true,
},
],
},
},
},
spec: 'skills-on',
agent_id: EPHEMERAL_AGENT_ID as string,
endpoint: 'openai',
model_parameters: { model: 'gpt-4' } as unknown as AgentModelParameters,
},
deps,
);
expect(result?.skills_enabled).toBe(true);
expect(result?.skills).toBeUndefined();
expect(result?.subagents).toBeUndefined();
});
test('should initialize an empty allowlist for ephemeral model spec skill names', async () => {
const { EPHEMERAL_AGENT_ID } = Constants;
const result = await loadAgent(
{
req: {
user: { id: 'user123' },
body: {},
config: {
config: {},
fileStrategy: FileSources.local,
imageOutputType: 'png',
modelSpecs: {
list: [
{
name: 'scoped-skills',
label: 'Scoped Skills',
preset: { endpoint: 'openai', model: 'gpt-4' },
skills: ['finance-analyst', 'brand-writer'],
},
],
},
},
},
spec: 'scoped-skills',
agent_id: EPHEMERAL_AGENT_ID as string,
endpoint: 'openai',
model_parameters: { model: 'gpt-4' } as unknown as AgentModelParameters,
},
deps,
);
expect(result?.skills_enabled).toBe(true);
expect(result?.skills).toEqual([]);
});
test('should apply subagent config for ephemeral model specs', async () => {
const { EPHEMERAL_AGENT_ID } = Constants;
const subagents = { enabled: true, allowSelf: true, agent_ids: [] };
const result = await loadAgent(
{
req: {
user: { id: 'user123' },
body: {},
config: {
config: {},
fileStrategy: FileSources.local,
imageOutputType: 'png',
modelSpecs: {
list: [
{
name: 'self-spawn',
label: 'Self Spawn',
preset: { endpoint: 'openai', model: 'gpt-4' },
subagents,
},
],
},
},
},
spec: 'self-spawn',
agent_id: EPHEMERAL_AGENT_ID as string,
endpoint: 'openai',
model_parameters: { model: 'gpt-4' } as unknown as AgentModelParameters,
},
deps,
);
expect(result?.subagents).toEqual(subagents);
});
test('should ignore request subagents for ephemeral agents', async () => {
const { EPHEMERAL_AGENT_ID } = Constants;
const result = await loadAgent(
{
req: {
user: { id: 'user123' },
body: {
ephemeralAgent: {
subagents: { enabled: true, allowSelf: true, agent_ids: ['agent_other'] },
} as unknown as TEphemeralAgent,
},
},
agent_id: EPHEMERAL_AGENT_ID as string,
endpoint: 'openai',
model_parameters: { model: 'gpt-4' } as unknown as AgentModelParameters,
},
deps,
);
expect(result?.subagents).toBeUndefined();
});
test('should ignore request subagents when added agent mirrors ephemeral primary tools', async () => {
const { EPHEMERAL_AGENT_ID } = Constants;
const result = await loadAddedAgent(
{
req: {
user: { id: 'user123' },
config: {
config: {},
fileStrategy: FileSources.local,
imageOutputType: 'png',
},
},
conversation: {
endpoint: 'openai',
model: 'gpt-4',
ephemeralAgent: { subagents: { enabled: true, allowSelf: true, agent_ids: [] } },
} as unknown as TConversation,
primaryAgent: { id: EPHEMERAL_AGENT_ID as string, tools: ['web_search'] } as LibreChatAgent,
},
deps,
);
expect(result?.tools).toEqual(['web_search']);
expect(result?.subagents).toBeUndefined();
});
test('should ignore request subagents for added ephemeral agents', async () => {
const result = await loadAddedAgent(
{
req: {
user: { id: 'user123' },
config: {
config: {},
fileStrategy: FileSources.local,
imageOutputType: 'png',
},
},
conversation: {
endpoint: 'openai',
model: 'gpt-4',
ephemeralAgent: { subagents: { enabled: true, allowSelf: true, agent_ids: [] } },
} as unknown as TConversation,
},
deps,
);
expect(result?.subagents).toBeUndefined();
});
test('addresses added-agent cached tools with the effective config overlay', async () => {
const overlayConfig = {
type: 'streamable-http' as const,
url: 'https://overlay.example.com/mcp',
};
mockGetMCPServerTools.mockResolvedValue({ overlay_tool_mcp_overlay: {} });
const result = await loadAddedAgent(
{
req: {
user: { id: 'user123' },
config: {
config: {},
fileStrategy: FileSources.local,
imageOutputType: 'png',
mcpConfig: { overlay: overlayConfig },
},
},
conversation: {
endpoint: 'openai',
model: 'gpt-4',
ephemeralAgent: { mcp: ['overlay'] },
} as unknown as TConversation,
},
deps,
);
expect(mockGetMCPServerTools).toHaveBeenCalledWith(
'user123',
'overlay',
overlayConfig,
STANDARD_MCP_CAPABILITY_PROFILE,
);
expect(result?.tools).toContain('overlay_tool_mcp_overlay');
});
test('should enable full skill scope for added ephemeral model spec with skills true', async () => {
const result = await loadAddedAgent(
{
req: {
user: { id: 'user123' },
config: {
config: {},
fileStrategy: FileSources.local,
imageOutputType: 'png',
modelSpecs: {
list: [
{
name: 'added-skills-on',
label: 'Added Skills On',
preset: { endpoint: 'openai', model: 'gpt-4' },
skills: true,
},
],
},
},
},
conversation: {
endpoint: 'openai',
model: 'gpt-4',
spec: 'added-skills-on',
} as unknown as TConversation,
},
deps,
);
expect(result?.skills_enabled).toBe(true);
expect(result?.skills).toBeUndefined();
});
test('should initialize an empty allowlist for added ephemeral model spec skill names', async () => {
const result = await loadAddedAgent(
{
req: {
user: { id: 'user123' },
config: {
config: {},
fileStrategy: FileSources.local,
imageOutputType: 'png',
modelSpecs: {
list: [
{
name: 'added-scoped-skills',
label: 'Added Scoped Skills',
preset: { endpoint: 'openai', model: 'gpt-4' },
skills: ['finance-analyst', 'brand-writer'],
},
],
},
},
},
conversation: {
endpoint: 'openai',
model: 'gpt-4',
spec: 'added-scoped-skills',
} as unknown as TConversation,
},
deps,
);
expect(result?.skills_enabled).toBe(true);
expect(result?.skills).toEqual([]);
});
test('should apply subagent config for added ephemeral model specs', async () => {
const subagents = { enabled: true, allowSelf: true, agent_ids: [] };
const result = await loadAddedAgent(
{
req: {
user: { id: 'user123' },
config: {
config: {},
fileStrategy: FileSources.local,
imageOutputType: 'png',
modelSpecs: {
list: [
{
name: 'added-self-spawn',
label: 'Added Self Spawn',
preset: { endpoint: 'openai', model: 'gpt-4' },
subagents,
},
],
},
},
},
conversation: {
endpoint: 'openai',
model: 'gpt-4',
spec: 'added-self-spawn',
} as unknown as TConversation,
},
deps,
);
expect(result?.subagents).toEqual(subagents);
});
test('should apply model spec skills when added agent mirrors ephemeral primary tools', async () => {
const { EPHEMERAL_AGENT_ID } = Constants;
const subagents = { enabled: true, allowSelf: true, agent_ids: [] };
const result = await loadAddedAgent(
{
req: {
user: { id: 'user123' },
config: {
config: {},
fileStrategy: FileSources.local,
imageOutputType: 'png',
modelSpecs: {
list: [
{
name: 'mirrored-scoped-skills',
label: 'Mirrored Scoped Skills',
preset: { endpoint: 'openai', model: 'gpt-4' },
skills: ['brand-writer'],
subagents,
},
],
},
},
},
conversation: {
endpoint: 'openai',
model: 'gpt-4',
spec: 'mirrored-scoped-skills',
} as unknown as TConversation,
primaryAgent: { id: EPHEMERAL_AGENT_ID as string, tools: ['web_search'] } as LibreChatAgent,
},
deps,
);
expect(result?.tools).toEqual(['web_search']);
expect(result?.skills_enabled).toBe(true);
expect(result?.skills).toEqual([]);
expect(result?.subagents).toEqual(subagents);
});
test('should equip ask_user_question for added agents from a model spec', async () => {
const result = await loadAddedAgent(
{
req: {
user: { id: 'user123' },
config: {
config: {},
fileStrategy: FileSources.local,
imageOutputType: 'png',
modelSpecs: {
list: [
{
name: 'added-asks',
label: 'Added Asks',
preset: { endpoint: 'openai', model: 'gpt-4' },
askUserQuestion: true,
},
],
},
},
},
conversation: {
endpoint: 'openai',
model: 'gpt-4',
spec: 'added-asks',
} as unknown as TConversation,
},
deps,
);
expect(result?.tools).toContain('ask_user_question');
});
test('should equip ask_user_question for added agents from the ephemeralAgent flag', async () => {
const result = await loadAddedAgent(
{
req: {
user: { id: 'user123' },
config: {
config: {},
fileStrategy: FileSources.local,
imageOutputType: 'png',
},
},
conversation: {
endpoint: 'openai',
model: 'gpt-4',
ephemeralAgent: { ask_user_question: true },
} as unknown as TConversation,
},
deps,
);
expect(result?.tools).toContain('ask_user_question');
});
test('should handle ephemeral agent with undefined ephemeralAgent in body', async () => {
const { EPHEMERAL_AGENT_ID } = Constants;
const mockReq = {
user: { id: 'user123' },
body: {
promptPrefix: 'Basic instructions',
},
};
const result = await loadAgent(
{
req: mockReq,
agent_id: EPHEMERAL_AGENT_ID as string,
endpoint: 'openai',
model_parameters: { model: 'gpt-4' } as unknown as AgentModelParameters,
},
deps,
);
if (result) {
expect(result.tools).toEqual([]);
} else {
expect(result).toBeFalsy();
}
});
describe('Edge Cases', () => {
test('should handle loadAgent with malformed req object', async () => {
const result = await loadAgent(
{
req: null as unknown as LoadAgentParams['req'],
agent_id: 'agent_test',
endpoint: 'openai',
model_parameters: { model: 'gpt-4' } as unknown as AgentModelParameters,
},
deps,
);
expect(result).toBeNull();
});
test('should handle ephemeral agent with extremely large tool list', async () => {
const { EPHEMERAL_AGENT_ID } = Constants;
const largeToolList = Array.from({ length: 100 }, (_, i) => `tool_${i}_mcp_server1`);
const availableTools: Record<string, object> = {};
for (const tool of largeToolList) {
availableTools[tool] = {};
}
// Mock getMCPServerTools to return all tools for server1
mockGetMCPServerTools.mockImplementation(async (_userId: string, server: string) => {
if (server === 'server1') {
return availableTools; // All 100 tools belong to server1
}
return null;
});
const mockReq = {
user: { id: 'user123' },
body: {
promptPrefix: 'Test',
ephemeralAgent: {
execute_code: true,
web_search: true,
mcp: ['server1'],
},
},
};
const result = await loadAgent(
{
req: mockReq,
agent_id: EPHEMERAL_AGENT_ID as string,
endpoint: 'openai',
model_parameters: { model: 'gpt-4' } as unknown as AgentModelParameters,
},
deps,
);
if (result) {
expect(result.tools!.length).toBeGreaterThan(100);
}
});
test('should return agent from different project (permissions checked at route level)', async () => {
const authorId = new mongoose.Types.ObjectId();
const userId = new mongoose.Types.ObjectId();
const agentId = `agent_${uuidv4()}`;
await createAgent({
id: agentId,
name: 'Project Agent',
provider: 'openai',
model: 'gpt-4',
author: authorId,
});
const mockReq = { user: { id: userId.toString() } };
const result = await loadAgent(
{
req: mockReq,
agent_id: agentId,
endpoint: 'openai',
model_parameters: { model: 'gpt-4' } as unknown as AgentModelParameters,
},
deps,
);
// With the new permission system, loadAgent returns the agent regardless of permissions
// Permission checks are handled at the route level via middleware
expect(result).toBeTruthy();
expect(result!.id).toBe(agentId);
expect(result!.name).toBe('Project Agent');
});
test('should handle loadEphemeralAgent with malformed MCP tool names', async () => {
const { EPHEMERAL_AGENT_ID } = Constants;
// Mock getMCPServerTools to return only tools matching the server
mockGetMCPServerTools.mockImplementation(async (_userId: string, server: string) => {
if (server === 'server1') {
// Only return tool that correctly matches server1 format
return { tool_mcp_server1: {} };
} else if (server === 'server2') {
return { tool_mcp_server2: {} };
}
return null;
});
const mockReq = {
user: { id: 'user123' },
body: {
promptPrefix: 'Test instructions',
ephemeralAgent: {
execute_code: false,
web_search: false,
mcp: ['server1'],
},
},
};
const result = await loadAgent(
{
req: mockReq,
agent_id: EPHEMERAL_AGENT_ID as string,
endpoint: 'openai',
model_parameters: { model: 'gpt-4' } as unknown as AgentModelParameters,
},
deps,
);
if (result) {
expect(result.tools).toEqual(['tool_mcp_server1']);
expect(result.tools).not.toContain('malformed_tool_name');
expect(result.tools).not.toContain('tool__server1');
expect(result.tools).not.toContain('tool_mcp_server2');
}
});
});
});