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
🪐 feat: MCP OAuth 2.0 Discovery Support (#7924)
Danny Avilaec7370dfe9a9
diff --git a/api/app/clients/tools/util/handleTools.js b/api/app/clients/tools/util/handleTools.jsindex 51f0c87ef9..b5a40fc4a3 100644--- a/api/app/clients/tools/util/handleTools.js+++ b/api/app/clients/tools/util/handleTools.js@@ -1,3 +1,4 @@+const { logger } = require('@librechat/data-schemas');const { SerpAPI } = require('@langchain/community/tools/serpapi');const { Calculator } = require('@langchain/community/tools/calculator');const { EnvVar, createCodeExecutionTool, createSearchTool } = require('@librechat/agents');@@ -29,8 +30,8 @@ const {const { primeFiles: primeCodeFiles } = require('~/server/services/Files/Code/process');const { createFileSearchTool, primeFiles: primeSearchFiles } = require('./fileSearch');const { loadAuthValues } = require('~/server/services/Tools/credentials');+const { getCachedTools } = require('~/server/services/Config');const { createMCPTool } = require('~/server/services/MCP');-const { logger } = require('~/config');const mcpToolPattern = new RegExp(`^.+${Constants.mcp_delimiter}.+$`);@@ -236,7 +237,7 @@ const loadTools = async ({/** @type {Record<string, string>} */const toolContextMap = {};- const appTools = options.req?.app?.locals?.availableTools ?? {};+ const appTools = (await getCachedTools({ includeGlobal: true })) ?? {};for (const tool of tools) {if (tool === Tools.execute_code) {@@ -299,6 +300,7 @@ Current Date & Time: ${replaceSpecialVars({ text: '{{iso_datetime}}' })}requestedTools[tool] = async () =>createMCPTool({req: options.req,+ res: options.res,toolKey: tool,model: agent?.model ?? model,provider: agent?.provider ?? endpoint,diff --git a/api/cache/getLogStores.js b/api/cache/getLogStores.jsindex 2478bf40d9..06cadf9f64 100644--- a/api/cache/getLogStores.js+++ b/api/cache/getLogStores.js@@ -29,6 +29,10 @@ const roles = isRedisEnabled? new Keyv({ store: keyvRedis }): new Keyv({ namespace: CacheKeys.ROLES });+const mcpTools = isRedisEnabled+ ? new Keyv({ store: keyvRedis })+ : new Keyv({ namespace: CacheKeys.MCP_TOOLS });+const audioRuns = isRedisEnabled? new Keyv({ store: keyvRedis, ttl: Time.TEN_MINUTES }): new Keyv({ namespace: CacheKeys.AUDIO_RUNS, ttl: Time.TEN_MINUTES });@@ -67,6 +71,7 @@ const openIdExchangedTokensCache = isRedisEnabledconst namespaces = {[CacheKeys.ROLES]: roles,+ [CacheKeys.MCP_TOOLS]: mcpTools,[CacheKeys.CONFIG_STORE]: config,[CacheKeys.PENDING_REQ]: pending_req,[ViolationTypes.BAN]: new Keyv({ store: keyvMongo, namespace: CacheKeys.BANS, ttl: duration }),diff --git a/api/config/index.js b/api/config/index.jsindex a02c75887e..2e69e87118 100644--- a/api/config/index.js+++ b/api/config/index.js@@ -15,7 +15,7 @@ let flowManager = null;*/function getMCPManager(userId) {if (!mcpManager) {- mcpManager = MCPManager.getInstance(logger);+ mcpManager = MCPManager.getInstance();} else {mcpManager.checkIdleConnections(userId);}@@ -30,7 +30,6 @@ function getFlowStateManager(flowsCache) {if (!flowManager) {flowManager = new FlowStateManager(flowsCache, {ttl: Time.ONE_MINUTE * 3,- logger,});}return flowManager;diff --git a/api/models/Agent.js b/api/models/Agent.jsindex 297604c444..d33ca8a8bf 100644--- a/api/models/Agent.js+++ b/api/models/Agent.js@@ -11,6 +11,7 @@ const {removeAgentIdsFromProject,removeAgentFromAllProjects,} = require('./Project');+const { getCachedTools } = require('~/server/services/Config');const getLogStores = require('~/cache/getLogStores');const { getActions } = require('./Action');const { Agent } = require('~/db/models');@@ -55,12 +56,12 @@ const getAgent = async (searchParameter) => await Agent.findOne(searchParameter)* @param {string} params.agent_id* @param {string} params.endpoint* @param {import('@librechat/agents').ClientOptions} [params.model_parameters]- * @returns {Agent|null} The agent document as a plain object, or null if not found.+ * @returns {Promise<Agent|null>} The agent document as a plain object, or null if not found.*/-const loadEphemeralAgent = ({ req, agent_id, endpoint, model_parameters: _m }) => {+const loadEphemeralAgent = async ({ req, agent_id, endpoint, model_parameters: _m }) => {const { model, ...model_parameters } = _m;/** @type {Record<string, FunctionTool>} */- const availableTools = req.app.locals.availableTools;+ const availableTools = await getCachedTools({ includeGlobal: true });/** @type {TEphemeralAgent | null} */const ephemeralAgent = req.body.ephemeralAgent;const mcpServers = new Set(ephemeralAgent?.mcp);@@ -111,7 +112,7 @@ const loadAgent = async ({ req, agent_id, endpoint, model_parameters }) => {return null;}if (agent_id === EPHEMERAL_AGENT_ID) {- return loadEphemeralAgent({ req, agent_id, endpoint, model_parameters });+ return await loadEphemeralAgent({ req, agent_id, endpoint, model_parameters });}const agent = await getAgent({id: agent_id,diff --git a/api/models/Agent.spec.js b/api/models/Agent.spec.jsindex 1e18168147..0b0646f524 100644--- a/api/models/Agent.spec.js+++ b/api/models/Agent.spec.js@@ -6,6 +6,10 @@ const originalEnv = {process.env.CREDS_KEY = '0123456789abcdef0123456789abcdef';process.env.CREDS_IV = '0123456789abcdef';+jest.mock('~/server/services/Config', () => ({+ getCachedTools: jest.fn(),+}));+const mongoose = require('mongoose');const { v4: uuidv4 } = require('uuid');const { agentSchema } = require('@librechat/data-schemas');@@ -23,6 +27,7 @@ const {generateActionMetadataHash,revertAgentVersion,} = require('./Agent');+const { getCachedTools } = require('~/server/services/Config');/*** @type {import('mongoose').Model<import('@librechat/data-schemas').IAgent>}@@ -406,6 +411,7 @@ describe('models/Agent', () => {beforeAll(async () => {mongoServer = await MongoMemoryServer.create();const mongoUri = mongoServer.getUri();+ Agent = mongoose.models.Agent || mongoose.model('Agent', agentSchema);await mongoose.connect(mongoUri);});@@ -1546,6 +1552,12 @@ describe('models/Agent', () => {test('should test ephemeral agent loading logic', async () => {const { EPHEMERAL_AGENT_ID } = require('librechat-data-provider').Constants;+ getCachedTools.mockResolvedValue({+ tool1_mcp_server1: {},+ tool2_mcp_server2: {},+ another_tool: {},+ });+const mockReq = {user: { id: 'user123' },body: {@@ -1556,15 +1568,6 @@ describe('models/Agent', () => {mcp: ['server1', 'server2'],},},- app: {- locals: {- availableTools: {- tool1_mcp_server1: {},- tool2_mcp_server2: {},- another_tool: {},- },- },- },};const result = await loadAgent({@@ -1657,6 +1660,8 @@ describe('models/Agent', () => {test('should handle ephemeral agent with no MCP servers', async () => {const { EPHEMERAL_AGENT_ID } = require('librechat-data-provider').Constants;+ getCachedTools.mockResolvedValue({});+const mockReq = {user: { id: 'user123' },body: {@@ -1667,11 +1672,6 @@ describe('models/Agent', () => {mcp: [],},},- app: {- locals: {- availableTools: {},- },- },};const result = await loadAgent({@@ -1692,16 +1692,13 @@ describe('models/Agent', () => {test('should handle ephemeral agent with undefined ephemeralAgent in body', async () => {const { EPHEMERAL_AGENT_ID } = require('librechat-data-provider').Constants;+ getCachedTools.mockResolvedValue({});+const mockReq = {user: { id: 'user123' },body: {promptPrefix: 'Basic instructions',},- app: {- locals: {- availableTools: {},- },- },};const result = await loadAgent({@@ -1734,6 +1731,13 @@ describe('models/Agent', () => {const { EPHEMERAL_AGENT_ID } = require('librechat-data-provider').Constants;const largeToolList = Array.from({ length: 100 }, (_, i) => `tool_${i}_mcp_server1`);+ const availableTools = largeToolList.reduce((acc, tool) => {+ acc[tool] = {};+ return acc;+ }, {});++ getCachedTools.mockResolvedValue(availableTools);+const mockReq = {user: { id: 'user123' },body: {@@ -1744,14 +1748,6 @@ describe('models/Agent', () => {mcp: ['server1'],},},- app: {- locals: {- availableTools: largeToolList.reduce((acc, tool) => {- acc[tool] = {};- return acc;- }, {}),- },- },};const result = await loadAgent({@@ -2272,6 +2268,13 @@ describe('models/Agent', () => {test('should handle loadEphemeralAgent with malformed MCP tool names', async () => {const { EPHEMERAL_AGENT_ID } = require('librechat-data-provider').Constants;+ getCachedTools.mockResolvedValue({+ malformed_tool_name: {}, // No mcp delimiter+ tool__server1: {}, // Wrong delimiter+ tool_mcp_server1: {}, // Correct format+ tool_mcp_server2: {}, // Different server+ });+const mockReq = {user: { id: 'user123' },body: {@@ -2282,16 +2285,6 @@ describe('models/Agent', () => {mcp: ['server1'],},},- app: {- locals: {- availableTools: {- malformed_tool_name: {}, // No mcp delimiter- tool__server1: {}, // Wrong delimiter- tool_mcp_server1: {}, // Correct format- tool_mcp_server2: {}, // Different server- },- },- },};const result = await loadAgent({diff --git a/api/models/Token.js b/api/models/Token.jsdeleted file mode 100644index 6f130eb2c4..0000000000--- a/api/models/Token.js+++ /dev/null@@ -1,42 +0,0 @@-const { findToken, updateToken, createToken } = require('~/models');-const { encryptV2 } = require('~/server/utils/crypto');--/**- * Handles the OAuth token by creating or updating the token.- * @param {object} fields- * @param {string} fields.userId - The user's ID.- * @param {string} fields.token - The full token to store.- * @param {string} fields.identifier - Unique, alternative identifier for the token.- * @param {number} fields.expiresIn - The number of seconds until the token expires.- * @param {object} fields.metadata - Additional metadata to store with the token.- * @param {string} [fields.type="oauth"] - The type of token. Default is 'oauth'.- */-async function handleOAuthToken({- token,- userId,- identifier,- expiresIn,- metadata,- type = 'oauth',-}) {- const encrypedToken = await encryptV2(token);- const tokenData = {- type,- userId,- metadata,- identifier,- token: encrypedToken,- expiresIn: parseInt(expiresIn, 10) || 3600,- };-- const existingToken = await findToken({ userId, identifier });- if (existingToken) {- return await updateToken({ identifier }, tokenData);- } else {- return await createToken(tokenData);- }-}--module.exports = {- handleOAuthToken,-};diff --git a/api/models/inviteUser.js b/api/models/inviteUser.jsindex 9f35b3f02b..eeb42841bf 100644--- a/api/models/inviteUser.js+++ b/api/models/inviteUser.js@@ -1,6 +1,6 @@const mongoose = require('mongoose');+const { getRandomValues } = require('@librechat/api');const { logger, hashToken } = require('@librechat/data-schemas');-const { getRandomValues } = require('~/server/utils/crypto');const { createToken, findToken } = require('~/models');/**diff --git a/api/server/controllers/PluginController.js b/api/server/controllers/PluginController.jsindex 674e36002a..98e9cbfc45 100644--- a/api/server/controllers/PluginController.js+++ b/api/server/controllers/PluginController.js@@ -1,8 +1,9 @@+const { logger } = require('@librechat/data-schemas');const { CacheKeys, AuthType } = require('librechat-data-provider');+const { getCustomConfig, getCachedTools } = require('~/server/services/Config');const { getToolkitKey } = require('~/server/services/ToolService');-const { getCustomConfig } = require('~/server/services/Config');+const { getMCPManager, getFlowStateManager } = require('~/config');const { availableTools } = require('~/app/clients/tools');-const { getMCPManager } = require('~/config');const { getLogStores } = require('~/cache');/**@@ -84,6 +85,45 @@ const getAvailablePluginsController = async (req, res) => {}};+function createServerToolsCallback() {+ /**+ * @param {string} serverName+ * @param {TPlugin[] | null} serverTools+ */+ return async function (serverName, serverTools) {+ try {+ const mcpToolsCache = getLogStores(CacheKeys.MCP_TOOLS);+ if (!serverName || !mcpToolsCache) {+ return;+ }+ await mcpToolsCache.set(serverName, serverTools);+ logger.debug(`MCP tools for ${serverName} added to cache.`);+ } catch (error) {+ logger.error('Error retrieving MCP tools from cache:', error);+ }+ };+}++function createGetServerTools() {+ /**+ * Retrieves cached server tools+ * @param {string} serverName+ * @returns {Promise<TPlugin[] | null>}+ */+ return async function (serverName) {+ try {+ const mcpToolsCache = getLogStores(CacheKeys.MCP_TOOLS);+ if (!mcpToolsCache) {+ return null;+ }+ return await mcpToolsCache.get(serverName);+ } catch (error) {+ logger.error('Error retrieving MCP tools from cache:', error);+ return null;+ }+ };+}+/*** Retrieves and returns a list of available tools, either from a cache or by reading a plugin manifest file.*@@ -109,7 +149,16 @@ const getAvailableTools = async (req, res) => {const customConfig = await getCustomConfig();if (customConfig?.mcpServers != null) {const mcpManager = getMCPManager();- pluginManifest = await mcpManager.loadManifestTools(pluginManifest);+ const flowsCache = getLogStores(CacheKeys.FLOWS);+ const flowManager = flowsCache ? getFlowStateManager(flowsCache) : null;+ const serverToolsCallback = createServerToolsCallback();+ const getServerTools = createGetServerTools();+ const mcpTools = await mcpManager.loadManifestTools({+ flowManager,+ serverToolsCallback,+ getServerTools,+ });+ pluginManifest = [...mcpTools, ...pluginManifest];}/** @type {TPlugin[]} */@@ -123,7 +172,7 @@ const getAvailableTools = async (req, res) => {}});- const toolDefinitions = req.app.locals.availableTools;+ const toolDefinitions = await getCachedTools({ includeGlobal: true });const tools = authenticatedPlugins.filter((plugin) =>toolDefinitions[plugin.pluginKey] !== undefined ||diff --git a/api/server/controllers/TwoFactorController.js b/api/server/controllers/TwoFactorController.jsindex 6e22db2e5c..44baf92ee7 100644--- a/api/server/controllers/TwoFactorController.js+++ b/api/server/controllers/TwoFactorController.js@@ -1,3 +1,4 @@+const { encryptV3 } = require('@librechat/api');const { logger } = require('@librechat/data-schemas');const {verifyTOTP,@@ -7,7 +8,6 @@ const {generateBackupCodes,} = require('~/server/services/twoFactorService');const { getUserById, updateUser } = require('~/models');-const { encryptV3 } = require('~/server/utils/crypto');const safeAppTitle = (process.env.APP_TITLE || 'LibreChat').replace(/\s+/g, '');diff --git a/api/server/controllers/agents/v1.js b/api/server/controllers/agents/v1.jsindex 38a058b540..18bd7190f0 100644--- a/api/server/controllers/agents/v1.js+++ b/api/server/controllers/agents/v1.js@@ -1,9 +1,9 @@const fs = require('fs').promises;const { nanoid } = require('nanoid');+const { logger } = require('@librechat/data-schemas');const {Tools,Constants,- FileContext,FileSources,SystemRoles,EToolResources,@@ -16,16 +16,16 @@ const {deleteAgent,getListAgents,} = require('~/models/Agent');-const { uploadImageBuffer, filterFile } = require('~/server/services/Files/process');const { getStrategyFunctions } = require('~/server/services/Files/strategies');const { resizeAvatar } = require('~/server/services/Files/images/avatar');const { refreshS3Url } = require('~/server/services/Files/S3/crud');+const { filterFile } = require('~/server/services/Files/process');const { updateAction, getActions } = require('~/models/Action');+const { getCachedTools } = require('~/server/services/Config');const { updateAgentProjects } = require('~/models/Agent');const { getProjectByName } = require('~/models/Project');-const { deleteFileByFilter } = require('~/models/File');const { revertAgentVersion } = require('~/models/Agent');-const { logger } = require('~/config');+const { deleteFileByFilter } = require('~/models/File');const systemTools = {[Tools.execute_code]: true,@@ -47,8 +47,9 @@ const createAgentHandler = async (req, res) => {agentData.tools = [];+ const availableTools = await getCachedTools({ includeGlobal: true });for (const tool of tools) {- if (req.app.locals.availableTools[tool]) {+ if (availableTools[tool]) {agentData.tools.push(tool);}@@ -445,7 +446,7 @@ const uploadAgentAvatarHandler = async (req, res) => {try {await fs.unlink(req.file.path);logger.debug('[/:agent_id/avatar] Temp. image upload file deleted');- } catch (error) {+ } catch {logger.debug('[/:agent_id/avatar] Temp. image upload file already deleted');}}diff --git a/api/server/controllers/assistants/v1.js b/api/server/controllers/assistants/v1.jsindex 8fb73167c1..e723cda4fc 100644--- a/api/server/controllers/assistants/v1.js+++ b/api/server/controllers/assistants/v1.js@@ -1,4 +1,5 @@const fs = require('fs').promises;+const { logger } = require('@librechat/data-schemas');const { FileContext } = require('librechat-data-provider');const { uploadImageBuffer, filterFile } = require('~/server/services/Files/process');const validateAuthor = require('~/server/middleware/assistants/validateAuthor');@@ -6,9 +7,9 @@ const { getStrategyFunctions } = require('~/server/services/Files/strategies');const { deleteAssistantActions } = require('~/server/services/ActionService');const { updateAssistantDoc, getAssistants } = require('~/models/Assistant');const { getOpenAIClient, fetchAssistants } = require('./helpers');+const { getCachedTools } = require('~/server/services/Config');const { manifestToolMap } = require('~/app/clients/tools');const { deleteFileByFilter } = require('~/models/File');-const { logger } = require('~/config');/*** Create an assistant.@@ -30,21 +31,20 @@ const createAssistant = async (req, res) => {delete assistantData.conversation_starters;delete assistantData.append_current_datetime;+ const toolDefinitions = await getCachedTools({ includeGlobal: true });+assistantData.tools = tools.map((tool) => {if (typeof tool !== 'string') {return tool;}- const toolDefinitions = req.app.locals.availableTools;const toolDef = toolDefinitions[tool];if (!toolDef && manifestToolMap[tool] && manifestToolMap[tool].toolkit === true) {- return (- Object.entries(toolDefinitions)- .filter(([key]) => key.startsWith(`${tool}_`))- // eslint-disable-next-line no-unused-vars- .map(([_, val]) => val)- );+ return Object.entries(toolDefinitions)+ .filter(([key]) => key.startsWith(`${tool}_`))++ .map(([_, val]) => val);}return toolDef;@@ -135,21 +135,21 @@ const patchAssistant = async (req, res) => {append_current_datetime,...updateData} = req.body;++ const toolDefinitions = await getCachedTools({ includeGlobal: true });+updateData.tools = (updateData.tools ?? []).map((tool) => {if (typeof tool !== 'string') {return tool;}- const toolDefinitions = req.app.locals.availableTools;const toolDef = toolDefinitions[tool];if (!toolDef && manifestToolMap[tool] && manifestToolMap[tool].toolkit === true) {- return (- Object.entries(toolDefinitions)- .filter(([key]) => key.startsWith(`${tool}_`))- // eslint-disable-next-line no-unused-vars- .map(([_, val]) => val)- );+ return Object.entries(toolDefinitions)+ .filter(([key]) => key.startsWith(`${tool}_`))++ .map(([_, val]) => val);}return toolDef;diff --git a/api/server/controllers/assistants/v2.js b/api/server/controllers/assistants/v2.jsindex 3bf83a626f..98441ba70a 100644--- a/api/server/controllers/assistants/v2.js+++ b/api/server/controllers/assistants/v2.js@@ -1,10 +1,11 @@+const { logger } = require('@librechat/data-schemas');const { ToolCallTypes } = require('librechat-data-provider');const validateAuthor = require('~/server/middleware/assistants/validateAuthor');const { validateAndUpdateTool } = require('~/server/services/ActionService');+const { getCachedTools } = require('~/server/services/Config');const { updateAssistantDoc } = require('~/models/Assistant');const { manifestToolMap } = require('~/app/clients/tools');const { getOpenAIClient } = require('./helpers');-const { logger } = require('~/config');/*** Create an assistant.@@ -27,21 +28,20 @@ const createAssistant = async (req, res) => {delete assistantData.conversation_starters;delete assistantData.append_current_datetime;+ const toolDefinitions = await getCachedTools({ includeGlobal: true });+assistantData.tools = tools.map((tool) => {if (typeof tool !== 'string') {return tool;}- const toolDefinitions = req.app.locals.availableTools;const toolDef = toolDefinitions[tool];if (!toolDef && manifestToolMap[tool] && manifestToolMap[tool].toolkit === true) {- return (- Object.entries(toolDefinitions)- .filter(([key]) => key.startsWith(`${tool}_`))- // eslint-disable-next-line no-unused-vars- .map(([_, val]) => val)- );+ return Object.entries(toolDefinitions)+ .filter(([key]) => key.startsWith(`${tool}_`))++ .map(([_, val]) => val);}return toolDef;@@ -125,13 +125,13 @@ const updateAssistant = async ({ req, openai, assistant_id, updateData }) => {let hasFileSearch = false;for (const tool of updateData.tools ?? []) {- const toolDefinitions = req.app.locals.availableTools;+ const toolDefinitions = await getCachedTools({ includeGlobal: true });let actualTool = typeof tool === 'string' ? toolDefinitions[tool] : tool;if (!actualTool && manifestToolMap[tool] && manifestToolMap[tool].toolkit === true) {actualTool = Object.entries(toolDefinitions).filter(([key]) => key.startsWith(`${tool}_`))- // eslint-disable-next-line no-unused-vars+.map(([_, val]) => val);} else if (!actualTool) {continue;diff --git a/api/server/index.js b/api/server/index.jsindex a04c339b0f..b1132873c7 100644--- a/api/server/index.js+++ b/api/server/index.js@@ -1,22 +1,22 @@require('dotenv').config();+const fs = require('fs');const path = require('path');require('module-alias')({ base: path.resolve(__dirname, '..') });const cors = require('cors');const axios = require('axios');const express = require('express');-const compression = require('compression');const passport = require('passport');-const mongoSanitize = require('express-mongo-sanitize');-const fs = require('fs');+const compression = require('compression');const cookieParser = require('cookie-parser');+const { isEnabled } = require('@librechat/api');+const { logger } = require('@librechat/data-schemas');+const mongoSanitize = require('express-mongo-sanitize');const { connectDb, indexSync } = require('~/db');-const { jwtLogin, passportLogin } = require('~/strategies');-const { isEnabled } = require('~/server/utils');-const { ldapLogin } = require('~/strategies');-const { logger } = require('~/config');const validateImageRequest = require('./middleware/validateImageRequest');+const { jwtLogin, ldapLogin, passportLogin } = require('~/strategies');const errorController = require('./controllers/ErrorController');+const initializeMCP = require('./services/initializeMCP');const configureSocialLogins = require('./socialLogins');const AppService = require('./services/AppService');const staticCache = require('./utils/staticCache');@@ -119,6 +119,7 @@ const startServer = async () => {app.use('/api/bedrock', routes.bedrock);app.use('/api/memories', routes.memories);app.use('/api/tags', routes.tags);+ app.use('/api/mcp', routes.mcp);app.use((req, res) => {res.set({@@ -142,6 +143,8 @@ const startServer = async () => {} else {logger.info(`Server listening at http://${host == '0.0.0.0' ? 'localhost' : host}:${port}`);}++ initializeMCP(app);});};@@ -184,5 +187,5 @@ process.on('uncaughtException', (err) => {process.exit(1);});-// export app for easier testing purposes+/** Export app for easier testing purposes */module.exports = app;diff --git a/api/server/routes/actions.js b/api/server/routes/actions.jsindex 242e52e4ae..9f94f617ce 100644--- a/api/server/routes/actions.js+++ b/api/server/routes/actions.js@@ -1,8 +1,10 @@const express = require('express');const jwt = require('jsonwebtoken');+const { getAccessToken } = require('@librechat/api');+const { logger } = require('@librechat/data-schemas');const { CacheKeys } = require('librechat-data-provider');-const { getAccessToken } = require('~/server/services/TokenService');-const { logger, getFlowStateManager } = require('~/config');+const { findToken, updateToken, createToken } = require('~/models');+const { getFlowStateManager } = require('~/config');const { getLogStores } = require('~/cache');const router = express.Router();@@ -28,18 +30,19 @@ router.get('/:action_id/oauth/callback', async (req, res) => {try {decodedState = jwt.verify(state, JWT_SECRET);} catch (err) {+ logger.error('Error verifying state parameter:', err);await flowManager.failFlow(identifier, 'oauth', 'Invalid or expired state parameter');- return res.status(400).send('Invalid or expired state parameter');+ return res.redirect('/oauth/error?error=invalid_state');}if (decodedState.action_id !== action_id) {await flowManager.failFlow(identifier, 'oauth', 'Mismatched action ID in state parameter');- return res.status(400).send('Mismatched action ID in state parameter');+ return res.redirect('/oauth/error?error=invalid_state');}if (!decodedState.user) {await flowManager.failFlow(identifier, 'oauth', 'Invalid user ID in state parameter');- return res.status(400).send('Invalid user ID in state parameter');+ return res.redirect('/oauth/error?error=invalid_state');}identifier = `${decodedState.user}:${action_id}`;const flowState = await flowManager.getFlowState(identifier, 'oauth');@@ -47,91 +50,34 @@ router.get('/:action_id/oauth/callback', async (req, res) => {throw new Error('OAuth flow not found');}- const tokenData = await getAccessToken({- code,- userId: decodedState.user,- identifier,- client_url: flowState.metadata.client_url,- redirect_uri: flowState.metadata.redirect_uri,- token_exchange_method: flowState.metadata.token_exchange_method,- /** Encrypted values */- encrypted_oauth_client_id: flowState.metadata.encrypted_oauth_client_id,- encrypted_oauth_client_secret: flowState.metadata.encrypted_oauth_client_secret,- });+ const tokenData = await getAccessToken(+ {+ code,+ userId: decodedState.user,+ identifier,+ client_url: flowState.metadata.client_url,+ redirect_uri: flowState.metadata.redirect_uri,+ token_exchange_method: flowState.metadata.token_exchange_method,+ /** Encrypted values */+ encrypted_oauth_client_id: flowState.metadata.encrypted_oauth_client_id,+ encrypted_oauth_client_secret: flowState.metadata.encrypted_oauth_client_secret,+ },+ {+ findToken,+ updateToken,+ createToken,+ },+ );await flowManager.completeFlow(identifier, 'oauth', tokenData);- res.send(`- <!DOCTYPE html>- <html>- <head>- <title>Authentication Successful</title>- <meta name="viewport" content="width=device-width, initial-scale=1.0">- <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">- <style>- body {- font-family: ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont;- background-color: rgb(249, 250, 251);- margin: 0;- padding: 2rem;- display: flex;- justify-content: center;- align-items: center;- min-height: 100vh;- }- .card {- background-color: white;- border-radius: 0.5rem;- padding: 2rem;- max-width: 28rem;- width: 100%;- box-shadow: 0 4px 6px -1px rgb(0 0 0 / 0.1), 0 2px 4px -2px rgb(0 0 0 / 0.1);- text-align: center;- }- .heading {- color: rgb(17, 24, 39);- font-size: 1.875rem;- font-weight: 700;- margin: 0 0 1rem;- }- .description {- color: rgb(75, 85, 99);- font-size: 0.875rem;- margin: 0.5rem 0;- }- .countdown {- color: rgb(99, 102, 241);- font-weight: 500;- }- </style>- </head>- <body>- <div class="card">- <h1 class="heading">Authentication Successful</h1>- <p class="description">- Your authentication was successful. This window will close in- <span class="countdown" id="countdown">3</span> seconds.- </p>- </div>- <script>- let secondsLeft = 3;- const countdownElement = document.getElementById('countdown');-- const countdown = setInterval(() => {- secondsLeft--;- countdownElement.textContent = secondsLeft;-- if (secondsLeft <= 0) {- clearInterval(countdown);- window.close();- }- }, 1000);- </script>- </body>- </html>- `);++ /** Redirect to React success page */+ const serverName = flowState.metadata?.action_name || `Action ${action_id}`;+ const redirectUrl = `/oauth/success?serverName=${encodeURIComponent(serverName)}`;+ res.redirect(redirectUrl);} catch (error) {logger.error('Error in OAuth callback:', error);await flowManager.failFlow(identifier, 'oauth', error);- res.status(500).send('Authentication failed. Please try again.');+ res.redirect('/oauth/error?error=callback_failed');}});diff --git a/api/server/routes/index.js b/api/server/routes/index.jsindex 06e39d3671..7c1b5de0fa 100644--- a/api/server/routes/index.js+++ b/api/server/routes/index.js@@ -27,6 +27,7 @@ const edit = require('./edit');const keys = require('./keys');const user = require('./user');const ask = require('./ask');+const mcp = require('./mcp');module.exports = {ask,@@ -58,4 +59,5 @@ module.exports = {assistants,categories,staticRoute,+ mcp,};diff --git a/api/server/routes/mcp.js b/api/server/routes/mcp.jsnew file mode 100644index 0000000000..3dfed4d240--- /dev/null+++ b/api/server/routes/mcp.js@@ -0,0 +1,205 @@+const { Router } = require('express');+const { MCPOAuthHandler } = require('@librechat/api');+const { logger } = require('@librechat/data-schemas');+const { CacheKeys } = require('librechat-data-provider');+const { requireJwtAuth } = require('~/server/middleware');+const { getFlowStateManager } = require('~/config');+const { getLogStores } = require('~/cache');++const router = Router();++/**+ * Initiate OAuth flow+ * This endpoint is called when the user clicks the auth link in the UI+ */+router.get('/:serverName/oauth/initiate', requireJwtAuth, async (req, res) => {+ try {+ const { serverName } = req.params;+ const { userId, flowId } = req.query;+ const user = req.user;++ // Verify the userId matches the authenticated user+ if (userId !== user.id) {+ return res.status(403).json({ error: 'User mismatch' });+ }++ logger.debug('[MCP OAuth] Initiate request', { serverName, userId, flowId });++ const flowsCache = getLogStores(CacheKeys.FLOWS);+ const flowManager = getFlowStateManager(flowsCache);++ /** Flow state to retrieve OAuth config */+ const flowState = await flowManager.getFlowState(flowId, 'mcp_oauth');+ if (!flowState) {+ logger.error('[MCP OAuth] Flow state not found', { flowId });+ return res.status(404).json({ error: 'Flow not found' });+ }++ const { serverUrl, oauth: oauthConfig } = flowState.metadata || {};+ if (!serverUrl || !oauthConfig) {+ logger.error('[MCP OAuth] Missing server URL or OAuth config in flow state');+ return res.status(400).json({ error: 'Invalid flow state' });+ }++ const { authorizationUrl, flowId: oauthFlowId } = await MCPOAuthHandler.initiateOAuthFlow(+ serverName,+ serverUrl,+ userId,+ oauthConfig,+ );++ logger.debug('[MCP OAuth] OAuth flow initiated', { oauthFlowId, authorizationUrl });++ // Redirect user to the authorization URL+ res.redirect(authorizationUrl);+ } catch (error) {+ logger.error('[MCP OAuth] Failed to initiate OAuth', error);+ res.status(500).json({ error: 'Failed to initiate OAuth' });+ }+});++/**+ * OAuth callback handler+ * This handles the OAuth callback after the user has authorized the application+ */+router.get('/:serverName/oauth/callback', async (req, res) => {+ try {+ const { serverName } = req.params;+ const { code, state, error: oauthError } = req.query;++ logger.debug('[MCP OAuth] Callback received', {+ serverName,+ code: code ? 'present' : 'missing',+ state,+ error: oauthError,+ });++ if (oauthError) {+ logger.error('[MCP OAuth] OAuth error received', { error: oauthError });+ return res.redirect(`/oauth/error?error=${encodeURIComponent(String(oauthError))}`);+ }++ if (!code || typeof code !== 'string') {+ logger.error('[MCP OAuth] Missing or invalid code');+ return res.redirect('/oauth/error?error=missing_code');+ }++ if (!state || typeof state !== 'string') {+ logger.error('[MCP OAuth] Missing or invalid state');+ return res.redirect('/oauth/error?error=missing_state');+ }++ // Extract flow ID from state+ const flowId = state;+ logger.debug('[MCP OAuth] Using flow ID from state', { flowId });++ const flowsCache = getLogStores(CacheKeys.FLOWS);+ const flowManager = getFlowStateManager(flowsCache);++ logger.debug('[MCP OAuth] Getting flow state for flowId: ' + flowId);+ const flowState = await MCPOAuthHandler.getFlowState(flowId, flowManager);++ if (!flowState) {+ logger.error('[MCP OAuth] Flow state not found for flowId:', flowId);+ return res.redirect('/oauth/error?error=invalid_state');+ }++ logger.debug('[MCP OAuth] Flow state details', {+ serverName: flowState.serverName,+ userId: flowState.userId,+ hasMetadata: !!flowState.metadata,+ hasClientInfo: !!flowState.clientInfo,+ hasCodeVerifier: !!flowState.codeVerifier,+ });++ // Complete the OAuth flow+ logger.debug('[MCP OAuth] Completing OAuth flow');+ const tokens = await MCPOAuthHandler.completeOAuthFlow(flowId, code, flowManager);+ logger.info('[MCP OAuth] OAuth flow completed, tokens received in callback route');++ // For system-level OAuth, we need to store the tokens and retry the connection+ if (flowState.userId === 'system') {+ logger.debug(`[MCP OAuth] System-level OAuth completed for ${serverName}`);+ }++ /** ID of the flow that the tool/connection is waiting for */+ const toolFlowId = flowState.metadata?.toolFlowId;+ if (toolFlowId) {+ logger.debug('[MCP OAuth] Completing tool flow', { toolFlowId });+ await flowManager.completeFlow(toolFlowId, 'mcp_oauth', tokens);+ }++ /** Redirect to success page with flowId and serverName */+ const redirectUrl = `/oauth/success?serverName=${encodeURIComponent(serverName)}`;+ res.redirect(redirectUrl);+ } catch (error) {+ logger.error('[MCP OAuth] OAuth callback error', error);+ res.redirect('/oauth/error?error=callback_failed');+ }+});++/**+ * Get OAuth tokens for a completed flow+ * This is primarily for user-level OAuth flows+ */+router.get('/oauth/tokens/:flowId', requireJwtAuth, async (req, res) => {+ try {+ const { flowId } = req.params;+ const user = req.user;++ if (!user?.id) {+ return res.status(401).json({ error: 'User not authenticated' });+ }++ // Allow system flows or user-owned flows+ if (!flowId.startsWith(`${user.id}:`) && !flowId.startsWith('system:')) {+ return res.status(403).json({ error: 'Access denied' });+ }++ const flowsCache = getLogStores(CacheKeys.FLOWS);+ const flowManager = getFlowStateManager(flowsCache);++ const flowState = await flowManager.getFlowState(flowId, 'mcp_oauth');+ if (!flowState) {+ return res.status(404).json({ error: 'Flow not found' });+ }++ if (flowState.status !== 'COMPLETED') {+ return res.status(400).json({ error: 'Flow not completed' });+ }++ res.json({ tokens: flowState.result });+ } catch (error) {+ logger.error('[MCP OAuth] Failed to get tokens', error);+ res.status(500).json({ error: 'Failed to get tokens' });+ }+});++/**+ * Check OAuth flow status+ * This endpoint can be used to poll the status of an OAuth flow+ */+router.get('/oauth/status/:flowId', async (req, res) => {+ try {+ const { flowId } = req.params;+ const flowsCache = getLogStores(CacheKeys.FLOWS);+ const flowManager = getFlowStateManager(flowsCache);++ const flowState = await flowManager.getFlowState(flowId, 'mcp_oauth');+ if (!flowState) {+ return res.status(404).json({ error: 'Flow not found' });+ }++ res.json({+ status: flowState.status,+ completed: flowState.status === 'COMPLETED',+ failed: flowState.status === 'FAILED',+ error: flowState.error,+ });+ } catch (error) {+ logger.error('[MCP OAuth] Failed to get flow status', error);+ res.status(500).json({ error: 'Failed to get flow status' });+ }+});++module.exports = router;diff --git a/api/server/routes/oauth.js b/api/server/routes/oauth.jsindex bc8d120ef5..afc4a05b75 100644--- a/api/server/routes/oauth.js+++ b/api/server/routes/oauth.js@@ -47,7 +47,9 @@ const oauthHandler = async (req, res) => {router.get('/error', (req, res) => {// A single error message is pushed by passport when authentication fails.- logger.error('Error in OAuth authentication:', { message: req.session.messages.pop() });+ logger.error('Error in OAuth authentication:', {+ message: req.session?.messages?.pop() || 'Unknown error',+ });// Redirect to login page with auth_failed parameter to prevent infinite redirect loopsres.redirect(`${domains.client}/login?redirect=false`);diff --git a/api/server/services/ActionService.js b/api/server/services/ActionService.jsindex 9bf7491543..b9555a752c 100644--- a/api/server/services/ActionService.js+++ b/api/server/services/ActionService.js@@ -3,7 +3,13 @@ const { nanoid } = require('nanoid');const { tool } = require('@langchain/core/tools');const { logger } = require('@librechat/data-schemas');const { GraphEvents, sleep } = require('@librechat/agents');-const { sendEvent, logAxiosError } = require('@librechat/api');+const {+ sendEvent,+ encryptV2,+ decryptV2,+ logAxiosError,+ refreshAccessToken,+} = require('@librechat/api');const {Time,CacheKeys,@@ -14,13 +20,11 @@ const {isImageVisionTool,actionDomainSeparator,} = require('librechat-data-provider');-const { refreshAccessToken } = require('~/server/services/TokenService');-const { encryptV2, decryptV2 } = require('~/server/utils/crypto');+const { findToken, updateToken, createToken } = require('~/models');const { getActions, deleteActions } = require('~/models/Action');const { deleteAssistant } = require('~/models/Assistant');const { getFlowStateManager } = require('~/config');const { getLogStores } = require('~/cache');-const { findToken } = require('~/models');const JWT_SECRET = process.env.JWT_SECRET;const toolNameRegex = /^[a-zA-Z0-9_-]+$/;@@ -258,15 +262,22 @@ async function createActionTool({try {const refresh_token = await decryptV2(refreshTokenData.token);const refreshTokens = async () =>- await refreshAccessToken({- userId,- identifier,- refresh_token,- client_url: metadata.auth.client_url,- encrypted_oauth_client_id: encrypted.oauth_client_id,- token_exchange_method: metadata.auth.token_exchange_method,- encrypted_oauth_client_secret: encrypted.oauth_client_secret,- });+ await refreshAccessToken(+ {+ userId,+ identifier,+ refresh_token,+ client_url: metadata.auth.client_url,+ encrypted_oauth_client_id: encrypted.oauth_client_id,+ token_exchange_method: metadata.auth.token_exchange_method,+ encrypted_oauth_client_secret: encrypted.oauth_client_secret,+ },+ {+ findToken,+ updateToken,+ createToken,+ },+ );const flowsCache = getLogStores(CacheKeys.FLOWS);const flowManager = getFlowStateManager(flowsCache);const refreshData = await flowManager.createFlowWithHandler(diff --git a/api/server/services/AppService.js b/api/server/services/AppService.jsindex 2e5a0e586b..6b7ff7417f 100644--- a/api/server/services/AppService.js+++ b/api/server/services/AppService.js@@ -1,7 +1,6 @@const {FileSources,loadOCRConfig,- processMCPEnv,EModelEndpoint,loadMemoryConfig,getConfigDefaults,@@ -28,7 +27,7 @@ const { initializeS3 } = require('./Files/S3/initialize');const { loadAndFormatTools } = require('./ToolService');const { isEnabled } = require('~/server/utils');const { initializeRoles } = require('~/models');-const { getMCPManager } = require('~/config');+const { setCachedTools } = require('./Config');const paths = require('~/config/paths');/**@@ -76,11 +75,10 @@ const AppService = async (app) => {directory: paths.structuredTools,});- if (config.mcpServers != null) {- const mcpManager = getMCPManager();- await mcpManager.initializeMCP(config.mcpServers, processMCPEnv);- await mcpManager.mapAvailableTools(availableTools);- }+ await setCachedTools(availableTools, { isGlobal: true });++ // Store MCP config for later initialization+ const mcpConfig = config.mcpServers || null;const socialLogins =config?.registration?.socialLogins ?? configDefaults?.registration?.socialLogins;@@ -96,11 +94,11 @@ const AppService = async (app) => {socialLogins,filteredTools,includedTools,- availableTools,imageOutputType,interfaceConfig,turnstileConfig,balance,+ mcpConfig,};const agentsDefaults = agentsConfigSetup(config);diff --git a/api/server/services/AppService.spec.js b/api/server/services/AppService.spec.jsindex 70a405ccdb..7edccc2c0d 100644--- a/api/server/services/AppService.spec.js+++ b/api/server/services/AppService.spec.js@@ -32,6 +32,25 @@ jest.mock('~/models', () => ({jest.mock('~/models/Role', () => ({updateAccessPermissions: jest.fn(),}));+jest.mock('./Config', () => ({+ setCachedTools: jest.fn(),+ getCachedTools: jest.fn().mockResolvedValue({+ ExampleTool: {+ type: 'function',+ function: {+ description: 'Example tool function',+ name: 'exampleFunction',+ parameters: {+ type: 'object',+ properties: {+ param1: { type: 'string', description: 'An example parameter' },+ },+ required: ['param1'],+ },+ },+ },+ }),+}));jest.mock('./ToolService', () => ({loadAndFormatTools: jest.fn().mockReturnValue({ExampleTool: {@@ -121,22 +140,9 @@ describe('AppService', () => {sidePanel: true,presets: true,}),+ mcpConfig: null,turnstileConfig: mockedTurnstileConfig,modelSpecs: undefined,- availableTools: {- ExampleTool: {- type: 'function',- function: expect.objectContaining({- description: 'Example tool function',- name: 'exampleFunction',- parameters: expect.objectContaining({- type: 'object',- properties: expect.any(Object),- required: expect.arrayContaining(['param1']),- }),- }),- },- },paths: expect.anything(),ocr: expect.anything(),imageOutputType: expect.any(String),@@ -223,14 +229,41 @@ describe('AppService', () => {it('should load and format tools accurately with defined structure', async () => {const { loadAndFormatTools } = require('./ToolService');+ const { setCachedTools, getCachedTools } = require('./Config');+await AppService(app);expect(loadAndFormatTools).toHaveBeenCalledWith({+ adminFilter: undefined,+ adminIncluded: undefined,directory: expect.anything(),});- expect(app.locals.availableTools.ExampleTool).toBeDefined();- expect(app.locals.availableTools.ExampleTool).toEqual({+ // Verify setCachedTools was called with the tools+ expect(setCachedTools).toHaveBeenCalledWith(+ {+ ExampleTool: {+ type: 'function',+ function: {+ description: 'Example tool function',+ name: 'exampleFunction',+ parameters: {+ type: 'object',+ properties: {+ param1: { type: 'string', description: 'An example parameter' },+ },+ required: ['param1'],+ },+ },+ },+ },+ { isGlobal: true },+ );++ // Verify we can retrieve the tools from cache+ const cachedTools = await getCachedTools({ includeGlobal: true });+ expect(cachedTools.ExampleTool).toBeDefined();+ expect(cachedTools.ExampleTool).toEqual({type: 'function',function: {description: 'Example tool function',@@ -535,7 +568,6 @@ describe('AppService updating app.locals and issuing warnings', () => {expect(app.locals).toBeDefined();expect(app.locals.paths).toBeDefined();- expect(app.locals.availableTools).toBeDefined();expect(app.locals.fileStrategy).toEqual(FileSources.local);expect(app.locals.socialLogins).toEqual(defaultSocialLogins);expect(app.locals.balance).toEqual(@@ -568,7 +600,6 @@ describe('AppService updating app.locals and issuing warnings', () => {expect(app.locals).toBeDefined();expect(app.locals.paths).toBeDefined();- expect(app.locals.availableTools).toBeDefined();expect(app.locals.fileStrategy).toEqual(customConfig.fileStrategy);expect(app.locals.socialLogins).toEqual(customConfig.registration.socialLogins);expect(app.locals.balance).toEqual(customConfig.balance);diff --git a/api/server/services/AuthService.js b/api/server/services/AuthService.jsindex 2c285512ee..6061277437 100644--- a/api/server/services/AuthService.js+++ b/api/server/services/AuthService.js@@ -1,5 +1,7 @@const bcrypt = require('bcryptjs');const { webcrypto } = require('node:crypto');+const { isEnabled } = require('@librechat/api');+const { logger } = require('@librechat/data-schemas');const { SystemRoles, errorsToString } = require('librechat-data-provider');const {findUser,@@ -17,11 +19,10 @@ const {deleteUserById,generateRefreshToken,} = require('~/models');-const { isEnabled, checkEmailConfig, sendEmail } = require('~/server/utils');const { isEmailDomainAllowed } = require('~/server/services/domains');+const { checkEmailConfig, sendEmail } = require('~/server/utils');const { getBalanceConfig } = require('~/server/services/Config');const { registerSchema } = require('~/strategies/validators');-const { logger } = require('~/config');const domains = {client: process.env.DOMAIN_CLIENT,diff --git a/api/server/services/Config/getCachedTools.js b/api/server/services/Config/getCachedTools.jsnew file mode 100644index 0000000000..b3a4f0c869--- /dev/null+++ b/api/server/services/Config/getCachedTools.js@@ -0,0 +1,258 @@+const { CacheKeys } = require('librechat-data-provider');+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}`,+};++/**+ * 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+ * @returns {Promise<Object|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;++ // 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);+ }++ // Future implementation will merge tools from multiple sources+ // based on user permissions, roles, and groups+ if (userId) {+ // Check if we have pre-computed effective tools for this user+ const effectiveTools = await cache.get(ToolCacheKeys.EFFECTIVE(userId));+ if (effectiveTools) {+ return effectiveTools;+ }++ // 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;+}++/**+ * Sets available tools in cache+ * @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 {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);+ }++ if (!cacheKey) {+ throw new Error('Invalid cache key options provided');+ }++ return await cache.set(cacheKey, 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 {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 keysToDelete = [];++ if (invalidateGlobal) {+ 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+ }++ 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+ */+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;+ }++ for (const [toolId, toolConfig] of Object.entries(source)) {+ // Simple last-write-wins for now+ // Future: merge based on permission levels+ merged[toolId] = toolConfig;+ }+ }++ return merged;+}++/**+ * Middleware-friendly function to get tools for a request+ * @function getToolsForRequest+ * @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,+ });+}++module.exports = {+ ToolCacheKeys,+ getCachedTools,+ setCachedTools,+ getToolsForRequest,+ invalidateCachedTools,+ computeEffectiveTools,+};diff --git a/api/server/services/Config/index.js b/api/server/services/Config/index.jsindex 9d668da958..ad25e57998 100644--- a/api/server/services/Config/index.js+++ b/api/server/services/Config/index.js@@ -1,4 +1,5 @@const { config } = require('./EndpointService');+const getCachedTools = require('./getCachedTools');const getCustomConfig = require('./getCustomConfig');const loadCustomConfig = require('./loadCustomConfig');const loadConfigModels = require('./loadConfigModels');@@ -14,6 +15,7 @@ module.exports = {loadDefaultModels,loadOverrideConfig,loadAsyncEndpoints,+ ...getCachedTools,...getCustomConfig,...getEndpointsConfig,};diff --git a/api/server/services/MCP.js b/api/server/services/MCP.jsindex 357913e519..9720305668 100644--- a/api/server/services/MCP.js+++ b/api/server/services/MCP.js@@ -1,27 +1,111 @@const { z } = require('zod');const { tool } = require('@langchain/core/tools');-const { normalizeServerName } = require('@librechat/api');-const { Constants: AgentConstants, Providers } = require('@librechat/agents');+const { logger } = require('@librechat/data-schemas');+const { Time, CacheKeys, StepTypes } = require('librechat-data-provider');+const { sendEvent, normalizeServerName, MCPOAuthHandler } = require('@librechat/api');+const { Constants: AgentConstants, Providers, GraphEvents } = require('@librechat/agents');const {Constants,ContentTypes,isAssistantsEndpoint,convertJsonSchemaToZod,} = require('librechat-data-provider');-const { logger, getMCPManager } = require('~/config');+const { getMCPManager, getFlowStateManager } = require('~/config');+const { findToken, createToken, updateToken } = require('~/models');+const { getCachedTools } = require('./Config');+const { getLogStores } = require('~/cache');++/**+ * @param {object} params+ * @param {ServerResponse} params.res - The Express response object for sending events.+ * @param {string} params.stepId - The ID of the step in the flow.+ * @param {ToolCallChunk} params.toolCall - The tool call object containing tool information.+ * @param {string} params.loginFlowId - The ID of the login flow.+ * @param {FlowStateManager<any>} params.flowManager - The flow manager instance.+ */+function createOAuthStart({ res, stepId, toolCall, loginFlowId, flowManager, signal }) {+ /**+ * Creates a function to handle OAuth login requests.+ * @param {string} authURL - The URL to redirect the user for OAuth authentication.+ * @returns {Promise<boolean>} Returns true to indicate the event was sent successfully.+ */+ return async function (authURL) {+ /** @type {{ id: string; delta: AgentToolCallDelta }} */+ const data = {+ id: stepId,+ delta: {+ type: StepTypes.TOOL_CALLS,+ tool_calls: [{ ...toolCall, args: '' }],+ auth: authURL,+ expires_at: Date.now() + Time.TWO_MINUTES,+ },+ };+ /** Used to ensure the handler (use of `sendEvent`) is only invoked once */+ await flowManager.createFlowWithHandler(+ loginFlowId,+ 'oauth_login',+ async () => {+ sendEvent(res, { event: GraphEvents.ON_RUN_STEP_DELTA, data });+ logger.debug('Sent OAuth login request to client');+ return true;+ },+ signal,+ );+ };+}++/**+ * @param {object} params+ * @param {ServerResponse} params.res - The Express response object for sending events.+ * @param {string} params.stepId - The ID of the step in the flow.+ * @param {ToolCallChunk} params.toolCall - The tool call object containing tool information.+ * @param {string} params.loginFlowId - The ID of the login flow.+ * @param {FlowStateManager<any>} params.flowManager - The flow manager instance.+ */+function createOAuthEnd({ res, stepId, toolCall }) {+ return async function () {+ /** @type {{ id: string; delta: AgentToolCallDelta }} */+ const data = {+ id: stepId,+ delta: {+ type: StepTypes.TOOL_CALLS,+ tool_calls: [{ ...toolCall }],+ },+ };+ sendEvent(res, { event: GraphEvents.ON_RUN_STEP_DELTA, data });+ logger.debug('Sent OAuth login success to client');+ };+}++/**+ * @param {object} params+ * @param {string} params.userId - The ID of the user.+ * @param {string} params.serverName - The name of the server.+ * @param {string} params.toolName - The name of the tool.+ * @param {FlowStateManager<any>} params.flowManager - The flow manager instance.+ */+function createAbortHandler({ userId, serverName, toolName, flowManager }) {+ return function () {+ logger.info(`[MCP][User: ${userId}][${serverName}][${toolName}] Tool call aborted`);+ const flowId = MCPOAuthHandler.generateFlowId(userId, serverName);+ flowManager.failFlow(flowId, 'mcp_oauth', new Error('Tool call aborted'));+ };+}/*** Creates a general tool for an entire action set.** @param {Object} params - The parameters for loading action sets.* @param {ServerRequest} params.req - The Express request object, containing user/request info.+ * @param {ServerResponse} params.res - The Express response object for sending events.* @param {string} params.toolKey - The toolKey for the tool.* @param {import('@librechat/agents').Providers | EModelEndpoint} params.provider - The provider for the tool.* @param {string} params.model - The model for the tool.* @returns { Promise<typeof tool | { _call: (toolInput: Object | string) => unknown}> } An object with `_call` method to execute the tool input.*/-async function createMCPTool({ req, toolKey, provider: _provider }) {- const toolDefinition = req.app.locals.availableTools[toolKey]?.function;+async function createMCPTool({ req, res, toolKey, provider: _provider }) {+ const availableTools = await getCachedTools({ includeGlobal: true });+ const toolDefinition = availableTools?.[toolKey]?.function;if (!toolDefinition) {logger.error(`Tool ${toolKey} not found in available tools`);return null;@@ -51,10 +135,39 @@ async function createMCPTool({ req, toolKey, provider: _provider }) {/** @type {(toolArguments: Object | string, config?: GraphRunnableConfig) => Promise<unknown>} */const _call = async (toolArguments, config) => {const userId = config?.configurable?.user?.id || config?.configurable?.user_id;+ /** @type {ReturnType<typeof createAbortHandler>} */+ let abortHandler = null;+ /** @type {AbortSignal} */+ let derivedSignal = null;+try {- const derivedSignal = config?.signal ? AbortSignal.any([config.signal]) : undefined;+ const flowsCache = getLogStores(CacheKeys.FLOWS);+ const flowManager = getFlowStateManager(flowsCache);+ derivedSignal = config?.signal ? AbortSignal.any([config.signal]) : undefined;const mcpManager = getMCPManager(userId);const provider = (config?.metadata?.provider || _provider)?.toLowerCase();++ const { args: _args, stepId, ...toolCall } = config.toolCall ?? {};+ const loginFlowId = `${serverName}:oauth_login:${config.metadata.thread_id}:${config.metadata.run_id}`;+ const oauthStart = createOAuthStart({+ res,+ stepId,+ toolCall,+ loginFlowId,+ flowManager,+ signal: derivedSignal,+ });+ const oauthEnd = createOAuthEnd({+ res,+ stepId,+ toolCall,+ });++ if (derivedSignal) {+ abortHandler = createAbortHandler({ userId, serverName, toolName, flowManager });+ derivedSignal.addEventListener('abort', abortHandler, { once: true });+ }+const result = await mcpManager.callTool({serverName,toolName,@@ -64,6 +177,14 @@ async function createMCPTool({ req, toolKey, provider: _provider }) {signal: derivedSignal,user: config?.configurable?.user,},+ flowManager,+ tokenMethods: {+ findToken,+ createToken,+ updateToken,+ },+ oauthStart,+ oauthEnd,});if (isAssistantsEndpoint(provider) && Array.isArray(result)) {@@ -78,9 +199,28 @@ async function createMCPTool({ req, toolKey, provider: _provider }) {`[MCP][User: ${userId}][${serverName}] Error calling "${toolName}" MCP tool:`,error,);++ /** OAuth error, provide a helpful message */+ const isOAuthError =+ error.message?.includes('401') ||+ error.message?.includes('OAuth') ||+ error.message?.includes('authentication') ||+ error.message?.includes('Non-200 status code (401)');++ if (isOAuthError) {+ throw new Error(+ `OAuth authentication required for ${serverName}. Please check the server logs for the authentication URL.`,+ );+ }+throw new Error(`"${toolKey}" tool call failed${error?.message ? `: ${error?.message}` : '.'}`,);+ } finally {+ // Clean up abort handler to prevent memory leaks+ if (abortHandler && derivedSignal) {+ derivedSignal.removeEventListener('abort', abortHandler);+ }}};diff --git a/api/server/services/PluginService.js b/api/server/services/PluginService.jsindex 7463e0814e..04c5abb32b 100644--- a/api/server/services/PluginService.js+++ b/api/server/services/PluginService.js@@ -1,6 +1,6 @@-const { encrypt, decrypt } = require('~/server/utils/crypto');+const { logger } = require('@librechat/data-schemas');+const { encrypt, decrypt } = require('@librechat/api');const { PluginAuth } = require('~/db/models');-const { logger } = require('~/config');/*** Asynchronously retrieves and decrypts the authentication value for a user's plugin, based on a specified authentication field.diff --git a/api/server/services/TokenService.js b/api/server/services/TokenService.jsdeleted file mode 100644index ec74844197..0000000000--- a/api/server/services/TokenService.js+++ /dev/null@@ -1,195 +0,0 @@-const axios = require('axios');-const { logAxiosError } = require('@librechat/api');-const { logger } = require('@librechat/data-schemas');-const { TokenExchangeMethodEnum } = require('librechat-data-provider');-const { handleOAuthToken } = require('~/models/Token');-const { decryptV2 } = require('~/server/utils/crypto');--/**- * Processes the access tokens and stores them in the database.- * @param {object} tokenData- * @param {string} tokenData.access_token- * @param {number} tokenData.expires_in- * @param {string} [tokenData.refresh_token]- * @param {number} [tokenData.refresh_token_expires_in]- * @param {object} metadata- * @param {string} metadata.userId- * @param {string} metadata.identifier- * @returns {Promise<void>}- */-async function processAccessTokens(tokenData, { userId, identifier }) {- const { access_token, expires_in = 3600, refresh_token, refresh_token_expires_in } = tokenData;- if (!access_token) {- logger.error('Access token not found: ', tokenData);- throw new Error('Access token not found');- }- await handleOAuthToken({- identifier,- token: access_token,- expiresIn: expires_in,- userId,- });-- if (refresh_token != null) {- logger.debug('Processing refresh token');- await handleOAuthToken({- token: refresh_token,- type: 'oauth_refresh',- userId,- identifier: `${identifier}:refresh`,- expiresIn: refresh_token_expires_in ?? null,- });- }- logger.debug('Access tokens processed');-}--/**- * Refreshes the access token using the refresh token.- * @param {object} fields- * @param {string} fields.userId - The ID of the user.- * @param {string} fields.client_url - The URL of the OAuth provider.- * @param {string} fields.identifier - The identifier for the token.- * @param {string} fields.refresh_token - The refresh token to use.- * @param {string} fields.token_exchange_method - The token exchange method ('default_post' or 'basic_auth_header').- * @param {string} fields.encrypted_oauth_client_id - The client ID for the OAuth provider.- * @param {string} fields.encrypted_oauth_client_secret - The client secret for the OAuth provider.- * @returns {Promise<{- * access_token: string,- * expires_in: number,- * refresh_token?: string,- * refresh_token_expires_in?: number,- * }>}- */-const refreshAccessToken = async ({- userId,- client_url,- identifier,- refresh_token,- token_exchange_method,- encrypted_oauth_client_id,- encrypted_oauth_client_secret,-}) => {- try {- const oauth_client_id = await decryptV2(encrypted_oauth_client_id);- const oauth_client_secret = await decryptV2(encrypted_oauth_client_secret);-- const headers = {- 'Content-Type': 'application/x-www-form-urlencoded',- Accept: 'application/json',- };-- const params = new URLSearchParams({- grant_type: 'refresh_token',- refresh_token,- });-- if (token_exchange_method === TokenExchangeMethodEnum.BasicAuthHeader) {- const basicAuth = Buffer.from(`${oauth_client_id}:${oauth_client_secret}`).toString('base64');- headers['Authorization'] = `Basic ${basicAuth}`;- } else {- params.append('client_id', oauth_client_id);- params.append('client_secret', oauth_client_secret);- }-- const response = await axios({- method: 'POST',- url: client_url,- headers,- data: params.toString(),- });- await processAccessTokens(response.data, {- userId,- identifier,- });- logger.debug(`Access token refreshed successfully for ${identifier}`);- return response.data;- } catch (error) {- const message = 'Error refreshing OAuth tokens';- throw new Error(- logAxiosError({- message,- error,- }),- );- }-};--/**- * Handles the OAuth callback and exchanges the authorization code for tokens.- * @param {object} fields- * @param {string} fields.code - The authorization code returned by the provider.- * @param {string} fields.userId - The ID of the user.- * @param {string} fields.identifier - The identifier for the token.- * @param {string} fields.client_url - The URL of the OAuth provider.- * @param {string} fields.redirect_uri - The redirect URI for the OAuth provider.- * @param {string} fields.token_exchange_method - The token exchange method ('default_post' or 'basic_auth_header').- * @param {string} fields.encrypted_oauth_client_id - The client ID for the OAuth provider.- * @param {string} fields.encrypted_oauth_client_secret - The client secret for the OAuth provider.- * @returns {Promise<{- * access_token: string,- * expires_in: number,- * refresh_token?: string,- * refresh_token_expires_in?: number,- * }>}- */-const getAccessToken = async ({- code,- userId,- identifier,- client_url,- redirect_uri,- token_exchange_method,- encrypted_oauth_client_id,- encrypted_oauth_client_secret,-}) => {- const oauth_client_id = await decryptV2(encrypted_oauth_client_id);- const oauth_client_secret = await decryptV2(encrypted_oauth_client_secret);-- const headers = {- 'Content-Type': 'application/x-www-form-urlencoded',- Accept: 'application/json',- };-- const params = new URLSearchParams({- code,- grant_type: 'authorization_code',- redirect_uri,- });-- if (token_exchange_method === TokenExchangeMethodEnum.BasicAuthHeader) {- const basicAuth = Buffer.from(`${oauth_client_id}:${oauth_client_secret}`).toString('base64');- headers['Authorization'] = `Basic ${basicAuth}`;- } else {- params.append('client_id', oauth_client_id);- params.append('client_secret', oauth_client_secret);- }-- try {- const response = await axios({- method: 'POST',- url: client_url,- headers,- data: params.toString(),- });-- await processAccessTokens(response.data, {- userId,- identifier,- });- logger.debug(`Access tokens successfully created for ${identifier}`);- return response.data;- } catch (error) {- const message = 'Error exchanging OAuth code';- throw new Error(- logAxiosError({- message,- error,- }),- );- }-};--module.exports = {- getAccessToken,- refreshAccessToken,-};diff --git a/api/server/services/ToolService.js b/api/server/services/ToolService.jsindex 9172c25e96..f1567a3783 100644--- a/api/server/services/ToolService.js+++ b/api/server/services/ToolService.js@@ -1,5 +1,7 @@const fs = require('fs');const path = require('path');+const { sleep } = require('@librechat/agents');+const { logger } = require('@librechat/data-schemas');const { zodToJsonSchema } = require('zod-to-json-schema');const { Calculator } = require('@langchain/community/tools/calculator');const { tool: toolFn, Tool, DynamicStructuredTool } = require('@langchain/core/tools');@@ -31,14 +33,12 @@ const {toolkits,} = require('~/app/clients/tools');const { processFileURL, uploadImageBuffer } = require('~/server/services/Files/process');+const { getEndpointsConfig, getCachedTools } = require('~/server/services/Config');const { createOnSearchResults } = require('~/server/services/Tools/search');const { isActionDomainAllowed } = require('~/server/services/domains');-const { getEndpointsConfig } = require('~/server/services/Config');const { recordUsage } = require('~/server/services/Threads');const { loadTools } = require('~/app/clients/tools/util');const { redactMessage } = require('~/config/parsers');-const { sleep } = require('~/server/utils');-const { logger } = require('~/config');/*** @param {string} toolName@@ -226,7 +226,7 @@ async function processRequiredActions(client, requiredActions) {`[required actions] user: ${client.req.user.id} | thread_id: ${requiredActions[0].thread_id} | run_id: ${requiredActions[0].run_id}`,requiredActions,);- const toolDefinitions = client.req.app.locals.availableTools;+ const toolDefinitions = await getCachedTools({ includeGlobal: true });const seenToolkits = new Set();const tools = requiredActions.map((action) => {@@ -553,6 +553,7 @@ async function loadAgentTools({ req, res, agent, tool_resources, openAIApiKey })tools: _agentTools,options: {req,+ res,openAIApiKey,tool_resources,processFileURL,diff --git a/api/server/services/UserService.js b/api/server/services/UserService.jsindex b729607f69..7cf2f832a3 100644--- a/api/server/services/UserService.js+++ b/api/server/services/UserService.js@@ -1,6 +1,6 @@const { logger } = require('@librechat/data-schemas');+const { encrypt, decrypt } = require('@librechat/api');const { ErrorTypes } = require('librechat-data-provider');-const { encrypt, decrypt } = require('~/server/utils/crypto');const { updateUser } = require('~/models');const { Key } = require('~/db/models');@@ -70,6 +70,7 @@ const getUserKeyValues = async ({ userId, name }) => {try {userValues = JSON.parse(userValues);} catch (e) {+ logger.error('[getUserKeyValues]', e);throw new Error(JSON.stringify({type: ErrorTypes.INVALID_USER_KEY,diff --git a/api/server/services/initializeMCP.js b/api/server/services/initializeMCP.jsnew file mode 100644index 0000000000..d7c5ab7d8a--- /dev/null+++ b/api/server/services/initializeMCP.js@@ -0,0 +1,54 @@+const { logger } = require('@librechat/data-schemas');+const { CacheKeys, processMCPEnv } = require('librechat-data-provider');+const { getMCPManager, getFlowStateManager } = require('~/config');+const { getCachedTools, setCachedTools } = require('./Config');+const { getLogStores } = require('~/cache');+const { findToken, updateToken, createToken, deleteTokens } = require('~/models');++/**+ * Initialize MCP servers+ * @param {import('express').Application} app - Express app instance+ */+async function initializeMCP(app) {+ const mcpServers = app.locals.mcpConfig;+ if (!mcpServers) {+ return;+ }++ logger.info('Initializing MCP servers...');+ const mcpManager = getMCPManager();+ const flowsCache = getLogStores(CacheKeys.FLOWS);+ const flowManager = flowsCache ? getFlowStateManager(flowsCache) : null;++ try {+ await mcpManager.initializeMCP({+ mcpServers,+ flowManager,+ tokenMethods: {+ findToken,+ updateToken,+ createToken,+ deleteTokens,+ },+ processMCPEnv,+ });++ delete app.locals.mcpConfig;+ const availableTools = await getCachedTools();++ if (!availableTools) {+ logger.warn('No available tools found in cache during MCP initialization');+ return;+ }++ const toolsCopy = { ...availableTools };+ await mcpManager.mapAvailableTools(toolsCopy, flowManager);+ await setCachedTools(toolsCopy, { isGlobal: true });++ logger.info('MCP servers initialized successfully');+ } catch (error) {+ logger.error('Failed to initialize MCP servers:', error);+ }+}++module.exports = initializeMCP;diff --git a/api/server/services/twoFactorService.js b/api/server/services/twoFactorService.jsindex 0274842367..4ac86a5549 100644--- a/api/server/services/twoFactorService.js+++ b/api/server/services/twoFactorService.js@@ -1,5 +1,5 @@const { webcrypto } = require('node:crypto');-const { hashBackupCode, decryptV3, decryptV2 } = require('~/server/utils/crypto');+const { hashBackupCode, decryptV3, decryptV2 } = require('@librechat/api');const { updateUser } = require('~/models');// Base32 alphabet for TOTP secret encoding.diff --git a/api/server/utils/index.js b/api/server/utils/index.jsindex aa432ec379..2661ff75e1 100644--- a/api/server/utils/index.js+++ b/api/server/utils/index.js@@ -3,7 +3,6 @@ const removePorts = require('./removePorts');const countTokens = require('./countTokens');const handleText = require('./handleText');const sendEmail = require('./sendEmail');-const cryptoUtils = require('./crypto');const queue = require('./queue');const files = require('./files');const math = require('./math');@@ -31,7 +30,6 @@ function checkEmailConfig() {module.exports = {...streamResponse,checkEmailConfig,- ...cryptoUtils,...handleText,countTokens,removePorts,diff --git a/api/strategies/openidStrategy.spec.js b/api/strategies/openidStrategy.spec.jsindex 3e52ad01f1..1e6750384e 100644--- a/api/strategies/openidStrategy.spec.js+++ b/api/strategies/openidStrategy.spec.js@@ -21,19 +21,18 @@ jest.mock('~/models', () => ({createUser: jest.fn(),updateUser: jest.fn(),}));-jest.mock('~/server/utils/crypto', () => ({- hashToken: jest.fn().mockResolvedValue('hashed-token'),-}));-jest.mock('~/server/utils', () => ({+jest.mock('@librechat/api', () => ({+ ...jest.requireActual('@librechat/api'),isEnabled: jest.fn(() => false),}));-jest.mock('~/config', () => ({+jest.mock('@librechat/data-schemas', () => ({+ ...jest.requireActual('@librechat/api'),logger: {info: jest.fn(),debug: jest.fn(),error: jest.fn(),- warn: jest.fn(),},+ hashToken: jest.fn().mockResolvedValue('hashed-token'),}));jest.mock('~/cache/getLogStores', () =>jest.fn(() => ({diff --git a/api/strategies/samlStrategy.spec.js b/api/strategies/samlStrategy.spec.jsindex 675bdc998b..fc8329a31a 100644--- a/api/strategies/samlStrategy.spec.js+++ b/api/strategies/samlStrategy.spec.js@@ -1,15 +1,17 @@-const fs = require('fs');-const path = require('path');-const fetch = require('node-fetch');-const { Strategy: SamlStrategy } = require('@node-saml/passport-saml');-const { findUser, createUser, updateUser } = require('~/models');-const { setupSaml, getCertificateContent } = require('./samlStrategy');-// --- Mocks ---+jest.mock('tiktoken');jest.mock('fs');jest.mock('path');jest.mock('node-fetch');jest.mock('@node-saml/passport-saml');+jest.mock('@librechat/data-schemas', () => ({+ logger: {+ info: jest.fn(),+ debug: jest.fn(),+ error: jest.fn(),+ },+ hashToken: jest.fn().mockResolvedValue('hashed-token'),+}));jest.mock('~/models', () => ({findUser: jest.fn(),createUser: jest.fn(),@@ -29,26 +31,26 @@ jest.mock('~/server/services/Config', () => ({jest.mock('~/server/services/Config/EndpointService', () => ({config: {},}));-jest.mock('~/server/utils', () => ({- isEnabled: jest.fn(() => false),- isUserProvided: jest.fn(() => false),-}));jest.mock('~/server/services/Files/strategies', () => ({getStrategyFunctions: jest.fn(() => ({saveBuffer: jest.fn().mockResolvedValue('/fake/path/to/avatar.png'),})),}));-jest.mock('~/server/utils/crypto', () => ({- hashToken: jest.fn().mockResolvedValue('hashed-token'),-}));-jest.mock('~/config', () => ({- logger: {- info: jest.fn(),- debug: jest.fn(),- error: jest.fn(),- },+jest.mock('~/config/paths', () => ({+ root: '/fake/root/path',}));+const fs = require('fs');+const path = require('path');+const fetch = require('node-fetch');+const { Strategy: SamlStrategy } = require('@node-saml/passport-saml');+const { setupSaml, getCertificateContent } = require('./samlStrategy');++// Configure fs mock+jest.mocked(fs).existsSync = jest.fn();+jest.mocked(fs).statSync = jest.fn();+jest.mocked(fs).readFileSync = jest.fn();+// To capture the verify callback from the strategy, we grab it from the mock constructorlet verifyCallback;SamlStrategy.mockImplementation((options, verify) => {diff --git a/api/typedefs.js b/api/typedefs.jsindex 5bc7ebf664..58cd802425 100644--- a/api/typedefs.js+++ b/api/typedefs.js@@ -476,11 +476,18 @@* @memberof typedefs*/+/**+ * @exports ToolCallChunk+ * @typedef {import('librechat-data-provider').Agents.ToolCallChunk} ToolCallChunk+ * @memberof typedefs+ */+/*** @exports MessageContentImageUrl* @typedef {import('librechat-data-provider').Agents.MessageContentImageUrl} MessageContentImageUrl* @memberof typedefs*/+/** Web Search *//**diff --git a/client/src/components/OAuth/OAuthError.tsx b/client/src/components/OAuth/OAuthError.tsxnew file mode 100644index 0000000000..ac5532c241--- /dev/null+++ b/client/src/components/OAuth/OAuthError.tsx@@ -0,0 +1,72 @@+import React from 'react';+import { useSearchParams } from 'react-router-dom';+import { useLocalize } from '~/hooks';++export default function OAuthError() {+ const localize = useLocalize();+ const [searchParams] = useSearchParams();+ const error = searchParams.get('error') || 'unknown_error';++ const getErrorMessage = (error: string): string => {+ switch (error) {+ case 'missing_code':+ return (+ localize('com_ui_oauth_error_missing_code') ||+ 'Authorization code is missing. Please try again.'+ );+ case 'missing_state':+ return (+ localize('com_ui_oauth_error_missing_state') ||+ 'State parameter is missing. Please try again.'+ );+ case 'invalid_state':+ return (+ localize('com_ui_oauth_error_invalid_state') ||+ 'Invalid state parameter. Please try again.'+ );+ case 'callback_failed':+ return (+ localize('com_ui_oauth_error_callback_failed') ||+ 'Authentication callback failed. Please try again.'+ );+ default:+ return localize('com_ui_oauth_error_generic') || error.replace(/_/g, ' ');+ }+ };++ return (+ <div className="flex min-h-screen items-center justify-center bg-gray-50 p-8">+ <div className="w-full max-w-md rounded-lg bg-white p-8 text-center shadow-lg">+ <div className="mb-4 flex justify-center">+ <div className="flex h-12 w-12 items-center justify-center rounded-full bg-red-100">+ <svg+ className="h-6 w-6 text-red-600"+ fill="none"+ viewBox="0 0 24 24"+ stroke="currentColor"+ aria-hidden="true"+ >+ <path+ strokeLinecap="round"+ strokeLinejoin="round"+ strokeWidth={2}+ d="M6 18L18 6M6 6l12 12"+ />+ </svg>+ </div>+ </div>+ <h1 className="mb-4 text-3xl font-bold text-gray-900">+ {localize('com_ui_oauth_error_title') || 'Authentication Failed'}+ </h1>+ <p className="mb-6 text-sm text-gray-600">{getErrorMessage(error)}</p>+ <button+ onClick={() => window.close()}+ className="rounded-md bg-gray-900 px-4 py-2 text-sm font-medium text-white hover:bg-gray-800 focus:outline-none focus:ring-2 focus:ring-gray-500 focus:ring-offset-2"+ aria-label={localize('com_ui_close_window') || 'Close Window'}+ >+ {localize('com_ui_close_window') || 'Close Window'}+ </button>+ </div>+ </div>+ );+}diff --git a/client/src/components/OAuth/OAuthSuccess.tsx b/client/src/components/OAuth/OAuthSuccess.tsxnew file mode 100644index 0000000000..fd8051a6f5--- /dev/null+++ b/client/src/components/OAuth/OAuthSuccess.tsx@@ -0,0 +1,47 @@+import React, { useEffect, useState } from 'react';+import { useSearchParams } from 'react-router-dom';+import { useLocalize } from '~/hooks';++export default function OAuthSuccess() {+ const localize = useLocalize();+ const [searchParams] = useSearchParams();+ const [secondsLeft, setSecondsLeft] = useState(3);+ const serverName = searchParams.get('serverName');++ useEffect(() => {+ const countdown = setInterval(() => {+ setSecondsLeft((prev) => {+ if (prev <= 1) {+ clearInterval(countdown);+ window.close();+ return 0;+ }+ return prev - 1;+ });+ }, 1000);++ return () => clearInterval(countdown);+ }, []);++ return (+ <div className="flex min-h-screen items-center justify-center bg-gray-50 p-8">+ <div className="w-full max-w-md rounded-lg bg-white p-8 text-center shadow-lg">+ <h1 className="mb-4 text-3xl font-bold text-gray-900">+ {localize('com_ui_oauth_success_title') || 'Authentication Successful'}+ </h1>+ <p className="mb-2 text-sm text-gray-600">+ {localize('com_ui_oauth_success_description') ||+ 'Your authentication was successful. This window will close in'}{' '}+ <span className="font-medium text-indigo-500">{secondsLeft}</span>{' '}+ {localize('com_ui_seconds') || 'seconds'}.+ </p>+ {serverName && (+ <p className="mt-4 text-xs text-gray-500">+ {localize('com_ui_oauth_connected_to') || 'Connected to'}:{' '}+ <span className="font-medium">{serverName}</span>+ </p>+ )}+ </div>+ </div>+ );+}diff --git a/client/src/components/OAuth/index.ts b/client/src/components/OAuth/index.tsnew file mode 100644index 0000000000..788b92c3a9--- /dev/null+++ b/client/src/components/OAuth/index.ts@@ -0,0 +1,2 @@+export { default as OAuthSuccess } from './OAuthSuccess';+export { default as OAuthError } from './OAuthError';diff --git a/client/src/locales/en/translation.json b/client/src/locales/en/translation.jsonindex 5791ff7713..d7171a032f 100644--- a/client/src/locales/en/translation.json+++ b/client/src/locales/en/translation.json@@ -833,6 +833,17 @@"com_ui_not_used": "Not Used","com_ui_nothing_found": "Nothing found","com_ui_oauth": "OAuth",+ "com_ui_oauth_success_title": "Authentication Successful",+ "com_ui_oauth_success_description": "Your authentication was successful. This window will close in",+ "com_ui_oauth_connected_to": "Connected to",+ "com_ui_oauth_error_title": "Authentication Failed",+ "com_ui_oauth_error_missing_code": "Authorization code is missing. Please try again.",+ "com_ui_oauth_error_missing_state": "State parameter is missing. Please try again.",+ "com_ui_oauth_error_invalid_state": "Invalid state parameter. Please try again.",+ "com_ui_oauth_error_callback_failed": "Authentication callback failed. Please try again.",+ "com_ui_oauth_error_generic": "Authentication failed. Please try again.",+ "com_ui_close_window": "Close Window",+ "com_ui_seconds": "seconds","com_ui_of": "of","com_ui_off": "Off","com_ui_on": "On",@@ -1006,7 +1017,7 @@"com_ui_zoom": "Zoom","com_user_message": "You","com_warning_resubmit_unsupported": "Resubmitting the AI message is not supported for this endpoint.",- "com_ui_add_mcp": "Add MCP",+ "com_ui_add_mcp": "Add MCP","com_ui_add_mcp_server": "Add MCP Server","com_ui_edit_mcp_server": "Edit MCP Server","com_agents_mcps_disabled": "You need to create an agent before adding MCPs.",@@ -1028,4 +1039,4 @@"com_agents_mcp_trust_subtext": "Custom connectors are not verified by LibreChat","com_ui_icon": "Icon","com_agents_mcp_icon_size": "Minimum size 128 x 128 px"-}\ No newline at end of file+}diff --git a/client/src/routes/index.tsx b/client/src/routes/index.tsxindex c8bc382a42..607464ecbb 100644--- a/client/src/routes/index.tsx+++ b/client/src/routes/index.tsx@@ -1,13 +1,14 @@import { createBrowserRouter, Navigate, Outlet } from 'react-router-dom';import {Login,+ VerifyEmail,Registration,- RequestPasswordReset,ResetPassword,- VerifyEmail,ApiErrorWatcher,TwoFactorScreen,+ RequestPasswordReset,} from '~/components/Auth';+import { OAuthSuccess, OAuthError } from '~/components/OAuth';import { AuthContextProvider } from '~/hooks/AuthContext';import RouteErrorBoundary from './RouteErrorBoundary';import StartupLayout from './Layouts/Startup';@@ -31,6 +32,20 @@ export const router = createBrowserRouter([element: <ShareRoute />,errorElement: <RouteErrorBoundary />,},+ {+ path: 'oauth',+ errorElement: <RouteErrorBoundary />,+ children: [+ {+ path: 'success',+ element: <OAuthSuccess />,+ },+ {+ path: 'error',+ element: <OAuthError />,+ },+ ],+ },{path: '/',element: <StartupLayout />,diff --git a/package-lock.json b/package-lock.jsonindex 50dacbb5c0..ed1ef74865 100644--- a/package-lock.json+++ b/package-lock.json@@ -20056,15 +20056,16 @@}},"node_modules/@modelcontextprotocol/sdk": {- "version": "1.11.2",- "resolved": "https://registry.npmjs.org/@modelcontextprotocol/sdk/-/sdk-1.11.2.tgz",- "integrity": "sha512-H9vwztj5OAqHg9GockCQC06k1natgcxWQSRpQcPJf6i5+MWBzfKkRtxGbjQf0X2ihii0ffLZCRGbYV2f2bjNCQ==",+ "version": "1.12.3",+ "resolved": "https://registry.npmjs.org/@modelcontextprotocol/sdk/-/sdk-1.12.3.tgz",+ "integrity": "sha512-DyVYSOafBvk3/j1Oka4z5BWT8o4AFmoNyZY9pALOm7Lh3GZglR71Co4r4dEUoqDWdDazIZQHBe7J2Nwkg6gHgQ==","license": "MIT","peer": true,"dependencies": {+ "ajv": "^6.12.6","content-type": "^1.0.5","cors": "^2.8.5",- "cross-spawn": "^7.0.3",+ "cross-spawn": "^7.0.5","eventsource": "^3.0.2","express": "^5.0.1","express-rate-limit": "^7.5.0",@@ -20091,6 +20092,23 @@"node": ">= 0.6"}},+ "node_modules/@modelcontextprotocol/sdk/node_modules/ajv": {+ "version": "6.12.6",+ "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.12.6.tgz",+ "integrity": "sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==",+ "license": "MIT",+ "peer": true,+ "dependencies": {+ "fast-deep-equal": "^3.1.1",+ "fast-json-stable-stringify": "^2.0.0",+ "json-schema-traverse": "^0.4.1",+ "uri-js": "^4.2.2"+ },+ "funding": {+ "type": "github",+ "url": "https://github.com/sponsors/epoberezkin"+ }+ },"node_modules/@modelcontextprotocol/sdk/node_modules/body-parser": {"version": "2.2.0","resolved": "https://registry.npmjs.org/body-parser/-/body-parser-2.2.0.tgz",@@ -20219,6 +20237,13 @@"node": ">=0.10.0"}},+ "node_modules/@modelcontextprotocol/sdk/node_modules/json-schema-traverse": {+ "version": "0.4.1",+ "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz",+ "integrity": "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==",+ "license": "MIT",+ "peer": true+ },"node_modules/@modelcontextprotocol/sdk/node_modules/media-typer": {"version": "1.1.0","resolved": "https://registry.npmjs.org/media-typer/-/media-typer-1.1.0.tgz",@@ -30602,8 +30627,7 @@"node_modules/fast-json-stable-stringify": {"version": "2.1.0","resolved": "https://registry.npmjs.org/fast-json-stable-stringify/-/fast-json-stable-stringify-2.1.0.tgz",- "integrity": "sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==",- "dev": true+ "integrity": "sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw=="},"node_modules/fast-levenshtein": {"version": "2.0.6",@@ -37599,9 +37623,9 @@"integrity": "sha512-1orQ9MT1vHFGQxhuy7E/0gECD3fd2fCC+PIX+/jgmU/gI3EpRocXtmtvxCO5x3WZ443FLTLFWNDjl5MPJf9u+Q=="},"node_modules/oauth4webapi": {- "version": "3.5.1",- "resolved": "https://registry.npmjs.org/oauth4webapi/-/oauth4webapi-3.5.1.tgz",- "integrity": "sha512-txg/jZQwcbaF7PMJgY7aoxc9QuCxHVFMiEkDIJ60DwDz3PbtXPQnrzo+3X4IRYGChIwWLabRBRpf1k9hO9+xrQ==",+ "version": "3.5.2",+ "resolved": "https://registry.npmjs.org/oauth4webapi/-/oauth4webapi-3.5.2.tgz",+ "integrity": "sha512-VYz5BaP3izIrUc1GAVzIoz4JnljiW0YAUFObMBwsqDnfHxz2sjLu3W7/8vE8Ms9IbMewN9+1kcvhY3tMscAeGQ==","license": "MIT","funding": {"url": "https://github.com/sponsors/panva"@@ -44419,7 +44443,6 @@"version": "4.4.1","resolved": "https://registry.npmjs.org/uri-js/-/uri-js-4.4.1.tgz","integrity": "sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==",- "dev": true,"license": "BSD-2-Clause","dependencies": {"punycode": "^2.1.0"@@ -46150,7 +46173,7 @@},"packages/api": {"name": "@librechat/api",- "version": "1.2.3",+ "version": "1.2.4","license": "ISC","devDependencies": {"@babel/preset-env": "^7.21.5",@@ -46184,7 +46207,7 @@"peerDependencies": {"@librechat/agents": "^2.4.37","@librechat/data-schemas": "*",- "@modelcontextprotocol/sdk": "^1.11.2",+ "@modelcontextprotocol/sdk": "^1.12.3","axios": "^1.8.2","diff": "^7.0.0","eventsource": "^3.0.2",@@ -46270,46 +46293,6 @@"url": "https://github.com/sponsors/isaacs"}},- "packages/auth": {- "name": "@librechat/auth",- "version": "0.0.1",- "extraneous": true,- "license": "MIT",- "dependencies": {- "https-proxy-agent": "^7.0.6",- "jsonwebtoken": "^9.0.2",- "mongoose": "^8.12.1",- "openid-client": "^6.5.0",- "passport": "^0.7.0",- "passport-facebook": "^3.0.0"- },- "devDependencies": {- "@librechat/data-schemas": "^0.0.9",- "@rollup/plugin-alias": "^5.1.0",- "@rollup/plugin-commonjs": "^25.0.2",- "@rollup/plugin-json": "^6.1.0",- "@rollup/plugin-node-resolve": "^15.1.0",- "@rollup/plugin-replace": "^5.0.5",- "@rollup/plugin-terser": "^0.4.4",- "@rollup/plugin-typescript": "^12.1.2",- "@types/diff": "^6.0.0",- "@types/express": "^5.0.0",- "@types/jest": "^29.5.2",- "@types/node": "^20.3.0",- "jest": "^29.5.0",- "jest-junit": "^16.0.0",- "rimraf": "^5.0.1",- "rollup": "^4.22.4",- "rollup-plugin-generate-package-json": "^3.2.0",- "rollup-plugin-peer-deps-external": "^2.2.4",- "rollup-plugin-typescript2": "^0.35.0",- "ts-node": "^10.9.2",- "typescript": "^5.0.4"- },- "peerDependencies": {- "keyv": "^5.3.2"- }- },"packages/data-provider": {"name": "librechat-data-provider","version": "0.7.87",diff --git a/package.json b/package.jsonindex cb33ac9164..251247f4b9 100644--- a/package.json+++ b/package.json@@ -64,6 +64,7 @@"b:data": "cd packages/data-provider && bun run b:build","b:mcp": "cd packages/api && bun run b:build","b:data-schemas": "cd packages/data-schemas && bun run b:build",+ "b:build:api": "cd packages/api && bun run b:build","b:client": "bun --bun run b:data && bun --bun run b:mcp && bun --bun run b:data-schemas && cd client && bun --bun run b:build","b:client:dev": "cd client && bun run b:dev","b:test:client": "cd client && bun run b:test",diff --git a/packages/api/package.json b/packages/api/package.jsonindex 61f4cda757..1c2ab534e3 100644--- a/packages/api/package.json+++ b/packages/api/package.json@@ -1,6 +1,6 @@{"name": "@librechat/api",- "version": "1.2.3",+ "version": "1.2.4","type": "commonjs","description": "MCP services for LibreChat","main": "dist/index.js",@@ -71,7 +71,7 @@"peerDependencies": {"@librechat/agents": "^2.4.37","@librechat/data-schemas": "*",- "@modelcontextprotocol/sdk": "^1.11.2",+ "@modelcontextprotocol/sdk": "^1.12.3","axios": "^1.8.2","diff": "^7.0.0","eventsource": "^3.0.2",diff --git a/packages/api/rollup.config.js b/packages/api/rollup.config.jsindex 0a56ea3d91..13d805874e 100644--- a/packages/api/rollup.config.js+++ b/packages/api/rollup.config.js@@ -36,10 +36,11 @@ const plugins = [const cjsBuild = {input: 'src/index.ts',output: {- file: pkg.main,+ dir: 'dist',format: 'cjs',sourcemap: true,exports: 'named',+ entryFileNames: '[name].js',},external: [...Object.keys(pkg.dependencies || {}), ...Object.keys(pkg.devDependencies || {})],preserveSymlinks: true,diff --git a/api/server/utils/crypto.js b/packages/api/src/crypto/encryption.tssimilarity index 81%rename from api/server/utils/crypto.jsrename to packages/api/src/crypto/encryption.tsindex 2f176fedee..aedf3c9c92 100644--- a/api/server/utils/crypto.js+++ b/packages/api/src/crypto/encryption.ts@@ -1,15 +1,15 @@-require('dotenv').config();-const crypto = require('node:crypto');+import 'dotenv/config';+import crypto from 'node:crypto';const { webcrypto } = crypto;// Use hex decoding for both key and IV for legacy methods.-const key = Buffer.from(process.env.CREDS_KEY, 'hex');-const iv = Buffer.from(process.env.CREDS_IV, 'hex');+const key = Buffer.from(process.env.CREDS_KEY ?? '', 'hex');+const iv = Buffer.from(process.env.CREDS_IV ?? '', 'hex');const algorithm = 'AES-CBC';// --- Legacy v1/v2 Setup: AES-CBC with fixed key and IV ----async function encrypt(value) {+export async function encrypt(value: string) {const cryptoKey = await webcrypto.subtle.importKey('raw', key, { name: algorithm }, false, ['encrypt',]);@@ -23,7 +23,7 @@ async function encrypt(value) {return Buffer.from(encryptedBuffer).toString('hex');}-async function decrypt(encryptedValue) {+export async function decrypt(encryptedValue: string) {const cryptoKey = await webcrypto.subtle.importKey('raw', key, { name: algorithm }, false, ['decrypt',]);@@ -39,7 +39,7 @@ async function decrypt(encryptedValue) {// --- v2: AES-CBC with a random IV per encryption ----async function encryptV2(value) {+export async function encryptV2(value: string) {const gen_iv = webcrypto.getRandomValues(new Uint8Array(16));const cryptoKey = await webcrypto.subtle.importKey('raw', key, { name: algorithm }, false, ['encrypt',@@ -54,12 +54,12 @@ async function encryptV2(value) {return Buffer.from(gen_iv).toString('hex') + ':' + Buffer.from(encryptedBuffer).toString('hex');}-async function decryptV2(encryptedValue) {+export async function decryptV2(encryptedValue: string) {const parts = encryptedValue.split(':');if (parts.length === 1) {return parts[0];}- const gen_iv = Buffer.from(parts.shift(), 'hex');+ const gen_iv = Buffer.from(parts.shift() ?? '', 'hex');const encrypted = parts.join(':');const cryptoKey = await webcrypto.subtle.importKey('raw', key, { name: algorithm }, false, ['decrypt',@@ -81,10 +81,10 @@ const algorithm_v3 = 'aes-256-ctr';* Encrypts a value using AES-256-CTR.* Note: AES-256 requires a 32-byte key. Ensure that process.env.CREDS_KEY is a 64-character hex string.*- * @param {string} value - The plaintext to encrypt.- * @returns {string} The encrypted string with a "v3:" prefix.+ * @param value - The plaintext to encrypt.+ * @returns The encrypted string with a "v3:" prefix.*/-function encryptV3(value) {+export function encryptV3(value: string) {if (key.length !== 32) {throw new Error(`Invalid key length: expected 32 bytes, got ${key.length} bytes`);}@@ -94,7 +94,7 @@ function encryptV3(value) {return `v3:${iv_v3.toString('hex')}:${encrypted.toString('hex')}`;}-function decryptV3(encryptedValue) {+export function decryptV3(encryptedValue: string) {const parts = encryptedValue.split(':');if (parts[0] !== 'v3') {throw new Error('Not a v3 encrypted value');@@ -106,7 +106,7 @@ function decryptV3(encryptedValue) {return decrypted.toString('utf8');}-async function getRandomValues(length) {+export async function getRandomValues(length: number) {if (!Number.isInteger(length) || length <= 0) {throw new Error('Length must be a positive integer');}@@ -117,24 +117,13 @@ async function getRandomValues(length) {/*** Computes SHA-256 hash for the given input.- * @param {string} input- * @returns {Promise<string>}+ * @param input - The input to hash.+ * @returns The SHA-256 hash of the input.*/-async function hashBackupCode(input) {+export async function hashBackupCode(input: string) {const encoder = new TextEncoder();const data = encoder.encode(input);const hashBuffer = await webcrypto.subtle.digest('SHA-256', data);const hashArray = Array.from(new Uint8Array(hashBuffer));return hashArray.map((b) => b.toString(16).padStart(2, '0')).join('');}--module.exports = {- encrypt,- decrypt,- encryptV2,- decryptV2,- encryptV3,- decryptV3,- hashBackupCode,- getRandomValues,-};diff --git a/packages/api/src/crypto/index.ts b/packages/api/src/crypto/index.tsnew file mode 100644index 0000000000..73ebae8b16--- /dev/null+++ b/packages/api/src/crypto/index.ts@@ -0,0 +1 @@+export * from './encryption';diff --git a/packages/api/src/flow/manager.spec.ts b/packages/api/src/flow/manager.spec.tsindex 1f1714509b..af6420ffc4 100644--- a/packages/api/src/flow/manager.spec.ts+++ b/packages/api/src/flow/manager.spec.ts@@ -1,8 +1,8 @@-import { FlowStateManager } from './manager';import { Keyv } from 'keyv';+import { FlowStateManager } from './manager';import type { FlowState } from './types';-// Create a mock class without extending Keyv+/** Mock class without extending Keyv */class MockKeyv {private store: Map<string, FlowState<string>>;diff --git a/packages/api/src/flow/manager.ts b/packages/api/src/flow/manager.tsindex 6a421b8d18..f27dfbb64b 100644--- a/packages/api/src/flow/manager.ts+++ b/packages/api/src/flow/manager.ts@@ -1,28 +1,18 @@import { Keyv } from 'keyv';+import { logger } from '@librechat/data-schemas';import type { StoredDataNoRaw } from 'keyv';-import type { Logger } from 'winston';import type { FlowState, FlowMetadata, FlowManagerOptions } from './types';export class FlowStateManager<T = unknown> {private keyv: Keyv;private ttl: number;- private logger: Logger;private intervals: Set<NodeJS.Timeout>;- private static getDefaultLogger(): Logger {- return {- error: console.error,- warn: console.warn,- info: console.info,- debug: console.debug,- } as Logger;- }-constructor(store: Keyv, options?: FlowManagerOptions) {if (!options) {options = { ttl: 60000 * 3 };}- const { ci = false, ttl, logger } = options;+ const { ci = false, ttl } = options;if (!ci && !(store instanceof Keyv)) {throw new Error('Invalid store provided to FlowStateManager');@@ -30,14 +20,13 @@ export class FlowStateManager<T = unknown> {this.ttl = ttl;this.keyv = store;- this.logger = logger || FlowStateManager.getDefaultLogger();this.intervals = new Set();this.setupCleanupHandlers();}private setupCleanupHandlers() {const cleanup = () => {- this.logger.info('Cleaning up FlowStateManager intervals...');+ logger.info('Cleaning up FlowStateManager intervals...');this.intervals.forEach((interval) => clearInterval(interval));this.intervals.clear();process.exit(0);@@ -66,7 +55,7 @@ export class FlowStateManager<T = unknown> {let existingState = (await this.keyv.get(flowKey)) as FlowState<T> | undefined;if (existingState) {- this.logger.debug(`[${flowKey}] Flow already exists`);+ logger.debug(`[${flowKey}] Flow already exists`);return this.monitorFlow(flowKey, type, signal);}@@ -74,7 +63,7 @@ export class FlowStateManager<T = unknown> {existingState = (await this.keyv.get(flowKey)) as FlowState<T> | undefined;if (existingState) {- this.logger.debug(`[${flowKey}] Flow exists on 2nd check`);+ logger.debug(`[${flowKey}] Flow exists on 2nd check`);return this.monitorFlow(flowKey, type, signal);}@@ -85,7 +74,7 @@ export class FlowStateManager<T = unknown> {createdAt: Date.now(),};- this.logger.debug('Creating initial flow state:', flowKey);+ logger.debug('Creating initial flow state:', flowKey);await this.keyv.set(flowKey, initialState, this.ttl);return this.monitorFlow(flowKey, type, signal);}@@ -102,7 +91,7 @@ export class FlowStateManager<T = unknown> {if (!flowState) {clearInterval(intervalId);this.intervals.delete(intervalId);- this.logger.error(`[${flowKey}] Flow state not found`);+ logger.error(`[${flowKey}] Flow state not found`);reject(new Error(`${type} Flow state not found`));return;}@@ -110,7 +99,7 @@ export class FlowStateManager<T = unknown> {if (signal?.aborted) {clearInterval(intervalId);this.intervals.delete(intervalId);- this.logger.warn(`[${flowKey}] Flow aborted`);+ logger.warn(`[${flowKey}] Flow aborted`);const message = `${type} flow aborted`;await this.keyv.delete(flowKey);reject(new Error(message));@@ -120,7 +109,7 @@ export class FlowStateManager<T = unknown> {if (flowState.status !== 'PENDING') {clearInterval(intervalId);this.intervals.delete(intervalId);- this.logger.debug(`[${flowKey}] Flow completed`);+ logger.debug(`[${flowKey}] Flow completed`);if (flowState.status === 'COMPLETED' && flowState.result !== undefined) {resolve(flowState.result);@@ -135,17 +124,15 @@ export class FlowStateManager<T = unknown> {if (elapsedTime >= this.ttl) {clearInterval(intervalId);this.intervals.delete(intervalId);- this.logger.error(+ logger.error(`[${flowKey}] Flow timed out | Elapsed time: ${elapsedTime} | TTL: ${this.ttl}`,);await this.keyv.delete(flowKey);reject(new Error(`${type} flow timed out`));}- this.logger.debug(- `[${flowKey}] Flow state elapsed time: ${elapsedTime}, checking again...`,- );+ logger.debug(`[${flowKey}] Flow state elapsed time: ${elapsedTime}, checking again...`);} catch (error) {- this.logger.error(`[${flowKey}] Error checking flow state:`, error);+ logger.error(`[${flowKey}] Error checking flow state:`, error);clearInterval(intervalId);this.intervals.delete(intervalId);reject(error);@@ -224,7 +211,7 @@ export class FlowStateManager<T = unknown> {const flowKey = this.getFlowKey(flowId, type);let existingState = (await this.keyv.get(flowKey)) as FlowState<T> | undefined;if (existingState) {- this.logger.debug(`[${flowKey}] Flow already exists`);+ logger.debug(`[${flowKey}] Flow already exists`);return this.monitorFlow(flowKey, type, signal);}@@ -232,7 +219,7 @@ export class FlowStateManager<T = unknown> {existingState = (await this.keyv.get(flowKey)) as FlowState<T> | undefined;if (existingState) {- this.logger.debug(`[${flowKey}] Flow exists on 2nd check`);+ logger.debug(`[${flowKey}] Flow exists on 2nd check`);return this.monitorFlow(flowKey, type, signal);}@@ -242,7 +229,7 @@ export class FlowStateManager<T = unknown> {metadata: {},createdAt: Date.now(),};- this.logger.debug(`[${flowKey}] Creating initial flow state`);+ logger.debug(`[${flowKey}] Creating initial flow state`);await this.keyv.set(flowKey, initialState, this.ttl);try {diff --git a/packages/api/src/index.ts b/packages/api/src/index.tsindex 9e3db4ef6b..b7859e7ca4 100644--- a/packages/api/src/index.ts+++ b/packages/api/src/index.ts@@ -1,8 +1,13 @@/* MCP */export * from './mcp/manager';+export * from './mcp/oauth';/* Utilities */export * from './mcp/utils';export * from './utils';+/* OAuth */+export * from './oauth';+/* Crypto */+export * from './crypto';/* Flow */export * from './flow/manager';/* Agents */diff --git a/packages/api/src/mcp/connection.ts b/packages/api/src/mcp/connection.tsindex 81a6831a70..38ca2b23d6 100644--- a/packages/api/src/mcp/connection.ts+++ b/packages/api/src/mcp/connection.ts@@ -1,4 +1,5 @@import { EventEmitter } from 'events';+import { logger } from '@librechat/data-schemas';import { Client } from '@modelcontextprotocol/sdk/client/index.js';import { SSEClientTransport } from '@modelcontextprotocol/sdk/client/sse.js';import {@@ -10,7 +11,7 @@ import { ResourceListChangedNotificationSchema } from '@modelcontextprotocol/sdkimport { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';import type { Transport } from '@modelcontextprotocol/sdk/shared/transport.js';import type { JSONRPCMessage } from '@modelcontextprotocol/sdk/types.js';-import type { Logger } from 'winston';+import type { MCPOAuthTokens } from './oauth/types';import type * as t from './types';function isStdioOptions(options: t.MCPOptions): options is t.StdioOptions {@@ -67,24 +68,29 @@ export class MCPConnection extends EventEmitter {private isReconnecting = false;private isInitializing = false;private reconnectAttempts = 0;- iconPath?: string;- timeout?: number;private readonly userId?: string;private lastPingTime: number;+ private oauthTokens?: MCPOAuthTokens | null;+ private oauthRequired = false;+ iconPath?: string;+ timeout?: number;+ url?: string;constructor(serverName: string,private readonly options: t.MCPOptions,- private logger?: Logger,userId?: string,+ oauthTokens?: MCPOAuthTokens | null,) {super();this.serverName = serverName;- this.logger = logger;this.userId = userId;this.iconPath = options.iconPath;this.timeout = options.timeout;this.lastPingTime = Date.now();+ if (oauthTokens) {+ this.oauthTokens = oauthTokens;+ }this.client = new Client({name: '@librechat/api-client',@@ -107,11 +113,10 @@ export class MCPConnection extends EventEmitter {public static getInstance(serverName: string,options: t.MCPOptions,- logger?: Logger,userId?: string,): MCPConnection {if (!MCPConnection.instance) {- MCPConnection.instance = new MCPConnection(serverName, options, logger, userId);+ MCPConnection.instance = new MCPConnection(serverName, options, userId);}return MCPConnection.instance;}@@ -129,7 +134,7 @@ export class MCPConnection extends EventEmitter {private emitError(error: unknown, errorContext: string): void {const errorMessage = error instanceof Error ? error.message : String(error);- this.logger?.error(`${this.getLogPrefix()} ${errorContext}: ${errorMessage}`);+ logger.error(`${this.getLogPrefix()} ${errorContext}: ${errorMessage}`);this.emit('error', new Error(`${errorContext}: ${errorMessage}`));}@@ -167,45 +172,52 @@ export class MCPConnection extends EventEmitter {if (!isWebSocketOptions(options)) {throw new Error('Invalid options for websocket transport.');}+ this.url = options.url;return new WebSocketClientTransport(new URL(options.url));case 'sse': {if (!isSSEOptions(options)) {throw new Error('Invalid options for sse transport.');}+ this.url = options.url;const url = new URL(options.url);- this.logger?.info(`${this.getLogPrefix()} Creating SSE transport: ${url.toString()}`);+ logger.info(`${this.getLogPrefix()} Creating SSE transport: ${url.toString()}`);const abortController = new AbortController();++ /** Add OAuth token to headers if available */+ const headers = { ...options.headers };+ if (this.oauthTokens?.access_token) {+ headers['Authorization'] = `Bearer ${this.oauthTokens.access_token}`;+ }+const transport = new SSEClientTransport(url, {requestInit: {- headers: options.headers,+ headers,signal: abortController.signal,},eventSourceInit: {fetch: (url, init) => {- const headers = new Headers(Object.assign({}, init?.headers, options.headers));+ const fetchHeaders = new Headers(Object.assign({}, init?.headers, headers));return fetch(url, {...init,- headers,+ headers: fetchHeaders,});},},});transport.onclose = () => {- this.logger?.info(`${this.getLogPrefix()} SSE transport closed`);+ logger.info(`${this.getLogPrefix()} SSE transport closed`);this.emit('connectionChange', 'disconnected');};transport.onerror = (error) => {- this.logger?.error(`${this.getLogPrefix()} SSE transport error:`, error);+ logger.error(`${this.getLogPrefix()} SSE transport error:`, error);this.emitError(error, 'SSE transport error:');};transport.onmessage = (message) => {- this.logger?.info(- `${this.getLogPrefix()} Message received: ${JSON.stringify(message)}`,- );+ logger.info(`${this.getLogPrefix()} Message received: ${JSON.stringify(message)}`);};this.setupTransportErrorHandlers(transport);@@ -216,33 +228,38 @@ export class MCPConnection extends EventEmitter {if (!isStreamableHTTPOptions(options)) {throw new Error('Invalid options for streamable-http transport.');}+ this.url = options.url;const url = new URL(options.url);- this.logger?.info(+ logger.info(`${this.getLogPrefix()} Creating streamable-http transport: ${url.toString()}`,);const abortController = new AbortController();+ // Add OAuth token to headers if available+ const headers = { ...options.headers };+ if (this.oauthTokens?.access_token) {+ headers['Authorization'] = `Bearer ${this.oauthTokens.access_token}`;+ }+const transport = new StreamableHTTPClientTransport(url, {requestInit: {- headers: options.headers,+ headers,signal: abortController.signal,},});transport.onclose = () => {- this.logger?.info(`${this.getLogPrefix()} Streamable-http transport closed`);+ logger.info(`${this.getLogPrefix()} Streamable-http transport closed`);this.emit('connectionChange', 'disconnected');};transport.onerror = (error: Error | unknown) => {- this.logger?.error(`${this.getLogPrefix()} Streamable-http transport error:`, error);+ logger.error(`${this.getLogPrefix()} Streamable-http transport error:`, error);this.emitError(error, 'Streamable-http transport error:');};transport.onmessage = (message: JSONRPCMessage) => {- this.logger?.info(- `${this.getLogPrefix()} Message received: ${JSON.stringify(message)}`,- );+ logger.info(`${this.getLogPrefix()} Message received: ${JSON.stringify(message)}`);};this.setupTransportErrorHandlers(transport);@@ -271,17 +288,17 @@ export class MCPConnection extends EventEmitter {/*** // FOR DEBUGGING* // this.client.setRequestHandler(PingRequestSchema, async (request, extra) => {- * // this.logger?.info(`[MCP][${this.serverName}] PingRequest: ${JSON.stringify(request)}`);+ * // logger.info(`[MCP][${this.serverName}] PingRequest: ${JSON.stringify(request)}`);* // if (getEventListeners && extra.signal) {* // const listenerCount = getEventListeners(extra.signal, 'abort').length;- * // this.logger?.debug(`Signal has ${listenerCount} abort listeners`);+ * // logger.debug(`Signal has ${listenerCount} abort listeners`);* // }* // return {};* // });*/} else if (state === 'error' && !this.isReconnecting && !this.isInitializing) {this.handleReconnection().catch((error) => {- this.logger?.error(`${this.getLogPrefix()} Reconnection handler failed:`, error);+ logger.error(`${this.getLogPrefix()} Reconnection handler failed:`, error);});}});@@ -290,7 +307,15 @@ export class MCPConnection extends EventEmitter {}private async handleReconnection(): Promise<void> {- if (this.isReconnecting || this.shouldStopReconnecting || this.isInitializing) {+ if (+ this.isReconnecting ||+ this.shouldStopReconnecting ||+ this.isInitializing ||+ this.oauthRequired+ ) {+ if (this.oauthRequired) {+ logger.info(`${this.getLogPrefix()} OAuth required, skipping reconnection attempts`);+ }return;}@@ -305,7 +330,7 @@ export class MCPConnection extends EventEmitter {this.reconnectAttempts++;const delay = backoffDelay(this.reconnectAttempts);- this.logger?.info(+ logger.info(`${this.getLogPrefix()} Reconnecting ${this.reconnectAttempts}/${this.MAX_RECONNECT_ATTEMPTS} (delay: ${delay}ms)`,);@@ -316,13 +341,13 @@ export class MCPConnection extends EventEmitter {this.reconnectAttempts = 0;return;} catch (error) {- this.logger?.error(`${this.getLogPrefix()} Reconnection attempt failed:`, error);+ logger.error(`${this.getLogPrefix()} Reconnection attempt failed:`, error);if (this.reconnectAttempts === this.MAX_RECONNECT_ATTEMPTS ||(this.shouldStopReconnecting as boolean)) {- this.logger?.error(`${this.getLogPrefix()} Stopping reconnection attempts`);+ logger.error(`${this.getLogPrefix()} Stopping reconnection attempts`);return;}}@@ -366,18 +391,21 @@ export class MCPConnection extends EventEmitter {await this.client.close();this.transport = null;} catch (error) {- this.logger?.warn(`${this.getLogPrefix()} Error closing connection:`, error);+ logger.warn(`${this.getLogPrefix()} Error closing connection:`, error);}}this.transport = this.constructTransport(this.options);this.setupTransportDebugHandlers();- const connectTimeout = this.options.initTimeout ?? 10000;+ const connectTimeout = this.options.initTimeout ?? 120000;await Promise.race([this.client.connect(this.transport),new Promise((_resolve, reject) =>- setTimeout(() => reject(new Error('Connection timeout')), connectTimeout),+ setTimeout(+ () => reject(new Error(`Connection timeout after ${connectTimeout}ms`)),+ connectTimeout,+ ),),]);@@ -385,9 +413,85 @@ export class MCPConnection extends EventEmitter {this.emit('connectionChange', 'connected');this.reconnectAttempts = 0;} catch (error) {+ // Check if it's an OAuth authentication error+ if (this.isOAuthError(error)) {+ logger.warn(`${this.getLogPrefix()} OAuth authentication required`);+ this.oauthRequired = true;+ const serverUrl = this.url;+ logger.debug(`${this.getLogPrefix()} Server URL for OAuth: ${serverUrl}`);++ const oauthTimeout = this.options.initTimeout ?? 60000;+ /** Promise that will resolve when OAuth is handled */+ const oauthHandledPromise = new Promise<void>((resolve, reject) => {+ let timeoutId: NodeJS.Timeout | null = null;+ let oauthHandledListener: (() => void) | null = null;+ let oauthFailedListener: ((error: Error) => void) | null = null;++ /** Cleanup function to remove listeners and clear timeout */+ const cleanup = () => {+ if (timeoutId) {+ clearTimeout(timeoutId);+ }+ if (oauthHandledListener) {+ this.off('oauthHandled', oauthHandledListener);+ }+ if (oauthFailedListener) {+ this.off('oauthFailed', oauthFailedListener);+ }+ };++ // Success handler+ oauthHandledListener = () => {+ cleanup();+ resolve();+ };++ // Failure handler+ oauthFailedListener = (error: Error) => {+ cleanup();+ reject(error);+ };++ // Timeout handler+ timeoutId = setTimeout(() => {+ cleanup();+ reject(new Error(`OAuth handling timeout after ${oauthTimeout}ms`));+ }, oauthTimeout);++ // Listen for both success and failure events+ this.once('oauthHandled', oauthHandledListener);+ this.once('oauthFailed', oauthFailedListener);+ });++ // Emit the event+ this.emit('oauthRequired', {+ serverName: this.serverName,+ error,+ serverUrl,+ userId: this.userId,+ });++ try {+ // Wait for OAuth to be handled+ await oauthHandledPromise;+ // Reset the oauthRequired flag+ this.oauthRequired = false;+ // Don't throw the error - just return so connection can be retried+ logger.info(+ `${this.getLogPrefix()} OAuth handled successfully, connection will be retried`,+ );+ return;+ } catch (oauthError) {+ // OAuth failed or timed out+ this.oauthRequired = false;+ logger.error(`${this.getLogPrefix()} OAuth handling failed:`, oauthError);+ // Re-throw the original authentication error+ throw error;+ }+ }+this.connectionState = 'error';this.emit('connectionChange', 'error');- this.lastError = error instanceof Error ? error : new Error(String(error));throw error;} finally {this.connectPromise = null;@@ -403,7 +507,7 @@ export class MCPConnection extends EventEmitter {}this.transport.onmessage = (msg) => {- this.logger?.debug(`${this.getLogPrefix()} Transport received: ${JSON.stringify(msg)}`);+ logger.debug(`${this.getLogPrefix()} Transport received: ${JSON.stringify(msg)}`);};const originalSend = this.transport.send.bind(this.transport);@@ -414,7 +518,7 @@ export class MCPConnection extends EventEmitter {}this.lastPingTime = Date.now();}- this.logger?.debug(`${this.getLogPrefix()} Transport sending: ${JSON.stringify(msg)}`);+ logger.debug(`${this.getLogPrefix()} Transport sending: ${JSON.stringify(msg)}`);return originalSend(msg);};}@@ -427,14 +531,24 @@ export class MCPConnection extends EventEmitter {throw new Error('Connection not established');}} catch (error) {- this.logger?.error(`${this.getLogPrefix()} Connection failed:`, error);+ logger.error(`${this.getLogPrefix()} Connection failed:`, error);throw error;}}private setupTransportErrorHandlers(transport: Transport): void {transport.onerror = (error) => {- this.logger?.error(`${this.getLogPrefix()} Transport error:`, error);+ logger.error(`${this.getLogPrefix()} Transport error:`, error);++ // Check if it's an OAuth authentication error+ if (error && typeof error === 'object' && 'code' in error) {+ const errorCode = (error as unknown as { code?: number }).code;+ if (errorCode === 401 || errorCode === 403) {+ logger.warn(`${this.getLogPrefix()} OAuth authentication error detected`);+ this.emit('oauthError', error);+ }+ }+this.emit('connectionChange', 'error');};}@@ -562,22 +676,36 @@ export class MCPConnection extends EventEmitter {// }// }- // Public getters for state information- public getConnectionState(): t.ConnectionState {- return this.connectionState;- }-public async isConnected(): Promise<boolean> {try {await this.client.ping();return this.connectionState === 'connected';} catch (error) {- this.logger?.error(`${this.getLogPrefix()} Ping failed:`, error);+ logger.error(`${this.getLogPrefix()} Ping failed:`, error);return false;}}- public getLastError(): Error | null {- return this.lastError;+ public setOAuthTokens(tokens: MCPOAuthTokens): void {+ this.oauthTokens = tokens;+ }++ private isOAuthError(error: unknown): boolean {+ if (!error || typeof error !== 'object') {+ return false;+ }++ // Check for SSE error with 401 status+ if ('message' in error && typeof error.message === 'string') {+ return error.message.includes('401') || error.message.includes('Non-200 status code (401)');+ }++ // Check for error code+ if ('code' in error) {+ const code = (error as { code?: number }).code;+ return code === 401 || code === 403;+ }++ return false;}}diff --git a/packages/api/src/mcp/enum.ts b/packages/api/src/mcp/enum.tsindex 995ddfb523..806e5c0054 100644--- a/packages/api/src/mcp/enum.ts+++ b/packages/api/src/mcp/enum.ts@@ -1,3 +1,9 @@export enum CONSTANTS {mcp_delimiter = '_mcp_',+ /** System user ID for app-level OAuth tokens (all zeros ObjectId) */+ SYSTEM_USER_ID = '000000000000000000000000',+}++export function isSystemUserId(userId?: string): boolean {+ return userId === CONSTANTS.SYSTEM_USER_ID;}diff --git a/packages/api/src/mcp/manager.ts b/packages/api/src/mcp/manager.tsindex af8f1632a7..0a60784457 100644--- a/packages/api/src/mcp/manager.ts+++ b/packages/api/src/mcp/manager.ts@@ -1,11 +1,18 @@+import { logger } from '@librechat/data-schemas';import { CallToolResultSchema, ErrorCode, McpError } from '@modelcontextprotocol/sdk/types.js';import type { RequestOptions } from '@modelcontextprotocol/sdk/shared/protocol.js';+import type { OAuthClientInformation } from '@modelcontextprotocol/sdk/shared/auth.js';import type { JsonSchemaType, MCPOptions, TUser } from 'librechat-data-provider';-import type { Logger } from 'winston';+import type { TokenMethods } from '@librechat/data-schemas';+import type { FlowStateManager } from '~/flow/manager';+import type { MCPOAuthTokens, MCPOAuthFlowMetadata } from './oauth/types';+import type { FlowMetadata } from '~/flow/types';import type * as t from './types';+import { CONSTANTS, isSystemUserId } from './enum';+import { MCPOAuthHandler } from './oauth/handler';+import { MCPTokenStorage } from './oauth/tokens';import { formatToolContent } from './parsers';import { MCPConnection } from './connection';-import { CONSTANTS } from './enum';export interface CallToolOptions extends RequestOptions {user?: TUser;@@ -24,24 +31,10 @@ export class MCPManager {private processMCPEnv?: (obj: MCPOptions, user?: TUser) => MCPOptions; // Store the processing function/** Store MCP server instructions */private serverInstructions: Map<string, string> = new Map();- private logger: Logger;-- private static getDefaultLogger(): Logger {- return {- error: console.error,- warn: console.warn,- info: console.info,- debug: console.debug,- } as Logger;- }-- private constructor(logger?: Logger) {- this.logger = logger || MCPManager.getDefaultLogger();- }- public static getInstance(logger?: Logger): MCPManager {+ public static getInstance(): MCPManager {if (!MCPManager.instance) {- MCPManager.instance = new MCPManager(logger);+ MCPManager.instance = new MCPManager();}// Check for idle connections when getInstance is calledMCPManager.instance.checkIdleConnections();@@ -49,79 +42,188 @@ export class MCPManager {}/** Stores configs and initializes app-level connections */- public async initializeMCP(- mcpServers: t.MCPServers,- processMCPEnv?: (obj: MCPOptions) => MCPOptions,- ): Promise<void> {- this.logger.info('[MCP] Initializing app-level servers');+ public async initializeMCP({+ mcpServers,+ flowManager,+ tokenMethods,+ processMCPEnv,+ }: {+ mcpServers: t.MCPServers;+ flowManager: FlowStateManager<MCPOAuthTokens | null>;+ tokenMethods?: TokenMethods;+ processMCPEnv?: (obj: MCPOptions) => MCPOptions;+ }): Promise<void> {this.processMCPEnv = processMCPEnv; // Store the functionthis.mcpConfigs = mcpServers;+ if (!flowManager) {+ logger.info('[MCP] No flow manager provided, OAuth will not be available');+ }++ if (!tokenMethods) {+ logger.info('[MCP] No token methods provided, token persistence will not be available');+ }+const entries = Object.entries(mcpServers);const initializedServers = new Set();const connectionResults = await Promise.allSettled(entries.map(async ([serverName, _config], i) => {/** Process env for app-level connections */const config = this.processMCPEnv ? this.processMCPEnv(_config) : _config;- const connection = new MCPConnection(serverName, config, this.logger);++ /** Existing tokens for system-level connections */+ let tokens: MCPOAuthTokens | null = null;+ if (tokenMethods?.findToken) {+ try {+ /** Refresh function for app-level connections */+ const refreshTokensFunction = async (+ refreshToken: string,+ metadata: {+ userId: string;+ serverName: string;+ identifier: string;+ clientInfo?: OAuthClientInformation;+ },+ ) => {+ /** URL from config if available */+ const serverUrl = (config as t.SSEOptions | t.StreamableHTTPOptions).url;+ return await MCPOAuthHandler.refreshOAuthTokens(+ refreshToken,+ {+ serverName: metadata.serverName,+ serverUrl,+ clientInfo: metadata.clientInfo,+ },+ config.oauth,+ );+ };++ /** Flow state to prevent concurrent token operations */+ const tokenFlowId = `tokens:${CONSTANTS.SYSTEM_USER_ID}:${serverName}`;+ tokens = await flowManager.createFlowWithHandler(+ tokenFlowId,+ 'mcp_get_tokens',+ async () => {+ return await MCPTokenStorage.getTokens({+ userId: CONSTANTS.SYSTEM_USER_ID,+ serverName,+ findToken: tokenMethods.findToken,+ refreshTokens: refreshTokensFunction,+ createToken: tokenMethods.createToken,+ updateToken: tokenMethods.updateToken,+ });+ },+ );+ } catch {+ logger.debug(`[MCP][${serverName}] No existing tokens found`);+ }+ }++ if (tokens) {+ logger.info(`[MCP][${serverName}] Loaded OAuth tokens`);+ }++ const connection = new MCPConnection(serverName, config, undefined, tokens);++ /** Listen for OAuth requirements */+ logger.info(`[MCP][${serverName}] Setting up OAuth event listener`);+ connection.on('oauthRequired', async (data) => {+ logger.debug(`[MCP][${serverName}] oauthRequired event received`);+ const result = await this.handleOAuthRequired({+ ...data,+ flowManager,+ });++ if (result?.tokens && tokenMethods?.createToken) {+ try {+ connection.setOAuthTokens(result.tokens);+ await MCPTokenStorage.storeTokens({+ userId: CONSTANTS.SYSTEM_USER_ID,+ serverName,+ tokens: result.tokens,+ createToken: tokenMethods.createToken,+ updateToken: tokenMethods.updateToken,+ findToken: tokenMethods.findToken,+ clientInfo: result.clientInfo,+ });+ logger.info(`[MCP][${serverName}] OAuth tokens saved to storage`);+ } catch (error) {+ logger.error(`[MCP][${serverName}] Failed to save OAuth tokens to storage`, error);+ }+ }++ // Only emit oauthHandled if we actually got tokens (OAuth succeeded)+ if (result?.tokens) {+ connection.emit('oauthHandled');+ } else {+ // OAuth failed, emit oauthFailed to properly reject the promise+ logger.warn(`[MCP][${serverName}] OAuth failed, emitting oauthFailed event`);+ connection.emit('oauthFailed', new Error('OAuth authentication failed'));+ }+ });try {+ const connectTimeout = config.initTimeout ?? 30000;const connectionTimeout = new Promise<void>((_, reject) =>- setTimeout(() => reject(new Error('Connection timeout')), 30000),+ setTimeout(+ () => reject(new Error(`Connection timeout after ${connectTimeout}ms`)),+ connectTimeout,+ ),);- const connectionAttempt = this.initializeServer(connection, `[MCP][${serverName}]`);+ const connectionAttempt = this.initializeServer({+ connection,+ logPrefix: `[MCP][${serverName}]`,+ flowManager,+ handleOAuth: false,+ });await Promise.race([connectionAttempt, connectionTimeout]);if (await connection.isConnected()) {initializedServers.add(i);- this.connections.set(serverName, connection); // Store in app-level map+ this.connections.set(serverName, connection);- // Handle unified serverInstructions configuration+ /** Unified `serverInstructions` configuration */const configInstructions = config.serverInstructions;if (configInstructions !== undefined) {if (typeof configInstructions === 'string') {- // Custom instructions providedthis.serverInstructions.set(serverName, configInstructions);- this.logger.info(+ logger.info(`[MCP][${serverName}] Custom instructions stored for context inclusion: ${configInstructions}`,);} else if (configInstructions === true) {- // Use server-provided instructions+ /** Server-provided instructions */const serverInstructions = connection.client.getInstructions();if (serverInstructions) {this.serverInstructions.set(serverName, serverInstructions);- this.logger.info(+ logger.info(`[MCP][${serverName}] Server instructions stored for context inclusion: ${serverInstructions}`,);} else {- this.logger.info(+ logger.info(`[MCP][${serverName}] serverInstructions=true but no server instructions available`,);}} else {- // configInstructions is false - explicitly disabled- this.logger.info(+ logger.info(`[MCP][${serverName}] Instructions explicitly disabled (serverInstructions=false)`,);}} else {- this.logger.info(+ logger.info(`[MCP][${serverName}] Instructions not included (serverInstructions not configured)`,);}const serverCapabilities = connection.client.getServerCapabilities();- this.logger.info(- `[MCP][${serverName}] Capabilities: ${JSON.stringify(serverCapabilities)}`,- );+ logger.info(`[MCP][${serverName}] Capabilities: ${JSON.stringify(serverCapabilities)}`);if (serverCapabilities?.tools) {const tools = await connection.client.listTools();if (tools.tools.length) {- this.logger.info(+ logger.info(`[MCP][${serverName}] Available tools: ${tools.tools.map((tool) => tool.name).join(', ')}`,@@ -130,7 +232,7 @@ export class MCPManager {}}} catch (error) {- this.logger.error(`[MCP][${serverName}] Initialization failed`, error);+ logger.error(`[MCP][${serverName}] Initialization failed`, error);throw error;}}),@@ -140,35 +242,47 @@ export class MCPManager {(result): result is PromiseRejectedResult => result.status === 'rejected',);- this.logger.info(+ logger.info(`[MCP] Initialized ${initializedServers.size}/${entries.length} app-level server(s)`,);if (failedConnections.length > 0) {- this.logger.warn(+ logger.warn(`[MCP] ${failedConnections.length}/${entries.length} app-level server(s) failed to initialize`,);}entries.forEach(([serverName], index) => {if (initializedServers.has(index)) {- this.logger.info(`[MCP][${serverName}] ✓ Initialized`);+ logger.info(`[MCP][${serverName}] ✓ Initialized`);} else {- this.logger.info(`[MCP][${serverName}] ✗ Failed`);+ logger.info(`[MCP][${serverName}] ✗ Failed`);}});if (initializedServers.size === entries.length) {- this.logger.info('[MCP] All app-level servers initialized successfully');+ logger.info('[MCP] All app-level servers initialized successfully');} else if (initializedServers.size === 0) {- this.logger.warn('[MCP] No app-level servers initialized');+ logger.warn('[MCP] No app-level servers initialized');}}/** Generic server initialization logic */- private async initializeServer(connection: MCPConnection, logPrefix: string): Promise<void> {+ private async initializeServer({+ connection,+ logPrefix,+ flowManager,+ handleOAuth = true,+ }: {+ connection: MCPConnection;+ logPrefix: string;+ flowManager: FlowStateManager<MCPOAuthTokens | null>;+ handleOAuth?: boolean;+ }): Promise<void> {const maxAttempts = 3;let attempts = 0;+ /** Whether OAuth has been handled by the connection */+ let oauthHandled = false;while (attempts < maxAttempts) {try {@@ -179,8 +293,34 @@ export class MCPManager {throw new Error('Connection attempt succeeded but status is not connected');} catch (error) {attempts++;++ if (this.isOAuthError(error)) {+ // Only handle OAuth if requested (not already handled by event listener)+ if (handleOAuth) {+ /** Check if OAuth was already handled by the connection */+ const errorWithFlag = error as (Error & { isOAuthError?: boolean }) | undefined;+ if (!oauthHandled && errorWithFlag?.isOAuthError) {+ oauthHandled = true;+ logger.info(`${logPrefix} Handling OAuth`);+ const serverUrl = connection.url;+ if (serverUrl) {+ await this.handleOAuthRequired({+ serverName: connection.serverName,+ serverUrl,+ flowManager,+ });+ }+ } else {+ logger.info(`${logPrefix} OAuth already handled by connection`);+ }+ }+ // Don't retry on OAuth errors - just throw+ logger.info(`${logPrefix} OAuth required, stopping connection attempts`);+ throw error;+ }+if (attempts === maxAttempts) {- this.logger.error(`${logPrefix} Failed to connect after ${maxAttempts} attempts`, error);+ logger.error(`${logPrefix} Failed to connect after ${maxAttempts} attempts`, error);throw error; // Re-throw the last error}await new Promise((resolve) => setTimeout(resolve, 2000 * attempts));@@ -188,6 +328,25 @@ export class MCPManager {}}+ private isOAuthError(error: unknown): boolean {+ if (!error || typeof error !== 'object') {+ return false;+ }++ // Check for SSE error with 401 status+ if ('message' in error && typeof error.message === 'string') {+ return error.message.includes('401') || error.message.includes('Non-200 status code (401)');+ }++ // Check for error code+ if ('code' in error) {+ const code = (error as { code?: number }).code;+ return code === 401 || code === 403;+ }++ return false;+ }+/** Check for and disconnect idle connections */private checkIdleConnections(currentUserId?: string): void {const now = Date.now();@@ -198,12 +357,12 @@ export class MCPManager {continue;}if (now - lastActivity > this.USER_CONNECTION_IDLE_TIMEOUT) {- this.logger.info(+ logger.info(`[MCP][User: ${userId}] User idle for too long. Disconnecting all connections...`,);// Disconnect all user connections asynchronously (fire and forget)this.disconnectUserConnections(userId).catch((err) =>- this.logger.error(`[MCP][User: ${userId}] Error disconnecting idle connections:`, err),+ logger.error(`[MCP][User: ${userId}] Error disconnecting idle connections:`, err),);}}@@ -213,13 +372,29 @@ export class MCPManager {private updateUserLastActivity(userId: string): void {const now = Date.now();this.userLastActivity.set(userId, now);- this.logger.debug(+ logger.debug(`[MCP][User: ${userId}] Updated last activity timestamp: ${new Date(now).toISOString()}`,);}/** Gets or creates a connection for a specific user */- public async getUserConnection(serverName: string, user: TUser): Promise<MCPConnection> {+ public async getUserConnection({+ user,+ serverName,+ flowManager,+ tokenMethods,+ oauthStart,+ oauthEnd,+ signal,+ }: {+ user: TUser;+ serverName: string;+ flowManager: FlowStateManager<MCPOAuthTokens | null>;+ tokenMethods?: TokenMethods;+ oauthStart?: (authURL: string) => Promise<void>;+ oauthEnd?: () => Promise<void>;+ signal?: AbortSignal;+ }): Promise<MCPConnection> {const userId = user.id;if (!userId) {throw new McpError(ErrorCode.InvalidRequest, `[MCP] User object missing id property`);@@ -232,25 +407,22 @@ export class MCPManager {// Check if user is idleconst lastActivity = this.userLastActivity.get(userId);if (lastActivity && now - lastActivity > this.USER_CONNECTION_IDLE_TIMEOUT) {- this.logger.info(- `[MCP][User: ${userId}] User idle for too long. Disconnecting all connections.`,- );+ logger.info(`[MCP][User: ${userId}] User idle for too long. Disconnecting all connections.`);// Disconnect all user connectionstry {await this.disconnectUserConnections(userId);} catch (err) {- this.logger.error(`[MCP][User: ${userId}] Error disconnecting idle connections:`, err);+ logger.error(`[MCP][User: ${userId}] Error disconnecting idle connections:`, err);}connection = undefined; // Force creation of a new connection} else if (connection) {if (await connection.isConnected()) {- this.logger.debug(`[MCP][User: ${userId}][${serverName}] Reusing active connection`);- // Update timestamp on reuse+ logger.debug(`[MCP][User: ${userId}][${serverName}] Reusing active connection`);this.updateUserLastActivity(userId);return connection;} else {// Connection exists but is not connected, attempt to remove potentially stale entry- this.logger.warn(+ logger.warn(`[MCP][User: ${userId}][${serverName}] Found existing but disconnected connection object. Cleaning up.`,);this.removeUserConnection(userId, serverName); // Clean up maps@@ -260,7 +432,7 @@ export class MCPManager {// If no valid connection exists, create a new oneif (!connection) {- this.logger.info(`[MCP][User: ${userId}][${serverName}] Establishing new connection`);+ logger.info(`[MCP][User: ${userId}][${serverName}] Establishing new connection`);}let config = this.mcpConfigs[serverName];@@ -275,19 +447,122 @@ export class MCPManager {config = { ...(this.processMCPEnv(config, user) ?? {}) };}- connection = new MCPConnection(serverName, config, this.logger, userId);+ /** If no in-memory tokens, tokens from persistent storage */+ let tokens: MCPOAuthTokens | null = null;+ if (tokenMethods?.findToken) {+ try {+ /** Refresh function for user-specific connections */+ const refreshTokensFunction = async (+ refreshToken: string,+ metadata: {+ userId: string;+ serverName: string;+ identifier: string;+ clientInfo?: OAuthClientInformation;+ },+ ) => {+ /** URL from config since connection doesn't exist yet */+ const serverUrl = (config as t.SSEOptions | t.StreamableHTTPOptions).url;+ return await MCPOAuthHandler.refreshOAuthTokens(+ refreshToken,+ {+ serverName: metadata.serverName,+ serverUrl,+ clientInfo: metadata.clientInfo,+ },+ config.oauth,+ );+ };++ /** Flow state to prevent concurrent token operations */+ const tokenFlowId = `tokens:${userId}:${serverName}`;+ tokens = await flowManager.createFlowWithHandler(+ tokenFlowId,+ 'mcp_get_tokens',+ async () => {+ return await MCPTokenStorage.getTokens({+ userId,+ serverName,+ findToken: tokenMethods.findToken,+ refreshTokens: refreshTokensFunction,+ createToken: tokenMethods.createToken,+ updateToken: tokenMethods.updateToken,+ });+ },+ signal,+ );+ } catch (error) {+ logger.error(+ `[MCP][User: ${userId}][${serverName}] Error loading OAuth tokens from storage`,+ error,+ );+ }+ }++ if (tokens) {+ logger.info(`[MCP][User: ${userId}][${serverName}] Loaded OAuth tokens`);+ }++ connection = new MCPConnection(serverName, config, userId, tokens);++ connection.on('oauthRequired', async (data) => {+ logger.info(`[MCP][User: ${userId}][${serverName}] oauthRequired event received`);+ const result = await this.handleOAuthRequired({+ ...data,+ flowManager,+ oauthStart,+ oauthEnd,+ });++ if (result?.tokens && tokenMethods?.createToken) {+ try {+ connection?.setOAuthTokens(result.tokens);+ await MCPTokenStorage.storeTokens({+ userId,+ serverName,+ tokens: result.tokens,+ createToken: tokenMethods.createToken,+ updateToken: tokenMethods.updateToken,+ findToken: tokenMethods.findToken,+ clientInfo: result.clientInfo,+ });+ logger.info(`[MCP][User: ${userId}][${serverName}] OAuth tokens saved to storage`);+ } catch (error) {+ logger.error(+ `[MCP][User: ${userId}][${serverName}] Failed to save OAuth tokens to storage`,+ error,+ );+ }+ }++ // Only emit oauthHandled if we actually got tokens (OAuth succeeded)+ if (result?.tokens) {+ connection?.emit('oauthHandled');+ } else {+ // OAuth failed, emit oauthFailed to properly reject the promise+ logger.warn(+ `[MCP][User: ${userId}][${serverName}] OAuth failed, emitting oauthFailed event`,+ );+ connection?.emit('oauthFailed', new Error('OAuth authentication failed'));+ }+ });try {+ const connectTimeout = config.initTimeout ?? 30000;const connectionTimeout = new Promise<void>((_, reject) =>- setTimeout(() => reject(new Error('Connection timeout')), 30000),+ setTimeout(+ () => reject(new Error(`Connection timeout after ${connectTimeout}ms`)),+ connectTimeout,+ ),);- const connectionAttempt = this.initializeServer(+ const connectionAttempt = this.initializeServer({connection,- `[MCP][User: ${userId}][${serverName}]`,- );+ logPrefix: `[MCP][User: ${userId}][${serverName}]`,+ flowManager,+ });await Promise.race([connectionAttempt, connectionTimeout]);- if (!(await connection.isConnected())) {+ if (!(await connection?.isConnected())) {throw new Error('Failed to establish connection after initialization attempt.');}@@ -295,18 +570,16 @@ export class MCPManager {this.userConnections.set(userId, new Map());}this.userConnections.get(userId)?.set(serverName, connection);- this.logger.info(`[MCP][User: ${userId}][${serverName}] Connection successfully established`);++ logger.info(`[MCP][User: ${userId}][${serverName}] Connection successfully established`);// Update timestamp on creationthis.updateUserLastActivity(userId);return connection;} catch (error) {- this.logger.error(- `[MCP][User: ${userId}][${serverName}] Failed to establish connection`,- error,- );+ logger.error(`[MCP][User: ${userId}][${serverName}] Failed to establish connection`, error);// Ensure partial connection state is cleaned up if initialization fails- await connection.disconnect().catch((disconnectError) => {- this.logger.error(+ await connection?.disconnect().catch((disconnectError) => {+ logger.error(`[MCP][User: ${userId}][${serverName}] Error during cleanup after failed connection`,disconnectError,);@@ -330,7 +603,7 @@ export class MCPManager {}}- this.logger.debug(`[MCP][User: ${userId}][${serverName}] Removed connection entry.`);+ logger.debug(`[MCP][User: ${userId}][${serverName}] Removed connection entry.`);}/** Disconnects and removes a specific user connection */@@ -338,7 +611,7 @@ export class MCPManager {const userMap = this.userConnections.get(userId);const connection = userMap?.get(serverName);if (connection) {- this.logger.info(`[MCP][User: ${userId}][${serverName}] Disconnecting...`);+ logger.info(`[MCP][User: ${userId}][${serverName}] Disconnecting...`);await connection.disconnect();this.removeUserConnection(userId, serverName);}@@ -349,12 +622,12 @@ export class MCPManager {const userMap = this.userConnections.get(userId);const disconnectPromises: Promise<void>[] = [];if (userMap) {- this.logger.info(`[MCP][User: ${userId}] Disconnecting all servers...`);+ logger.info(`[MCP][User: ${userId}] Disconnecting all servers...`);const userServers = Array.from(userMap.keys());for (const serverName of userServers) {disconnectPromises.push(this.disconnectUserConnection(userId, serverName).catch((error) => {- this.logger.error(+ logger.error(`[MCP][User: ${userId}][${serverName}] Error during disconnection:`,error,);@@ -364,7 +637,7 @@ export class MCPManager {await Promise.allSettled(disconnectPromises);// Ensure user activity timestamp is removedthis.userLastActivity.delete(userId);- this.logger.info(`[MCP][User: ${userId}] All connections processed for disconnection.`);+ logger.info(`[MCP][User: ${userId}] All connections processed for disconnection.`);}}@@ -378,17 +651,73 @@ export class MCPManager {return this.connections;}+ /** Attempts to reconnect an app-level connection if it's disconnected */+ private async isConnectionActive({+ serverName,+ connection,+ flowManager,+ skipReconnect = false,+ }: {+ serverName: string;+ connection: MCPConnection;+ flowManager: FlowStateManager<MCPOAuthTokens | null>;+ skipReconnect?: boolean;+ }): Promise<boolean> {+ if (await connection.isConnected()) {+ return true;+ }++ if (skipReconnect) {+ logger.warn(+ `[MCP][${serverName}] App-level connection is disconnected, skipping reconnection attempt`,+ );+ return false;+ }++ logger.warn(+ `[MCP][${serverName}] App-level connection disconnected, attempting to reconnect...`,+ );++ try {+ const config = this.mcpConfigs[serverName];+ if (!config) {+ logger.error(`[MCP][${serverName}] Configuration not found for reconnection`);+ return false;+ }++ await this.initializeServer({+ connection,+ logPrefix: `[MCP][${serverName}]`,+ flowManager,+ });++ if (await connection.isConnected()) {+ logger.info(`[MCP][${serverName}] App-level connection successfully reconnected`);+ return true;+ } else {+ logger.warn(`[MCP][${serverName}] App-level connection reconnection failed`);+ return false;+ }+ } catch (error) {+ logger.error(`[MCP][${serverName}] Error during app-level connection reconnection:`, error);+ return false;+ }+ }+/*** Maps available tools from all app-level connections into the provided object.* The object is modified in place.*/- public async mapAvailableTools(availableTools: t.LCAvailableTools): Promise<void> {+ public async mapAvailableTools(+ availableTools: t.LCAvailableTools,+ flowManager: FlowStateManager<MCPOAuthTokens | null>,+ ): Promise<void> {for (const [serverName, connection] of this.connections.entries()) {try {- if ((await connection.isConnected()) !== true) {- this.logger.warn(- `[MCP][${serverName}] Connection not established. Skipping tool mapping.`,- );+ /** Attempt to ensure connection is active, with reconnection if needed */+ const isActive = await this.isConnectionActive({ serverName, connection, flowManager });+ if (!isActive) {+ logger.warn(`[MCP][${serverName}] Connection not available. Skipping tool mapping.`);continue;}@@ -405,7 +734,7 @@ export class MCPManager {};}} catch (error) {- this.logger.warn(`[MCP][${serverName}] Error fetching tools for mapping:`, error);+ logger.warn(`[MCP][${serverName}] Error fetching tools`, error);}}}@@ -413,19 +742,46 @@ export class MCPManager {/*** Loads tools from all app-level connections into the manifest.*/- public async loadManifestTools(manifestTools: t.LCToolManifest): Promise<t.LCToolManifest> {+ public async loadManifestTools({+ flowManager,+ serverToolsCallback,+ getServerTools,+ }: {+ flowManager: FlowStateManager<MCPOAuthTokens | null>;+ serverToolsCallback?: (serverName: string, tools: t.LCManifestTool[]) => Promise<void>;+ getServerTools?: (serverName: string) => Promise<t.LCManifestTool[] | undefined>;+ }): Promise<t.LCToolManifest> {const mcpTools: t.LCManifestTool[] = [];for (const [serverName, connection] of this.connections.entries()) {try {- if ((await connection.isConnected()) !== true) {- this.logger.warn(- `[MCP][${serverName}] Connection not established. Skipping manifest loading.`,+ /** Attempt to ensure connection is active, with reconnection if needed */+ const isActive = await this.isConnectionActive({+ serverName,+ connection,+ flowManager,+ skipReconnect: true,+ });+ if (!isActive) {+ logger.warn(+ `[MCP][${serverName}] Connection not available for ${serverName} manifest tools.`,);+ if (typeof getServerTools !== 'function') {+ logger.warn(+ `[MCP][${serverName}] No \`getServerTools\` function provided, skipping tool loading.`,+ );+ continue;+ }+ const serverTools = await getServerTools(serverName);+ if (serverTools && serverTools.length > 0) {+ logger.info(`[MCP][${serverName}] Loaded tools from cache for manifest`);+ mcpTools.push(...serverTools);+ }continue;}const tools = await connection.fetchTools();+ const serverTools: t.LCManifestTool[] = [];for (const tool of tools) {const pluginKey = `${tool.name}${CONSTANTS.mcp_delimiter}${serverName}`;const manifestTool: t.LCManifestTool = {@@ -439,13 +795,17 @@ export class MCPManager {manifestTool.chatMenu = false;}mcpTools.push(manifestTool);+ serverTools.push(manifestTool);+ }+ if (typeof serverToolsCallback === 'function') {+ await serverToolsCallback(serverName, serverTools);}} catch (error) {- this.logger.error(`[MCP][${serverName}] Error fetching tools for manifest:`, error);+ logger.error(`[MCP][${serverName}] Error fetching tools for manifest:`, error);}}- return [...mcpTools, ...manifestTools];+ return mcpTools;}/**@@ -459,13 +819,22 @@ export class MCPManager {provider,toolArguments,options,+ tokenMethods,+ flowManager,+ oauthStart,+ oauthEnd,}: {serverName: string;toolName: string;provider: t.Provider;toolArguments?: Record<string, unknown>;options?: CallToolOptions;+ tokenMethods?: TokenMethods;+ flowManager: FlowStateManager<MCPOAuthTokens | null>;+ oauthStart?: (authURL: string) => Promise<void>;+ oauthEnd?: () => Promise<void>;}): Promise<t.FormattedToolResponse> {+ /** User-specific connection */let connection: MCPConnection | undefined;const { user, ...callOptions } = options ?? {};const userId = user?.id;@@ -474,10 +843,18 @@ export class MCPManager {try {if (userId && user) {this.updateUserLastActivity(userId);- // Get or create user-specific connection- connection = await this.getUserConnection(serverName, user);+ /** Get or create user-specific connection */+ connection = await this.getUserConnection({+ user,+ serverName,+ flowManager,+ tokenMethods,+ oauthStart,+ oauthEnd,+ signal: options?.signal,+ });} else {- // Use app-level connection+ /** App-level connection */connection = this.connections.get(serverName);if (!connection) {throw new McpError(@@ -488,7 +865,7 @@ export class MCPManager {}if (!(await connection.isConnected())) {- // This might happen if getUserConnection failed silently or app connection dropped+ /** May happen if getUserConnection failed silently or app connection dropped */throw new McpError(ErrorCode.InternalError, // Use InternalError for connection issues`${logPrefix} Connection is not active. Cannot execute tool ${toolName}.`,@@ -516,7 +893,7 @@ export class MCPManager {return formatToolContent(result, provider);} catch (error) {// Log with context and re-throw or handle as needed- this.logger.error(`${logPrefix}[${toolName}] Tool call failed`, error);+ logger.error(`${logPrefix}[${toolName}] Tool call failed`, error);// Rethrowing allows the caller (createMCPTool) to handle the final user messagethrow error;}@@ -526,7 +903,7 @@ export class MCPManager {public async disconnectServer(serverName: string): Promise<void> {const connection = this.connections.get(serverName);if (connection) {- this.logger.info(`[MCP][${serverName}] Disconnecting...`);+ logger.info(`[MCP][${serverName}] Disconnecting...`);await connection.disconnect();this.connections.delete(serverName);}@@ -534,7 +911,7 @@ export class MCPManager {/** Disconnects all app-level and user-level connections */public async disconnectAll(): Promise<void> {- this.logger.info('[MCP] Disconnecting all app-level and user-level connections...');+ logger.info('[MCP] Disconnecting all app-level and user-level connections...');const userDisconnectPromises = Array.from(this.userConnections.keys()).map((userId) =>this.disconnectUserConnections(userId),@@ -545,13 +922,13 @@ export class MCPManager {// Disconnect all app-level connectionsconst appDisconnectPromises = Array.from(this.connections.values()).map((connection) =>connection.disconnect().catch((error) => {- this.logger.error(`[MCP][${connection.serverName}] Error during disconnectAll:`, error);+ logger.error(`[MCP][${connection.serverName}] Error during disconnectAll:`, error);}),);await Promise.allSettled(appDisconnectPromises);this.connections.clear();- this.logger.info('[MCP] All connections processed for disconnection.');+ logger.info('[MCP] All connections processed for disconnection.');}/** Destroys the singleton instance and disconnects all connections */@@ -559,7 +936,6 @@ export class MCPManager {if (MCPManager.instance) {await MCPManager.instance.disconnectAll();MCPManager.instance = null;- const logger = MCPManager.getDefaultLogger();logger.info('[MCP] Manager instance destroyed.');}}@@ -620,4 +996,102 @@ ${formattedInstructions}Please follow these instructions when using tools from the respective MCP servers.`;}++ /** Handles OAuth authentication requirements */+ private async handleOAuthRequired({+ serverName,+ serverUrl,+ flowManager,+ userId = CONSTANTS.SYSTEM_USER_ID,+ oauthStart,+ oauthEnd,+ }: {+ serverName: string;+ flowManager: FlowStateManager<MCPOAuthTokens | null>;+ userId?: string;+ serverUrl?: string;+ oauthStart?: (authURL: string) => Promise<void>;+ oauthEnd?: () => Promise<void>;+ }): Promise<{ tokens: MCPOAuthTokens | null; clientInfo?: OAuthClientInformation } | null> {+ const userPart = isSystemUserId(userId) ? '' : `[User: ${userId}]`;+ const logPrefix = `[MCP]${userPart}[${serverName}]`;+ logger.debug(`${logPrefix} \`handleOAuthRequired\` called with serverUrl: ${serverUrl}`);++ if (!flowManager || !serverUrl) {+ logger.error(+ `${logPrefix} OAuth required but flow manager not available or server URL missing for ${serverName}`,+ );+ logger.warn(`${logPrefix} Please configure OAuth credentials for ${serverName}`);+ return null;+ }++ try {+ const config = this.mcpConfigs[serverName];+ logger.debug(`${logPrefix} Checking for existing OAuth flow for ${serverName}...`);++ /** Flow ID to check if a flow already exists */+ const flowId = MCPOAuthHandler.generateFlowId(userId, serverName);++ /** Check if there's already an ongoing OAuth flow for this flowId */+ const existingFlow = await flowManager.getFlowState(flowId, 'mcp_oauth');+ if (existingFlow && existingFlow.status === 'PENDING') {+ logger.debug(+ `${logPrefix} OAuth flow already exists for ${flowId}, waiting for completion`,+ );+ /** Tokens from existing flow to complete */+ const tokens = await flowManager.createFlow(flowId, 'mcp_oauth');+ if (typeof oauthEnd === 'function') {+ await oauthEnd();+ }+ logger.info(`${logPrefix} OAuth flow completed, tokens received for ${serverName}`);++ /** Client information from the existing flow metadata */+ const existingMetadata = existingFlow.metadata as unknown as MCPOAuthFlowMetadata;+ const clientInfo = existingMetadata?.clientInfo;++ return { tokens, clientInfo };+ }++ logger.debug(`${logPrefix} Initiating new OAuth flow for ${serverName}...`);+ const {+ authorizationUrl,+ flowId: newFlowId,+ flowMetadata,+ } = await MCPOAuthHandler.initiateOAuthFlow(serverName, serverUrl, userId, config?.oauth);++ if (typeof oauthStart === 'function') {+ logger.info(`${logPrefix} OAuth flow started, issued authorization URL to user`);+ await oauthStart(authorizationUrl);+ } else {+ logger.info(`+═══════════════════════════════════════════════════════════════════════+Please visit the following URL to authenticate:++${authorizationUrl}++${logPrefix} Flow ID: ${newFlowId}+═══════════════════════════════════════════════════════════════════════+`);+ }++ /** Tokens from the new flow */+ const tokens = await flowManager.createFlow(+ newFlowId,+ 'mcp_oauth',+ flowMetadata as FlowMetadata,+ );+ if (typeof oauthEnd === 'function') {+ await oauthEnd();+ }+ logger.info(`${logPrefix} OAuth flow completed, tokens received for ${serverName}`);++ /** Client information from the flow metadata */+ const clientInfo = flowMetadata?.clientInfo;++ return { tokens, clientInfo };+ } catch (error) {+ logger.error(`${logPrefix} Failed to complete OAuth flow for ${serverName}`, error);+ return null;+ }+ }}diff --git a/packages/api/src/mcp/oauth/handler.ts b/packages/api/src/mcp/oauth/handler.tsnew file mode 100644index 0000000000..ab9bbe46c1--- /dev/null+++ b/packages/api/src/mcp/oauth/handler.ts@@ -0,0 +1,603 @@+import { randomBytes } from 'crypto';+import { logger } from '@librechat/data-schemas';+import {+ discoverOAuthMetadata,+ registerClient,+ startAuthorization,+ exchangeAuthorization,+ discoverOAuthProtectedResourceMetadata,+} from '@modelcontextprotocol/sdk/client/auth.js';+import { OAuthMetadataSchema } from '@modelcontextprotocol/sdk/shared/auth.js';+import type { MCPOptions } from 'librechat-data-provider';+import type { FlowStateManager } from '~/flow/manager';+import type {+ OAuthClientInformation,+ OAuthProtectedResourceMetadata,+ MCPOAuthFlowMetadata,+ MCPOAuthTokens,+ OAuthMetadata,+} from './types';++/** Type for the OAuth metadata from the SDK */+type SDKOAuthMetadata = Parameters<typeof registerClient>[1]['metadata'];++export class MCPOAuthHandler {+ private static readonly FLOW_TYPE = 'mcp_oauth';+ private static readonly FLOW_TTL = 10 * 60 * 1000; // 10 minutes++ /**+ * Discovers OAuth metadata from the server+ */+ private static async discoverMetadata(serverUrl: string): Promise<{+ metadata: OAuthMetadata;+ resourceMetadata?: OAuthProtectedResourceMetadata;+ authServerUrl: URL;+ }> {+ logger.debug(`[MCPOAuth] discoverMetadata called with serverUrl: ${serverUrl}`);++ let authServerUrl = new URL(serverUrl);+ let resourceMetadata: OAuthProtectedResourceMetadata | undefined;++ try {+ // Try to discover resource metadata first+ logger.debug(+ `[MCPOAuth] Attempting to discover protected resource metadata from ${serverUrl}`,+ );+ resourceMetadata = await discoverOAuthProtectedResourceMetadata(serverUrl);++ if (resourceMetadata?.authorization_servers?.length) {+ authServerUrl = new URL(resourceMetadata.authorization_servers[0]);+ logger.debug(+ `[MCPOAuth] Found authorization server from resource metadata: ${authServerUrl}`,+ );+ } else {+ logger.debug(`[MCPOAuth] No authorization servers found in resource metadata`);+ }+ } catch (error) {+ logger.debug('[MCPOAuth] Resource metadata discovery failed, continuing with server URL', {+ error,+ });+ }++ // Discover OAuth metadata+ logger.debug(`[MCPOAuth] Discovering OAuth metadata from ${authServerUrl}`);+ const rawMetadata = await discoverOAuthMetadata(authServerUrl);++ if (!rawMetadata) {+ logger.error(`[MCPOAuth] Failed to discover OAuth metadata from ${authServerUrl}`);+ throw new Error('Failed to discover OAuth metadata');+ }++ logger.debug(`[MCPOAuth] OAuth metadata discovered successfully`);+ const metadata = await OAuthMetadataSchema.parseAsync(rawMetadata);++ logger.debug(`[MCPOAuth] OAuth metadata parsed successfully`);+ return {+ metadata: metadata as unknown as OAuthMetadata,+ resourceMetadata,+ authServerUrl,+ };+ }++ /**+ * Registers an OAuth client dynamically+ */+ private static async registerOAuthClient(+ serverUrl: string,+ metadata: OAuthMetadata,+ resourceMetadata?: OAuthProtectedResourceMetadata,+ redirectUri?: string,+ ): Promise<OAuthClientInformation> {+ logger.debug(`[MCPOAuth] Starting client registration for ${serverUrl}, server metadata:`, {+ grant_types_supported: metadata.grant_types_supported,+ response_types_supported: metadata.response_types_supported,+ token_endpoint_auth_methods_supported: metadata.token_endpoint_auth_methods_supported,+ scopes_supported: metadata.scopes_supported,+ });++ /** Client metadata based on what the server supports */+ const clientMetadata = {+ client_name: 'LibreChat MCP Client',+ redirect_uris: [redirectUri || this.getDefaultRedirectUri()],+ grant_types: ['authorization_code'] as string[],+ response_types: ['code'] as string[],+ token_endpoint_auth_method: 'client_secret_basic',+ scope: undefined as string | undefined,+ };++ const supportedGrantTypes = metadata.grant_types_supported || ['authorization_code'];+ const requestedGrantTypes = ['authorization_code'];++ if (supportedGrantTypes.includes('refresh_token')) {+ requestedGrantTypes.push('refresh_token');+ logger.debug(+ `[MCPOAuth] Server ${serverUrl} supports \`refresh_token\` grant type, adding to request`,+ );+ } else {+ logger.debug(`[MCPOAuth] Server ${serverUrl} does not support \`refresh_token\` grant type`);+ }+ clientMetadata.grant_types = requestedGrantTypes;++ clientMetadata.response_types = metadata.response_types_supported || ['code'];++ if (metadata.token_endpoint_auth_methods_supported) {+ // Prefer client_secret_basic if supported, otherwise use the first supported method+ if (metadata.token_endpoint_auth_methods_supported.includes('client_secret_basic')) {+ clientMetadata.token_endpoint_auth_method = 'client_secret_basic';+ } else if (metadata.token_endpoint_auth_methods_supported.includes('client_secret_post')) {+ clientMetadata.token_endpoint_auth_method = 'client_secret_post';+ } else if (metadata.token_endpoint_auth_methods_supported.includes('none')) {+ clientMetadata.token_endpoint_auth_method = 'none';+ } else {+ clientMetadata.token_endpoint_auth_method =+ metadata.token_endpoint_auth_methods_supported[0];+ }+ }++ const availableScopes = resourceMetadata?.scopes_supported || metadata.scopes_supported;+ if (availableScopes) {+ clientMetadata.scope = availableScopes.join(' ');+ }++ logger.debug(`[MCPOAuth] Registering client for ${serverUrl} with metadata:`, clientMetadata);++ const clientInfo = await registerClient(serverUrl, {+ metadata: metadata as unknown as SDKOAuthMetadata,+ clientMetadata,+ });++ logger.debug(`[MCPOAuth] Client registered successfully for ${serverUrl}:`, {+ client_id: clientInfo.client_id,+ has_client_secret: !!clientInfo.client_secret,+ grant_types: clientInfo.grant_types,+ scope: clientInfo.scope,+ });++ return clientInfo;+ }++ /**+ * Initiates the OAuth flow for an MCP server+ */+ static async initiateOAuthFlow(+ serverName: string,+ serverUrl: string,+ userId: string,+ config: MCPOptions['oauth'] | undefined,+ ): Promise<{ authorizationUrl: string; flowId: string; flowMetadata: MCPOAuthFlowMetadata }> {+ logger.debug(`[MCPOAuth] initiateOAuthFlow called for ${serverName} with URL: ${serverUrl}`);++ const flowId = this.generateFlowId(userId, serverName);+ const state = this.generateState();++ logger.debug(`[MCPOAuth] Generated flowId: ${flowId}, state: ${state}`);++ try {+ // Check if we have pre-configured OAuth settings+ if (config?.authorization_url && config?.token_url && config?.client_id) {+ logger.debug(`[MCPOAuth] Using pre-configured OAuth settings for ${serverName}`);+ /** Metadata based on pre-configured settings */+ const metadata: OAuthMetadata = {+ authorization_endpoint: config.authorization_url,+ token_endpoint: config.token_url,+ issuer: serverUrl,+ scopes_supported: config.scope?.split(' '),+ };++ const clientInfo: OAuthClientInformation = {+ client_id: config.client_id,+ client_secret: config.client_secret,+ redirect_uris: [config.redirect_uri || this.getDefaultRedirectUri(serverName)],+ scope: config.scope,+ };++ logger.debug(`[MCPOAuth] Starting authorization with pre-configured settings`);+ const { authorizationUrl, codeVerifier } = await startAuthorization(serverUrl, {+ metadata: metadata as unknown as SDKOAuthMetadata,+ clientInformation: clientInfo,+ redirectUrl: clientInfo.redirect_uris?.[0] || this.getDefaultRedirectUri(serverName),+ scope: config.scope,+ });++ /** Add state parameter with flowId to the authorization URL */+ authorizationUrl.searchParams.set('state', flowId);+ logger.debug(`[MCPOAuth] Added state parameter to authorization URL`);++ const flowMetadata: MCPOAuthFlowMetadata = {+ serverName,+ userId,+ serverUrl,+ state,+ codeVerifier,+ clientInfo,+ metadata,+ };++ logger.debug(`[MCPOAuth] Authorization URL generated: ${authorizationUrl.toString()}`);+ return {+ authorizationUrl: authorizationUrl.toString(),+ flowId,+ flowMetadata,+ };+ }++ logger.debug(`[MCPOAuth] Starting auto-discovery of OAuth metadata from ${serverUrl}`);+ const { metadata, resourceMetadata, authServerUrl } = await this.discoverMetadata(serverUrl);++ logger.debug(`[MCPOAuth] OAuth metadata discovered, auth server URL: ${authServerUrl}`);++ /** Dynamic client registration based on the discovered metadata */+ const redirectUri = config?.redirect_uri || this.getDefaultRedirectUri(serverName);+ logger.debug(`[MCPOAuth] Registering OAuth client with redirect URI: ${redirectUri}`);++ const clientInfo = await this.registerOAuthClient(+ authServerUrl.toString(),+ metadata,+ resourceMetadata,+ redirectUri,+ );++ logger.debug(`[MCPOAuth] Client registered with ID: ${clientInfo.client_id}`);++ /** Authorization Scope */+ const scope =+ config?.scope ||+ resourceMetadata?.scopes_supported?.join(' ') ||+ metadata.scopes_supported?.join(' ');++ logger.debug(`[MCPOAuth] Starting authorization with scope: ${scope}`);++ let authorizationUrl: URL;+ let codeVerifier: string;++ try {+ logger.debug(`[MCPOAuth] Calling startAuthorization...`);+ const authResult = await startAuthorization(serverUrl, {+ metadata: metadata as unknown as SDKOAuthMetadata,+ clientInformation: clientInfo,+ redirectUrl: redirectUri,+ scope,+ });++ authorizationUrl = authResult.authorizationUrl;+ codeVerifier = authResult.codeVerifier;++ logger.debug(`[MCPOAuth] startAuthorization completed successfully`);+ logger.debug(`[MCPOAuth] Authorization URL: ${authorizationUrl.toString()}`);++ /** Add state parameter with flowId to the authorization URL */+ authorizationUrl.searchParams.set('state', flowId);+ logger.debug(`[MCPOAuth] Added state parameter to authorization URL`);+ } catch (error) {+ logger.error(`[MCPOAuth] startAuthorization failed:`, error);+ throw error;+ }++ const flowMetadata: MCPOAuthFlowMetadata = {+ serverName,+ userId,+ serverUrl,+ state,+ codeVerifier,+ clientInfo,+ metadata,+ resourceMetadata,+ };++ logger.debug(+ `[MCPOAuth] Authorization URL generated for ${serverName}: ${authorizationUrl.toString()}`,+ );++ const result = {+ authorizationUrl: authorizationUrl.toString(),+ flowId,+ flowMetadata,+ };++ logger.debug(+ `[MCPOAuth] Returning from initiateOAuthFlow with result ${flowId} for ${serverName}`,+ result,+ );+ return result;+ } catch (error) {+ logger.error('[MCPOAuth] Failed to initiate OAuth flow', { error, serverName, userId });+ throw error;+ }+ }++ /**+ * Completes the OAuth flow by exchanging the authorization code for tokens+ */+ static async completeOAuthFlow(+ flowId: string,+ authorizationCode: string,+ flowManager: FlowStateManager<MCPOAuthTokens>,+ ): Promise<MCPOAuthTokens> {+ try {+ /** Flow state which contains our metadata */+ const flowState = await flowManager.getFlowState(flowId, this.FLOW_TYPE);+ if (!flowState) {+ throw new Error('OAuth flow not found');+ }++ const flowMetadata = flowState.metadata as MCPOAuthFlowMetadata;+ if (!flowMetadata) {+ throw new Error('OAuth flow metadata not found');+ }++ const metadata = flowMetadata;+ if (!metadata.metadata || !metadata.clientInfo || !metadata.codeVerifier) {+ throw new Error('Invalid flow metadata');+ }++ const tokens = await exchangeAuthorization(metadata.serverUrl, {+ metadata: metadata.metadata as unknown as SDKOAuthMetadata,+ clientInformation: metadata.clientInfo,+ authorizationCode,+ codeVerifier: metadata.codeVerifier,+ redirectUri: metadata.clientInfo.redirect_uris?.[0] || this.getDefaultRedirectUri(),+ });++ logger.debug('[MCPOAuth] Raw tokens from exchange:', {+ access_token: tokens.access_token ? '[REDACTED]' : undefined,+ refresh_token: tokens.refresh_token ? '[REDACTED]' : undefined,+ expires_in: tokens.expires_in,+ token_type: tokens.token_type,+ scope: tokens.scope,+ });++ const mcpTokens: MCPOAuthTokens = {+ ...tokens,+ obtained_at: Date.now(),+ expires_at: tokens.expires_in ? Date.now() + tokens.expires_in * 1000 : undefined,+ };++ /** Now complete the flow with the tokens */+ await flowManager.completeFlow(flowId, this.FLOW_TYPE, mcpTokens);++ return mcpTokens;+ } catch (error) {+ logger.error('[MCPOAuth] Failed to complete OAuth flow', { error, flowId });+ await flowManager.failFlow(flowId, this.FLOW_TYPE, error as Error);+ throw error;+ }+ }++ /**+ * Gets the OAuth flow metadata+ */+ static async getFlowState(+ flowId: string,+ flowManager: FlowStateManager<MCPOAuthTokens>,+ ): Promise<MCPOAuthFlowMetadata | null> {+ const flowState = await flowManager.getFlowState(flowId, this.FLOW_TYPE);+ if (!flowState) {+ return null;+ }+ return flowState.metadata as MCPOAuthFlowMetadata;+ }++ /**+ * Generates a flow ID for the OAuth flow+ * @returns Consistent ID so concurrent requests share the same flow+ */+ public static generateFlowId(userId: string, serverName: string): string {+ return `${userId}:${serverName}`;+ }++ /**+ * Generates a secure state parameter+ */+ private static generateState(): string {+ return randomBytes(32).toString('base64url');+ }++ /**+ * Gets the default redirect URI for a server+ */+ private static getDefaultRedirectUri(serverName?: string): string {+ const baseUrl = process.env.DOMAIN_SERVER || 'http://localhost:3080';+ return serverName+ ? `${baseUrl}/api/mcp/${serverName}/oauth/callback`+ : `${baseUrl}/api/mcp/oauth/callback`;+ }++ /**+ * Refreshes OAuth tokens using a refresh token+ */+ static async refreshOAuthTokens(+ refreshToken: string,+ metadata: { serverName: string; serverUrl?: string; clientInfo?: OAuthClientInformation },+ config?: MCPOptions['oauth'],+ ): Promise<MCPOAuthTokens> {+ logger.debug(`[MCPOAuth] Refreshing tokens for ${metadata.serverName}`);++ try {+ /** If we have stored client information from the original flow, use that first */+ if (metadata.clientInfo?.client_id) {+ logger.debug(+ `[MCPOAuth] Using stored client information for token refresh for ${metadata.serverName}`,+ );+ logger.debug(+ `[MCPOAuth] Client ID: ${metadata.clientInfo.client_id} for ${metadata.serverName}`,+ );+ logger.debug(+ `[MCPOAuth] Has client secret: ${!!metadata.clientInfo.client_secret} for ${metadata.serverName}`,+ );+ logger.debug(`[MCPOAuth] Stored client info for ${metadata.serverName}:`, {+ client_id: metadata.clientInfo.client_id,+ has_client_secret: !!metadata.clientInfo.client_secret,+ grant_types: metadata.clientInfo.grant_types,+ scope: metadata.clientInfo.scope,+ });++ /** Use the stored client information and metadata to determine the token URL */+ let tokenUrl: string;+ if (config?.token_url) {+ tokenUrl = config.token_url;+ } else if (!metadata.serverUrl) {+ throw new Error('No token URL available for refresh');+ } else {+ /** Auto-discover OAuth configuration for refresh */+ const { metadata: oauthMetadata } = await this.discoverMetadata(metadata.serverUrl);+ if (!oauthMetadata.token_endpoint) {+ throw new Error('No token endpoint found in OAuth metadata');+ }+ tokenUrl = oauthMetadata.token_endpoint;+ }++ const body = new URLSearchParams({+ grant_type: 'refresh_token',+ refresh_token: refreshToken,+ });++ /** Add scope if available */+ if (metadata.clientInfo.scope) {+ body.append('scope', metadata.clientInfo.scope);+ }++ const headers: HeadersInit = {+ 'Content-Type': 'application/x-www-form-urlencoded',+ Accept: 'application/json',+ };++ /** Use client_secret for authentication if available */+ if (metadata.clientInfo.client_secret) {+ const clientAuth = Buffer.from(+ `${metadata.clientInfo.client_id}:${metadata.clientInfo.client_secret}`,+ ).toString('base64');+ headers['Authorization'] = `Basic ${clientAuth}`;+ } else {+ /** For public clients, client_id must be in the body */+ body.append('client_id', metadata.clientInfo.client_id);+ }++ logger.debug(`[MCPOAuth] Refresh request to: ${tokenUrl}`, {+ body: body.toString(),+ headers,+ });++ const response = await fetch(tokenUrl, {+ method: 'POST',+ headers,+ body,+ });++ if (!response.ok) {+ const errorText = await response.text();+ throw new Error(+ `Token refresh failed: ${response.status} ${response.statusText} - ${errorText}`,+ );+ }++ const tokens = await response.json();++ return {+ ...tokens,+ obtained_at: Date.now(),+ expires_at: tokens.expires_in ? Date.now() + tokens.expires_in * 1000 : undefined,+ };+ }++ // Fallback: If we have pre-configured OAuth settings, use them+ if (config?.token_url && config?.client_id) {+ logger.debug(`[MCPOAuth] Using pre-configured OAuth settings for token refresh`);++ const tokenUrl = new URL(config.token_url);+ const clientAuth = config.client_secret+ ? Buffer.from(`${config.client_id}:${config.client_secret}`).toString('base64')+ : null;++ const body = new URLSearchParams({+ grant_type: 'refresh_token',+ refresh_token: refreshToken,+ });++ if (config.scope) {+ body.append('scope', config.scope);+ }++ const headers: HeadersInit = {+ 'Content-Type': 'application/x-www-form-urlencoded',+ Accept: 'application/json',+ };++ if (clientAuth) {+ headers['Authorization'] = `Basic ${clientAuth}`;+ } else {+ // Use client_id in body for public clients+ body.append('client_id', config.client_id);+ }++ const response = await fetch(tokenUrl, {+ method: 'POST',+ headers,+ body,+ });++ if (!response.ok) {+ const errorText = await response.text();+ throw new Error(+ `Token refresh failed: ${response.status} ${response.statusText} - ${errorText}`,+ );+ }++ const tokens = await response.json();++ return {+ ...tokens,+ obtained_at: Date.now(),+ expires_at: tokens.expires_in ? Date.now() + tokens.expires_in * 1000 : undefined,+ };+ }++ /** For auto-discovered OAuth, we need the server URL */+ if (!metadata.serverUrl) {+ throw new Error('Server URL required for auto-discovered OAuth token refresh');+ }++ /** Auto-discover OAuth configuration for refresh */+ const { metadata: oauthMetadata } = await this.discoverMetadata(metadata.serverUrl);++ if (!oauthMetadata.token_endpoint) {+ throw new Error('No token endpoint found in OAuth metadata');+ }++ const tokenUrl = new URL(oauthMetadata.token_endpoint);++ const body = new URLSearchParams({+ grant_type: 'refresh_token',+ refresh_token: refreshToken,+ });++ const headers: HeadersInit = {+ 'Content-Type': 'application/x-www-form-urlencoded',+ Accept: 'application/json',+ };++ const response = await fetch(tokenUrl, {+ method: 'POST',+ headers,+ body,+ });++ if (!response.ok) {+ const errorText = await response.text();+ throw new Error(+ `Token refresh failed: ${response.status} ${response.statusText} - ${errorText}`,+ );+ }++ const tokens = await response.json();++ return {+ ...tokens,+ obtained_at: Date.now(),+ expires_at: tokens.expires_in ? Date.now() + tokens.expires_in * 1000 : undefined,+ };+ } catch (error) {+ logger.error(`[MCPOAuth] Failed to refresh tokens for ${metadata.serverName}`, error);+ throw error;+ }+ }+}diff --git a/packages/api/src/mcp/oauth/index.ts b/packages/api/src/mcp/oauth/index.tsnew file mode 100644index 0000000000..ff82bd92f7--- /dev/null+++ b/packages/api/src/mcp/oauth/index.ts@@ -0,0 +1,3 @@+export * from './types';+export * from './handler';+export * from './tokens';diff --git a/packages/api/src/mcp/oauth/tokens.ts b/packages/api/src/mcp/oauth/tokens.tsnew file mode 100644index 0000000000..4aeb11482a--- /dev/null+++ b/packages/api/src/mcp/oauth/tokens.ts@@ -0,0 +1,382 @@+import { logger } from '@librechat/data-schemas';+import type { OAuthTokens, OAuthClientInformation } from '@modelcontextprotocol/sdk/shared/auth.js';+import type { TokenMethods, IToken } from '@librechat/data-schemas';+import type { MCPOAuthTokens, ExtendedOAuthTokens } from './types';+import { encryptV2, decryptV2 } from '~/crypto';+import { isSystemUserId } from '~/mcp/enum';++interface StoreTokensParams {+ userId: string;+ serverName: string;+ tokens: OAuthTokens | ExtendedOAuthTokens | MCPOAuthTokens;+ createToken: TokenMethods['createToken'];+ updateToken?: TokenMethods['updateToken'];+ findToken?: TokenMethods['findToken'];+ clientInfo?: OAuthClientInformation;+ /** Optional: Pass existing token state to avoid duplicate DB calls */+ existingTokens?: {+ accessToken?: IToken | null;+ refreshToken?: IToken | null;+ clientInfoToken?: IToken | null;+ };+}++interface GetTokensParams {+ userId: string;+ serverName: string;+ findToken: TokenMethods['findToken'];+ refreshTokens?: (+ refreshToken: string,+ metadata: { userId: string; serverName: string; identifier: string },+ ) => Promise<MCPOAuthTokens>;+ createToken?: TokenMethods['createToken'];+ updateToken?: TokenMethods['updateToken'];+}++export class MCPTokenStorage {+ static getLogPrefix(userId: string, serverName: string): string {+ return isSystemUserId(userId)+ ? `[MCP][${serverName}]`+ : `[MCP][User: ${userId}][${serverName}]`;+ }++ /**+ * Stores OAuth tokens for an MCP server+ *+ * @param params.existingTokens - Optional: Pass existing token state to avoid duplicate DB calls.+ * This is useful when refreshing tokens, as getTokens() already has the token state.+ */+ static async storeTokens({+ userId,+ serverName,+ tokens,+ createToken,+ updateToken,+ findToken,+ clientInfo,+ existingTokens,+ }: StoreTokensParams): Promise<void> {+ const logPrefix = this.getLogPrefix(userId, serverName);++ try {+ const identifier = `mcp:${serverName}`;++ // Encrypt and store access token+ const encryptedAccessToken = await encryptV2(tokens.access_token);++ logger.debug(+ `${logPrefix} Token expires_in: ${'expires_in' in tokens ? tokens.expires_in : 'N/A'}, expires_at: ${'expires_at' in tokens ? tokens.expires_at : 'N/A'}`,+ );++ // Handle both expires_in and expires_at formats+ let accessTokenExpiry: Date;+ if ('expires_at' in tokens && tokens.expires_at) {+ /** MCPOAuthTokens format - already has calculated expiry */+ logger.debug(`${logPrefix} Using expires_at: ${tokens.expires_at}`);+ accessTokenExpiry = new Date(tokens.expires_at);+ } else if (tokens.expires_in) {+ /** Standard OAuthTokens format - calculate expiry */+ logger.debug(`${logPrefix} Using expires_in: ${tokens.expires_in}`);+ accessTokenExpiry = new Date(Date.now() + tokens.expires_in * 1000);+ } else {+ /** No expiry provided - default to 1 year */+ logger.debug(`${logPrefix} No expiry provided, using default`);+ accessTokenExpiry = new Date(Date.now() + 365 * 24 * 60 * 60 * 1000);+ }++ logger.debug(`${logPrefix} Calculated expiry date: ${accessTokenExpiry.toISOString()}`);+ logger.debug(+ `${logPrefix} Date object: ${JSON.stringify({+ time: accessTokenExpiry.getTime(),+ valid: !isNaN(accessTokenExpiry.getTime()),+ iso: accessTokenExpiry.toISOString(),+ })}`,+ );++ // Ensure the date is valid before passing to createToken+ if (isNaN(accessTokenExpiry.getTime())) {+ logger.error(`${logPrefix} Invalid expiry date calculated, using default`);+ accessTokenExpiry = new Date(Date.now() + 365 * 24 * 60 * 60 * 1000);+ }++ // Calculate expiresIn (seconds from now)+ const expiresIn = Math.floor((accessTokenExpiry.getTime() - Date.now()) / 1000);++ const accessTokenData = {+ userId,+ type: 'mcp_oauth',+ identifier,+ token: encryptedAccessToken,+ expiresIn: expiresIn > 0 ? expiresIn : 365 * 24 * 60 * 60, // Default to 1 year if negative+ };++ // Check if token already exists and update if it does+ if (findToken && updateToken) {+ // Use provided existing token state if available, otherwise look it up+ const existingToken =+ existingTokens?.accessToken !== undefined+ ? existingTokens.accessToken+ : await findToken({ userId, identifier });++ if (existingToken) {+ await updateToken({ userId, identifier }, accessTokenData);+ logger.debug(`${logPrefix} Updated existing access token`);+ } else {+ await createToken(accessTokenData);+ logger.debug(`${logPrefix} Created new access token`);+ }+ } else {+ // Create new token if it's initial store or update methods not provided+ await createToken(accessTokenData);+ logger.debug(`${logPrefix} Created access token (no update methods available)`);+ }++ // Store refresh token if available+ if (tokens.refresh_token) {+ const encryptedRefreshToken = await encryptV2(tokens.refresh_token);+ const extendedTokens = tokens as ExtendedOAuthTokens;+ const refreshTokenExpiry = extendedTokens.refresh_token_expires_in+ ? new Date(Date.now() + extendedTokens.refresh_token_expires_in * 1000)+ : new Date(Date.now() + 365 * 24 * 60 * 60 * 1000); // Default to 1 year++ /** Calculated expiresIn for refresh token */+ const refreshExpiresIn = Math.floor((refreshTokenExpiry.getTime() - Date.now()) / 1000);++ const refreshTokenData = {+ userId,+ type: 'mcp_oauth_refresh',+ identifier: `${identifier}:refresh`,+ token: encryptedRefreshToken,+ expiresIn: refreshExpiresIn > 0 ? refreshExpiresIn : 365 * 24 * 60 * 60,+ };++ // Check if refresh token already exists and update if it does+ if (findToken && updateToken) {+ // Use provided existing token state if available, otherwise look it up+ const existingRefreshToken =+ existingTokens?.refreshToken !== undefined+ ? existingTokens.refreshToken+ : await findToken({+ userId,+ identifier: `${identifier}:refresh`,+ });++ if (existingRefreshToken) {+ await updateToken({ userId, identifier: `${identifier}:refresh` }, refreshTokenData);+ logger.debug(`${logPrefix} Updated existing refresh token`);+ } else {+ await createToken(refreshTokenData);+ logger.debug(`${logPrefix} Created new refresh token`);+ }+ } else {+ await createToken(refreshTokenData);+ logger.debug(`${logPrefix} Created refresh token (no update methods available)`);+ }+ }++ /** Store client information if provided */+ if (clientInfo) {+ logger.debug(`${logPrefix} Storing client info:`, {+ client_id: clientInfo.client_id,+ has_client_secret: !!clientInfo.client_secret,+ });+ const encryptedClientInfo = await encryptV2(JSON.stringify(clientInfo));++ const clientInfoData = {+ userId,+ type: 'mcp_oauth_client',+ identifier: `${identifier}:client`,+ token: encryptedClientInfo,+ expiresIn: 365 * 24 * 60 * 60,+ };++ // Check if client info already exists and update if it does+ if (findToken && updateToken) {+ // Use provided existing token state if available, otherwise look it up+ const existingClientInfo =+ existingTokens?.clientInfoToken !== undefined+ ? existingTokens.clientInfoToken+ : await findToken({+ userId,+ identifier: `${identifier}:client`,+ });++ if (existingClientInfo) {+ await updateToken({ userId, identifier: `${identifier}:client` }, clientInfoData);+ logger.debug(`${logPrefix} Updated existing client info`);+ } else {+ await createToken(clientInfoData);+ logger.debug(`${logPrefix} Created new client info`);+ }+ } else {+ await createToken(clientInfoData);+ logger.debug(`${logPrefix} Created client info (no update methods available)`);+ }+ }++ logger.debug(`${logPrefix} Stored OAuth tokens`);+ } catch (error) {+ const logPrefix = this.getLogPrefix(userId, serverName);+ logger.error(`${logPrefix} Failed to store tokens`, error);+ throw error;+ }+ }++ /**+ * Retrieves OAuth tokens for an MCP server+ */+ static async getTokens({+ userId,+ serverName,+ findToken,+ createToken,+ updateToken,+ refreshTokens,+ }: GetTokensParams): Promise<MCPOAuthTokens | null> {+ const logPrefix = this.getLogPrefix(userId, serverName);++ try {+ const identifier = `mcp:${serverName}`;++ // Get access token+ const accessTokenData = await findToken({+ userId,+ type: 'mcp_oauth',+ identifier,+ });++ /** Check if access token is missing or expired */+ const isMissing = !accessTokenData;+ const isExpired = accessTokenData?.expiresAt && new Date() >= accessTokenData.expiresAt;++ if (isMissing || isExpired) {+ logger.info(`${logPrefix} Access token ${isMissing ? 'missing' : 'expired'}`);++ /** Refresh data if we have a refresh token and refresh function */+ const refreshTokenData = await findToken({+ userId,+ type: 'mcp_oauth_refresh',+ identifier: `${identifier}:refresh`,+ });++ if (!refreshTokenData) {+ logger.info(+ `${logPrefix} Access token ${isMissing ? 'missing' : 'expired'} and no refresh token available`,+ );+ return null;+ }++ if (!refreshTokens) {+ logger.warn(+ `${logPrefix} Access token ${isMissing ? 'missing' : 'expired'}, refresh token available but no \`refreshTokens\` provided`,+ );+ return null;+ }++ if (!createToken) {+ logger.warn(+ `${logPrefix} Access token ${isMissing ? 'missing' : 'expired'}, refresh token available but no \`createToken\` function provided`,+ );+ return null;+ }++ try {+ logger.info(`${logPrefix} Attempting to refresh token`);+ const decryptedRefreshToken = await decryptV2(refreshTokenData.token);++ /** Client information if available */+ let clientInfo;+ let clientInfoData;+ try {+ clientInfoData = await findToken({+ userId,+ type: 'mcp_oauth_client',+ identifier: `${identifier}:client`,+ });+ if (clientInfoData) {+ const decryptedClientInfo = await decryptV2(clientInfoData.token);+ clientInfo = JSON.parse(decryptedClientInfo);+ logger.debug(`${logPrefix} Retrieved client info:`, {+ client_id: clientInfo.client_id,+ has_client_secret: !!clientInfo.client_secret,+ });+ }+ } catch {+ logger.debug(`${logPrefix} No client info found`);+ }++ const metadata = {+ userId,+ serverName,+ identifier,+ clientInfo,+ };++ const newTokens = await refreshTokens(decryptedRefreshToken, metadata);++ // Store the refreshed tokens (handles both create and update)+ // Pass existing token state to avoid duplicate DB calls+ await this.storeTokens({+ userId,+ serverName,+ tokens: newTokens,+ createToken,+ updateToken,+ findToken,+ clientInfo,+ existingTokens: {+ accessToken: accessTokenData, // We know this is expired/missing+ refreshToken: refreshTokenData, // We already have this+ clientInfoToken: clientInfoData, // We already looked this up+ },+ });++ logger.info(`${logPrefix} Successfully refreshed and stored OAuth tokens`);+ return newTokens;+ } catch (refreshError) {+ logger.error(`${logPrefix} Failed to refresh tokens`, refreshError);+ // Check if it's an unauthorized_client error (refresh not supported)+ const errorMessage =+ refreshError instanceof Error ? refreshError.message : String(refreshError);+ if (errorMessage.includes('unauthorized_client')) {+ logger.info(+ `${logPrefix} Server does not support refresh tokens for this client. New authentication required.`,+ );+ }+ return null;+ }+ }++ // If we reach here, access token should exist and be valid+ if (!accessTokenData) {+ return null;+ }++ const decryptedAccessToken = await decryptV2(accessTokenData.token);++ /** Get refresh token if available */+ const refreshTokenData = await findToken({+ userId,+ type: 'mcp_oauth_refresh',+ identifier: `${identifier}:refresh`,+ });++ const tokens: MCPOAuthTokens = {+ access_token: decryptedAccessToken,+ token_type: 'Bearer',+ obtained_at: accessTokenData.createdAt.getTime(),+ expires_at: accessTokenData.expiresAt?.getTime(),+ };++ if (refreshTokenData) {+ tokens.refresh_token = await decryptV2(refreshTokenData.token);+ }++ logger.debug(`${logPrefix} Loaded existing OAuth tokens from storage`);+ return tokens;+ } catch (error) {+ logger.error(`${logPrefix} Failed to retrieve tokens`, error);+ return null;+ }+ }+}diff --git a/packages/api/src/mcp/oauth/types.ts b/packages/api/src/mcp/oauth/types.tsnew file mode 100644index 0000000000..7fa9d69921--- /dev/null+++ b/packages/api/src/mcp/oauth/types.ts@@ -0,0 +1,98 @@+import type { OAuthTokens } from '@modelcontextprotocol/sdk/shared/auth.js';+import type { FlowMetadata } from '~/flow/types';++export interface OAuthMetadata {+ /** OAuth authorization endpoint */+ authorization_endpoint: string;+ /** OAuth token endpoint */+ token_endpoint: string;+ /** OAuth issuer */+ issuer?: string;+ /** Supported scopes */+ scopes_supported?: string[];+ /** Response types supported */+ response_types_supported?: string[];+ /** Grant types supported */+ grant_types_supported?: string[];+ /** Token endpoint auth methods supported */+ token_endpoint_auth_methods_supported?: string[];+ /** Code challenge methods supported */+ code_challenge_methods_supported?: string[];+}++export interface OAuthProtectedResourceMetadata {+ /** Resource identifier */+ resource: string;+ /** Authorization servers */+ authorization_servers?: string[];+ /** Scopes supported by the resource */+ scopes_supported?: string[];+}++export interface OAuthClientInformation {+ /** Client ID */+ client_id: string;+ /** Client secret (optional for public clients) */+ client_secret?: string;+ /** Client name */+ client_name?: string;+ /** Redirect URIs */+ redirect_uris?: string[];+ /** Grant types */+ grant_types?: string[];+ /** Response types */+ response_types?: string[];+ /** Scope */+ scope?: string;+ /** Token endpoint auth method */+ token_endpoint_auth_method?: string;+}++export interface MCPOAuthState {+ /** Current step in the OAuth flow */+ step: 'discovery' | 'registration' | 'authorization' | 'token_exchange' | 'complete' | 'error';+ /** Server name */+ serverName: string;+ /** User ID */+ userId: string;+ /** OAuth metadata from discovery */+ metadata?: OAuthMetadata;+ /** Resource metadata */+ resourceMetadata?: OAuthProtectedResourceMetadata;+ /** Client information */+ clientInfo?: OAuthClientInformation;+ /** Authorization URL */+ authorizationUrl?: string;+ /** Code verifier for PKCE */+ codeVerifier?: string;+ /** State parameter for OAuth flow */+ state?: string;+ /** Error information */+ error?: string;+ /** Timestamp */+ timestamp: number;+}++export interface MCPOAuthFlowMetadata extends FlowMetadata {+ serverName: string;+ userId: string;+ serverUrl: string;+ state: string;+ codeVerifier?: string;+ clientInfo?: OAuthClientInformation;+ metadata?: OAuthMetadata;+ resourceMetadata?: OAuthProtectedResourceMetadata;+}++export interface MCPOAuthTokens extends OAuthTokens {+ /** When the tokens were obtained */+ obtained_at: number;+ /** Calculated expiry time */+ expires_at?: number;+}++/** Extended OAuth tokens that may include refresh token expiry */+export interface ExtendedOAuthTokens extends OAuthTokens {+ /** Refresh token expiry in seconds (non-standard, some providers include this) */+ refresh_token_expires_in?: number;+}diff --git a/packages/api/src/oauth/index.ts b/packages/api/src/oauth/index.tsnew file mode 100644index 0000000000..e56053c166--- /dev/null+++ b/packages/api/src/oauth/index.ts@@ -0,0 +1 @@+export * from './tokens';diff --git a/packages/api/src/oauth/tokens.ts b/packages/api/src/oauth/tokens.tsnew file mode 100644index 0000000000..8489bdcb97--- /dev/null+++ b/packages/api/src/oauth/tokens.ts@@ -0,0 +1,324 @@+import axios from 'axios';+import { logger } from '@librechat/data-schemas';+import { TokenExchangeMethodEnum } from 'librechat-data-provider';+import type { TokenMethods } from '@librechat/data-schemas';+import type { AxiosError } from 'axios';+import { encryptV2, decryptV2 } from '~/crypto';+import { logAxiosError } from '~/utils';++export function createHandleOAuthToken({+ findToken,+ updateToken,+ createToken,+}: {+ findToken: TokenMethods['findToken'];+ updateToken: TokenMethods['updateToken'];+ createToken: TokenMethods['createToken'];+}) {+ /**+ * Handles the OAuth token by creating or updating the token.+ * @param fields+ * @param fields.userId - The user's ID.+ * @param fields.token - The full token to store.+ * @param fields.identifier - Unique, alternative identifier for the token.+ * @param fields.expiresIn - The number of seconds until the token expires.+ * @param fields.metadata - Additional metadata to store with the token.+ * @param [fields.type="oauth"] - The type of token. Default is 'oauth'.+ */+ return async function handleOAuthToken({+ token,+ userId,+ identifier,+ expiresIn,+ metadata,+ type = 'oauth',+ }: {+ token: string;+ userId: string;+ identifier: string;+ expiresIn?: number | string | null;+ metadata?: Record<string, unknown>;+ type?: string;+ }) {+ const encrypedToken = await encryptV2(token);+ let expiresInNumber = 3600;+ if (typeof expiresIn === 'number') {+ expiresInNumber = expiresIn;+ } else if (expiresIn != null) {+ expiresInNumber = parseInt(expiresIn, 10) || 3600;+ }+ const tokenData = {+ type,+ userId,+ metadata,+ identifier,+ token: encrypedToken,+ expiresIn: expiresInNumber,+ };++ const existingToken = await findToken({ userId, identifier });+ if (existingToken) {+ return await updateToken({ identifier }, tokenData);+ } else {+ return await createToken(tokenData);+ }+ };+}++/**+ * Processes the access tokens and stores them in the database.+ * @param tokenData+ * @param tokenData.access_token+ * @param tokenData.expires_in+ * @param [tokenData.refresh_token]+ * @param [tokenData.refresh_token_expires_in]+ * @param metadata+ * @param metadata.userId+ * @param metadata.identifier+ */+async function processAccessTokens(+ tokenData: {+ access_token: string;+ expires_in: number;+ refresh_token?: string;+ refresh_token_expires_in?: number;+ },+ { userId, identifier }: { userId: string; identifier: string },+ {+ findToken,+ updateToken,+ createToken,+ }: {+ findToken: TokenMethods['findToken'];+ updateToken: TokenMethods['updateToken'];+ createToken: TokenMethods['createToken'];+ },+) {+ const { access_token, expires_in = 3600, refresh_token, refresh_token_expires_in } = tokenData;+ if (!access_token) {+ logger.error('Access token not found: ', tokenData);+ throw new Error('Access token not found');+ }+ const handleOAuthToken = createHandleOAuthToken({+ findToken,+ updateToken,+ createToken,+ });+ await handleOAuthToken({+ identifier,+ token: access_token,+ expiresIn: expires_in,+ userId,+ });++ if (refresh_token != null) {+ logger.debug('Processing refresh token');+ await handleOAuthToken({+ token: refresh_token,+ type: 'oauth_refresh',+ userId,+ identifier: `${identifier}:refresh`,+ expiresIn: refresh_token_expires_in ?? null,+ });+ }+ logger.debug('Access tokens processed');+}++/**+ * Refreshes the access token using the refresh token.+ * @param fields+ * @param fields.userId - The ID of the user.+ * @param fields.client_url - The URL of the OAuth provider.+ * @param fields.identifier - The identifier for the token.+ * @param fields.refresh_token - The refresh token to use.+ * @param fields.token_exchange_method - The token exchange method ('default_post' or 'basic_auth_header').+ * @param fields.encrypted_oauth_client_id - The client ID for the OAuth provider.+ * @param fields.encrypted_oauth_client_secret - The client secret for the OAuth provider.+ */+export async function refreshAccessToken(+ {+ userId,+ client_url,+ identifier,+ refresh_token,+ token_exchange_method,+ encrypted_oauth_client_id,+ encrypted_oauth_client_secret,+ }: {+ userId: string;+ client_url: string;+ identifier: string;+ refresh_token: string;+ token_exchange_method: TokenExchangeMethodEnum;+ encrypted_oauth_client_id: string;+ encrypted_oauth_client_secret: string;+ },+ {+ findToken,+ updateToken,+ createToken,+ }: {+ findToken: TokenMethods['findToken'];+ updateToken: TokenMethods['updateToken'];+ createToken: TokenMethods['createToken'];+ },+): Promise<{+ access_token: string;+ expires_in: number;+ refresh_token?: string;+ refresh_token_expires_in?: number;+}> {+ try {+ const oauth_client_id = await decryptV2(encrypted_oauth_client_id);+ const oauth_client_secret = await decryptV2(encrypted_oauth_client_secret);++ const headers: Record<string, string> = {+ 'Content-Type': 'application/x-www-form-urlencoded',+ Accept: 'application/json',+ };++ const params = new URLSearchParams({+ grant_type: 'refresh_token',+ refresh_token,+ });++ if (token_exchange_method === TokenExchangeMethodEnum.BasicAuthHeader) {+ const basicAuth = Buffer.from(`${oauth_client_id}:${oauth_client_secret}`).toString('base64');+ headers['Authorization'] = `Basic ${basicAuth}`;+ } else {+ params.append('client_id', oauth_client_id);+ params.append('client_secret', oauth_client_secret);+ }++ const response = await axios({+ method: 'POST',+ url: client_url,+ headers,+ data: params.toString(),+ });+ await processAccessTokens(+ response.data,+ {+ userId,+ identifier,+ },+ {+ findToken,+ updateToken,+ createToken,+ },+ );+ logger.debug(`Access token refreshed successfully for ${identifier}`);+ return response.data;+ } catch (error) {+ const message = 'Error refreshing OAuth tokens';+ throw new Error(+ logAxiosError({+ message,+ error: error as AxiosError,+ }),+ );+ }+}++/**+ * Handles the OAuth callback and exchanges the authorization code for tokens.+ * @param {object} fields+ * @param {string} fields.code - The authorization code returned by the provider.+ * @param {string} fields.userId - The ID of the user.+ * @param {string} fields.identifier - The identifier for the token.+ * @param {string} fields.client_url - The URL of the OAuth provider.+ * @param {string} fields.redirect_uri - The redirect URI for the OAuth provider.+ * @param {string} fields.token_exchange_method - The token exchange method ('default_post' or 'basic_auth_header').+ * @param {string} fields.encrypted_oauth_client_id - The client ID for the OAuth provider.+ * @param {string} fields.encrypted_oauth_client_secret - The client secret for the OAuth provider.+ */+export async function getAccessToken(+ {+ code,+ userId,+ identifier,+ client_url,+ redirect_uri,+ token_exchange_method,+ encrypted_oauth_client_id,+ encrypted_oauth_client_secret,+ }: {+ code: string;+ userId: string;+ identifier: string;+ client_url: string;+ redirect_uri: string;+ token_exchange_method: TokenExchangeMethodEnum;+ encrypted_oauth_client_id: string;+ encrypted_oauth_client_secret: string;+ },+ {+ findToken,+ updateToken,+ createToken,+ }: {+ findToken: TokenMethods['findToken'];+ updateToken: TokenMethods['updateToken'];+ createToken: TokenMethods['createToken'];+ },+): Promise<{+ access_token: string;+ expires_in: number;+ refresh_token?: string;+ refresh_token_expires_in?: number;+}> {+ const oauth_client_id = await decryptV2(encrypted_oauth_client_id);+ const oauth_client_secret = await decryptV2(encrypted_oauth_client_secret);++ const headers: Record<string, string> = {+ 'Content-Type': 'application/x-www-form-urlencoded',+ Accept: 'application/json',+ };++ const params = new URLSearchParams({+ code,+ grant_type: 'authorization_code',+ redirect_uri,+ });++ if (token_exchange_method === TokenExchangeMethodEnum.BasicAuthHeader) {+ const basicAuth = Buffer.from(`${oauth_client_id}:${oauth_client_secret}`).toString('base64');+ headers['Authorization'] = `Basic ${basicAuth}`;+ } else {+ params.append('client_id', oauth_client_id);+ params.append('client_secret', oauth_client_secret);+ }++ try {+ const response = await axios({+ method: 'POST',+ url: client_url,+ headers,+ data: params.toString(),+ });++ await processAccessTokens(+ response.data,+ {+ userId,+ identifier,+ },+ {+ findToken,+ updateToken,+ createToken,+ },+ );+ logger.debug(`Access tokens successfully created for ${identifier}`);+ return response.data;+ } catch (error) {+ const message = 'Error exchanging OAuth code';+ throw new Error(+ logAxiosError({+ message,+ error: error as AxiosError,+ }),+ );+ }+}diff --git a/packages/data-provider/src/config.ts b/packages/data-provider/src/config.tsindex d851891ac4..145487d7ef 100644--- a/packages/data-provider/src/config.ts+++ b/packages/data-provider/src/config.ts@@ -1136,6 +1136,10 @@ export enum CacheKeys {* Key for in-progress flow states.*/FLOWS = 'flows',+ /**+ * Key for individual MCP Tool Manifests.+ */+ MCP_TOOLS = 'mcp_tools',/*** Key for pending chat requests (concurrency check)*/diff --git a/packages/data-provider/src/mcp.ts b/packages/data-provider/src/mcp.tsindex 2d7be8458f..ffcb65cda1 100644--- a/packages/data-provider/src/mcp.ts+++ b/packages/data-provider/src/mcp.ts@@ -1,6 +1,7 @@import { z } from 'zod';import type { TUser } from './types';import { extractEnvVariable } from './utils';+import { TokenExchangeMethodEnum } from './types/assistants';const BaseOptionsSchema = z.object({iconPath: z.string().optional(),@@ -15,6 +16,29 @@ const BaseOptionsSchema = z.object({* - string: Use custom instructions (overrides server-provided)*/serverInstructions: z.union([z.boolean(), z.string()]).optional(),+ /**+ * OAuth configuration for SSE and Streamable HTTP transports+ * - Optional: OAuth can be auto-discovered on 401 responses+ * - Pre-configured values will skip discovery steps+ */+ oauth: z+ .object({+ /** OAuth authorization endpoint (optional - can be auto-discovered) */+ authorization_url: z.string().url().optional(),+ /** OAuth token endpoint (optional - can be auto-discovered) */+ token_url: z.string().url().optional(),+ /** OAuth client ID (optional - can use dynamic registration) */+ client_id: z.string().optional(),+ /** OAuth client secret (optional - can use dynamic registration) */+ client_secret: z.string().optional(),+ /** OAuth scopes to request */+ scope: z.string().optional(),+ /** OAuth redirect URI (defaults to /api/mcp/{serverName}/oauth/callback) */+ redirect_uri: z.string().url().optional(),+ /** Token exchange method */+ token_exchange_method: z.nativeEnum(TokenExchangeMethodEnum).optional(),+ })+ .optional(),});export const StdioOptionsSchema = BaseOptionsSchema.extend({diff --git a/packages/data-schemas/src/methods/index.ts b/packages/data-schemas/src/methods/index.tsindex 67f8255c8d..be4308ecd9 100644--- a/packages/data-schemas/src/methods/index.ts+++ b/packages/data-schemas/src/methods/index.ts@@ -20,7 +20,7 @@ export function createMethods(mongoose: typeof import('mongoose')) {};}-export type { MemoryMethods, ShareMethods };+export type { MemoryMethods, ShareMethods, TokenMethods };export type AllMethods = UserMethods &SessionMethods &TokenMethods &