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
🧰 refactor: Decouple MCP Tools from System Tools (#9748)
Danny Avila386900fb4ffa
diff --git a/api/server/controllers/PluginController.js b/api/server/controllers/PluginController.jsindex e97afeccdc..c5e074b8ff 100644--- a/api/server/controllers/PluginController.js+++ b/api/server/controllers/PluginController.js@@ -1,16 +1,9 @@const { logger } = require('@librechat/data-schemas');-const { CacheKeys, Constants } = require('librechat-data-provider');-const {- getToolkitKey,- checkPluginAuth,- filterUniquePlugins,- convertMCPToolToPlugin,- convertMCPToolsToPlugins,-} = require('@librechat/api');-const { getCachedTools, setCachedTools, mergeUserTools } = require('~/server/services/Config');+const { CacheKeys } = require('librechat-data-provider');+const { getToolkitKey, checkPluginAuth, filterUniquePlugins } = require('@librechat/api');+const { getCachedTools, setCachedTools } = require('~/server/services/Config');const { availableTools, toolkits } = require('~/app/clients/tools');const { getAppConfig } = require('~/server/services/Config');-const { getMCPManager } = require('~/config');const { getLogStores } = require('~/cache');const getAvailablePluginsController = async (req, res) => {@@ -72,69 +65,27 @@ const getAvailableTools = async (req, res) => {}const cache = getLogStores(CacheKeys.CONFIG_STORE);const cachedToolsArray = await cache.get(CacheKeys.TOOLS);- const cachedUserTools = await getCachedTools({ userId });const appConfig = req.config ?? (await getAppConfig({ role: req.user?.role }));- /** @type {TPlugin[]} */- let mcpPlugins;- if (appConfig?.mcpConfig) {- const mcpManager = getMCPManager();- mcpPlugins =- cachedUserTools != null- ? convertMCPToolsToPlugins({ functionTools: cachedUserTools, mcpManager })- : undefined;- }-- if (- cachedToolsArray != null &&- (appConfig?.mcpConfig != null ? mcpPlugins != null && mcpPlugins.length > 0 : true)- ) {- const dedupedTools = filterUniquePlugins([...(mcpPlugins ?? []), ...cachedToolsArray]);- res.status(200).json(dedupedTools);+ // Return early if we have cached tools+ if (cachedToolsArray != null) {+ res.status(200).json(cachedToolsArray);return;}/** @type {Record<string, FunctionTool> | null} Get tool definitions to filter which tools are actually available */- let toolDefinitions = await getCachedTools({ includeGlobal: true });- let prelimCachedTools;+ let toolDefinitions = await getCachedTools();if (toolDefinitions == null && appConfig?.availableTools != null) {logger.warn('[getAvailableTools] Tool cache was empty, re-initializing from app config');- await setCachedTools(appConfig.availableTools, { isGlobal: true });+ await setCachedTools(appConfig.availableTools);toolDefinitions = appConfig.availableTools;}/** @type {import('@librechat/api').LCManifestTool[]} */let pluginManifest = availableTools;- if (appConfig?.mcpConfig != null) {- try {- const mcpManager = getMCPManager();- const mcpTools = await mcpManager.getAllToolFunctions(userId);- prelimCachedTools = prelimCachedTools ?? {};- for (const [toolKey, toolData] of Object.entries(mcpTools)) {- const plugin = convertMCPToolToPlugin({- toolKey,- toolData,- mcpManager,- });- if (plugin) {- pluginManifest.push(plugin);- }- prelimCachedTools[toolKey] = toolData;- }- await mergeUserTools({ userId, cachedUserTools, userTools: prelimCachedTools });- } catch (error) {- logger.error(- '[getAvailableTools] Error loading MCP Tools, servers may still be initializing:',- error,- );- }- } else if (prelimCachedTools != null) {- await setCachedTools(prelimCachedTools, { isGlobal: true });- }-/** @type {TPlugin[]} Deduplicate and authenticate plugins */const uniquePlugins = filterUniquePlugins(pluginManifest);const authenticatedPlugins = uniquePlugins.map((plugin) => {@@ -145,7 +96,7 @@ const getAvailableTools = async (req, res) => {}});- /** Filter plugins based on availability and add MCP-specific auth config */+ /** Filter plugins based on availability */const toolsOutput = [];for (const plugin of authenticatedPlugins) {const isToolDefined = toolDefinitions?.[plugin.pluginKey] !== undefined;@@ -159,39 +110,13 @@ const getAvailableTools = async (req, res) => {continue;}- const toolToAdd = { ...plugin };-- if (plugin.pluginKey.includes(Constants.mcp_delimiter)) {- const parts = plugin.pluginKey.split(Constants.mcp_delimiter);- const serverName = parts[parts.length - 1];- const serverConfig = appConfig?.mcpConfig?.[serverName];-- if (serverConfig?.customUserVars) {- const customVarKeys = Object.keys(serverConfig.customUserVars);- if (customVarKeys.length === 0) {- toolToAdd.authConfig = [];- toolToAdd.authenticated = true;- } else {- toolToAdd.authConfig = Object.entries(serverConfig.customUserVars).map(- ([key, value]) => ({- authField: key,- label: value.title || key,- description: value.description || '',- }),- );- toolToAdd.authenticated = false;- }- }- }-- toolsOutput.push(toolToAdd);+ toolsOutput.push(plugin);}const finalTools = filterUniquePlugins(toolsOutput);await cache.set(CacheKeys.TOOLS, finalTools);- const dedupedTools = filterUniquePlugins([...(mcpPlugins ?? []), ...finalTools]);- res.status(200).json(dedupedTools);+ res.status(200).json(finalTools);} catch (error) {logger.error('[getAvailableTools]', error);res.status(500).json({ message: error.message });diff --git a/api/server/controllers/PluginController.spec.js b/api/server/controllers/PluginController.spec.jsindex cdbcabd75c..d7d3f83a8b 100644--- a/api/server/controllers/PluginController.spec.js+++ b/api/server/controllers/PluginController.spec.js@@ -1,4 +1,3 @@-const { Constants } = require('librechat-data-provider');const { getCachedTools, getAppConfig } = require('~/server/services/Config');const { getLogStores } = require('~/cache');@@ -17,18 +16,10 @@ jest.mock('~/server/services/Config', () => ({includedTools: [],}),setCachedTools: jest.fn(),- mergeUserTools: jest.fn(),}));// loadAndFormatTools mock removed - no longer used in PluginController--jest.mock('~/config', () => ({- getMCPManager: jest.fn(() => ({- getAllToolFunctions: jest.fn().mockResolvedValue({}),- getRawConfig: jest.fn().mockReturnValue({}),- })),- getFlowStateManager: jest.fn(),-}));+// getMCPManager mock removed - no longer used in PluginControllerjest.mock('~/app/clients/tools', () => ({availableTools: [],@@ -159,52 +150,6 @@ describe('PluginController', () => {});describe('getAvailableTools', () => {- it('should use convertMCPToolsToPlugins for user-specific MCP tools', async () => {- const mockUserTools = {- [`tool1${Constants.mcp_delimiter}server1`]: {- type: 'function',- function: {- name: `tool1${Constants.mcp_delimiter}server1`,- description: 'Tool 1',- parameters: { type: 'object', properties: {} },- },- },- };-- mockCache.get.mockResolvedValue(null);- getCachedTools.mockResolvedValueOnce(mockUserTools);- mockReq.config = {- mcpConfig: {- server1: {},- },- paths: { structuredTools: '/mock/path' },- };-- // Mock MCP manager to return empty tools initially (since getAllToolFunctions is called)- const mockMCPManager = {- getAllToolFunctions: jest.fn().mockResolvedValue({}),- getRawConfig: jest.fn().mockReturnValue({}),- };- require('~/config').getMCPManager.mockReturnValue(mockMCPManager);-- // Mock second call to return tool definitions (includeGlobal: true)- getCachedTools.mockResolvedValueOnce(mockUserTools);-- await getAvailableTools(mockReq, mockRes);-- expect(mockRes.status).toHaveBeenCalledWith(200);- const responseData = mockRes.json.mock.calls[0][0];- expect(responseData).toBeDefined();- expect(Array.isArray(responseData)).toBe(true);- expect(responseData.length).toBeGreaterThan(0);- const convertedTool = responseData.find(- (tool) => tool.pluginKey === `tool1${Constants.mcp_delimiter}server1`,- );- expect(convertedTool).toBeDefined();- // The real convertMCPToolsToPlugins extracts the name from the delimiter- expect(convertedTool.name).toBe('tool1');- });-it('should use filterUniquePlugins to deduplicate combined tools', async () => {const mockUserTools = {'user-tool': {@@ -229,9 +174,6 @@ describe('PluginController', () => {paths: { structuredTools: '/mock/path' },};- // Mock second call to return tool definitions- getCachedTools.mockResolvedValueOnce(mockUserTools);-await getAvailableTools(mockReq, mockRes);expect(mockRes.status).toHaveBeenCalledWith(200);@@ -254,14 +196,7 @@ describe('PluginController', () => {require('~/app/clients/tools').availableTools.push(mockPlugin);mockCache.get.mockResolvedValue(null);- // First call returns null for user tools- getCachedTools.mockResolvedValueOnce(null);- mockReq.config = {- mcpConfig: null,- paths: { structuredTools: '/mock/path' },- };-- // Second call (with includeGlobal: true) returns the tool definitions+ // getCachedTools returns the tool definitionsgetCachedTools.mockResolvedValueOnce({tool1: {type: 'function',@@ -272,6 +207,10 @@ describe('PluginController', () => {},},});+ mockReq.config = {+ mcpConfig: null,+ paths: { structuredTools: '/mock/path' },+ };await getAvailableTools(mockReq, mockRes);@@ -302,14 +241,7 @@ describe('PluginController', () => {});mockCache.get.mockResolvedValue(null);- // First call returns null for user tools- getCachedTools.mockResolvedValueOnce(null);- mockReq.config = {- mcpConfig: null,- paths: { structuredTools: '/mock/path' },- };-- // Second call (with includeGlobal: true) returns the tool definitions+ // getCachedTools returns the tool definitionsgetCachedTools.mockResolvedValueOnce({toolkit1_function: {type: 'function',@@ -320,6 +252,10 @@ describe('PluginController', () => {},},});+ mockReq.config = {+ mcpConfig: null,+ paths: { structuredTools: '/mock/path' },+ };await getAvailableTools(mockReq, mockRes);@@ -331,126 +267,7 @@ describe('PluginController', () => {});});- describe('plugin.icon behavior', () => {- const callGetAvailableToolsWithMCPServer = async (serverConfig) => {- mockCache.get.mockResolvedValue(null);-- const functionTools = {- [`test-tool${Constants.mcp_delimiter}test-server`]: {- type: 'function',- function: {- name: `test-tool${Constants.mcp_delimiter}test-server`,- description: 'A test tool',- parameters: { type: 'object', properties: {} },- },- },- };-- // Mock the MCP manager to return tools and server config- const mockMCPManager = {- getAllToolFunctions: jest.fn().mockResolvedValue(functionTools),- getRawConfig: jest.fn().mockReturnValue(serverConfig),- };- require('~/config').getMCPManager.mockReturnValue(mockMCPManager);-- // First call returns empty user tools- getCachedTools.mockResolvedValueOnce({});-- // Mock getAppConfig to return the mcpConfig- mockReq.config = {- mcpConfig: {- 'test-server': serverConfig,- },- };-- // Second call (with includeGlobal: true) returns the tool definitions- getCachedTools.mockResolvedValueOnce(functionTools);-- await getAvailableTools(mockReq, mockRes);- const responseData = mockRes.json.mock.calls[0][0];- return responseData.find(- (tool) => tool.pluginKey === `test-tool${Constants.mcp_delimiter}test-server`,- );- };-- it('should set plugin.icon when iconPath is defined', async () => {- const serverConfig = {- iconPath: '/path/to/icon.png',- };- const testTool = await callGetAvailableToolsWithMCPServer(serverConfig);- expect(testTool.icon).toBe('/path/to/icon.png');- });-- it('should set plugin.icon to undefined when iconPath is not defined', async () => {- const serverConfig = {};- const testTool = await callGetAvailableToolsWithMCPServer(serverConfig);- expect(testTool.icon).toBeUndefined();- });- });-describe('helper function integration', () => {- it('should properly handle MCP tools with custom user variables', async () => {- const appConfig = {- mcpConfig: {- 'test-server': {- customUserVars: {- API_KEY: { title: 'API Key', description: 'Your API key' },- },- },- },- };-- // Mock MCP tools returned by getAllToolFunctions- const mcpToolFunctions = {- [`tool1${Constants.mcp_delimiter}test-server`]: {- type: 'function',- function: {- name: `tool1${Constants.mcp_delimiter}test-server`,- description: 'Tool 1',- parameters: {},- },- },- };-- // Mock the MCP manager to return tools- const mockMCPManager = {- getAllToolFunctions: jest.fn().mockResolvedValue(mcpToolFunctions),- getRawConfig: jest.fn().mockReturnValue({- customUserVars: {- API_KEY: { title: 'API Key', description: 'Your API key' },- },- }),- };- require('~/config').getMCPManager.mockReturnValue(mockMCPManager);-- mockCache.get.mockResolvedValue(null);- mockReq.config = appConfig;-- // First call returns user tools (empty in this case)- getCachedTools.mockResolvedValueOnce({});-- // Second call (with includeGlobal: true) returns tool definitions including our MCP tool- getCachedTools.mockResolvedValueOnce(mcpToolFunctions);-- await getAvailableTools(mockReq, mockRes);-- expect(mockRes.status).toHaveBeenCalledWith(200);- const responseData = mockRes.json.mock.calls[0][0];- expect(Array.isArray(responseData)).toBe(true);-- // Find the MCP tool in the response- const mcpTool = responseData.find(- (tool) => tool.pluginKey === `tool1${Constants.mcp_delimiter}test-server`,- );-- // The actual implementation adds authConfig and sets authenticated to false when customUserVars exist- expect(mcpTool).toBeDefined();- expect(mcpTool.authConfig).toEqual([- { authField: 'API_KEY', label: 'API Key', description: 'Your API key' },- ]);- expect(mcpTool.authenticated).toBe(false);- });-it('should handle error cases gracefully', async () => {mockCache.get.mockRejectedValue(new Error('Cache error'));@@ -472,23 +289,13 @@ describe('PluginController', () => {it('should handle null cachedTools and cachedUserTools', async () => {mockCache.get.mockResolvedValue(null);- // First call returns null for user tools- getCachedTools.mockResolvedValueOnce(null);+ // getCachedTools returns empty object instead of null+ getCachedTools.mockResolvedValueOnce({});mockReq.config = {mcpConfig: null,paths: { structuredTools: '/mock/path' },};- // Mock MCP manager to return no tools- const mockMCPManager = {- getAllToolFunctions: jest.fn().mockResolvedValue({}),- getRawConfig: jest.fn().mockReturnValue({}),- };- require('~/config').getMCPManager.mockReturnValue(mockMCPManager);-- // Second call (with includeGlobal: true) returns empty object instead of null- getCachedTools.mockResolvedValueOnce({});-await getAvailableTools(mockReq, mockRes);// Should handle null values gracefully@@ -503,9 +310,9 @@ describe('PluginController', () => {paths: { structuredTools: '/mock/path' },};- // Mock getCachedTools to return undefined for both calls+ // Mock getCachedTools to return undefinedgetCachedTools.mockReset();- getCachedTools.mockResolvedValueOnce(undefined).mockResolvedValueOnce(undefined);+ getCachedTools.mockResolvedValueOnce(undefined);await getAvailableTools(mockReq, mockRes);@@ -514,51 +321,6 @@ describe('PluginController', () => {expect(mockRes.json).toHaveBeenCalledWith([]);});- it('should handle `cachedToolsArray` and `mcpPlugins` both being defined', async () => {- const cachedTools = [{ name: 'CachedTool', pluginKey: 'cached-tool', description: 'Cached' }];- // Use MCP delimiter for the user tool so convertMCPToolsToPlugins works- const userTools = {- [`user-tool${Constants.mcp_delimiter}server1`]: {- type: 'function',- function: {- name: `user-tool${Constants.mcp_delimiter}server1`,- description: 'User tool',- parameters: {},- },- },- };-- mockCache.get.mockResolvedValue(cachedTools);- getCachedTools.mockResolvedValueOnce(userTools);- mockReq.config = {- mcpConfig: {- server1: {},- },- paths: { structuredTools: '/mock/path' },- };-- // Mock MCP manager to return empty tools initially- const mockMCPManager = {- getAllToolFunctions: jest.fn().mockResolvedValue({}),- getRawConfig: jest.fn().mockReturnValue({}),- };- require('~/config').getMCPManager.mockReturnValue(mockMCPManager);-- // The controller expects a second call to getCachedTools- getCachedTools.mockResolvedValueOnce({- 'cached-tool': { type: 'function', function: { name: 'cached-tool' } },- [`user-tool${Constants.mcp_delimiter}server1`]:- userTools[`user-tool${Constants.mcp_delimiter}server1`],- });-- await getAvailableTools(mockReq, mockRes);-- expect(mockRes.status).toHaveBeenCalledWith(200);- const responseData = mockRes.json.mock.calls[0][0];- // Should have both cached and user tools- expect(responseData.length).toBeGreaterThanOrEqual(2);- });-it('should handle empty toolDefinitions object', async () => {mockCache.get.mockResolvedValue(null);// Reset getCachedTools to ensure clean state@@ -569,76 +331,12 @@ describe('PluginController', () => {// Ensure no plugins are availablerequire('~/app/clients/tools').availableTools.length = 0;- // Reset MCP manager to default state- const mockMCPManager = {- getAllToolFunctions: jest.fn().mockResolvedValue({}),- getRawConfig: jest.fn().mockReturnValue({}),- };- require('~/config').getMCPManager.mockReturnValue(mockMCPManager);-await getAvailableTools(mockReq, mockRes);// With empty tool definitions, no tools should be in the final outputexpect(mockRes.json).toHaveBeenCalledWith([]);});- it('should handle MCP tools without customUserVars', async () => {- const appConfig = {- mcpConfig: {- 'test-server': {- // No customUserVars defined- },- },- };-- const mockUserTools = {- [`tool1${Constants.mcp_delimiter}test-server`]: {- type: 'function',- function: {- name: `tool1${Constants.mcp_delimiter}test-server`,- description: 'Tool 1',- parameters: { type: 'object', properties: {} },- },- },- };-- // Mock the MCP manager to return the tools- const mockMCPManager = {- getAllToolFunctions: jest.fn().mockResolvedValue(mockUserTools),- getRawConfig: jest.fn().mockReturnValue({- // No customUserVars defined- }),- };- require('~/config').getMCPManager.mockReturnValue(mockMCPManager);-- mockCache.get.mockResolvedValue(null);- mockReq.config = appConfig;- // First call returns empty user tools- getCachedTools.mockResolvedValueOnce({});-- // Second call (with includeGlobal: true) returns the tool definitions- getCachedTools.mockResolvedValueOnce(mockUserTools);-- // Ensure no plugins in availableTools for clean test- require('~/app/clients/tools').availableTools.length = 0;-- await getAvailableTools(mockReq, mockRes);-- expect(mockRes.status).toHaveBeenCalledWith(200);- const responseData = mockRes.json.mock.calls[0][0];- expect(Array.isArray(responseData)).toBe(true);- expect(responseData.length).toBeGreaterThan(0);-- const mcpTool = responseData.find(- (tool) => tool.pluginKey === `tool1${Constants.mcp_delimiter}test-server`,- );-- expect(mcpTool).toBeDefined();- expect(mcpTool.authenticated).toBe(true);- // The actual implementation sets authConfig to empty array when no customUserVars- expect(mcpTool.authConfig).toEqual([]);- });-it('should handle undefined filteredTools and includedTools', async () => {mockReq.config = {};mockCache.get.mockResolvedValue(null);@@ -667,16 +365,13 @@ describe('PluginController', () => {require('~/app/clients/tools').availableTools.push(mockToolkit);mockCache.get.mockResolvedValue(null);- // First call returns empty object+ // getCachedTools returns empty object to avoid null reference errorgetCachedTools.mockResolvedValueOnce({});mockReq.config = {mcpConfig: null,paths: { structuredTools: '/mock/path' },};- // Second call (with includeGlobal: true) returns empty object to avoid null reference error- getCachedTools.mockResolvedValueOnce({});-await getAvailableTools(mockReq, mockRes);// Should handle null toolDefinitions gracefully@@ -697,15 +392,12 @@ describe('PluginController', () => {mockCache.get.mockResolvedValue(null);- // First call returns null for user tools- getCachedTools.mockResolvedValueOnce(null);-mockReq.config = {mcpConfig: null,paths: { structuredTools: '/mock/path' },};- // CRITICAL: Second call (with includeGlobal: true) returns undefined+ // CRITICAL: getCachedTools returns undefined// This is what causes the bug when trying to access toolDefinitions[plugin.pluginKey]getCachedTools.mockResolvedValueOnce(undefined);@@ -744,9 +436,8 @@ describe('PluginController', () => {{ name: 'Tool 2', pluginKey: 'tool2', description: 'Tool 2' },);- // First call: Simulate cache cleared state (returns null for both global and user tools)+ // Simulate cache cleared state (returns null)mockCache.get.mockResolvedValue(null);- getCachedTools.mockResolvedValueOnce(null); // User toolsgetCachedTools.mockResolvedValueOnce(null); // Global tools (cache cleared)mockReq.config = {@@ -761,7 +452,7 @@ describe('PluginController', () => {await getAvailableTools(mockReq, mockRes);// Should have re-initialized the cache with tools from appConfig- expect(setCachedTools).toHaveBeenCalledWith(mockAppTools, { isGlobal: true });+ expect(setCachedTools).toHaveBeenCalledWith(mockAppTools);// Should still return tools successfullyexpect(mockRes.status).toHaveBeenCalledWith(200);@@ -784,7 +475,6 @@ describe('PluginController', () => {// Cache returns null (cleared state)mockCache.get.mockResolvedValue(null);- getCachedTools.mockResolvedValueOnce(null); // User toolsgetCachedTools.mockResolvedValueOnce(null); // Global tools (cache cleared)mockReq.config = {diff --git a/api/server/controllers/UserController.js b/api/server/controllers/UserController.jsindex e5c480c639..5d8dd9a5d2 100644--- a/api/server/controllers/UserController.js+++ b/api/server/controllers/UserController.js@@ -1,37 +1,34 @@const { logger } = require('@librechat/data-schemas');+const { Tools, CacheKeys, Constants, FileSources } = require('librechat-data-provider');const {webSearchKeys,- extractWebSearchEnvVars,- normalizeHttpError,+ MCPOAuthHandler,MCPTokenStorage,+ normalizeHttpError,+ extractWebSearchEnvVars,} = require('@librechat/api');const {getFiles,+ findToken,updateUser,deleteFiles,deleteConvos,deletePresets,deleteMessages,deleteUserById,+ deleteAllSharedLinks,deleteAllUserSessions,} = require('~/models');const { updateUserPluginAuth, deleteUserPluginAuth } = require('~/server/services/PluginService');const { updateUserPluginsService, deleteUserKey } = require('~/server/services/UserService');const { verifyEmail, resendVerificationEmail } = require('~/server/services/AuthService');+const { getAppConfig, clearMCPServerTools } = require('~/server/services/Config');const { needsRefresh, getNewS3URL } = require('~/server/services/Files/S3/crud');-const { Tools, Constants, FileSources } = require('librechat-data-provider');const { processDeleteRequest } = require('~/server/services/Files/process');const { Transaction, Balance, User, Token } = require('~/db/models');-const { getAppConfig } = require('~/server/services/Config');+const { getMCPManager, getFlowStateManager } = require('~/config');const { deleteToolCalls } = require('~/models/ToolCall');-const { deleteAllSharedLinks } = require('~/models');-const { getMCPManager } = require('~/config');-const { MCPOAuthHandler } = require('@librechat/api');-const { getFlowStateManager } = require('~/config');-const { CacheKeys } = require('librechat-data-provider');const { getLogStores } = require('~/cache');-const { clearMCPServerTools } = require('~/server/services/Config/mcpToolsCache');-const { findToken } = require('~/models');const getUserController = async (req, res) => {const appConfig = await getAppConfig({ role: req.user?.role });diff --git a/api/server/controllers/mcp.js b/api/server/controllers/mcp.jsnew file mode 100644index 0000000000..40607a5840--- /dev/null+++ b/api/server/controllers/mcp.js@@ -0,0 +1,105 @@+/**+ * MCP Tools Controller+ * Handles MCP-specific tool endpoints, decoupled from regular LibreChat tools+ */+const { logger } = require('@librechat/data-schemas');+const { Constants } = require('librechat-data-provider');+const { convertMCPToolToPlugin } = require('@librechat/api');+const { getAppConfig, getMCPServerTools } = require('~/server/services/Config');+const { getMCPManager } = require('~/config');++/**+ * Get all MCP tools available to the user+ * Returns only MCP tools, not regular LibreChat tools+ */+const getMCPTools = async (req, res) => {+ try {+ const userId = req.user?.id;+ if (!userId) {+ logger.warn('[getMCPTools] User ID not found in request');+ return res.status(401).json({ message: 'Unauthorized' });+ }++ const appConfig = req.config ?? (await getAppConfig({ role: req.user?.role }));+ if (!appConfig?.mcpConfig) {+ return res.status(200).json([]);+ }++ const mcpManager = getMCPManager();+ const configuredServers = Object.keys(appConfig.mcpConfig);+ const mcpTools = [];++ // Fetch tools from each configured server+ for (const serverName of configuredServers) {+ try {+ // First check server-specific cache+ let serverTools = await getMCPServerTools(serverName);++ if (!serverTools) {+ // If not cached, fetch from MCP manager+ const allTools = await mcpManager.getAllToolFunctions(userId);+ serverTools = {};++ // Filter tools for this specific server+ for (const [toolKey, toolData] of Object.entries(allTools)) {+ if (toolKey.endsWith(`${Constants.mcp_delimiter}${serverName}`)) {+ serverTools[toolKey] = toolData;+ }+ }++ // Cache server tools if found+ if (Object.keys(serverTools).length > 0) {+ const { cacheMCPServerTools } = require('~/server/services/Config');+ await cacheMCPServerTools({ serverName, serverTools });+ }+ }++ // Convert to plugin format+ for (const [toolKey, toolData] of Object.entries(serverTools)) {+ const plugin = convertMCPToolToPlugin({+ toolKey,+ toolData,+ mcpManager,+ });++ if (plugin) {+ // Add authentication config from server config+ const serverConfig = appConfig.mcpConfig[serverName];+ if (serverConfig?.customUserVars) {+ const customVarKeys = Object.keys(serverConfig.customUserVars);+ if (customVarKeys.length === 0) {+ plugin.authConfig = [];+ plugin.authenticated = true;+ } else {+ plugin.authConfig = Object.entries(serverConfig.customUserVars).map(+ ([key, value]) => ({+ authField: key,+ label: value.title || key,+ description: value.description || '',+ }),+ );+ plugin.authenticated = false;+ }+ } else {+ plugin.authConfig = [];+ plugin.authenticated = true;+ }++ mcpTools.push(plugin);+ }+ }+ } catch (error) {+ logger.error(`[getMCPTools] Error loading tools for server ${serverName}:`, error);+ }+ }++ res.status(200).json(mcpTools);+ } catch (error) {+ logger.error('[getMCPTools]', error);+ res.status(500).json({ message: error.message });+ }+};++module.exports = {+ getMCPTools,+};diff --git a/api/server/controllers/mcp.spec.js b/api/server/controllers/mcp.spec.jsnew file mode 100644index 0000000000..6dea3ac348--- /dev/null+++ b/api/server/controllers/mcp.spec.js@@ -0,0 +1,561 @@+const { getMCPTools } = require('./mcp');+const { getAppConfig, getMCPServerTools } = require('~/server/services/Config');+const { getMCPManager } = require('~/config');+const { convertMCPToolToPlugin } = require('@librechat/api');++jest.mock('@librechat/data-schemas', () => ({+ logger: {+ debug: jest.fn(),+ error: jest.fn(),+ warn: jest.fn(),+ },+}));++jest.mock('librechat-data-provider', () => ({+ Constants: {+ mcp_delimiter: '~~~',+ },+}));++jest.mock('@librechat/api', () => ({+ convertMCPToolToPlugin: jest.fn(),+}));++jest.mock('~/server/services/Config', () => ({+ getAppConfig: jest.fn(),+ getMCPServerTools: jest.fn(),+ cacheMCPServerTools: jest.fn(),+}));++jest.mock('~/config', () => ({+ getMCPManager: jest.fn(),+}));++describe('MCP Controller', () => {+ let mockReq, mockRes, mockMCPManager;++ beforeEach(() => {+ jest.clearAllMocks();++ mockReq = {+ user: { id: 'test-user-id', role: 'user' },+ config: null,+ };++ mockRes = {+ status: jest.fn().mockReturnThis(),+ json: jest.fn(),+ };++ mockMCPManager = {+ getAllToolFunctions: jest.fn().mockResolvedValue({}),+ };++ getMCPManager.mockReturnValue(mockMCPManager);+ getAppConfig.mockResolvedValue({+ mcpConfig: {},+ });+ getMCPServerTools.mockResolvedValue(null);+ });++ describe('getMCPTools', () => {+ it('should return 401 when user ID is not found', async () => {+ mockReq.user = null;++ await getMCPTools(mockReq, mockRes);++ expect(mockRes.status).toHaveBeenCalledWith(401);+ expect(mockRes.json).toHaveBeenCalledWith({ message: 'Unauthorized' });+ const { logger } = require('@librechat/data-schemas');+ expect(logger.warn).toHaveBeenCalledWith('[getMCPTools] User ID not found in request');+ });++ it('should return empty array when no mcpConfig exists', async () => {+ getAppConfig.mockResolvedValue({+ // No mcpConfig+ });++ await getMCPTools(mockReq, mockRes);++ expect(mockRes.status).toHaveBeenCalledWith(200);+ expect(mockRes.json).toHaveBeenCalledWith([]);+ });++ it('should use cached server tools when available', async () => {+ const cachedTools = {+ 'tool1~~~server1': {+ type: 'function',+ function: {+ name: 'tool1',+ description: 'Tool 1',+ parameters: {},+ },+ },+ };++ getMCPServerTools.mockResolvedValue(cachedTools);+ getAppConfig.mockResolvedValue({+ mcpConfig: {+ server1: {},+ },+ });++ const mockPlugin = {+ name: 'Tool 1',+ pluginKey: 'tool1~~~server1',+ description: 'Tool 1',+ };+ convertMCPToolToPlugin.mockReturnValue(mockPlugin);++ await getMCPTools(mockReq, mockRes);++ expect(getMCPServerTools).toHaveBeenCalledWith('server1');+ expect(mockMCPManager.getAllToolFunctions).not.toHaveBeenCalled();+ expect(convertMCPToolToPlugin).toHaveBeenCalledWith({+ toolKey: 'tool1~~~server1',+ toolData: cachedTools['tool1~~~server1'],+ mcpManager: mockMCPManager,+ });+ expect(mockRes.status).toHaveBeenCalledWith(200);+ expect(mockRes.json).toHaveBeenCalledWith([+ {+ ...mockPlugin,+ authConfig: [],+ authenticated: true,+ },+ ]);+ });++ it('should fetch from MCP manager when cache is empty', async () => {+ getMCPServerTools.mockResolvedValue(null);++ const allTools = {+ 'tool1~~~server1': {+ type: 'function',+ function: {+ name: 'tool1',+ description: 'Tool 1',+ parameters: {},+ },+ },+ 'tool2~~~server2': {+ type: 'function',+ function: {+ name: 'tool2',+ description: 'Tool 2',+ parameters: {},+ },+ },+ };++ mockMCPManager.getAllToolFunctions.mockResolvedValue(allTools);++ getAppConfig.mockResolvedValue({+ mcpConfig: {+ server1: {},+ },+ });++ const mockPlugin = {+ name: 'Tool 1',+ pluginKey: 'tool1~~~server1',+ description: 'Tool 1',+ };+ convertMCPToolToPlugin.mockReturnValue(mockPlugin);++ await getMCPTools(mockReq, mockRes);++ expect(getMCPServerTools).toHaveBeenCalledWith('server1');+ expect(mockMCPManager.getAllToolFunctions).toHaveBeenCalledWith('test-user-id');++ // Should cache the server tools+ const { cacheMCPServerTools } = require('~/server/services/Config');+ expect(cacheMCPServerTools).toHaveBeenCalledWith({+ serverName: 'server1',+ serverTools: {+ 'tool1~~~server1': allTools['tool1~~~server1'],+ },+ });++ expect(mockRes.status).toHaveBeenCalledWith(200);+ expect(mockRes.json).toHaveBeenCalledWith([+ {+ ...mockPlugin,+ authConfig: [],+ authenticated: true,+ },+ ]);+ });++ it('should handle custom user variables in server config', async () => {+ getMCPServerTools.mockResolvedValue({+ 'tool1~~~server1': {+ type: 'function',+ function: {+ name: 'tool1',+ description: 'Tool 1',+ parameters: {},+ },+ },+ });++ getAppConfig.mockResolvedValue({+ mcpConfig: {+ server1: {+ customUserVars: {+ API_KEY: {+ title: 'API Key',+ description: 'Your API key',+ },+ SECRET: {+ title: 'Secret Token',+ description: 'Your secret token',+ },+ },+ },+ },+ });++ const mockPlugin = {+ name: 'Tool 1',+ pluginKey: 'tool1~~~server1',+ description: 'Tool 1',+ };+ convertMCPToolToPlugin.mockReturnValue(mockPlugin);++ await getMCPTools(mockReq, mockRes);++ expect(mockRes.status).toHaveBeenCalledWith(200);+ expect(mockRes.json).toHaveBeenCalledWith([+ {+ ...mockPlugin,+ authConfig: [+ {+ authField: 'API_KEY',+ label: 'API Key',+ description: 'Your API key',+ },+ {+ authField: 'SECRET',+ label: 'Secret Token',+ description: 'Your secret token',+ },+ ],+ authenticated: false,+ },+ ]);+ });++ it('should handle empty custom user variables', async () => {+ getMCPServerTools.mockResolvedValue({+ 'tool1~~~server1': {+ type: 'function',+ function: {+ name: 'tool1',+ description: 'Tool 1',+ parameters: {},+ },+ },+ });++ getAppConfig.mockResolvedValue({+ mcpConfig: {+ server1: {+ customUserVars: {},+ },+ },+ });++ const mockPlugin = {+ name: 'Tool 1',+ pluginKey: 'tool1~~~server1',+ description: 'Tool 1',+ };+ convertMCPToolToPlugin.mockReturnValue(mockPlugin);++ await getMCPTools(mockReq, mockRes);++ expect(mockRes.status).toHaveBeenCalledWith(200);+ expect(mockRes.json).toHaveBeenCalledWith([+ {+ ...mockPlugin,+ authConfig: [],+ authenticated: true,+ },+ ]);+ });++ it('should handle multiple servers', async () => {+ getMCPServerTools.mockResolvedValue(null);++ const allTools = {+ 'tool1~~~server1': {+ type: 'function',+ function: {+ name: 'tool1',+ description: 'Tool 1',+ parameters: {},+ },+ },+ 'tool2~~~server2': {+ type: 'function',+ function: {+ name: 'tool2',+ description: 'Tool 2',+ parameters: {},+ },+ },+ };++ mockMCPManager.getAllToolFunctions.mockResolvedValue(allTools);++ getAppConfig.mockResolvedValue({+ mcpConfig: {+ server1: {},+ server2: {},+ },+ });++ const mockPlugin1 = {+ name: 'Tool 1',+ pluginKey: 'tool1~~~server1',+ description: 'Tool 1',+ };+ const mockPlugin2 = {+ name: 'Tool 2',+ pluginKey: 'tool2~~~server2',+ description: 'Tool 2',+ };++ convertMCPToolToPlugin.mockReturnValueOnce(mockPlugin1).mockReturnValueOnce(mockPlugin2);++ await getMCPTools(mockReq, mockRes);++ expect(getMCPServerTools).toHaveBeenCalledWith('server1');+ expect(getMCPServerTools).toHaveBeenCalledWith('server2');+ expect(mockMCPManager.getAllToolFunctions).toHaveBeenCalledTimes(2);++ expect(mockRes.status).toHaveBeenCalledWith(200);+ expect(mockRes.json).toHaveBeenCalledWith([+ {+ ...mockPlugin1,+ authConfig: [],+ authenticated: true,+ },+ {+ ...mockPlugin2,+ authConfig: [],+ authenticated: true,+ },+ ]);+ });++ it('should handle server-specific errors gracefully', async () => {+ getMCPServerTools.mockResolvedValue(null);+ mockMCPManager.getAllToolFunctions.mockRejectedValue(new Error('Server connection failed'));++ getAppConfig.mockResolvedValue({+ mcpConfig: {+ server1: {},+ server2: {},+ },+ });++ await getMCPTools(mockReq, mockRes);++ const { logger } = require('@librechat/data-schemas');+ expect(logger.error).toHaveBeenCalledWith(+ '[getMCPTools] Error loading tools for server server1:',+ expect.any(Error),+ );+ expect(logger.error).toHaveBeenCalledWith(+ '[getMCPTools] Error loading tools for server server2:',+ expect.any(Error),+ );++ // Should still return 200 with empty array+ expect(mockRes.status).toHaveBeenCalledWith(200);+ expect(mockRes.json).toHaveBeenCalledWith([]);+ });++ it('should skip tools when convertMCPToolToPlugin returns null', async () => {+ getMCPServerTools.mockResolvedValue({+ 'tool1~~~server1': {+ type: 'function',+ function: {+ name: 'tool1',+ description: 'Tool 1',+ parameters: {},+ },+ },+ 'tool2~~~server1': {+ type: 'function',+ function: {+ name: 'tool2',+ description: 'Tool 2',+ parameters: {},+ },+ },+ });++ getAppConfig.mockResolvedValue({+ mcpConfig: {+ server1: {},+ },+ });++ const mockPlugin = {+ name: 'Tool 1',+ pluginKey: 'tool1~~~server1',+ description: 'Tool 1',+ };++ // First tool returns plugin, second returns null+ convertMCPToolToPlugin.mockReturnValueOnce(mockPlugin).mockReturnValueOnce(null);++ await getMCPTools(mockReq, mockRes);++ expect(mockRes.status).toHaveBeenCalledWith(200);+ expect(mockRes.json).toHaveBeenCalledWith([+ {+ ...mockPlugin,+ authConfig: [],+ authenticated: true,+ },+ ]);+ });++ it('should use req.config when available', async () => {+ const reqConfig = {+ mcpConfig: {+ server1: {},+ },+ };+ mockReq.config = reqConfig;++ getMCPServerTools.mockResolvedValue({+ 'tool1~~~server1': {+ type: 'function',+ function: {+ name: 'tool1',+ description: 'Tool 1',+ parameters: {},+ },+ },+ });++ const mockPlugin = {+ name: 'Tool 1',+ pluginKey: 'tool1~~~server1',+ description: 'Tool 1',+ };+ convertMCPToolToPlugin.mockReturnValue(mockPlugin);++ await getMCPTools(mockReq, mockRes);++ // Should not call getAppConfig when req.config is available+ expect(getAppConfig).not.toHaveBeenCalled();++ expect(mockRes.status).toHaveBeenCalledWith(200);+ expect(mockRes.json).toHaveBeenCalledWith([+ {+ ...mockPlugin,+ authConfig: [],+ authenticated: true,+ },+ ]);+ });++ it('should handle general error in getMCPTools', async () => {+ const error = new Error('Unexpected error');+ getAppConfig.mockRejectedValue(error);++ await getMCPTools(mockReq, mockRes);++ const { logger } = require('@librechat/data-schemas');+ expect(logger.error).toHaveBeenCalledWith('[getMCPTools]', error);+ expect(mockRes.status).toHaveBeenCalledWith(500);+ expect(mockRes.json).toHaveBeenCalledWith({ message: 'Unexpected error' });+ });++ it('should handle custom user variables without title or description', async () => {+ getMCPServerTools.mockResolvedValue({+ 'tool1~~~server1': {+ type: 'function',+ function: {+ name: 'tool1',+ description: 'Tool 1',+ parameters: {},+ },+ },+ });++ getAppConfig.mockResolvedValue({+ mcpConfig: {+ server1: {+ customUserVars: {+ MY_VAR: {+ // No title or description+ },+ },+ },+ },+ });++ const mockPlugin = {+ name: 'Tool 1',+ pluginKey: 'tool1~~~server1',+ description: 'Tool 1',+ };+ convertMCPToolToPlugin.mockReturnValue(mockPlugin);++ await getMCPTools(mockReq, mockRes);++ expect(mockRes.status).toHaveBeenCalledWith(200);+ expect(mockRes.json).toHaveBeenCalledWith([+ {+ ...mockPlugin,+ authConfig: [+ {+ authField: 'MY_VAR',+ label: 'MY_VAR', // Falls back to key+ description: '', // Empty string+ },+ ],+ authenticated: false,+ },+ ]);+ });++ it('should not cache when no tools are found for a server', async () => {+ getMCPServerTools.mockResolvedValue(null);++ const allTools = {+ 'tool1~~~otherserver': {+ type: 'function',+ function: {+ name: 'tool1',+ description: 'Tool 1',+ parameters: {},+ },+ },+ };++ mockMCPManager.getAllToolFunctions.mockResolvedValue(allTools);++ getAppConfig.mockResolvedValue({+ mcpConfig: {+ server1: {},+ },+ });++ await getMCPTools(mockReq, mockRes);++ const { cacheMCPServerTools } = require('~/server/services/Config');+ expect(cacheMCPServerTools).not.toHaveBeenCalled();++ expect(mockRes.status).toHaveBeenCalledWith(200);+ expect(mockRes.json).toHaveBeenCalledWith([]);+ });+ });+});diff --git a/api/server/routes/__tests__/mcp.spec.js b/api/server/routes/__tests__/mcp.spec.jsindex b572340c5f..1eb55224f5 100644--- a/api/server/routes/__tests__/mcp.spec.js+++ b/api/server/routes/__tests__/mcp.spec.js@@ -47,8 +47,8 @@ jest.mock('~/server/services/Config', () => ({loadCustomConfig: jest.fn(),}));-jest.mock('~/server/services/Config/mcpToolsCache', () => ({- updateMCPUserTools: jest.fn(),+jest.mock('~/server/services/Config/mcp', () => ({+ updateMCPServerTools: jest.fn(),}));jest.mock('~/server/services/MCP', () => ({@@ -778,10 +778,10 @@ describe('MCP Routes', () => {require('~/cache').getLogStores.mockReturnValue({});const { getCachedTools, setCachedTools } = require('~/server/services/Config');- const { updateMCPUserTools } = require('~/server/services/Config/mcpToolsCache');+ const { updateMCPServerTools } = require('~/server/services/Config/mcp');getCachedTools.mockResolvedValue({});setCachedTools.mockResolvedValue();- updateMCPUserTools.mockResolvedValue();+ updateMCPServerTools.mockResolvedValue();require('~/server/services/Tools/mcp').reinitMCPServer.mockResolvedValue({success: true,@@ -836,10 +836,10 @@ describe('MCP Routes', () => {]);const { getCachedTools, setCachedTools } = require('~/server/services/Config');- const { updateMCPUserTools } = require('~/server/services/Config/mcpToolsCache');+ const { updateMCPServerTools } = require('~/server/services/Config/mcp');getCachedTools.mockResolvedValue({});setCachedTools.mockResolvedValue();- updateMCPUserTools.mockResolvedValue();+ updateMCPServerTools.mockResolvedValue();require('~/server/services/Tools/mcp').reinitMCPServer.mockResolvedValue({success: true,diff --git a/api/server/routes/mcp.js b/api/server/routes/mcp.jsindex bff919158e..fa0166830b 100644--- a/api/server/routes/mcp.js+++ b/api/server/routes/mcp.js@@ -5,15 +5,24 @@ const { MCPOAuthHandler, getUserMCPAuthMap } = require('@librechat/api');const { getMCPManager, getFlowStateManager, getOAuthReconnectionManager } = require('~/config');const { getMCPSetupData, getServerConnectionStatus } = require('~/server/services/MCP');const { findToken, updateToken, createToken, deleteTokens } = require('~/models');-const { updateMCPUserTools } = require('~/server/services/Config/mcpToolsCache');const { getUserPluginAuthValue } = require('~/server/services/PluginService');+const { updateMCPServerTools } = require('~/server/services/Config/mcp');const { reinitMCPServer } = require('~/server/services/Tools/mcp');+const { getMCPTools } = require('~/server/controllers/mcp');const { requireJwtAuth } = require('~/server/middleware');const { findPluginAuthsByKeys } = require('~/models');const { getLogStores } = require('~/cache');const router = Router();+/**+ * Get all MCP tools available to the user+ * Returns only MCP tools, completely decoupled from regular LibreChat tools+ */+router.get('/tools', requireJwtAuth, async (req, res) => {+ return getMCPTools(req, res);+});+/*** Initiate OAuth flow* This endpoint is called when the user clicks the auth link in the UI@@ -149,8 +158,7 @@ router.get('/:serverName/oauth/callback', async (req, res) => {oauthReconnectionManager.clearReconnection(flowState.userId, serverName);const tools = await userConnection.fetchTools();- await updateMCPUserTools({- userId: flowState.userId,+ await updateMCPServerTools({serverName,tools,});diff --git a/api/server/services/Config/app.js b/api/server/services/Config/app.jsindex a5e771eff7..ec6af77432 100644--- a/api/server/services/Config/app.js+++ b/api/server/services/Config/app.js@@ -36,7 +36,7 @@ async function getAppConfig(options = {}) {}if (baseConfig.availableTools) {- await setCachedTools(baseConfig.availableTools, { isGlobal: true });+ await setCachedTools(baseConfig.availableTools);}await cache.set(BASE_CONFIG_KEY, baseConfig);diff --git a/api/server/services/Config/getCachedTools.js b/api/server/services/Config/getCachedTools.jsindex 669c179a8c..e33b2046a7 100644--- a/api/server/services/Config/getCachedTools.js+++ b/api/server/services/Config/getCachedTools.js@@ -3,89 +3,32 @@ const getLogStores = require('~/cache/getLogStores');/*** Cache key generators for different tool access patterns- * These will support future permission-based caching*/const ToolCacheKeys = {/** Global tools available to all users */GLOBAL: 'tools:global',- /** Tools available to a specific user */- USER: (userId) => `tools:user:${userId}`,- /** Tools available to a specific role */- ROLE: (roleId) => `tools:role:${roleId}`,- /** Tools available to a specific group */- GROUP: (groupId) => `tools:group:${groupId}`,- /** Combined effective tools for a user (computed from all sources) */- EFFECTIVE: (userId) => `tools:effective:${userId}`,+ /** MCP tools cached by server name */+ MCP_SERVER: (serverName) => `tools:mcp:${serverName}`,};/*** Retrieves available tools from cache* @function getCachedTools* @param {Object} options - Options for retrieving tools- * @param {string} [options.userId] - User ID for user-specific tools- * @param {string[]} [options.roleIds] - Role IDs for role-based tools- * @param {string[]} [options.groupIds] - Group IDs for group-based tools- * @param {boolean} [options.includeGlobal=true] - Whether to include global tools+ * @param {string} [options.serverName] - MCP server name to get cached tools for* @returns {Promise<LCAvailableTools|null>} The available tools object or null if not cached*/async function getCachedTools(options = {}) {const cache = getLogStores(CacheKeys.CONFIG_STORE);- const { userId, roleIds = [], groupIds = [], includeGlobal = true } = options;+ const { serverName } = options;- // For now, return global tools (current behavior)- // This will be expanded to merge tools from different sources- if (!userId && includeGlobal) {- return await cache.get(ToolCacheKeys.GLOBAL);+ // Return MCP server-specific tools if requested+ if (serverName) {+ return await cache.get(ToolCacheKeys.MCP_SERVER(serverName));}- // Future implementation will merge tools from multiple sources- // based on user permissions, roles, and groups- if (userId) {- /** @type {LCAvailableTools | null} Check if we have pre-computed effective tools for this user */- const effectiveTools = await cache.get(ToolCacheKeys.EFFECTIVE(userId));- if (effectiveTools) {- return effectiveTools;- }-- /** @type {LCAvailableTools | null} Otherwise, compute from individual sources */- const toolSources = [];-- if (includeGlobal) {- const globalTools = await cache.get(ToolCacheKeys.GLOBAL);- if (globalTools) {- toolSources.push(globalTools);- }- }-- // User-specific tools- const userTools = await cache.get(ToolCacheKeys.USER(userId));- if (userTools) {- toolSources.push(userTools);- }-- // Role-based tools- for (const roleId of roleIds) {- const roleTools = await cache.get(ToolCacheKeys.ROLE(roleId));- if (roleTools) {- toolSources.push(roleTools);- }- }-- // Group-based tools- for (const groupId of groupIds) {- const groupTools = await cache.get(ToolCacheKeys.GROUP(groupId));- if (groupTools) {- toolSources.push(groupTools);- }- }-- // Merge all tool sources (for now, simple merge - future will handle conflicts)- if (toolSources.length > 0) {- return mergeToolSources(toolSources);- }- }-- return null;+ // Default to global tools+ return await cache.get(ToolCacheKeys.GLOBAL);}/**@@ -93,49 +36,34 @@ async function getCachedTools(options = {}) {* @function setCachedTools* @param {Object} tools - The tools object to cache* @param {Object} options - Options for caching tools- * @param {string} [options.userId] - User ID for user-specific tools- * @param {string} [options.roleId] - Role ID for role-based tools- * @param {string} [options.groupId] - Group ID for group-based tools- * @param {boolean} [options.isGlobal=false] - Whether these are global tools+ * @param {string} [options.serverName] - MCP server name for server-specific tools* @param {number} [options.ttl] - Time to live in milliseconds* @returns {Promise<boolean>} Whether the operation was successful*/async function setCachedTools(tools, options = {}) {const cache = getLogStores(CacheKeys.CONFIG_STORE);- const { userId, roleId, groupId, isGlobal = false, ttl } = options;-- let cacheKey;- if (isGlobal || (!userId && !roleId && !groupId)) {- cacheKey = ToolCacheKeys.GLOBAL;- } else if (userId) {- cacheKey = ToolCacheKeys.USER(userId);- } else if (roleId) {- cacheKey = ToolCacheKeys.ROLE(roleId);- } else if (groupId) {- cacheKey = ToolCacheKeys.GROUP(groupId);- }+ const { serverName, ttl } = options;- if (!cacheKey) {- throw new Error('Invalid cache key options provided');+ // Cache by MCP server if specified+ if (serverName) {+ return await cache.set(ToolCacheKeys.MCP_SERVER(serverName), tools, ttl);}- return await cache.set(cacheKey, tools, ttl);+ // Default to global cache+ return await cache.set(ToolCacheKeys.GLOBAL, tools, ttl);}/*** Invalidates cached tools* @function invalidateCachedTools* @param {Object} options - Options for invalidating tools- * @param {string} [options.userId] - User ID to invalidate- * @param {string} [options.roleId] - Role ID to invalidate- * @param {string} [options.groupId] - Group ID to invalidate+ * @param {string} [options.serverName] - MCP server name to invalidate* @param {boolean} [options.invalidateGlobal=false] - Whether to invalidate global tools- * @param {boolean} [options.invalidateEffective=true] - Whether to invalidate effective tools* @returns {Promise<void>}*/async function invalidateCachedTools(options = {}) {const cache = getLogStores(CacheKeys.CONFIG_STORE);- const { userId, roleId, groupId, invalidateGlobal = false, invalidateEffective = true } = options;+ const { serverName, invalidateGlobal = false } = options;const keysToDelete = [];@@ -143,116 +71,45 @@ async function invalidateCachedTools(options = {}) {keysToDelete.push(ToolCacheKeys.GLOBAL);}- if (userId) {- keysToDelete.push(ToolCacheKeys.USER(userId));- if (invalidateEffective) {- keysToDelete.push(ToolCacheKeys.EFFECTIVE(userId));- }- }-- if (roleId) {- keysToDelete.push(ToolCacheKeys.ROLE(roleId));- // TODO: In future, invalidate all users with this role- }-- if (groupId) {- keysToDelete.push(ToolCacheKeys.GROUP(groupId));- // TODO: In future, invalidate all users in this group+ if (serverName) {+ keysToDelete.push(ToolCacheKeys.MCP_SERVER(serverName));}await Promise.all(keysToDelete.map((key) => cache.delete(key)));}/**- * Computes and caches effective tools for a user- * @function computeEffectiveTools- * @param {string} userId - The user ID- * @param {Object} context - Context containing user's roles and groups- * @param {string[]} [context.roleIds=[]] - User's role IDs- * @param {string[]} [context.groupIds=[]] - User's group IDs- * @param {number} [ttl] - Time to live for the computed result- * @returns {Promise<Object>} The computed effective tools+ * Gets MCP tools for a specific server from cache or merges with global tools+ * @function getMCPServerTools+ * @param {string} serverName - The MCP server name+ * @returns {Promise<LCAvailableTools|null>} The available tools for the server*/-async function computeEffectiveTools(userId, context = {}, ttl) {- const { roleIds = [], groupIds = [] } = context;-- // Get all tool sources- const tools = await getCachedTools({- userId,- roleIds,- groupIds,- includeGlobal: true,- });-- if (tools) {- // Cache the computed result- const cache = getLogStores(CacheKeys.CONFIG_STORE);- await cache.set(ToolCacheKeys.EFFECTIVE(userId), tools, ttl);- }-- return tools;-}--/**- * Merges multiple tool sources into a single tools object- * @function mergeToolSources- * @param {Object[]} sources - Array of tool objects to merge- * @returns {Object} Merged tools object- */-function mergeToolSources(sources) {- // For now, simple merge that combines all tools- // Future implementation will handle:- // - Permission precedence (deny > allow)- // - Tool property conflicts- // - Metadata merging- const merged = {};-- for (const source of sources) {- if (!source || typeof source !== 'object') {- continue;- }+async function getMCPServerTools(serverName) {+ const cache = getLogStores(CacheKeys.CONFIG_STORE);+ const serverTools = await cache.get(ToolCacheKeys.MCP_SERVER(serverName));- for (const [toolId, toolConfig] of Object.entries(source)) {- // Simple last-write-wins for now- // Future: merge based on permission levels- merged[toolId] = toolConfig;- }+ if (serverTools) {+ return serverTools;}- return merged;+ return null;}/*** Middleware-friendly function to get tools for a request* @function getToolsForRequest- * @param {Object} req - Express request object+ * @param {Object} [req] - Express request object* @returns {Promise<Object|null>} Available tools for the request*/-async function getToolsForRequest(req) {- const userId = req.user?.id;-- // For now, return global tools if no user- if (!userId) {- return getCachedTools({ includeGlobal: true });- }-- // Future: Extract roles and groups from req.user- const roleIds = req.user?.roles || [];- const groupIds = req.user?.groups || [];-- return getCachedTools({- userId,- roleIds,- groupIds,- includeGlobal: true,- });+async function getToolsForRequest(_req) {+ return getCachedTools();}module.exports = {ToolCacheKeys,getCachedTools,setCachedTools,+ getMCPServerTools,getToolsForRequest,invalidateCachedTools,- computeEffectiveTools,};diff --git a/api/server/services/Config/index.js b/api/server/services/Config/index.jsindex f1767ddec1..63c9108c92 100644--- a/api/server/services/Config/index.js+++ b/api/server/services/Config/index.js@@ -1,7 +1,7 @@const appConfig = require('./app');+const mcpToolsCache = require('./mcp');const { config } = require('./EndpointService');const getCachedTools = require('./getCachedTools');-const mcpToolsCache = require('./mcpToolsCache');const loadCustomConfig = require('./loadCustomConfig');const loadConfigModels = require('./loadConfigModels');const loadDefaultModels = require('./loadDefaultModels');diff --git a/api/server/services/Config/mcpToolsCache.js b/api/server/services/Config/mcp.jssimilarity index 56%rename from api/server/services/Config/mcpToolsCache.jsrename to api/server/services/Config/mcp.jsindex d335868d8c..aab2edf3c2 100644--- a/api/server/services/Config/mcpToolsCache.js+++ b/api/server/services/Config/mcp.js@@ -4,27 +4,20 @@ const { getCachedTools, setCachedTools } = require('./getCachedTools');const { getLogStores } = require('~/cache');/**- * Updates MCP tools in the cache for a specific server and user+ * Updates MCP tools in the cache for a specific server* @param {Object} params - Parameters for updating MCP tools- * @param {string} params.userId - User ID* @param {string} params.serverName - MCP server name* @param {Array} params.tools - Array of tool objects from MCP server* @returns {Promise<LCAvailableTools>}*/-async function updateMCPUserTools({ userId, serverName, tools }) {+async function updateMCPServerTools({ serverName, tools }) {try {- const userTools = await getCachedTools({ userId });-+ const serverTools = {};const mcpDelimiter = Constants.mcp_delimiter;- for (const key of Object.keys(userTools)) {- if (key.endsWith(`${mcpDelimiter}${serverName}`)) {- delete userTools[key];- }- }for (const tool of tools) {- const name = `${tool.name}${Constants.mcp_delimiter}${serverName}`;- userTools[name] = {+ const name = `${tool.name}${mcpDelimiter}${serverName}`;+ serverTools[name] = {type: 'function',['function']: {name,@@ -34,12 +27,12 @@ async function updateMCPUserTools({ userId, serverName, tools }) {};}- await setCachedTools(userTools, { userId });+ await setCachedTools(serverTools, { serverName });const cache = getLogStores(CacheKeys.CONFIG_STORE);await cache.delete(CacheKeys.TOOLS);- logger.debug(`[MCP Cache] Updated ${tools.length} tools for ${serverName} user ${userId}`);- return userTools;+ logger.debug(`[MCP Cache] Updated ${tools.length} tools for server ${serverName}`);+ return serverTools;} catch (error) {logger.error(`[MCP Cache] Failed to update tools for ${serverName}:`, error);throw error;@@ -57,9 +50,9 @@ async function mergeAppTools(appTools) {if (!count) {return;}- const cachedTools = await getCachedTools({ includeGlobal: true });+ const cachedTools = await getCachedTools();const mergedTools = { ...cachedTools, ...appTools };- await setCachedTools(mergedTools, { isGlobal: true });+ await setCachedTools(mergedTools);const cache = getLogStores(CacheKeys.CONFIG_STORE);await cache.delete(CacheKeys.TOOLS);logger.debug(`Merged ${count} app-level tools`);@@ -70,30 +63,23 @@ async function mergeAppTools(appTools) {}/**- * Merges user-level tools with global tools+ * Caches MCP server tools (no longer merges with global)* @param {object} params- * @param {string} params.userId- * @param {Record<string, FunctionTool>} params.cachedUserTools- * @param {import('@librechat/api').LCAvailableTools} params.userTools+ * @param {string} params.serverName+ * @param {import('@librechat/api').LCAvailableTools} params.serverTools* @returns {Promise<void>}*/-async function mergeUserTools({ userId, cachedUserTools, userTools }) {+async function cacheMCPServerTools({ serverName, serverTools }) {try {- if (!userId) {- return;- }- const count = Object.keys(userTools).length;+ const count = Object.keys(serverTools).length;if (!count) {return;}- const cachedTools = cachedUserTools ?? (await getCachedTools({ userId }));- const mergedTools = { ...cachedTools, ...userTools };- await setCachedTools(mergedTools, { userId });- const cache = getLogStores(CacheKeys.CONFIG_STORE);- await cache.delete(CacheKeys.TOOLS);- logger.debug(`Merged ${count} user-level tools`);+ // Only cache server-specific tools, no merging with global+ await setCachedTools(serverTools, { serverName });+ logger.debug(`Cached ${count} MCP server tools for ${serverName}`);} catch (error) {- logger.error('Failed to merge user-level tools:', error);+ logger.error(`Failed to cache MCP server tools for ${serverName}:`, error);throw error;}}@@ -101,13 +87,12 @@ async function mergeUserTools({ userId, cachedUserTools, userTools }) {/*** Clears all MCP tools for a specific server* @param {Object} params - Parameters for clearing MCP tools- * @param {string} [params.userId] - User ID (if clearing user-specific tools)* @param {string} params.serverName - MCP server name* @returns {Promise<void>}*/-async function clearMCPServerTools({ userId, serverName }) {+async function clearMCPServerTools({ serverName }) {try {- const tools = await getCachedTools({ userId, includeGlobal: !userId });+ const tools = await getCachedTools();// Remove all tools for this serverconst mcpDelimiter = Constants.mcp_delimiter;@@ -120,14 +105,14 @@ async function clearMCPServerTools({ userId, serverName }) {}if (removedCount > 0) {- await setCachedTools(tools, userId ? { userId } : { isGlobal: true });+ await setCachedTools(tools);const cache = getLogStores(CacheKeys.CONFIG_STORE);await cache.delete(CacheKeys.TOOLS);+ // Also clear the server-specific cache+ await cache.delete(`tools:mcp:${serverName}`);- logger.debug(- `[MCP Cache] Removed ${removedCount} tools for ${serverName}${userId ? ` user ${userId}` : ' (global)'}`,- );+ logger.debug(`[MCP Cache] Removed ${removedCount} tools for ${serverName} (global)`);}} catch (error) {logger.error(`[MCP Cache] Failed to clear tools for ${serverName}:`, error);@@ -137,7 +122,7 @@ async function clearMCPServerTools({ userId, serverName }) {module.exports = {mergeAppTools,- mergeUserTools,- updateMCPUserTools,+ cacheMCPServerTools,clearMCPServerTools,+ updateMCPServerTools,};diff --git a/api/server/services/Tools/mcp.js b/api/server/services/Tools/mcp.jsindex 069447e3b8..c9c369868e 100644--- a/api/server/services/Tools/mcp.js+++ b/api/server/services/Tools/mcp.js@@ -2,7 +2,7 @@ const { logger } = require('@librechat/data-schemas');const { CacheKeys, Constants } = require('librechat-data-provider');const { findToken, createToken, updateToken, deleteTokens } = require('~/models');const { getMCPManager, getFlowStateManager } = require('~/config');-const { updateMCPUserTools } = require('~/server/services/Config');+const { updateMCPServerTools } = require('~/server/services/Config');const { getLogStores } = require('~/cache');/**@@ -97,8 +97,7 @@ async function reinitMCPServer({if (userConnection && !oauthRequired) {tools = await userConnection.fetchTools();- availableTools = await updateMCPUserTools({- userId: req.user.id,+ availableTools = await updateMCPServerTools({serverName,tools,});diff --git a/client/src/Providers/AgentPanelContext.tsx b/client/src/Providers/AgentPanelContext.tsxindex 135066c784..e97e25403b 100644--- a/client/src/Providers/AgentPanelContext.tsx+++ b/client/src/Providers/AgentPanelContext.tsx@@ -1,14 +1,16 @@import React, { createContext, useContext, useState, useMemo } from 'react';import { Constants, EModelEndpoint } from 'librechat-data-provider';-import type { MCP, Action, TPlugin, AgentToolType } from 'librechat-data-provider';+import type { MCP, Action, TPlugin } from 'librechat-data-provider';import type { AgentPanelContextType, MCPServerInfo } from '~/common';-import { useAvailableToolsQuery, useGetActionsQuery, useGetStartupConfig } from '~/data-provider';+import {+ useAvailableToolsQuery,+ useGetActionsQuery,+ useGetStartupConfig,+ useMCPToolsQuery,+} from '~/data-provider';import { useLocalize, useGetAgentsConfig, useMCPConnectionStatus } from '~/hooks';import { Panel } from '~/common';-type GroupedToolType = AgentToolType & { tools?: AgentToolType[] };-type GroupedToolsRecord = Record<string, GroupedToolType>;-const AgentPanelContext = createContext<AgentPanelContextType | undefined>(undefined);export function useAgentPanelContext() {@@ -32,11 +34,16 @@ export function AgentPanelProvider({ children }: { children: React.ReactNode })enabled: !!agent_id,});- const { data: pluginTools } = useAvailableToolsQuery(EModelEndpoint.agents, {+ const { data: regularTools } = useAvailableToolsQuery(EModelEndpoint.agents, {+ enabled: !!agent_id,+ });++ const { data: mcpTools } = useMCPToolsQuery({enabled: !!agent_id,});const { data: startupConfig } = useGetStartupConfig();+ const { agentsConfig, endpointsConfig } = useGetAgentsConfig();const mcpServerNames = useMemo(() => Object.keys(startupConfig?.mcpServers ?? {}),[startupConfig],@@ -46,61 +53,43 @@ export function AgentPanelProvider({ children }: { children: React.ReactNode })enabled: !!agent_id && mcpServerNames.length > 0,});- const processedData = useMemo(() => {- if (!pluginTools) {- return {- tools: [],- groupedTools: {},- mcpServersMap: new Map<string, MCPServerInfo>(),- };- }-- const tools: AgentToolType[] = [];- const groupedTools: GroupedToolsRecord = {};-+ const mcpServersMap = useMemo(() => {const configuredServers = new Set(mcpServerNames);- const mcpServersMap = new Map<string, MCPServerInfo>();-- for (const pluginTool of pluginTools) {- const tool: AgentToolType = {- tool_id: pluginTool.pluginKey,- metadata: pluginTool as TPlugin,- };-- tools.push(tool);-- if (tool.tool_id.includes(Constants.mcp_delimiter)) {- const [_toolName, serverName] = tool.tool_id.split(Constants.mcp_delimiter);-- if (!mcpServersMap.has(serverName)) {- const metadata = {- name: serverName,- pluginKey: serverName,- description: `${localize('com_ui_tool_collection_prefix')} ${serverName}`,- icon: pluginTool.icon || '',- } as TPlugin;-- mcpServersMap.set(serverName, {- serverName,- tools: [],- isConfigured: configuredServers.has(serverName),- isConnected: connectionStatus?.[serverName]?.connectionState === 'connected',- metadata,+ const serversMap = new Map<string, MCPServerInfo>();++ if (mcpTools) {+ for (const pluginTool of mcpTools) {+ if (pluginTool.pluginKey.includes(Constants.mcp_delimiter)) {+ const [_toolName, serverName] = pluginTool.pluginKey.split(Constants.mcp_delimiter);++ if (!serversMap.has(serverName)) {+ const metadata = {+ name: serverName,+ pluginKey: serverName,+ description: `${localize('com_ui_tool_collection_prefix')} ${serverName}`,+ icon: pluginTool.icon || '',+ } as TPlugin;++ serversMap.set(serverName, {+ serverName,+ tools: [],+ isConfigured: configuredServers.has(serverName),+ isConnected: connectionStatus?.[serverName]?.connectionState === 'connected',+ metadata,+ });+ }++ serversMap.get(serverName)!.tools.push({+ tool_id: pluginTool.pluginKey,+ metadata: pluginTool as TPlugin,});}-- mcpServersMap.get(serverName)!.tools.push(tool);- } else {- // Non-MCP tool- groupedTools[tool.tool_id] = {- tool_id: tool.tool_id,- metadata: tool.metadata,- };}}+ // Add configured servers that don't have tools yetfor (const mcpServerName of mcpServerNames) {- if (mcpServersMap.has(mcpServerName)) {+ if (serversMap.has(mcpServerName)) {continue;}const metadata = {@@ -110,7 +99,7 @@ export function AgentPanelProvider({ children }: { children: React.ReactNode })description: `${localize('com_ui_tool_collection_prefix')} ${mcpServerName}`,} as TPlugin;- mcpServersMap.set(mcpServerName, {+ serversMap.set(mcpServerName, {tools: [],metadata,isConfigured: true,@@ -119,14 +108,8 @@ export function AgentPanelProvider({ children }: { children: React.ReactNode })});}- return {- tools,- groupedTools,- mcpServersMap,- };- }, [pluginTools, localize, mcpServerNames, connectionStatus]);-- const { agentsConfig, endpointsConfig } = useGetAgentsConfig();+ return serversMap;+ }, [mcpTools, localize, mcpServerNames, connectionStatus]);const value: AgentPanelContextType = {mcp,@@ -137,16 +120,15 @@ export function AgentPanelProvider({ children }: { children: React.ReactNode })setMcps,agent_id,setAction,- pluginTools,+ mcpTools,activePanel,+ regularTools,agentsConfig,startupConfig,+ mcpServersMap,setActivePanel,endpointsConfig,setCurrentAgentId,- tools: processedData.tools,- groupedTools: processedData.groupedTools,- mcpServersMap: processedData.mcpServersMap,};return <AgentPanelContext.Provider value={value}>{children}</AgentPanelContext.Provider>;diff --git a/client/src/common/types.ts b/client/src/common/types.tsindex 5ea6ad6bba..211c7a7a7d 100644--- a/client/src/common/types.ts+++ b/client/src/common/types.ts@@ -232,10 +232,9 @@ export type AgentPanelContextType = {mcps?: t.MCP[];setMcp: React.Dispatch<React.SetStateAction<t.MCP | undefined>>;setMcps: React.Dispatch<React.SetStateAction<t.MCP[] | undefined>>;- groupedTools: Record<string, t.AgentToolType & { tools?: t.AgentToolType[] }>;activePanel?: string;- tools: t.AgentToolType[];- pluginTools?: t.TPlugin[];+ regularTools?: t.TPlugin[];+ mcpTools?: t.TPlugin[];setActivePanel: React.Dispatch<React.SetStateAction<Panel>>;setCurrentAgentId: React.Dispatch<React.SetStateAction<string | undefined>>;agent_id?: string;diff --git a/client/src/components/SidePanel/Agents/AgentConfig.tsx b/client/src/components/SidePanel/Agents/AgentConfig.tsxindex 7f296fe8c3..dcb047374c 100644--- a/client/src/components/SidePanel/Agents/AgentConfig.tsx+++ b/client/src/components/SidePanel/Agents/AgentConfig.tsx@@ -48,12 +48,12 @@ export default function AgentConfig({ createMutation }: Pick<AgentPanelProps, 'cconst {actions,setAction,+ regularTools,agentsConfig,startupConfig,mcpServersMap,setActivePanel,endpointsConfig,- groupedTools: allTools,} = useAgentPanelContext();const {@@ -177,7 +177,7 @@ export default function AgentConfig({ createMutation }: Pick<AgentPanelProps, 'cIcon = icons[iconKey];}- const { toolIds, mcpServerNames } = useVisibleTools(tools, allTools, mcpServersMap);+ const { toolIds, mcpServerNames } = useVisibleTools(tools, regularTools, mcpServersMap);return (<>@@ -326,16 +326,15 @@ export default function AgentConfig({ createMutation }: Pick<AgentPanelProps, 'c</label><div><div className="mb-1">- {/* Render all visible IDs (including groups with subtools selected) */}+ {/* Render all visible IDs */}{toolIds.map((toolId, i) => {- if (!allTools) return null;- const tool = allTools[toolId];+ const tool = regularTools?.find((t) => t.pluginKey === toolId);if (!tool) return null;return (<AgentToolkey={`${toolId}-${i}-${agent_id}`}tool={toolId}- allTools={allTools}+ regularTools={regularTools}agent_id={agent_id}/>);diff --git a/client/src/components/SidePanel/Agents/AgentTool.tsx b/client/src/components/SidePanel/Agents/AgentTool.tsxindex 07857c7be0..5685506fe2 100644--- a/client/src/components/SidePanel/Agents/AgentTool.tsx+++ b/client/src/components/SidePanel/Agents/AgentTool.tsx@@ -1,68 +1,47 @@import React, { useState } from 'react';-import * as Ariakit from '@ariakit/react';-import { ChevronDown } from 'lucide-react';import { useFormContext } from 'react-hook-form';-import * as AccordionPrimitive from '@radix-ui/react-accordion';import { useUpdateUserPluginsMutation } from 'librechat-data-provider/react-query';import {- Accordion,- AccordionItem,- AccordionContent,+ OGDialog,TrashIcon,CircleHelpIcon,- OGDialog,+ useToastContext,OGDialogTrigger,- Label,- Checkbox,OGDialogTemplate,- useToastContext,} from '@librechat/client';-import type { AgentToolType } from 'librechat-data-provider';+import type { TPlugin } from 'librechat-data-provider';import type { AgentForm } from '~/common';import { useLocalize } from '~/hooks';import { cn } from '~/utils';export default function AgentTool({tool,- allTools,+ regularTools,}: {tool: string;- allTools?: Record<string, AgentToolType & { tools?: AgentToolType[] }>;+ regularTools?: TPlugin[];agent_id?: string;}) {- const [isHovering, setIsHovering] = useState(false);- const [isFocused, setIsFocused] = useState(false);- const [hoveredToolId, setHoveredToolId] = useState<string | null>(null);- const [accordionValue, setAccordionValue] = useState<string>('');const localize = useLocalize();const { showToast } = useToastContext();const updateUserPlugins = useUpdateUserPluginsMutation();const { getValues, setValue } = useFormContext<AgentForm>();- if (!allTools) {++ const [isFocused, setIsFocused] = useState(false);+ const [isHovering, setIsHovering] = useState(false);++ if (!regularTools) {return null;}- const currentTool = allTools[tool];- const getSelectedTools = () => {- if (!currentTool?.tools) return [];- const formTools = getValues('tools') || [];- return currentTool.tools.filter((t) => formTools.includes(t.tool_id)).map((t) => t.tool_id);- };- const updateFormTools = (newSelectedTools: string[]) => {- const currentTools = getValues('tools') || [];- const otherTools = currentTools.filter(- (t: string) => !currentTool?.tools?.some((st) => st.tool_id === t),- );- setValue('tools', [...otherTools, ...newSelectedTools]);- };+ const currentTool = regularTools.find((t) => t.pluginKey === tool);++ if (!currentTool) {+ return null;+ }const removeTool = (toolId: string) => {if (toolId) {- const toolIdsToRemove =- isGroup && currentTool.tools- ? [toolId, ...currentTool.tools.map((t) => t.tool_id)]- : [toolId];-updateUserPlugins.mutate({ pluginKey: toolId, action: 'uninstall', auth: {}, isEntityTool: true },{@@ -70,9 +49,7 @@ export default function AgentTool({showToast({ message: `Error while deleting the tool: ${error}`, status: 'error' });},onSuccess: () => {- const remainingToolIds = getValues('tools')?.filter(- (toolId: string) => !toolIdsToRemove.includes(toolId),- );+ const remainingToolIds = getValues('tools')?.filter((id: string) => id !== toolId);setValue('tools', remainingToolIds);showToast({ message: 'Tool deleted successfully', status: 'success' });},@@ -81,327 +58,82 @@ export default function AgentTool({}};- if (!currentTool) {- return null;- }-- const isGroup = currentTool.tools && currentTool.tools.length > 0;- const selectedTools = getSelectedTools();- const isExpanded = accordionValue === currentTool.tool_id;-- if (!isGroup) {- return (- <OGDialog>- <div- className="group relative flex w-full items-center gap-1 rounded-lg p-1 text-sm hover:bg-gray-50 dark:hover:bg-gray-800/50"- onMouseEnter={() => setIsHovering(true)}- onMouseLeave={() => setIsHovering(false)}- onFocus={() => setIsFocused(true)}- onBlur={(e) => {- // Check if focus is moving to a child element- if (!e.currentTarget.contains(e.relatedTarget)) {- setIsFocused(false);- }- }}- >- <div className="flex grow items-center">- {currentTool.metadata.icon && (- <div className="flex h-8 w-8 items-center justify-center overflow-hidden rounded-full">- <div- className="flex h-6 w-6 items-center justify-center overflow-hidden rounded-full bg-center bg-no-repeat dark:bg-white/20"- style={{- backgroundImage: `url(${currentTool.metadata.icon})`,- backgroundSize: 'cover',- }}- />- </div>- )}- <div- className="grow px-2 py-1.5"- style={{ textOverflow: 'ellipsis', wordBreak: 'break-all', overflow: 'hidden' }}- >- {currentTool.metadata.name}- </div>- </div>-- <OGDialogTrigger asChild>- <button- type="button"- className={cn(- 'flex h-7 w-7 items-center justify-center rounded transition-all duration-200',- 'hover:bg-gray-200 dark:hover:bg-gray-700',- 'focus:outline-none focus:ring-2 focus:ring-ring focus:ring-offset-1',- 'focus:opacity-100',- isHovering || isFocused ? 'opacity-100' : 'pointer-events-none opacity-0',- )}- aria-label={`Delete ${currentTool.metadata.name}`}- tabIndex={0}- onFocus={() => setIsFocused(true)}- >- <TrashIcon className="h-4 w-4" />- </button>- </OGDialogTrigger>- </div>- <OGDialogTemplate- showCloseButton={false}- title={localize('com_ui_delete_tool')}- mainClassName="px-0"- className="max-w-[450px]"- main={- <Label className="text-left text-sm font-medium">- {localize('com_ui_delete_tool_confirm')}- </Label>- }- selection={{- selectHandler: () => removeTool(currentTool.tool_id),- selectClasses:- 'bg-red-700 dark:bg-red-600 hover:bg-red-800 dark:hover:bg-red-800 transition-color duration-200 text-white',- selectText: localize('com_ui_delete'),- }}- />- </OGDialog>- );- }-- // Group tool with accordionreturn (<OGDialog>- <Accordion type="single" value={accordionValue} onValueChange={setAccordionValue} collapsible>- <AccordionItem value={currentTool.tool_id} className="group relative w-full border-none">+ <div+ className="group relative flex w-full items-center gap-1 rounded-lg p-1 text-sm hover:bg-gray-50 dark:hover:bg-gray-800/50"+ onMouseEnter={() => setIsHovering(true)}+ onMouseLeave={() => setIsHovering(false)}+ onFocus={() => setIsFocused(true)}+ onBlur={(e) => {+ // Check if focus is moving to a child element+ if (!e.currentTarget.contains(e.relatedTarget)) {+ setIsFocused(false);+ }+ }}+ >+ <div className="flex grow items-center">+ {currentTool.icon && (+ <div className="flex h-8 w-8 items-center justify-center overflow-hidden rounded-full">+ <div+ className="flex h-6 w-6 items-center justify-center overflow-hidden rounded-full bg-center bg-no-repeat dark:bg-white/20"+ style={{+ backgroundImage: `url(${currentTool.icon})`,+ backgroundSize: 'cover',+ }}+ />+ </div>+ )}<div- className="relative flex w-full items-center gap-1 rounded-lg p-1 hover:bg-gray-50 dark:hover:bg-gray-800/50"- onMouseEnter={() => setIsHovering(true)}- onMouseLeave={() => setIsHovering(false)}- onFocus={() => setIsFocused(true)}- onBlur={(e) => {- // Check if focus is moving to a child element- if (!e.currentTarget.contains(e.relatedTarget)) {- setIsFocused(false);- }- }}+ className="grow px-2 py-1.5"+ style={{ textOverflow: 'ellipsis', wordBreak: 'break-all', overflow: 'hidden' }}>- <AccordionPrimitive.Header asChild>- <AccordionPrimitive.Trigger asChild>- <button- type="button"- className={cn(- 'flex grow items-center gap-1 rounded bg-transparent p-0 text-left transition-colors',- 'focus:outline-none focus:ring-2 focus:ring-ring focus:ring-offset-1',- )}- >- {currentTool.metadata.icon && (- <div className="flex h-8 w-8 items-center justify-center overflow-hidden rounded-full">- <div- className="flex h-6 w-6 items-center justify-center overflow-hidden rounded-full bg-center bg-no-repeat dark:bg-white/20"- style={{- backgroundImage: `url(${currentTool.metadata.icon})`,- backgroundSize: 'cover',- }}- />- </div>- )}- <div- className="grow px-2 py-1.5"- style={{ textOverflow: 'ellipsis', wordBreak: 'break-all', overflow: 'hidden' }}- >- {currentTool.metadata.name}- </div>- <div className="flex items-center">- {/* Container for grouped checkbox and chevron */}- <div className="relative flex items-center">- {/* Grouped checkbox and chevron that slide together */}- <div- className={cn(- 'flex items-center gap-2 transition-all duration-300',- isHovering || isFocused ? '-translate-x-8' : 'translate-x-0',- )}- >- <div- data-checkbox-container- onClick={(e) => e.stopPropagation()}- className="mt-1"- >- <Checkbox- id={`select-all-${currentTool.tool_id}`}- checked={selectedTools.length === currentTool.tools?.length}- onCheckedChange={(checked) => {- if (currentTool.tools) {- const newSelectedTools = checked- ? currentTool.tools.map((t) => t.tool_id)- : [];- updateFormTools(newSelectedTools);- }- }}- className={cn(- 'h-4 w-4 rounded border border-gray-300 transition-all duration-200 hover:border-gray-400 dark:border-gray-600 dark:hover:border-gray-500',- isExpanded ? 'visible' : 'pointer-events-none invisible',- )}- onClick={(e) => e.stopPropagation()}- onKeyDown={(e) => {- if (e.key === 'Enter' || e.key === ' ') {- e.preventDefault();- e.stopPropagation();- const checkbox = e.currentTarget as HTMLButtonElement;- checkbox.click();- }- }}- tabIndex={isExpanded ? 0 : -1}- />- </div>-- <div- className={cn(- 'pointer-events-none flex h-4 w-4 items-center justify-center transition-transform duration-300',- isExpanded ? 'rotate-180' : '',- )}- aria-hidden="true"- >- <ChevronDown className="h-4 w-4" />- </div>- </div>-- {/* Delete button slides in from behind */}- <div- className={cn(- 'absolute right-0 transition-all duration-300',- isHovering || isFocused- ? 'translate-x-0 opacity-100'- : 'translate-x-8 opacity-0',- )}- >- <OGDialogTrigger asChild>- <button- type="button"- className={cn(- 'flex h-7 w-7 items-center justify-center rounded transition-colors duration-200',- 'hover:bg-gray-200 dark:hover:bg-gray-700',- 'focus:outline-none focus:ring-2 focus:ring-ring focus:ring-offset-1',- 'focus:translate-x-0 focus:opacity-100',- )}- onClick={(e) => e.stopPropagation()}- aria-label={`Delete ${currentTool.metadata.name}`}- tabIndex={0}- onFocus={() => setIsFocused(true)}- >- <TrashIcon className="h-4 w-4" />- </button>- </OGDialogTrigger>- </div>- </div>- </div>- </button>- </AccordionPrimitive.Trigger>- </AccordionPrimitive.Header>+ {currentTool.name}</div>+ </div>- <AccordionContent className="relative ml-1 pt-1 before:absolute before:bottom-2 before:left-0 before:top-0 before:w-0.5 before:bg-border-medium">- <div className="space-y-1">- {currentTool.tools?.map((subTool) => (- <label- key={subTool.tool_id}- htmlFor={subTool.tool_id}- className={cn(- 'border-token-border-light hover:bg-token-surface-secondary flex cursor-pointer items-center rounded-lg border p-2',- 'ml-2 mr-1 focus-within:ring-2 focus-within:ring-ring focus-within:ring-offset-2 focus-within:ring-offset-background',- )}- onClick={(e) => e.stopPropagation()}- onKeyDown={(e) => {- e.stopPropagation();- }}- onMouseEnter={() => setHoveredToolId(subTool.tool_id)}- onMouseLeave={() => setHoveredToolId(null)}- >- <Checkbox- id={subTool.tool_id}- checked={selectedTools.includes(subTool.tool_id)}- onCheckedChange={(_checked) => {- const newSelectedTools = selectedTools.includes(subTool.tool_id)- ? selectedTools.filter((t) => t !== subTool.tool_id)- : [...selectedTools, subTool.tool_id];- updateFormTools(newSelectedTools);- }}- onKeyDown={(e) => {- e.stopPropagation();- if (e.key === 'Enter' || e.key === ' ') {- e.preventDefault();- const checkbox = e.currentTarget as HTMLButtonElement;- checkbox.click();- }- }}- onClick={(e) => e.stopPropagation()}- className="relative float-left mr-2 inline-flex h-4 w-4 cursor-pointer rounded border border-gray-300 transition-[border-color] duration-200 hover:border-gray-400 focus:outline-none focus:ring-2 focus:ring-ring focus:ring-offset-2 focus:ring-offset-background dark:border-gray-600 dark:hover:border-gray-500"- />- <span className="text-token-text-primary">{subTool.metadata.name}</span>- {subTool.metadata.description && (- <Ariakit.HovercardProvider placement="left-start">- <div className="ml-auto flex h-6 w-6 items-center justify-center">- <Ariakit.HovercardAnchor- render={- <Ariakit.Button- className={cn(- 'flex h-5 w-5 cursor-help items-center rounded-full text-text-secondary transition-opacity duration-200',- hoveredToolId === subTool.tool_id ? 'opacity-100' : 'opacity-0',- )}- aria-label={localize('com_ui_tool_info')}- >- <CircleHelpIcon className="h-4 w-4" />- <Ariakit.VisuallyHidden>- {localize('com_ui_tool_info')}- </Ariakit.VisuallyHidden>- </Ariakit.Button>- }- />- <Ariakit.HovercardDisclosure- className="rounded-full text-text-secondary focus:outline-none focus:ring-2 focus:ring-ring"- aria-label={localize('com_ui_tool_more_info')}- aria-expanded={hoveredToolId === subTool.tool_id}- aria-controls={`tool-description-${subTool.tool_id}`}- >- <Ariakit.VisuallyHidden>- {localize('com_ui_tool_more_info')}- </Ariakit.VisuallyHidden>- <ChevronDown className="h-4 w-4" />- </Ariakit.HovercardDisclosure>- </div>- <Ariakit.Hovercard- id={`tool-description-${subTool.tool_id}`}- gutter={14}- shift={40}- flip={false}- className="z-[999] w-80 scale-95 rounded-2xl border border-border-medium bg-surface-secondary p-4 text-text-primary opacity-0 shadow-md transition-all duration-200 data-[enter]:scale-100 data-[leave]:scale-95 data-[enter]:opacity-100 data-[leave]:opacity-0"- portal={true}- unmountOnHide={true}- role="tooltip"- aria-label={subTool.metadata.description}- >- <div className="space-y-2">- <p className="text-sm text-text-secondary">- {subTool.metadata.description}- </p>- </div>- </Ariakit.Hovercard>- </Ariakit.HovercardProvider>- )}- </label>- ))}- </div>- </AccordionContent>- </AccordionItem>- </Accordion>+ <OGDialogTrigger asChild>+ <button+ type="button"+ className={cn(+ 'flex h-7 w-7 items-center justify-center rounded transition-all duration-200',+ 'hover:bg-gray-200 dark:hover:bg-gray-700',+ 'focus:outline-none focus:ring-2 focus:ring-ring focus:ring-offset-1',+ 'focus:opacity-100',+ isHovering || isFocused ? 'opacity-100' : 'pointer-events-none opacity-0',+ )}+ aria-label={`Delete ${currentTool.name}`}+ tabIndex={0}+ onFocus={() => setIsFocused(true)}+ >+ <TrashIcon className="h-4 w-4" />+ </button>+ </OGDialogTrigger>+ </div><OGDialogTemplateshowCloseButton={false}title={localize('com_ui_delete_tool')}- mainClassName="px-0"className="max-w-[450px]"main={- <Label className="text-left text-sm font-medium">- {localize('com_ui_delete_tool_confirm')}- </Label>+ <>+ <div className="flex w-full flex-col items-start gap-2 text-sm text-text-secondary">+ <p>+ {localize('com_ui_delete_tool_confirm')}{' '}+ <strong>"{currentTool.name}"</strong>?+ </p>+ {currentTool.description && (+ <div className="flex items-start gap-2">+ <CircleHelpIcon className="h-4 w-4 flex-shrink-0 text-text-secondary" />+ <p className="text-sm">{currentTool.description}</p>+ </div>+ )}+ </div>+ </>}selection={{- selectHandler: () => removeTool(currentTool.tool_id),+ selectHandler: () => removeTool(tool),selectClasses:- 'bg-red-700 dark:bg-red-600 hover:bg-red-800 dark:hover:bg-red-800 transition-color duration-200 text-white',+ 'bg-red-700 hover:bg-red-800 dark:bg-red-600 dark:hover:bg-red-800 text-white',selectText: localize('com_ui_delete'),}}/>diff --git a/client/src/components/SidePanel/MCP/MCPPanel.tsx b/client/src/components/SidePanel/MCP/MCPPanel.tsxindex adcb81e0e5..5bb6d18b81 100644--- a/client/src/components/SidePanel/MCP/MCPPanel.tsx+++ b/client/src/components/SidePanel/MCP/MCPPanel.tsx@@ -56,7 +56,7 @@ function MCPPanelContent() {showToast({ message: localize('com_nav_mcp_vars_updated'), status: 'success' });await Promise.all([- queryClient.refetchQueries([QueryKeys.tools]),+ queryClient.refetchQueries([QueryKeys.mcpTools]),queryClient.refetchQueries([QueryKeys.mcpAuthValues]),queryClient.refetchQueries([QueryKeys.mcpConnectionStatus]),]);diff --git a/client/src/components/Tools/MCPToolSelectDialog.tsx b/client/src/components/Tools/MCPToolSelectDialog.tsxindex 268cd38641..62710d032c 100644--- a/client/src/components/Tools/MCPToolSelectDialog.tsx+++ b/client/src/components/Tools/MCPToolSelectDialog.tsx@@ -7,8 +7,8 @@ import { useUpdateUserPluginsMutation } from 'librechat-data-provider/react-querimport type { TError, AgentToolType } from 'librechat-data-provider';import type { AgentForm, TPluginStoreDialogProps } from '~/common';import { useLocalize, usePluginDialogHelpers, useMCPServerManager } from '~/hooks';-import { useGetStartupConfig, useAvailableToolsQuery } from '~/data-provider';import CustomUserVarsSection from '~/components/MCP/CustomUserVarsSection';+import { useGetStartupConfig, useMCPToolsQuery } from '~/data-provider';import { PluginPagination } from '~/components/Plugins/Store';import { useAgentPanelContext } from '~/Providers';import MCPToolItem from './MCPToolItem';@@ -27,8 +27,8 @@ function MCPToolSelectDialog({const { mcpServersMap } = useAgentPanelContext();const { initializeServer } = useMCPServerManager();const { data: startupConfig } = useGetStartupConfig();+ const { refetch: refetchMCPTools } = useMCPToolsQuery();const { getValues, setValue } = useFormContext<AgentForm>();- const { refetch: refetchAvailableTools } = useAvailableToolsQuery(EModelEndpoint.agents);const [isInitializing, setIsInitializing] = useState<string | null>(null);const [configuringServer, setConfiguringServer] = useState<string | null>(null);@@ -90,15 +90,15 @@ function MCPToolSelectDialog({setIsInitializing(null);},onSuccess: async () => {- const { data: updatedAvailableTools } = await refetchAvailableTools();+ const { data: updatedMCPTools } = await refetchMCPTools();const currentTools = getValues('tools') || [];const toolsToAdd: string[] = [`${Constants.mcp_server}${Constants.mcp_delimiter}${serverName}`,];- if (updatedAvailableTools) {- updatedAvailableTools.forEach((tool) => {+ if (updatedMCPTools) {+ updatedMCPTools.forEach((tool) => {if (tool.pluginKey.endsWith(`${Constants.mcp_delimiter}${serverName}`)) {toolsToAdd.push(tool.pluginKey);}diff --git a/client/src/components/Tools/ToolSelectDialog.tsx b/client/src/components/Tools/ToolSelectDialog.tsxindex cdd70b9075..14bab50603 100644--- a/client/src/components/Tools/ToolSelectDialog.tsx+++ b/client/src/components/Tools/ToolSelectDialog.tsx@@ -8,7 +8,7 @@ import type {AssistantsEndpoint,EModelEndpoint,TPluginAction,- AgentToolType,+ TPlugin,TError,} from 'librechat-data-provider';import type { AgentForm, TPluginStoreDialogProps } from '~/common';@@ -27,7 +27,8 @@ function ToolSelectDialog({const localize = useLocalize();const isAgentTools = isAgentsEndpoint(endpoint);const { getValues, setValue } = useFormContext<AgentForm>();- const { groupedTools, pluginTools } = useAgentPanelContext();+ // Only use regular tools, not MCP tools+ const { regularTools } = useAgentPanelContext();const {maxPage,@@ -68,19 +69,8 @@ function ToolSelectDialog({const handleInstall = (pluginAction: TPluginAction) => {const addFunction = () => {const installedToolIds: string[] = getValues('tools') || [];- // Add the parentinstalledToolIds.push(pluginAction.pluginKey);-- // If this tool is a group, add subtools too- const groupObj = groupedTools?.[pluginAction.pluginKey];- if (groupObj?.tools && groupObj.tools.length > 0) {- for (const sub of groupObj.tools) {- if (!installedToolIds.includes(sub.tool_id)) {- installedToolIds.push(sub.tool_id);- }- }- }- setValue('tools', Array.from(new Set(installedToolIds))); // no duplicates just in case+ setValue('tools', Array.from(new Set(installedToolIds)));};if (!pluginAction.auth) {@@ -98,19 +88,12 @@ function ToolSelectDialog({};const onRemoveTool = (toolId: string) => {- const groupObj = groupedTools?.[toolId];- const toolIdsToRemove = [toolId];- if (groupObj?.tools && groupObj.tools.length > 0) {- toolIdsToRemove.push(...groupObj.tools.map((sub) => sub.tool_id));- }- // Remove these from the formToolsupdateUserPlugins.mutate({ pluginKey: toolId, action: 'uninstall', auth: {}, isEntityTool: true },{onError: (error: unknown) => handleInstallError(error as TError),onSuccess: () => {- const remainingToolIds =- getValues('tools')?.filter((toolId) => !toolIdsToRemove.includes(toolId)) || [];+ const remainingToolIds = getValues('tools')?.filter((id) => id !== toolId) || [];setValue('tools', remainingToolIds);},},@@ -119,7 +102,8 @@ function ToolSelectDialog({const onAddTool = (pluginKey: string) => {setShowPluginAuthForm(false);- const availablePluginFromKey = pluginTools?.find((p) => p.pluginKey === pluginKey);+ // Find the tool in regularTools+ const availablePluginFromKey = regularTools?.find((p) => p.pluginKey === pluginKey);setSelectedPlugin(availablePluginFromKey);const { authConfig, authenticated = false } = availablePluginFromKey ?? {};@@ -134,30 +118,19 @@ function ToolSelectDialog({}};- const filteredTools = Object.values(groupedTools || {}).filter(- (currentTool: AgentToolType & { tools?: AgentToolType[] }) => {- if (currentTool.metadata?.name?.toLowerCase().includes(searchValue.toLowerCase())) {- return true;- }- if (currentTool.tools) {- return currentTool.tools.some((childTool) =>- childTool.metadata?.name?.toLowerCase().includes(searchValue.toLowerCase()),- );- }- return false;- },- );+ const filteredTools = (regularTools || []).filter((tool: TPlugin) => {+ return tool.name?.toLowerCase().includes(searchValue.toLowerCase());+ });useEffect(() => {if (filteredTools) {- setMaxPage(Math.ceil(Object.keys(filteredTools || {}).length / itemsPerPage));+ setMaxPage(Math.ceil(filteredTools.length / itemsPerPage));if (searchChanged) {setCurrentPage(1);setSearchChanged(false);}}}, [- pluginTools,searchValue,itemsPerPage,filteredTools,@@ -254,10 +227,13 @@ function ToolSelectDialog({.map((tool, index) => (<ToolItemkey={index}- tool={tool}- isInstalled={getValues('tools')?.includes(tool.tool_id) || false}- onAddTool={() => onAddTool(tool.tool_id)}- onRemoveTool={() => onRemoveTool(tool.tool_id)}+ tool={{+ tool_id: tool.pluginKey,+ metadata: tool,+ }}+ isInstalled={getValues('tools')?.includes(tool.pluginKey) || false}+ onAddTool={() => onAddTool(tool.pluginKey)}+ onRemoveTool={() => onRemoveTool(tool.pluginKey)}/>))}</div>diff --git a/client/src/data-provider/index.ts b/client/src/data-provider/index.tsindex 1b1ceed19f..1e2582cb84 100644--- a/client/src/data-provider/index.ts+++ b/client/src/data-provider/index.ts@@ -11,5 +11,6 @@ export * from './connection';export * from './mutations';export * from './prompts';export * from './queries';+export * from './mcp';export * from './roles';export * from './tags';diff --git a/client/src/data-provider/mcp.ts b/client/src/data-provider/mcp.tsnew file mode 100644index 0000000000..cc144f78b4--- /dev/null+++ b/client/src/data-provider/mcp.ts@@ -0,0 +1,29 @@+/**+ * Dedicated queries for MCP (Model Context Protocol) tools+ * Decoupled from regular LibreChat tools+ */+import { useQuery } from '@tanstack/react-query';+import { QueryKeys, dataService } from 'librechat-data-provider';+import type { UseQueryOptions, QueryObserverResult } from '@tanstack/react-query';+import type { TPlugin } from 'librechat-data-provider';++/**+ * Hook for fetching MCP-specific tools+ * @param config - React Query configuration+ * @returns MCP tools grouped by server+ */+export const useMCPToolsQuery = <TData = TPlugin[]>(+ config?: UseQueryOptions<TPlugin[], unknown, TData>,+): QueryObserverResult<TData> => {+ return useQuery<TPlugin[], unknown, TData>(+ [QueryKeys.mcpTools],+ () => dataService.getMCPTools(),+ {+ refetchOnWindowFocus: false,+ refetchOnReconnect: false,+ refetchOnMount: false,+ staleTime: 5 * 60 * 1000, // 5 minutes+ ...config,+ },+ );+};diff --git a/client/src/data-provider/queries.ts b/client/src/data-provider/queries.tsindex 447775067e..8f2b702a3b 100644--- a/client/src/data-provider/queries.ts+++ b/client/src/data-provider/queries.ts@@ -178,7 +178,8 @@ export const useConversationTagsQuery = (*//**- * Hook for getting all available tools for Assistants+ * Hook for getting available LibreChat tools (excludes MCP tools)+ * For MCP tools, use `useMCPToolsQuery` from mcp-queries.ts*/export const useAvailableToolsQuery = <TData = t.TPlugin[]>(endpoint: t.AssistantsEndpoint | EModelEndpoint.agents,diff --git a/client/src/hooks/MCP/useGetMCPTools.ts b/client/src/hooks/MCP/useGetMCPTools.tsindex adffb963e9..2785675b99 100644--- a/client/src/hooks/MCP/useGetMCPTools.ts+++ b/client/src/hooks/MCP/useGetMCPTools.ts@@ -1,32 +1,37 @@import { useMemo } from 'react';-import { Constants, EModelEndpoint } from 'librechat-data-provider';+import { Constants } from 'librechat-data-provider';import type { TPlugin } from 'librechat-data-provider';-import { useAvailableToolsQuery, useGetStartupConfig } from '~/data-provider';+import { useMCPToolsQuery, useGetStartupConfig } from '~/data-provider';+/**+ * Hook for fetching and filtering MCP tools based on server configuration+ * Uses the dedicated MCP tools query instead of filtering from general tools+ */export function useGetMCPTools() {const { data: startupConfig } = useGetStartupConfig();- const { data: rawMcpTools } = useAvailableToolsQuery(EModelEndpoint.agents, {++ // Use dedicated MCP tools query+ const { data: rawMcpTools } = useMCPToolsQuery({select: (data: TPlugin[]) => {+ // Group tools by server for easier managementconst mcpToolsMap = new Map<string, TPlugin>();data.forEach((tool) => {- const isMCP = tool.pluginKey.includes(Constants.mcp_delimiter);- if (isMCP) {- const parts = tool.pluginKey.split(Constants.mcp_delimiter);- const serverName = parts[parts.length - 1];- if (!mcpToolsMap.has(serverName)) {- mcpToolsMap.set(serverName, {- name: serverName,- pluginKey: tool.pluginKey,- authConfig: tool.authConfig,- authenticated: tool.authenticated,- });- }+ const parts = tool.pluginKey.split(Constants.mcp_delimiter);+ const serverName = parts[parts.length - 1];+ if (!mcpToolsMap.has(serverName)) {+ mcpToolsMap.set(serverName, {+ name: serverName,+ pluginKey: tool.pluginKey,+ authConfig: tool.authConfig,+ authenticated: tool.authenticated,+ });}});return Array.from(mcpToolsMap.values());},});+ // Filter out servers that have chatMenu disabledconst mcpToolDetails = useMemo(() => {if (!rawMcpTools || !startupConfig?.mcpServers) {return rawMcpTools;diff --git a/client/src/hooks/MCP/useMCPServerManager.ts b/client/src/hooks/MCP/useMCPServerManager.tsindex 733168c1a1..c301939193 100644--- a/client/src/hooks/MCP/useMCPServerManager.ts+++ b/client/src/hooks/MCP/useMCPServerManager.ts@@ -53,7 +53,7 @@ export function useMCPServerManager({ conversationId }: { conversationId?: strinshowToast({ message: localize('com_nav_mcp_vars_updated'), status: 'success' });await Promise.all([- queryClient.refetchQueries([QueryKeys.tools]),+ queryClient.refetchQueries([QueryKeys.mcpTools]),queryClient.refetchQueries([QueryKeys.mcpAuthValues]),queryClient.refetchQueries([QueryKeys.mcpConnectionStatus]),]);@@ -170,7 +170,7 @@ export function useMCPServerManager({ conversationId }: { conversationId?: strinsetMCPValues([...currentValues, serverName]);}- await queryClient.invalidateQueries([QueryKeys.tools]);+ await queryClient.invalidateQueries([QueryKeys.mcpTools]);// This delay is to ensure UI has updated with new connection status before cleanup// Otherwise servers will show as disconnected for a second after OAuth flow completesdiff --git a/client/src/hooks/MCP/useVisibleTools.ts b/client/src/hooks/MCP/useVisibleTools.tsindex acb48bf111..1e48d08914 100644--- a/client/src/hooks/MCP/useVisibleTools.ts+++ b/client/src/hooks/MCP/useVisibleTools.ts@@ -1,79 +1,52 @@import { useMemo } from 'react';import { Constants } from 'librechat-data-provider';-import type { AgentToolType } from 'librechat-data-provider';+import type { TPlugin } from 'librechat-data-provider';import type { MCPServerInfo } from '~/common';-type GroupedToolType = AgentToolType & { tools?: AgentToolType[] };-type GroupedToolsRecord = Record<string, GroupedToolType>;-interface VisibleToolsResult {toolIds: string[];mcpServerNames: string[];}/**- * Custom hook to calculate visible tool IDs based on selected tools and their parent groups.- * If any subtool of a group is selected, the parent group tool is also made visible.+ * Custom hook to calculate visible tool IDs based on selected tools.+ * Separates regular LibreChat tools from MCP servers.** @param selectedToolIds - Array of selected tool IDs- * @param allTools - Record of all available tools+ * @param regularTools - Array of regular LibreChat tools* @param mcpServersMap - Map of all MCP servers* @returns Object containing separate arrays of visible tool IDs for regular and MCP tools*/export function useVisibleTools(selectedToolIds: string[] | undefined,- allTools: GroupedToolsRecord | undefined,+ regularTools: TPlugin[] | undefined,mcpServersMap: Map<string, MCPServerInfo>,): VisibleToolsResult {return useMemo(() => {const mcpServers = new Set<string>();- const selectedSet = new Set<string>();- const regularToolIds = new Set<string>();+ const regularToolIds: string[] = [];for (const toolId of selectedToolIds ?? []) {- if (!toolId.includes(Constants.mcp_delimiter)) {- selectedSet.add(toolId);- continue;- }- const serverName = toolId.split(Constants.mcp_delimiter)[1];- if (!serverName) {- continue;- }- mcpServers.add(serverName);- }-- if (allTools) {- for (const [toolId, toolObj] of Object.entries(allTools)) {- if (selectedSet.has(toolId)) {- regularToolIds.add(toolId);- }-- if (toolObj.tools?.length) {- for (const subtool of toolObj.tools) {- if (selectedSet.has(subtool.tool_id)) {- regularToolIds.add(toolId);- break;- }- }+ // MCP tools/servers+ if (toolId.includes(Constants.mcp_delimiter)) {+ const serverName = toolId.split(Constants.mcp_delimiter)[1];+ if (serverName) {+ mcpServers.add(serverName);}}- }-- if (mcpServersMap) {- for (const [mcpServerName] of mcpServersMap) {- if (mcpServers.has(mcpServerName)) {- continue;- }- /** Legacy check */- if (selectedSet.has(mcpServerName)) {- mcpServers.add(mcpServerName);- }+ // Legacy MCP server check (just server name)+ else if (mcpServersMap.has(toolId)) {+ mcpServers.add(toolId);+ }+ // Regular LibreChat tools+ else if (regularTools?.some((t) => t.pluginKey === toolId)) {+ regularToolIds.push(toolId);}}return {- toolIds: Array.from(regularToolIds).sort((a, b) => a.localeCompare(b)),+ toolIds: regularToolIds.sort((a, b) => a.localeCompare(b)),mcpServerNames: Array.from(mcpServers).sort((a, b) => a.localeCompare(b)),};- }, [allTools, mcpServersMap, selectedToolIds]);+ }, [regularTools, mcpServersMap, selectedToolIds]);}diff --git a/packages/data-provider/src/api-endpoints.ts b/packages/data-provider/src/api-endpoints.tsindex be3f2a62a2..8c1447abee 100644--- a/packages/data-provider/src/api-endpoints.ts+++ b/packages/data-provider/src/api-endpoints.ts@@ -222,6 +222,10 @@ export const agents = ({ path = '', options }: { path?: string; options?: objectreturn url;};+export const mcp = {+ tools: `${BASE_URL}/api/mcp/tools`,+};+export const revertAgentVersion = (agent_id: string) => `${agents({ path: `${agent_id}/revert` })}`;export const files = () => `${BASE_URL}/api/files`;diff --git a/packages/data-provider/src/data-service.ts b/packages/data-provider/src/data-service.tsindex 7116f0d7c3..9926e18be8 100644--- a/packages/data-provider/src/data-service.ts+++ b/packages/data-provider/src/data-service.ts@@ -297,6 +297,12 @@ export const getAvailableTools = (return request.get(path);};+/* MCP Tools - Decoupled from regular tools */++export const getMCPTools = (): Promise<s.TPlugin[]> => {+ return request.get(endpoints.mcp.tools);+};+export const getVerifyAgentToolAuth = (params: q.VerifyToolAuthParams,): Promise<q.VerifyToolAuthResponse> => {diff --git a/packages/data-provider/src/keys.ts b/packages/data-provider/src/keys.tsindex 79d1fa38df..1d6e1d813c 100644--- a/packages/data-provider/src/keys.ts+++ b/packages/data-provider/src/keys.ts@@ -26,6 +26,7 @@ export enum QueryKeys {tools = 'tools',toolAuth = 'toolAuth',toolCalls = 'toolCalls',+ mcpTools = 'mcpTools',mcpConnectionStatus = 'mcpConnectionStatus',mcpAuthValues = 'mcpAuthValues',agentTools = 'agentTools',diff --git a/packages/data-provider/src/react-query/react-query-service.ts b/packages/data-provider/src/react-query/react-query-service.tsindex ab150a1336..db1f0c9052 100644--- a/packages/data-provider/src/react-query/react-query-service.ts+++ b/packages/data-provider/src/react-query/react-query-service.ts@@ -147,6 +147,7 @@ export const useRevokeUserKeyMutation = (name: string): UseMutationResult<unknowqueryClient.invalidateQueries([QueryKeys.assistantDocs]);queryClient.invalidateQueries([QueryKeys.assistants]);queryClient.invalidateQueries([QueryKeys.assistant]);+ queryClient.invalidateQueries([QueryKeys.mcpTools]);queryClient.invalidateQueries([QueryKeys.actions]);queryClient.invalidateQueries([QueryKeys.tools]);}@@ -172,6 +173,7 @@ export const useRevokeAllUserKeysMutation = (): UseMutationResult<unknown> => {queryClient.invalidateQueries([QueryKeys.assistantDocs]);queryClient.invalidateQueries([QueryKeys.assistants]);queryClient.invalidateQueries([QueryKeys.assistant]);+ queryClient.invalidateQueries([QueryKeys.mcpTools]);queryClient.invalidateQueries([QueryKeys.actions]);queryClient.invalidateQueries([QueryKeys.tools]);},@@ -337,7 +339,7 @@ export const useReinitializeMCPServerMutation = (): UseMutationResult<const queryClient = useQueryClient();return useMutation((serverName: string) => dataService.reinitializeMCPServer(serverName), {onSuccess: () => {- queryClient.refetchQueries([QueryKeys.tools]);+ queryClient.refetchQueries([QueryKeys.mcpTools]);},});};