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
🧪 ci: Unit Tests for MCP Routes (#8803)
Dustin Healyf1c6e4d55ee5
diff --git a/api/server/routes/__tests__/mcp.spec.js b/api/server/routes/__tests__/mcp.spec.jsnew file mode 100644index 0000000000..272b9f7236--- /dev/null+++ b/api/server/routes/__tests__/mcp.spec.js@@ -0,0 +1,1259 @@+const express = require('express');+const request = require('supertest');+const mongoose = require('mongoose');+const { MongoMemoryServer } = require('mongodb-memory-server');++jest.mock('@librechat/api', () => ({+ MCPOAuthHandler: {+ initiateOAuthFlow: jest.fn(),+ getFlowState: jest.fn(),+ completeOAuthFlow: jest.fn(),+ generateFlowId: jest.fn(),+ },+}));++jest.mock('@librechat/data-schemas', () => ({+ logger: {+ debug: jest.fn(),+ info: jest.fn(),+ warn: jest.fn(),+ error: jest.fn(),+ },+ createModels: jest.fn(() => ({+ User: {+ findOne: jest.fn(),+ findById: jest.fn(),+ },+ Conversation: {+ findOne: jest.fn(),+ findById: jest.fn(),+ },+ })),+}));++jest.mock('~/models', () => ({+ findToken: jest.fn(),+ updateToken: jest.fn(),+ createToken: jest.fn(),+ deleteTokens: jest.fn(),+}));++jest.mock('~/server/services/Config', () => ({+ setCachedTools: jest.fn(),+ getCachedTools: jest.fn(),+ loadCustomConfig: jest.fn(),+}));++jest.mock('~/server/services/MCP', () => ({+ getMCPSetupData: jest.fn(),+ getServerConnectionStatus: jest.fn(),+}));++jest.mock('~/server/services/PluginService', () => ({+ getUserPluginAuthValue: jest.fn(),+}));++jest.mock('~/config', () => ({+ getMCPManager: jest.fn(),+ getFlowStateManager: jest.fn(),+}));++jest.mock('~/cache', () => ({+ getLogStores: jest.fn(),+}));++jest.mock('~/server/middleware', () => ({+ requireJwtAuth: (req, res, next) => next(),+}));++describe('MCP Routes', () => {+ let app;+ let mongoServer;+ let mcpRouter;++ beforeAll(async () => {+ mongoServer = await MongoMemoryServer.create();+ await mongoose.connect(mongoServer.getUri());++ require('~/db/models');++ mcpRouter = require('../mcp');++ app = express();+ app.use(express.json());++ app.use((req, res, next) => {+ req.user = { id: 'test-user-id' };+ next();+ });++ app.use('/api/mcp', mcpRouter);+ });++ afterAll(async () => {+ await mongoose.disconnect();+ await mongoServer.stop();+ });++ beforeEach(() => {+ jest.clearAllMocks();+ });++ describe('GET /:serverName/oauth/initiate', () => {+ const { MCPOAuthHandler } = require('@librechat/api');+ const { getLogStores } = require('~/cache');++ it('should initiate OAuth flow successfully', async () => {+ const mockFlowManager = {+ getFlowState: jest.fn().mockResolvedValue({+ metadata: {+ serverUrl: 'https://test-server.com',+ oauth: { clientId: 'test-client-id' },+ },+ }),+ };++ getLogStores.mockReturnValue({});+ require('~/config').getFlowStateManager.mockReturnValue(mockFlowManager);++ MCPOAuthHandler.initiateOAuthFlow.mockResolvedValue({+ authorizationUrl: 'https://oauth.example.com/auth',+ flowId: 'test-flow-id',+ });++ const response = await request(app).get('/api/mcp/test-server/oauth/initiate').query({+ userId: 'test-user-id',+ flowId: 'test-flow-id',+ });++ expect(response.status).toBe(302);+ expect(response.headers.location).toBe('https://oauth.example.com/auth');+ expect(MCPOAuthHandler.initiateOAuthFlow).toHaveBeenCalledWith(+ 'test-server',+ 'https://test-server.com',+ 'test-user-id',+ { clientId: 'test-client-id' },+ );+ });++ it('should return 403 when userId does not match authenticated user', async () => {+ const response = await request(app).get('/api/mcp/test-server/oauth/initiate').query({+ userId: 'different-user-id',+ flowId: 'test-flow-id',+ });++ expect(response.status).toBe(403);+ expect(response.body).toEqual({ error: 'User mismatch' });+ });++ it('should return 404 when flow state is not found', async () => {+ const mockFlowManager = {+ getFlowState: jest.fn().mockResolvedValue(null),+ };++ getLogStores.mockReturnValue({});+ require('~/config').getFlowStateManager.mockReturnValue(mockFlowManager);++ const response = await request(app).get('/api/mcp/test-server/oauth/initiate').query({+ userId: 'test-user-id',+ flowId: 'non-existent-flow-id',+ });++ expect(response.status).toBe(404);+ expect(response.body).toEqual({ error: 'Flow not found' });+ });++ it('should return 400 when flow state has missing OAuth config', async () => {+ const mockFlowManager = {+ getFlowState: jest.fn().mockResolvedValue({+ metadata: {+ serverUrl: 'https://test-server.com',+ },+ }),+ };++ getLogStores.mockReturnValue({});+ require('~/config').getFlowStateManager.mockReturnValue(mockFlowManager);++ const response = await request(app).get('/api/mcp/test-server/oauth/initiate').query({+ userId: 'test-user-id',+ flowId: 'test-flow-id',+ });++ expect(response.status).toBe(400);+ expect(response.body).toEqual({ error: 'Invalid flow state' });+ });++ it('should return 500 when OAuth initiation throws unexpected error', async () => {+ const mockFlowManager = {+ getFlowState: jest.fn().mockRejectedValue(new Error('Database error')),+ };++ getLogStores.mockReturnValue({});+ require('~/config').getFlowStateManager.mockReturnValue(mockFlowManager);++ const response = await request(app).get('/api/mcp/test-server/oauth/initiate').query({+ userId: 'test-user-id',+ flowId: 'test-flow-id',+ });++ expect(response.status).toBe(500);+ expect(response.body).toEqual({ error: 'Failed to initiate OAuth' });+ });++ it('should return 400 when flow state metadata is null', async () => {+ const mockFlowManager = {+ getFlowState: jest.fn().mockResolvedValue({+ id: 'test-flow-id',+ metadata: null,+ }),+ };++ getLogStores.mockReturnValue({});+ require('~/config').getFlowStateManager.mockReturnValue(mockFlowManager);++ const response = await request(app).get('/api/mcp/test-server/oauth/initiate').query({+ userId: 'test-user-id',+ flowId: 'test-flow-id',+ });++ expect(response.status).toBe(400);+ expect(response.body).toEqual({ error: 'Invalid flow state' });+ });+ });++ describe('GET /:serverName/oauth/callback', () => {+ const { MCPOAuthHandler } = require('@librechat/api');+ const { getLogStores } = require('~/cache');++ it('should redirect to error page when OAuth error is received', async () => {+ const response = await request(app).get('/api/mcp/test-server/oauth/callback').query({+ error: 'access_denied',+ state: 'test-flow-id',+ });++ expect(response.status).toBe(302);+ expect(response.headers.location).toBe('/oauth/error?error=access_denied');+ });++ it('should redirect to error page when code is missing', async () => {+ const response = await request(app).get('/api/mcp/test-server/oauth/callback').query({+ state: 'test-flow-id',+ });++ expect(response.status).toBe(302);+ expect(response.headers.location).toBe('/oauth/error?error=missing_code');+ });++ it('should redirect to error page when state is missing', async () => {+ const response = await request(app).get('/api/mcp/test-server/oauth/callback').query({+ code: 'test-auth-code',+ });++ expect(response.status).toBe(302);+ expect(response.headers.location).toBe('/oauth/error?error=missing_state');+ });++ it('should redirect to error page when flow state is not found', async () => {+ MCPOAuthHandler.getFlowState.mockResolvedValue(null);++ const response = await request(app).get('/api/mcp/test-server/oauth/callback').query({+ code: 'test-auth-code',+ state: 'invalid-flow-id',+ });++ expect(response.status).toBe(302);+ expect(response.headers.location).toBe('/oauth/error?error=invalid_state');+ });++ it('should handle OAuth callback successfully', async () => {+ const mockFlowManager = {+ completeFlow: jest.fn().mockResolvedValue(),+ };+ const mockFlowState = {+ serverName: 'test-server',+ userId: 'test-user-id',+ metadata: { toolFlowId: 'tool-flow-123' },+ clientInfo: {},+ codeVerifier: 'test-verifier',+ };+ const mockTokens = {+ access_token: 'test-access-token',+ refresh_token: 'test-refresh-token',+ };++ MCPOAuthHandler.getFlowState.mockResolvedValue(mockFlowState);+ MCPOAuthHandler.completeOAuthFlow.mockResolvedValue(mockTokens);+ getLogStores.mockReturnValue({});+ require('~/config').getFlowStateManager.mockReturnValue(mockFlowManager);++ const mockUserConnection = {+ fetchTools: jest.fn().mockResolvedValue([+ {+ name: 'test-tool',+ description: 'A test tool',+ inputSchema: { type: 'object' },+ },+ ]),+ };+ const mockMcpManager = {+ getUserConnection: jest.fn().mockResolvedValue(mockUserConnection),+ };+ require('~/config').getMCPManager.mockReturnValue(mockMcpManager);++ const { getCachedTools, setCachedTools } = require('~/server/services/Config');+ const { Constants } = require('librechat-data-provider');+ getCachedTools.mockResolvedValue({+ [`existing-tool${Constants.mcp_delimiter}test-server`]: { type: 'function' },+ [`other-tool${Constants.mcp_delimiter}other-server`]: { type: 'function' },+ });+ setCachedTools.mockResolvedValue();++ const response = await request(app).get('/api/mcp/test-server/oauth/callback').query({+ code: 'test-auth-code',+ state: 'test-flow-id',+ });++ expect(response.status).toBe(302);+ expect(response.headers.location).toBe('/oauth/success?serverName=test-server');+ expect(MCPOAuthHandler.completeOAuthFlow).toHaveBeenCalledWith(+ 'test-flow-id',+ 'test-auth-code',+ mockFlowManager,+ );+ expect(mockFlowManager.completeFlow).toHaveBeenCalledWith(+ 'tool-flow-123',+ 'mcp_oauth',+ mockTokens,+ );+ });++ it('should redirect to error page when callback processing fails', async () => {+ MCPOAuthHandler.getFlowState.mockRejectedValue(new Error('Callback error'));++ const response = await request(app).get('/api/mcp/test-server/oauth/callback').query({+ code: 'test-auth-code',+ state: 'test-flow-id',+ });++ expect(response.status).toBe(302);+ expect(response.headers.location).toBe('/oauth/error?error=callback_failed');+ });++ it('should handle system-level OAuth completion', async () => {+ const mockFlowManager = {+ completeFlow: jest.fn().mockResolvedValue(),+ };+ const mockFlowState = {+ serverName: 'test-server',+ userId: 'system',+ metadata: { toolFlowId: 'tool-flow-123' },+ clientInfo: {},+ codeVerifier: 'test-verifier',+ };+ const mockTokens = {+ access_token: 'test-access-token',+ refresh_token: 'test-refresh-token',+ };++ MCPOAuthHandler.getFlowState.mockResolvedValue(mockFlowState);+ MCPOAuthHandler.completeOAuthFlow.mockResolvedValue(mockTokens);+ getLogStores.mockReturnValue({});+ require('~/config').getFlowStateManager.mockReturnValue(mockFlowManager);++ const response = await request(app).get('/api/mcp/test-server/oauth/callback').query({+ code: 'test-auth-code',+ state: 'test-flow-id',+ });++ expect(response.status).toBe(302);+ expect(response.headers.location).toBe('/oauth/success?serverName=test-server');+ });++ it('should handle reconnection failure after OAuth', async () => {+ const mockFlowManager = {+ completeFlow: jest.fn().mockResolvedValue(),+ };+ const mockFlowState = {+ serverName: 'test-server',+ userId: 'test-user-id',+ metadata: { toolFlowId: 'tool-flow-123' },+ clientInfo: {},+ codeVerifier: 'test-verifier',+ };+ const mockTokens = {+ access_token: 'test-access-token',+ refresh_token: 'test-refresh-token',+ };++ MCPOAuthHandler.getFlowState.mockResolvedValue(mockFlowState);+ MCPOAuthHandler.completeOAuthFlow.mockResolvedValue(mockTokens);+ getLogStores.mockReturnValue({});+ require('~/config').getFlowStateManager.mockReturnValue(mockFlowManager);++ const mockMcpManager = {+ getUserConnection: jest.fn().mockRejectedValue(new Error('Reconnection failed')),+ };+ require('~/config').getMCPManager.mockReturnValue(mockMcpManager);++ const { getCachedTools, setCachedTools } = require('~/server/services/Config');+ getCachedTools.mockResolvedValue({});+ setCachedTools.mockResolvedValue();++ const response = await request(app).get('/api/mcp/test-server/oauth/callback').query({+ code: 'test-auth-code',+ state: 'test-flow-id',+ });++ expect(response.status).toBe(302);+ expect(response.headers.location).toBe('/oauth/success?serverName=test-server');+ });+ });++ describe('GET /oauth/tokens/:flowId', () => {+ const { getLogStores } = require('~/cache');++ it('should return tokens for completed flow', async () => {+ const mockFlowManager = {+ getFlowState: jest.fn().mockResolvedValue({+ status: 'COMPLETED',+ result: {+ access_token: 'test-access-token',+ refresh_token: 'test-refresh-token',+ },+ }),+ };++ getLogStores.mockReturnValue({});+ require('~/config').getFlowStateManager.mockReturnValue(mockFlowManager);++ const response = await request(app).get('/api/mcp/oauth/tokens/test-user-id:flow-123');++ expect(response.status).toBe(200);+ expect(response.body).toEqual({+ tokens: {+ access_token: 'test-access-token',+ refresh_token: 'test-refresh-token',+ },+ });+ });++ it('should return 401 when user is not authenticated', async () => {+ const unauthApp = express();+ unauthApp.use(express.json());+ unauthApp.use((req, res, next) => {+ req.user = null;+ next();+ });+ unauthApp.use('/api/mcp', mcpRouter);++ const response = await request(unauthApp).get('/api/mcp/oauth/tokens/test-flow-id');++ expect(response.status).toBe(401);+ expect(response.body).toEqual({ error: 'User not authenticated' });+ });++ it('should return 403 when user tries to access flow they do not own', async () => {+ const response = await request(app).get('/api/mcp/oauth/tokens/other-user-id:flow-123');++ expect(response.status).toBe(403);+ expect(response.body).toEqual({ error: 'Access denied' });+ });++ it('should return 404 when flow is not found', async () => {+ const mockFlowManager = {+ getFlowState: jest.fn().mockResolvedValue(null),+ };++ getLogStores.mockReturnValue({});+ require('~/config').getFlowStateManager.mockReturnValue(mockFlowManager);++ const response = await request(app).get(+ '/api/mcp/oauth/tokens/test-user-id:non-existent-flow',+ );++ expect(response.status).toBe(404);+ expect(response.body).toEqual({ error: 'Flow not found' });+ });++ it('should return 400 when flow is not completed', async () => {+ const mockFlowManager = {+ getFlowState: jest.fn().mockResolvedValue({+ status: 'PENDING',+ result: null,+ }),+ };++ getLogStores.mockReturnValue({});+ require('~/config').getFlowStateManager.mockReturnValue(mockFlowManager);++ const response = await request(app).get('/api/mcp/oauth/tokens/test-user-id:pending-flow');++ expect(response.status).toBe(400);+ expect(response.body).toEqual({ error: 'Flow not completed' });+ });++ it('should return 500 when token retrieval throws an unexpected error', async () => {+ const mockFlowManager = {+ getFlowState: jest.fn().mockRejectedValue(new Error('Database connection failed')),+ };++ getLogStores.mockReturnValue({});+ require('~/config').getFlowStateManager.mockReturnValue(mockFlowManager);++ const response = await request(app).get('/api/mcp/oauth/tokens/test-user-id:error-flow');++ expect(response.status).toBe(500);+ expect(response.body).toEqual({ error: 'Failed to get tokens' });+ });+ });++ describe('GET /oauth/status/:flowId', () => {+ const { getLogStores } = require('~/cache');++ it('should return flow status when flow exists', async () => {+ const mockFlowManager = {+ getFlowState: jest.fn().mockResolvedValue({+ status: 'PENDING',+ error: null,+ }),+ };++ getLogStores.mockReturnValue({});+ require('~/config').getFlowStateManager.mockReturnValue(mockFlowManager);++ const response = await request(app).get('/api/mcp/oauth/status/test-flow-id');++ expect(response.status).toBe(200);+ expect(response.body).toEqual({+ status: 'PENDING',+ completed: false,+ failed: false,+ error: null,+ });+ });++ it('should return 404 when flow is not found', async () => {+ const mockFlowManager = {+ getFlowState: jest.fn().mockResolvedValue(null),+ };++ getLogStores.mockReturnValue({});+ require('~/config').getFlowStateManager.mockReturnValue(mockFlowManager);++ const response = await request(app).get('/api/mcp/oauth/status/non-existent-flow');++ expect(response.status).toBe(404);+ expect(response.body).toEqual({ error: 'Flow not found' });+ });++ it('should return 500 when status check fails', async () => {+ const mockFlowManager = {+ getFlowState: jest.fn().mockRejectedValue(new Error('Database error')),+ };++ getLogStores.mockReturnValue({});+ require('~/config').getFlowStateManager.mockReturnValue(mockFlowManager);++ const response = await request(app).get('/api/mcp/oauth/status/error-flow-id');++ expect(response.status).toBe(500);+ expect(response.body).toEqual({ error: 'Failed to get flow status' });+ });+ });++ describe('POST /oauth/cancel/:serverName', () => {+ const { getLogStores } = require('~/cache');+ const { MCPOAuthHandler } = require('@librechat/api');++ it('should cancel OAuth flow successfully', async () => {+ const mockFlowManager = {+ getFlowState: jest.fn().mockResolvedValue({+ status: 'PENDING',+ }),+ failFlow: jest.fn().mockResolvedValue(),+ };++ getLogStores.mockReturnValue({});+ require('~/config').getFlowStateManager.mockReturnValue(mockFlowManager);+ MCPOAuthHandler.generateFlowId.mockReturnValue('test-user-id:test-server');++ const response = await request(app).post('/api/mcp/oauth/cancel/test-server');++ expect(response.status).toBe(200);+ expect(response.body).toEqual({+ success: true,+ message: 'OAuth flow for test-server cancelled successfully',+ });++ expect(mockFlowManager.failFlow).toHaveBeenCalledWith(+ 'test-user-id:test-server',+ 'mcp_oauth',+ 'User cancelled OAuth flow',+ );+ });++ it('should return success message when no active flow exists', async () => {+ const mockFlowManager = {+ getFlowState: jest.fn().mockResolvedValue(null),+ };++ getLogStores.mockReturnValue({});+ require('~/config').getFlowStateManager.mockReturnValue(mockFlowManager);+ MCPOAuthHandler.generateFlowId.mockReturnValue('test-user-id:test-server');++ const response = await request(app).post('/api/mcp/oauth/cancel/test-server');++ expect(response.status).toBe(200);+ expect(response.body).toEqual({+ success: true,+ message: 'No active OAuth flow to cancel',+ });+ });++ it('should return 500 when cancellation fails', async () => {+ const mockFlowManager = {+ getFlowState: jest.fn().mockResolvedValue({ status: 'PENDING' }),+ failFlow: jest.fn().mockRejectedValue(new Error('Database error')),+ };++ getLogStores.mockReturnValue({});+ require('~/config').getFlowStateManager.mockReturnValue(mockFlowManager);+ MCPOAuthHandler.generateFlowId.mockReturnValue('test-user-id:test-server');++ const response = await request(app).post('/api/mcp/oauth/cancel/test-server');++ expect(response.status).toBe(500);+ expect(response.body).toEqual({ error: 'Failed to cancel OAuth flow' });+ });++ it('should return 401 when user is not authenticated', async () => {+ const unauthApp = express();+ unauthApp.use(express.json());+ unauthApp.use((req, res, next) => {+ req.user = null;+ next();+ });+ unauthApp.use('/api/mcp', mcpRouter);++ const response = await request(unauthApp).post('/api/mcp/oauth/cancel/test-server');++ expect(response.status).toBe(401);+ expect(response.body).toEqual({ error: 'User not authenticated' });+ });+ });++ describe('POST /:serverName/reinitialize', () => {+ const { loadCustomConfig } = require('~/server/services/Config');+ const { getUserPluginAuthValue } = require('~/server/services/PluginService');++ it('should return 404 when server is not found in configuration', async () => {+ loadCustomConfig.mockResolvedValue({+ mcpServers: {+ 'other-server': {},+ },+ });++ const response = await request(app).post('/api/mcp/non-existent-server/reinitialize');++ expect(response.status).toBe(404);+ expect(response.body).toEqual({+ error: "MCP server 'non-existent-server' not found in configuration",+ });+ });++ it('should handle OAuth requirement during reinitialize', async () => {+ loadCustomConfig.mockResolvedValue({+ mcpServers: {+ 'oauth-server': {+ customUserVars: {},+ },+ },+ });++ const mockMcpManager = {+ disconnectServer: jest.fn().mockResolvedValue(),+ mcpConfigs: {},+ getUserConnection: jest.fn().mockImplementation(async ({ oauthStart }) => {+ if (oauthStart) {+ await oauthStart('https://oauth.example.com/auth');+ }+ throw new Error('OAuth flow initiated - return early');+ }),+ };++ require('~/config').getMCPManager.mockReturnValue(mockMcpManager);+ require('~/config').getFlowStateManager.mockReturnValue({});+ require('~/cache').getLogStores.mockReturnValue({});++ const response = await request(app).post('/api/mcp/oauth-server/reinitialize');++ expect(response.status).toBe(200);+ expect(response.body).toEqual({+ success: 'https://oauth.example.com/auth',+ message: "MCP server 'oauth-server' ready for OAuth authentication",+ serverName: 'oauth-server',+ oauthRequired: true,+ oauthUrl: 'https://oauth.example.com/auth',+ });+ });++ it('should return 500 when reinitialize fails with non-OAuth error', async () => {+ loadCustomConfig.mockResolvedValue({+ mcpServers: {+ 'error-server': {},+ },+ });++ const mockMcpManager = {+ disconnectServer: jest.fn().mockResolvedValue(),+ mcpConfigs: {},+ getUserConnection: jest.fn().mockRejectedValue(new Error('Connection failed')),+ };++ require('~/config').getMCPManager.mockReturnValue(mockMcpManager);+ require('~/config').getFlowStateManager.mockReturnValue({});+ require('~/cache').getLogStores.mockReturnValue({});++ const response = await request(app).post('/api/mcp/error-server/reinitialize');++ expect(response.status).toBe(500);+ expect(response.body).toEqual({+ error: 'Failed to reinitialize MCP server for user',+ });+ });++ it('should return 500 when unexpected error occurs', async () => {+ loadCustomConfig.mockRejectedValue(new Error('Config loading failed'));++ const response = await request(app).post('/api/mcp/test-server/reinitialize');++ expect(response.status).toBe(500);+ expect(response.body).toEqual({ error: 'Internal server error' });+ });++ it('should return 401 when user is not authenticated', async () => {+ const unauthApp = express();+ unauthApp.use(express.json());+ unauthApp.use((req, res, next) => {+ req.user = null;+ next();+ });+ unauthApp.use('/api/mcp', mcpRouter);++ const response = await request(unauthApp).post('/api/mcp/test-server/reinitialize');++ expect(response.status).toBe(401);+ expect(response.body).toEqual({ error: 'User not authenticated' });+ });++ it('should handle errors when fetching custom user variables', async () => {+ loadCustomConfig.mockResolvedValue({+ mcpServers: {+ 'test-server': {+ customUserVars: {+ API_KEY: 'test-key-var',+ SECRET_TOKEN: 'test-secret-var',+ },+ },+ },+ });++ getUserPluginAuthValue+ .mockResolvedValueOnce('test-api-key-value')+ .mockRejectedValueOnce(new Error('Database error'));++ const mockUserConnection = {+ fetchTools: jest.fn().mockResolvedValue([]),+ };++ const mockMcpManager = {+ disconnectServer: jest.fn().mockResolvedValue(),+ mcpConfigs: {},+ getUserConnection: jest.fn().mockResolvedValue(mockUserConnection),+ };++ require('~/config').getMCPManager.mockReturnValue(mockMcpManager);+ require('~/config').getFlowStateManager.mockReturnValue({});+ require('~/cache').getLogStores.mockReturnValue({});++ const { getCachedTools, setCachedTools } = require('~/server/services/Config');+ getCachedTools.mockResolvedValue({});+ setCachedTools.mockResolvedValue();++ const response = await request(app).post('/api/mcp/test-server/reinitialize');++ expect(response.status).toBe(200);+ expect(response.body.success).toBe(true);+ });++ it('should return failure message when reinitialize completely fails', async () => {+ loadCustomConfig.mockResolvedValue({+ mcpServers: {+ 'test-server': {},+ },+ });++ const mockMcpManager = {+ disconnectServer: jest.fn().mockResolvedValue(),+ mcpConfigs: {},+ getUserConnection: jest.fn().mockResolvedValue(null),+ };++ require('~/config').getMCPManager.mockReturnValue(mockMcpManager);+ require('~/config').getFlowStateManager.mockReturnValue({});+ require('~/cache').getLogStores.mockReturnValue({});++ const { getCachedTools, setCachedTools } = require('~/server/services/Config');+ const { Constants } = require('librechat-data-provider');+ getCachedTools.mockResolvedValue({+ [`existing-tool${Constants.mcp_delimiter}test-server`]: { type: 'function' },+ });+ setCachedTools.mockResolvedValue();++ const response = await request(app).post('/api/mcp/test-server/reinitialize');++ expect(response.status).toBe(200);+ expect(response.body.success).toBe(false);+ expect(response.body.message).toBe("Failed to reinitialize MCP server 'test-server'");+ });+ });++ describe('GET /connection/status', () => {+ const { getMCPSetupData, getServerConnectionStatus } = require('~/server/services/MCP');++ it('should return connection status for all servers', async () => {+ const mockMcpConfig = {+ server1: { endpoint: 'http://server1.com' },+ server2: { endpoint: 'http://server2.com' },+ };++ getMCPSetupData.mockResolvedValue({+ mcpConfig: mockMcpConfig,+ appConnections: {},+ userConnections: {},+ oauthServers: [],+ });++ getServerConnectionStatus+ .mockResolvedValueOnce({+ connectionState: 'connected',+ requiresOAuth: false,+ })+ .mockResolvedValueOnce({+ connectionState: 'disconnected',+ requiresOAuth: true,+ });++ const response = await request(app).get('/api/mcp/connection/status');++ expect(response.status).toBe(200);+ expect(response.body).toEqual({+ success: true,+ connectionStatus: {+ server1: {+ connectionState: 'connected',+ requiresOAuth: false,+ },+ server2: {+ connectionState: 'disconnected',+ requiresOAuth: true,+ },+ },+ });++ expect(getMCPSetupData).toHaveBeenCalledWith('test-user-id');+ expect(getServerConnectionStatus).toHaveBeenCalledTimes(2);+ });++ it('should return 404 when MCP config is not found', async () => {+ getMCPSetupData.mockRejectedValue(new Error('MCP config not found'));++ const response = await request(app).get('/api/mcp/connection/status');++ expect(response.status).toBe(404);+ expect(response.body).toEqual({ error: 'MCP config not found' });+ });++ it('should return 500 when connection status check fails', async () => {+ getMCPSetupData.mockRejectedValue(new Error('Database error'));++ const response = await request(app).get('/api/mcp/connection/status');++ expect(response.status).toBe(500);+ expect(response.body).toEqual({ error: 'Failed to get connection status' });+ });++ it('should return 401 when user is not authenticated', async () => {+ const unauthApp = express();+ unauthApp.use(express.json());+ unauthApp.use((req, res, next) => {+ req.user = null;+ next();+ });+ unauthApp.use('/api/mcp', mcpRouter);++ const response = await request(unauthApp).get('/api/mcp/connection/status');++ expect(response.status).toBe(401);+ expect(response.body).toEqual({ error: 'User not authenticated' });+ });+ });++ describe('GET /connection/status/:serverName', () => {+ const { getMCPSetupData, getServerConnectionStatus } = require('~/server/services/MCP');++ it('should return connection status for OAuth-required server', async () => {+ const mockMcpConfig = {+ 'oauth-server': { endpoint: 'http://oauth-server.com' },+ };++ getMCPSetupData.mockResolvedValue({+ mcpConfig: mockMcpConfig,+ appConnections: {},+ userConnections: {},+ oauthServers: [],+ });++ getServerConnectionStatus.mockResolvedValue({+ connectionState: 'requires_auth',+ requiresOAuth: true,+ });++ const response = await request(app).get('/api/mcp/connection/status/oauth-server');++ expect(response.status).toBe(200);+ expect(response.body).toEqual({+ success: true,+ serverName: 'oauth-server',+ connectionStatus: 'requires_auth',+ requiresOAuth: true,+ });+ });++ it('should return 404 when server is not found in configuration', async () => {+ getMCPSetupData.mockResolvedValue({+ mcpConfig: {+ 'other-server': { endpoint: 'http://other-server.com' },+ },+ appConnections: {},+ userConnections: {},+ oauthServers: [],+ });++ const response = await request(app).get('/api/mcp/connection/status/non-existent-server');++ expect(response.status).toBe(404);+ expect(response.body).toEqual({+ error: "MCP server 'non-existent-server' not found in configuration",+ });+ });++ it('should return 404 when MCP config is not found', async () => {+ getMCPSetupData.mockRejectedValue(new Error('MCP config not found'));++ const response = await request(app).get('/api/mcp/connection/status/test-server');++ expect(response.status).toBe(404);+ expect(response.body).toEqual({ error: 'MCP config not found' });+ });++ it('should return 500 when connection status check fails', async () => {+ getMCPSetupData.mockRejectedValue(new Error('Database connection failed'));++ const response = await request(app).get('/api/mcp/connection/status/test-server');++ expect(response.status).toBe(500);+ expect(response.body).toEqual({ error: 'Failed to get connection status' });+ });++ it('should return 401 when user is not authenticated', async () => {+ const unauthApp = express();+ unauthApp.use(express.json());+ unauthApp.use((req, res, next) => {+ req.user = null;+ next();+ });+ unauthApp.use('/api/mcp', mcpRouter);++ const response = await request(unauthApp).get('/api/mcp/connection/status/test-server');++ expect(response.status).toBe(401);+ expect(response.body).toEqual({ error: 'User not authenticated' });+ });+ });++ describe('GET /:serverName/auth-values', () => {+ const { loadCustomConfig } = require('~/server/services/Config');+ const { getUserPluginAuthValue } = require('~/server/services/PluginService');++ it('should return auth value flags for server', async () => {+ loadCustomConfig.mockResolvedValue({+ mcpServers: {+ 'test-server': {+ customUserVars: {+ API_KEY: 'some-env-var',+ SECRET_TOKEN: 'another-env-var',+ },+ },+ },+ });++ getUserPluginAuthValue.mockResolvedValueOnce('some-api-key-value').mockResolvedValueOnce('');++ const response = await request(app).get('/api/mcp/test-server/auth-values');++ expect(response.status).toBe(200);+ expect(response.body).toEqual({+ success: true,+ serverName: 'test-server',+ authValueFlags: {+ API_KEY: true,+ SECRET_TOKEN: false,+ },+ });++ expect(getUserPluginAuthValue).toHaveBeenCalledTimes(2);+ });++ it('should return 404 when server is not found in configuration', async () => {+ loadCustomConfig.mockResolvedValue({+ mcpServers: {+ 'other-server': {},+ },+ });++ const response = await request(app).get('/api/mcp/non-existent-server/auth-values');++ expect(response.status).toBe(404);+ expect(response.body).toEqual({+ error: "MCP server 'non-existent-server' not found in configuration",+ });+ });++ it('should handle errors when checking auth values', async () => {+ loadCustomConfig.mockResolvedValue({+ mcpServers: {+ 'test-server': {+ customUserVars: {+ API_KEY: 'some-env-var',+ },+ },+ },+ });++ getUserPluginAuthValue.mockRejectedValue(new Error('Database error'));++ const response = await request(app).get('/api/mcp/test-server/auth-values');++ expect(response.status).toBe(200);+ expect(response.body).toEqual({+ success: true,+ serverName: 'test-server',+ authValueFlags: {+ API_KEY: false,+ },+ });+ });++ it('should return 500 when auth values check throws unexpected error', async () => {+ loadCustomConfig.mockRejectedValue(new Error('Config loading failed'));++ const response = await request(app).get('/api/mcp/test-server/auth-values');++ expect(response.status).toBe(500);+ expect(response.body).toEqual({ error: 'Failed to check auth value flags' });+ });++ it('should handle customUserVars that is not an object', async () => {+ const { loadCustomConfig } = require('~/server/services/Config');+ loadCustomConfig.mockResolvedValue({+ mcpServers: {+ 'test-server': {+ customUserVars: 'not-an-object',+ },+ },+ });++ const response = await request(app).get('/api/mcp/test-server/auth-values');++ expect(response.status).toBe(200);+ expect(response.body).toEqual({+ success: true,+ serverName: 'test-server',+ authValueFlags: {},+ });+ });++ it('should return 401 when user is not authenticated in auth-values endpoint', async () => {+ const appWithoutAuth = express();+ appWithoutAuth.use(express.json());+ appWithoutAuth.use('/api/mcp', mcpRouter);++ const response = await request(appWithoutAuth).get('/api/mcp/test-server/auth-values');++ expect(response.status).toBe(401);+ expect(response.body).toEqual({ error: 'User not authenticated' });+ });+ });++ describe('POST /:serverName/reinitialize - Tool Deletion Coverage', () => {+ it('should handle null cached tools during reinitialize (triggers || {} fallback)', async () => {+ const { loadCustomConfig, getCachedTools } = require('~/server/services/Config');++ const mockUserConnection = {+ fetchTools: jest.fn().mockResolvedValue([{ name: 'new-tool', description: 'A new tool' }]),+ };++ const mockMcpManager = {+ getUserConnection: jest.fn().mockResolvedValue(mockUserConnection),+ disconnectServer: jest.fn(),+ initializeServer: jest.fn(),+ mcpConfigs: {},+ };+ require('~/config').getMCPManager.mockReturnValue(mockMcpManager);++ loadCustomConfig.mockResolvedValue({+ mcpServers: {+ 'test-server': { env: { API_KEY: 'test-key' } },+ },+ });++ getCachedTools.mockResolvedValue(null);++ const response = await request(app).post('/api/mcp/test-server/reinitialize').expect(200);++ expect(response.body).toEqual({+ message: "MCP server 'test-server' reinitialized successfully",+ success: true,+ oauthRequired: false,+ oauthUrl: null,+ serverName: 'test-server',+ });+ });++ it('should delete existing cached tools during successful reinitialize', async () => {+ const {+ loadCustomConfig,+ getCachedTools,+ setCachedTools,+ } = require('~/server/services/Config');++ const mockUserConnection = {+ fetchTools: jest.fn().mockResolvedValue([{ name: 'new-tool', description: 'A new tool' }]),+ };++ const mockMcpManager = {+ getUserConnection: jest.fn().mockResolvedValue(mockUserConnection),+ disconnectServer: jest.fn(),+ initializeServer: jest.fn(),+ mcpConfigs: {},+ };+ require('~/config').getMCPManager.mockReturnValue(mockMcpManager);++ loadCustomConfig.mockResolvedValue({+ mcpServers: {+ 'test-server': { env: { API_KEY: 'test-key' } },+ },+ });++ const existingTools = {+ 'old-tool_mcp_test-server': { type: 'function' },+ 'other-tool_mcp_other-server': { type: 'function' },+ };+ getCachedTools.mockResolvedValue(existingTools);++ const response = await request(app).post('/api/mcp/test-server/reinitialize').expect(200);++ expect(response.body).toEqual({+ message: "MCP server 'test-server' reinitialized successfully",+ success: true,+ oauthRequired: false,+ oauthUrl: null,+ serverName: 'test-server',+ });++ expect(setCachedTools).toHaveBeenCalledWith(+ expect.objectContaining({+ 'new-tool_mcp_test-server': expect.any(Object),+ 'other-tool_mcp_other-server': { type: 'function' },+ }),+ { userId: 'test-user-id' },+ );+ expect(setCachedTools).toHaveBeenCalledWith(+ expect.not.objectContaining({+ 'old-tool_mcp_test-server': expect.anything(),+ }),+ { userId: 'test-user-id' },+ );+ });+ });++ describe('GET /:serverName/oauth/callback - Edge Cases', () => {+ it('should handle OAuth callback without toolFlowId (falsy toolFlowId)', async () => {+ const { MCPOAuthHandler } = require('@librechat/api');+ MCPOAuthHandler.getFlowState = jest.fn().mockResolvedValue({+ id: 'test-flow-id',+ userId: 'test-user-id',+ metadata: {+ serverUrl: 'https://example.com',+ oauth: {},+ // No toolFlowId property+ },+ clientInfo: {},+ codeVerifier: 'test-verifier',+ });++ const mockFlowManager = {+ completeFlow: jest.fn(),+ };+ require('~/config').getFlowStateManager.mockReturnValue(mockFlowManager);++ const mockMcpManager = {+ getUserConnection: jest.fn().mockResolvedValue({+ fetchTools: jest.fn().mockResolvedValue([]),+ }),+ };+ require('~/config').getMCPManager.mockReturnValue(mockMcpManager);++ const response = await request(app)+ .get('/api/mcp/test-server/oauth/callback?code=test-code&state=test-flow-id')+ .expect(302);++ expect(mockFlowManager.completeFlow).not.toHaveBeenCalled();+ expect(response.headers.location).toContain('/oauth/success');+ });++ it('should handle null cached tools in OAuth callback (triggers || {} fallback)', async () => {+ const { getCachedTools } = require('~/server/services/Config');+ getCachedTools.mockResolvedValue(null);++ const mockFlowManager = {+ getFlowState: jest.fn().mockResolvedValue({+ id: 'test-flow-id',+ userId: 'test-user-id',+ metadata: { serverUrl: 'https://example.com', oauth: {} },+ clientInfo: {},+ codeVerifier: 'test-verifier',+ }),+ completeFlow: jest.fn(),+ };+ require('~/config').getFlowStateManager.mockReturnValue(mockFlowManager);++ const mockMcpManager = {+ getUserConnection: jest.fn().mockResolvedValue({+ fetchTools: jest+ .fn()+ .mockResolvedValue([{ name: 'test-tool', description: 'Test tool' }]),+ }),+ };+ require('~/config').getMCPManager.mockReturnValue(mockMcpManager);++ const response = await request(app)+ .get('/api/mcp/test-server/oauth/callback?code=test-code&state=test-flow-id')+ .expect(302);++ expect(response.headers.location).toContain('/oauth/success');+ });+ });+});diff --git a/api/server/routes/mcp.js b/api/server/routes/mcp.jsindex 4e35052cd7..a725cf666a 100644--- a/api/server/routes/mcp.js+++ b/api/server/routes/mcp.js@@ -337,9 +337,7 @@ router.post('/:serverName/reinitialize', requireJwtAuth, async (req, res) => {for (const varName of Object.keys(serverConfig.customUserVars)) {try {const value = await getUserPluginAuthValue(user.id, varName, false);- if (value) {- customUserVars[varName] = value;- }+ customUserVars[varName] = value;} catch (err) {logger.error(`[MCP Reinitialize] Error fetching ${varName} for user ${user.id}:`, err);}@@ -504,10 +502,6 @@ router.get('/connection/status/:serverName', requireJwtAuth, async (req, res) =>return res.status(401).json({ error: 'User not authenticated' });}- if (!serverName) {- return res.status(400).json({ error: 'Server name is required' });- }-const { mcpConfig, appConnections, userConnections, oauthServers } = await getMCPSetupData(user.id,);