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 { Constants } from 'librechat-data-provider';
import { DynamicStructuredTool } from '@librechat/agents/langchain/tools';
import type { Agent, TEphemeralAgent } from 'librechat-data-provider';
import type { LCTool } from '@librechat/agents';
import type { Logger } from 'winston';
import type { MCPLookupUser, ParsedServerConfig } from '~/mcp/types';
import type { MCPManager } from '~/mcp/MCPManager';
/**
* Agent type with optional tools array that can contain DynamicStructuredTool or string.
* For context operations, we only require id and instructions, other Agent fields are optional.
*/
export type AgentWithTools = Pick<Agent, 'id'> &
Partial<Omit<Agent, 'id' | 'tools'>> & {
tools?: Array<DynamicStructuredTool | string>;
/** Serializable tool definitions for event-driven mode */
toolDefinitions?: LCTool[];
};
/**
* Extracts unique MCP server names from an agent's tools or tool definitions.
* Supports both full tool instances (tools) and serializable definitions (toolDefinitions).
* @param agent - The agent with tools and/or tool definitions
* @returns Array of unique MCP server names
*/
export function extractMCPServers(agent: AgentWithTools): string[] {
const mcpServers = new Set<string>();
/** Check tool instances (non-event-driven mode) */
if (agent?.tools?.length) {
for (const tool of agent.tools) {
if (tool instanceof DynamicStructuredTool && tool.name.includes(Constants.mcp_delimiter)) {
const carried = (tool as { mcpRawServerName?: string }).mcpRawServerName;
const serverName = carried ?? tool.name.split(Constants.mcp_delimiter).pop();
if (serverName) {
mcpServers.add(serverName);
}
}
}
}
/** Check tool definitions (event-driven mode) */
if (agent?.toolDefinitions?.length) {
for (const toolDef of agent.toolDefinitions) {
if (toolDef.name?.includes(Constants.mcp_delimiter)) {
const serverName = toolDef.serverName ?? toolDef.name.split(Constants.mcp_delimiter).pop();
if (serverName) {
mcpServers.add(serverName);
}
}
}
}
return Array.from(mcpServers);
}
/**
* Fetches MCP instructions for the given server names.
* @param {string[]} mcpServers - Array of MCP server names
* @param {MCPManager} mcpManager - MCP manager instance
* @param {Logger} [logger] - Optional logger instance
* @param {MCPLookupUser} [user] - The acting user; servers hidden from them are left out
* @returns {Promise<string>} MCP instructions string, empty if none
*/
export async function getMCPInstructionsForServers(
mcpServers: string[],
mcpManager: MCPManager,
logger?: Logger,
configServers?: Record<string, ParsedServerConfig>,
user?: MCPLookupUser,
): Promise<string> {
if (!mcpServers.length) {
return '';
}
try {
const mcpInstructions = await mcpManager.formatInstructionsForContext(
mcpServers,
configServers,
user,
);
if (mcpInstructions && logger) {
logger.debug('[AgentContext] Fetched MCP instructions', {
serverCount: mcpServers.length,
});
}
return mcpInstructions || '';
} catch {
if (logger) {
logger.error('[AgentContext] Failed to get MCP instructions');
}
return '';
}
}
/**
* Builds stable instructions for an agent by combining agent-specific context and MCP context.
* Order: baseInstructions -> mcpInstructions
*
* @param {Object} params
* @param {string} [params.baseInstructions] - Agent's base instructions
* @param {string} [params.mcpInstructions] - Agent's MCP server instructions
* @returns {string | undefined} Combined instructions, or undefined if empty
*/
export function buildAgentInstructions({
baseInstructions,
mcpInstructions,
}: {
baseInstructions?: string;
mcpInstructions?: string;
}): string | undefined {
const parts = [baseInstructions, mcpInstructions].filter(Boolean);
const combined = parts.join('\n\n').trim();
return combined || undefined;
}
/**
* Builds dynamic system-tail instructions for an agent.
* Order: existing additional instructions -> shared run context.
*/
export function buildAgentAdditionalInstructions({
additionalInstructions,
sharedRunContext,
}: {
additionalInstructions?: string;
sharedRunContext?: string;
}): string | undefined {
const parts = [additionalInstructions, sharedRunContext].filter(Boolean);
const combined = parts.join('\n\n').trim();
return combined || undefined;
}
/**
* Applies run context and MCP instructions to an agent's configuration.
* Mutates the agent object in place.
*
* @param {Object} params
* @param {Agent} params.agent - The agent to update
* @param {string} params.sharedRunContext - Run-level shared context
* @param {MCPManager} params.mcpManager - MCP manager instance
* @param {Object} [params.ephemeralAgent] - Ephemeral agent config (for MCP override)
* @param {string} [params.agentId] - Agent ID for logging
* @param {Logger} [params.logger] - Optional logger instance
* @param {MCPLookupUser} [params.user] - The acting user, whose hidden MCP servers contribute no instructions
* @returns {Promise<void>}
*/
export async function applyContextToAgent({
agent,
sharedRunContext,
mcpManager,
ephemeralAgent,
agentId,
logger,
configServers,
user,
}: {
agent: AgentWithTools;
sharedRunContext: string;
mcpManager: MCPManager;
ephemeralAgent?: TEphemeralAgent;
agentId?: string;
logger?: Logger;
configServers?: Record<string, ParsedServerConfig>;
user?: MCPLookupUser;
}): Promise<void> {
const baseInstructions = agent.instructions || '';
const additionalInstructions = agent.additional_instructions || '';
try {
const mcpServers = ephemeralAgent?.mcp?.length ? ephemeralAgent.mcp : extractMCPServers(agent);
const mcpInstructions = await getMCPInstructionsForServers(
mcpServers,
mcpManager,
logger,
configServers,
user,
);
agent.instructions = buildAgentInstructions({
baseInstructions,
mcpInstructions,
});
agent.additional_instructions = buildAgentAdditionalInstructions({
additionalInstructions,
sharedRunContext,
});
if (agentId && logger) {
logger.debug('[AgentContext] Applied context to agent');
}
} catch {
agent.instructions = buildAgentInstructions({
baseInstructions,
mcpInstructions: '',
});
agent.additional_instructions = buildAgentAdditionalInstructions({
additionalInstructions,
sharedRunContext,
});
if (logger) {
logger.error('[AgentContext] Failed to apply context; using base instructions only');
}
}
}