@1mcp/agent 0.2.0 → 0.4.0

package/build/handlers/requestHandlers.js

@@ -1,19 +1,21 @@
-import { CallToolRequestSchema, ListResourcesRequestSchema, ListToolsRequestSchema, ReadResourceRequestSchema, ListPromptsRequestSchema, GetPromptRequestSchema, ListResourceTemplatesRequestSchema, SubscribeRequestSchema, UnsubscribeRequestSchema, SetLevelRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
+import { CallToolRequestSchema, ListResourcesRequestSchema, ListToolsRequestSchema, ReadResourceRequestSchema, ListPromptsRequestSchema, GetPromptRequestSchema, ListResourceTemplatesRequestSchema, SubscribeRequestSchema, UnsubscribeRequestSchema, SetLevelRequestSchema, CallToolResultSchema, } from '@modelcontextprotocol/sdk/types.js';
 import logger from '../logger/logger.js';
 import { setLogLevel } from '../logger/logger.js';
-import { MCP_URI_SEPARATOR, MCP_SERVER_NAME } from '../constants.js';
+import { MCP_URI_SEPARATOR, MCP_SERVER_NAME, ERROR_CODES } from '../constants.js';
 import { executeClientOperation } from '../clients/clientManager.js';
-import { ProxyError, parseUri, withErrorHandling } from '../utils/errorHandling.js';
+import { parseUri, withErrorHandling } from '../utils/errorHandling.js';
+import { MCPError } from '../utils/errorTypes.js';
+import { filterClientsByTags } from '../utils/clientFiltering.js';
 /**
  * Sends a partial failure notification to inform clients about backend failures
  * @param server The MCP server instance
  * @param operation The operation that partially failed
  * @param failedClients Array of failed clients with error details
  */
-function sendPartialFailureNotification(server, operation, failedClients) {
+function sendPartialFailureNotification(serverInfo, operation, failedClients) {
     if (failedClients.length === 0)
         return;
-    server.notification({
+    serverInfo.server.notification({
         method: 'notifications/message',
         params: {
             level: 'warning',
@@ -32,40 +34,44 @@ function sendPartialFailureNotification(server, operation, failedClients) {
  * @param clients Record of client instances
  * @param server The MCP server instance
  * @param capabilities The server capabilities
+ * @param tags Array of tags to filter clients by
  */
-export function registerRequestHandlers(clients, server, capabilities) {
+export function registerRequestHandlers(clients, serverInfo, capabilities) {
     // Register logging level handler
-    server.setRequestHandler(SetLevelRequestSchema, async (request) => {
+    serverInfo.server.setRequestHandler(SetLevelRequestSchema, async (request) => {
         setLogLevel(request.params.level);
         return {};
     });
     // Register resource-related handlers if capability is available
     if (capabilities.resources) {
-        registerResourceHandlers(clients, server);
+        registerResourceHandlers(clients, serverInfo);
     }
     // Register tool-related handlers if capability is available
     if (capabilities.tools) {
-        registerToolHandlers(clients, server);
+        registerToolHandlers(clients, serverInfo);
     }
     // Register prompt-related handlers if capability is available
     if (capabilities.prompts) {
-        registerPromptHandlers(clients, server);
+        registerPromptHandlers(clients, serverInfo);
     }
 }
 /**
  * Registers resource-related request handlers
  * @param clients Record of client instances
- * @param server The MCP server instance
+ * @param serverInfo The MCP server instance
  */
-function registerResourceHandlers(clients, server) {
+function registerResourceHandlers(clients, serverInfo) {
     // List Resources handler
-    server.setRequestHandler(ListResourcesRequestSchema, withErrorHandling(async (request) => {
+    serverInfo.server.setRequestHandler(ListResourcesRequestSchema, withErrorHandling(async (request) => {
         const resources = [];
         const failedClients = [];
-        for (const [name, client] of Object.entries(clients)) {
+        const filteredClients = filterClientsByTags(clients, serverInfo.tags);
+        for (const [name, clientInfo] of Object.entries(filteredClients)) {
             logger.info(`Listing resources for ${name}`);
             try {
-                const result = await client.listResources(request.params);
+                const result = await clientInfo.client.listResources(request.params, {
+                    timeout: clientInfo.transport.timeout,
+                });
                 resources.push(...result.resources.map((resource) => ({
                     uri: `${name}${MCP_URI_SEPARATOR}${resource.uri}`,
                     name: resource.name,
@@ -79,23 +85,28 @@ function registerResourceHandlers(clients, server) {
             }
         }
         // If all clients failed, throw an error
-        if (failedClients.length === Object.keys(clients).length && Object.keys(clients).length > 0) {
-            throw new ProxyError('Failed to list resources from all clients', new Error(JSON.stringify(failedClients)));
+        if (failedClients.length === Object.keys(filteredClients).length && Object.keys(filteredClients).length > 0) {
+            throw new MCPError('Failed to list resources from all clients', ERROR_CODES.INTERNAL_SERVER_ERROR, {
+                failedClients,
+            });
         }
         // Send notification about partial failures
         if (failedClients.length > 0) {
-            sendPartialFailureNotification(server, 'listResources', failedClients);
+            sendPartialFailureNotification(serverInfo, 'listResources', failedClients);
         }
         return { resources };
     }, 'Error listing resources'));
     // List Resource Templates handler
-    server.setRequestHandler(ListResourceTemplatesRequestSchema, withErrorHandling(async (request) => {
+    serverInfo.server.setRequestHandler(ListResourceTemplatesRequestSchema, withErrorHandling(async (request) => {
         const resourceTemplates = [];
         const failedClients = [];
-        for (const [name, client] of Object.entries(clients)) {
+        const filteredClients = filterClientsByTags(clients, serverInfo.tags);
+        for (const [name, clientInfo] of Object.entries(filteredClients)) {
             logger.info(`Listing resource templates for ${name}`);
             try {
-                const result = await client.listResourceTemplates(request.params);
+                const result = await clientInfo.client.listResourceTemplates(request.params, {
+                    timeout: clientInfo.transport.timeout,
+                });
                 resourceTemplates.push(...result.resourceTemplates.map((template) => ({
                     uriTemplate: `${name}${MCP_URI_SEPARATOR}${template.uriTemplate}`,
                     name: template.name,
@@ -109,45 +120,56 @@ function registerResourceHandlers(clients, server) {
             }
         }
         // If all clients failed, throw an error
-        if (failedClients.length === Object.keys(clients).length && Object.keys(clients).length > 0) {
-            throw new ProxyError('Failed to list resource templates from all clients', new Error(JSON.stringify(failedClients)));
+        if (failedClients.length === Object.keys(filteredClients).length && Object.keys(filteredClients).length > 0) {
+            throw new MCPError('Failed to list resource templates from all clients', ERROR_CODES.INTERNAL_SERVER_ERROR, {
+                failedClients,
+            });
         }
         // Send notification about partial failures
         if (failedClients.length > 0) {
-            sendPartialFailureNotification(server, 'listResourceTemplates', failedClients);
+            sendPartialFailureNotification(serverInfo, 'listResourceTemplates', failedClients);
         }
         return { resourceTemplates };
     }, 'Error listing resource templates'));
     // Subscribe Resource handler
-    server.setRequestHandler(SubscribeRequestSchema, withErrorHandling(async (request) => {
+    serverInfo.server.setRequestHandler(SubscribeRequestSchema, withErrorHandling(async (request) => {
         const { clientName, resourceName } = parseUri(request.params.uri, MCP_URI_SEPARATOR);
-        return executeClientOperation(clients, clientName, (client) => client.subscribeResource({ ...request.params, uri: resourceName }));
+        return executeClientOperation(clients, clientName, (clientInfo) => clientInfo.client.subscribeResource({ ...request.params, uri: resourceName }, {
+            timeout: clientInfo.transport.timeout,
+        }));
     }, 'Error subscribing to resource'));
     // Unsubscribe Resource handler
-    server.setRequestHandler(UnsubscribeRequestSchema, withErrorHandling(async (request) => {
+    serverInfo.server.setRequestHandler(UnsubscribeRequestSchema, withErrorHandling(async (request) => {
         const { clientName, resourceName } = parseUri(request.params.uri, MCP_URI_SEPARATOR);
-        return executeClientOperation(clients, clientName, (client) => client.unsubscribeResource({ ...request.params, uri: resourceName }));
+        return executeClientOperation(clients, clientName, (clientInfo) => clientInfo.client.unsubscribeResource({ ...request.params, uri: resourceName }, {
+            timeout: clientInfo.transport.timeout,
+        }));
     }, 'Error unsubscribing from resource'));
     // Read Resource handler
-    server.setRequestHandler(ReadResourceRequestSchema, withErrorHandling(async (request) => {
+    serverInfo.server.setRequestHandler(ReadResourceRequestSchema, withErrorHandling(async (request) => {
         const { clientName, resourceName } = parseUri(request.params.uri, MCP_URI_SEPARATOR);
-        return executeClientOperation(clients, clientName, (client) => client.readResource({ ...request.params, uri: resourceName }));
+        return executeClientOperation(clients, clientName, (clientInfo) => clientInfo.client.readResource({ ...request.params, uri: resourceName }, {
+            timeout: clientInfo.transport.timeout,
+        }));
     }, 'Error reading resource'));
 }
 /**
  * Registers tool-related request handlers
  * @param clients Record of client instances
- * @param server The MCP server instance
+ * @param serverInfo The MCP server instance
  */
-function registerToolHandlers(clients, server) {
+function registerToolHandlers(clients, serverInfo) {
     // List Tools handler
-    server.setRequestHandler(ListToolsRequestSchema, withErrorHandling(async (request) => {
+    serverInfo.server.setRequestHandler(ListToolsRequestSchema, withErrorHandling(async (request) => {
         const tools = [];
         const failedClients = [];
-        for (const [name, client] of Object.entries(clients)) {
+        const filteredClients = filterClientsByTags(clients, serverInfo.tags);
+        for (const [name, clientInfo] of Object.entries(filteredClients)) {
             logger.info(`Listing tools for ${name}`);
             try {
-                const result = await client.listTools(request.params);
+                const result = await clientInfo.client.listTools(request.params, {
+                    timeout: clientInfo.transport.timeout,
+                });
                 tools.push(...result.tools.map((tool) => ({
                     name: `${name}${MCP_URI_SEPARATOR}${tool.name}`,
                     description: tool.description,
@@ -160,35 +182,40 @@ function registerToolHandlers(clients, server) {
             }
         }
         // If all clients failed, throw an error
-        if (failedClients.length === Object.keys(clients).length && Object.keys(clients).length > 0) {
-            throw new ProxyError('Failed to list tools from all clients', new Error(JSON.stringify(failedClients)));
+        if (failedClients.length === Object.keys(filteredClients).length && Object.keys(filteredClients).length > 0) {
+            throw new MCPError('Failed to list tools from all clients', ERROR_CODES.INTERNAL_SERVER_ERROR, {
+                failedClients,
+            });
         }
         // Send notification about partial failures
         if (failedClients.length > 0) {
-            sendPartialFailureNotification(server, 'listTools', failedClients);
+            sendPartialFailureNotification(serverInfo, 'listTools', failedClients);
         }
         return { tools };
     }, 'Error listing tools'));
     // Call Tool handler
-    server.setRequestHandler(CallToolRequestSchema, withErrorHandling(async (request) => {
+    serverInfo.server.setRequestHandler(CallToolRequestSchema, withErrorHandling(async (request) => {
         const { clientName, resourceName: toolName } = parseUri(request.params.name, MCP_URI_SEPARATOR);
-        return executeClientOperation(clients, clientName, (client) => client.callTool({ ...request.params, name: toolName }));
+        return executeClientOperation(clients, clientName, (clientInfo) => clientInfo.client.callTool({ ...request.params, name: toolName }, CallToolResultSchema, {
+            timeout: clientInfo.transport.timeout,
+        }));
     }, 'Error calling tool'));
 }
 /**
  * Registers prompt-related request handlers
  * @param clients Record of client instances
- * @param server The MCP server instance
+ * @param serverInfo The MCP server instance
  */
-function registerPromptHandlers(clients, server) {
+function registerPromptHandlers(clients, serverInfo) {
     // List Prompts handler
-    server.setRequestHandler(ListPromptsRequestSchema, withErrorHandling(async (request) => {
+    serverInfo.server.setRequestHandler(ListPromptsRequestSchema, withErrorHandling(async (request) => {
         const prompts = [];
         const failedClients = [];
-        for (const [name, client] of Object.entries(clients)) {
+        const filteredClients = filterClientsByTags(clients, serverInfo.tags);
+        for (const [name, clientInfo] of Object.entries(filteredClients)) {
             logger.info(`Listing prompts for ${name}`);
             try {
-                const result = await client.listPrompts(request.params);
+                const result = await clientInfo.client.listPrompts(request.params);
                 prompts.push(...result.prompts.map((prompt) => ({
                     name: `${name}${MCP_URI_SEPARATOR}${prompt.name}`,
                     description: prompt.description,
@@ -201,18 +228,20 @@ function registerPromptHandlers(clients, server) {
             }
         }
         // If all clients failed, throw an error
-        if (failedClients.length === Object.keys(clients).length && Object.keys(clients).length > 0) {
-            throw new ProxyError('Failed to list prompts from all clients', new Error(JSON.stringify(failedClients)));
+        if (failedClients.length === Object.keys(filteredClients).length && Object.keys(filteredClients).length > 0) {
+            throw new MCPError('Failed to list prompts from all clients', ERROR_CODES.INTERNAL_SERVER_ERROR, {
+                failedClients,
+            });
         }
         // Send notification about partial failures
         if (failedClients.length > 0) {
-            sendPartialFailureNotification(server, 'listPrompts', failedClients);
+            sendPartialFailureNotification(serverInfo, 'listPrompts', failedClients);
         }
         return { prompts };
     }, 'Error listing prompts'));
     // Get Prompt handler
-    server.setRequestHandler(GetPromptRequestSchema, withErrorHandling(async (request) => {
+    serverInfo.server.setRequestHandler(GetPromptRequestSchema, withErrorHandling(async (request) => {
         const { clientName, resourceName: promptName } = parseUri(request.params.name, MCP_URI_SEPARATOR);
-        return executeClientOperation(clients, clientName, (client) => client.getPrompt({ ...request.params, name: promptName }));
+        return executeClientOperation(clients, clientName, (clientInfo) => clientInfo.client.getPrompt({ ...request.params, name: promptName }));
     }, 'Error getting prompt'));
 }

package/build/index.js

@@ -7,6 +7,7 @@ import logger from './logger/logger.js';
 import configReloadService from './services/configReloadService.js';
 import { ConfigManager } from './config/configManager.js';
 import { ExpressServer } from './server/expressServer.js';
+import { PORT, HOST } from './constants.js';
 // Parse command line arguments
 const argv = yargs(hideBin(process.argv))
     .usage('Usage: $0 [options]')
@@ -18,12 +19,30 @@ const argv = yargs(hideBin(process.argv))
         choices: ['stdio', 'sse'],
         default: 'sse',
     },
+    port: {
+        alias: 'P',
+        describe: 'SSE port to listen on, applicable when transport is sse',
+        type: 'number',
+        default: PORT,
+    },
+    host: {
+        alias: 'H',
+        describe: 'SSE host to listen on, applicable when transport is sse',
+        type: 'string',
+        default: HOST,
+    },
     config: {
         alias: 'c',
         describe: 'Path to the config file',
         type: 'string',
         default: undefined,
     },
+    tags: {
+        alias: 'g',
+        describe: 'Tags to filter clients (comma-separated)',
+        type: 'string',
+        default: undefined,
+    },
 })
     .help()
     .alias('help', 'h')
@@ -67,13 +86,22 @@ async function main() {
         if (argv.transport === 'stdio') {
             // Use stdio transport
             const transport = new StdioServerTransport();
-            await serverManager.connectTransport(transport, 'stdio');
+            // Parse and validate tags from CLI if provided
+            let tags;
+            if (argv.tags) {
+                tags = argv.tags.split(',').filter((tag) => tag.trim().length > 0);
+                if (tags.length === 0) {
+                    logger.warn('No valid tags provided, ignoring tags parameter');
+                    tags = undefined;
+                }
+            }
+            await serverManager.connectTransport(transport, 'stdio', tags);
             logger.info('Server started with stdio transport');
         }
         else {
             // Use HTTP/SSE transport
             const expressServer = new ExpressServer(serverManager);
-            expressServer.start();
+            expressServer.start(argv.port, argv.host);
         }
     }
     catch (error) {

package/build/logger/logger.js

@@ -36,23 +36,6 @@ const logger = winston.createLogger({
         new winston.transports.Console({
             format: consoleFormat,
         }),
-        //
-        // - Write all logs with importance level of `error` or higher to `error.log`
-        //   (i.e., error, fatal, but not other levels)
-        //
-        new winston.transports.File({
-            filename: path.join(logsDir, 'error.log'),
-            level: 'error',
-            format: customFormat,
-        }),
-        //
-        // - Write all logs with importance level of `info` or higher to `combined.log`
-        //   (i.e., fatal, error, warn, and info, but not trace)
-        //
-        new winston.transports.File({
-            filename: path.join(logsDir, 'combined.log'),
-            format: customFormat,
-        }),
     ],
     // Prevent logger from exiting on error
     exitOnError: false,

package/build/logger/mcpTransport.js

@@ -133,7 +133,7 @@ export class MCPTransport extends Transport {
             try {
                 this.sendLogNotification(info);
             }
-            catch (error) {
+            catch (_) {
                 // Ignore any errors during log sending
             }
         }

package/build/server/expressServer.js

@@ -1,7 +1,7 @@
 import express from 'express';
 import { SSEServerTransport } from '@modelcontextprotocol/sdk/server/sse.js';
 import logger, { setMCPTransportConnected } from '../logger/logger.js';
-import { PORT, SSE_ENDPOINT, MESSAGES_ENDPOINT, ERROR_CODES } from '../constants.js';
+import { SSE_ENDPOINT, MESSAGES_ENDPOINT, ERROR_CODES } from '../constants.js';
 export class ExpressServer {
     app;
     serverManager;
@@ -13,7 +13,7 @@ export class ExpressServer {
     }
     setupMiddleware() {
         // Add error handling middleware
-        this.app.use((err, req, res, next) => {
+        this.app.use((err, req, res, _next) => {
             logger.error('Express error:', err);
             res.status(500).json({
                 error: {
@@ -28,8 +28,23 @@ export class ExpressServer {
             try {
                 logger.info('sse', { query: req.query, headers: req.headers });
                 const transport = new SSEServerTransport(MESSAGES_ENDPOINT, res);
+                // Extract and validate tags from query parameters
+                let tags;
+                if (req.query.tags) {
+                    const tagsStr = req.query.tags;
+                    if (typeof tagsStr !== 'string') {
+                        res.status(400).json({
+                            error: {
+                                code: ERROR_CODES.INVALID_PARAMS,
+                                message: 'Invalid params: tags must be a string',
+                            },
+                        });
+                        return;
+                    }
+                    tags = tagsStr.split(',').filter((tag) => tag.trim().length > 0);
+                }
                 // Connect the transport using the server manager
-                await this.serverManager.connectTransport(transport, transport.sessionId);
+                await this.serverManager.connectTransport(transport, transport.sessionId, tags);
                 // Update MCP transport connection status when a client connects
                 if (this.serverManager.getActiveTransportsCount() === 1) {
                     setMCPTransportConnected(true);
@@ -86,9 +101,9 @@ export class ExpressServer {
             }
         });
     }
-    start() {
-        this.app.listen(PORT, () => {
-            logger.info(`Server is running on port ${PORT} with HTTP/SSE transport`);
+    start(port, host) {
+        this.app.listen(port, host, () => {
+            logger.info(`Server is running on port ${port} with HTTP/SSE transport`);
         });
     }
 }

package/build/serverManager.js

@@ -9,33 +9,37 @@ export class ServerManager {
     serverConfig;
     serverCapabilities;
     clients = {};
-    clientTransports = {};
-    constructor(config, capabilities, clients, clientTransports) {
+    transports = {};
+    constructor(config, capabilities, clients, transports) {
         this.serverConfig = config;
         this.serverCapabilities = capabilities;
         this.clients = clients;
-        this.clientTransports = clientTransports;
+        this.transports = transports;
     }
-    static getInstance(config, capabilities, clients, clientTransports) {
+    static getInstance(config, capabilities, clients, transports) {
         if (!ServerManager.instance) {
-            ServerManager.instance = new ServerManager(config, capabilities, clients, clientTransports);
+            ServerManager.instance = new ServerManager(config, capabilities, clients, transports);
         }
         return ServerManager.instance;
     }
-    async connectTransport(transport, sessionId) {
+    async connectTransport(transport, sessionId, tags) {
         try {
             // Create a new server instance for this transport
             const server = new Server(this.serverConfig, this.serverCapabilities);
             // Enhance server with logging middleware
             enhanceServerWithLogging(server);
-            // Collect capabilities and register handlers
-            await setupCapabilities(this.clients, server);
+            const serverInfo = {
+                server,
+                tags,
+            };
+            // Set up capabilities for this server instance
+            await setupCapabilities(this.clients, serverInfo);
             // Initialize the configuration reload service
-            configReloadService.initialize(server, this.clientTransports);
+            configReloadService.initialize(serverInfo, this.transports);
+            // Store the server instance
+            this.servers.set(sessionId, serverInfo);
             // Connect the transport to the new server instance
             await server.connect(transport);
-            // Store the server instance
-            this.servers.set(sessionId, server);
             logger.info(`Connected transport for session ${sessionId}`);
         }
         catch (error) {
@@ -51,17 +55,20 @@ export class ServerManager {
         }
     }
     getTransport(sessionId) {
-        return this.servers.get(sessionId)?.transport;
+        return this.servers.get(sessionId)?.server.transport;
     }
     getTransports() {
         const transports = new Map();
         for (const [id, server] of this.servers.entries()) {
-            if (server.transport) {
-                transports.set(id, server.transport);
+            if (server.server.transport) {
+                transports.set(id, server.server.transport);
             }
         }
         return transports;
     }
+    getClientTransports() {
+        return this.transports;
+    }
     getActiveTransportsCount() {
         return this.servers.size;
     }

package/build/serverManager.test.js

@@ -0,0 +1,158 @@
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { ServerManager } from './serverManager.js';
+import logger from './logger/logger.js';
+import configReloadService from './services/configReloadService.js';
+import { setupCapabilities } from './capabilities/capabilityManager.js';
+import { enhanceServerWithLogging } from './middleware/loggingMiddleware.js';
+// Mock dependencies
+jest.mock('@modelcontextprotocol/sdk/server/index.js', () => ({
+    Server: jest.fn(),
+}));
+jest.mock('@modelcontextprotocol/sdk/shared/transport.js', () => ({
+    Transport: jest.fn(),
+}));
+jest.mock('./logger/logger.js', () => {
+    const mockLogger = {
+        info: jest.fn(),
+        error: jest.fn(),
+    };
+    return {
+        __esModule: true,
+        default: mockLogger,
+    };
+});
+jest.mock('./services/configReloadService.js', () => ({
+    __esModule: true,
+    default: {
+        initialize: jest.fn(),
+    },
+}));
+jest.mock('./capabilities/capabilityManager.js', () => ({
+    setupCapabilities: jest.fn(),
+}));
+jest.mock('./middleware/loggingMiddleware.js', () => ({
+    enhanceServerWithLogging: jest.fn(),
+}));
+describe('ServerManager', () => {
+    let mockConfig;
+    let mockCapabilities;
+    let mockClients;
+    let mockTransports;
+    let mockTransport;
+    let mockServer;
+    beforeEach(() => {
+        // Reset all mocks
+        jest.clearAllMocks();
+        // Setup test data
+        mockConfig = { name: 'test-server', version: '1.0.0' };
+        mockCapabilities = { capabilities: { test: true } };
+        mockClients = {};
+        mockTransports = {};
+        mockTransport = {
+        // Add any required Transport properties here
+        };
+        mockServer = {
+            connect: jest.fn().mockResolvedValue(undefined),
+            transport: mockTransport,
+        };
+        // Setup mocks
+        Server.mockImplementation(() => mockServer);
+        setupCapabilities.mockResolvedValue(undefined);
+        enhanceServerWithLogging.mockReturnValue(undefined);
+        configReloadService.initialize.mockImplementation(() => undefined);
+    });
+    describe('getInstance', () => {
+        it('should create a singleton instance', () => {
+            const instance1 = ServerManager.getInstance(mockConfig, mockCapabilities, mockClients, mockTransports);
+            const instance2 = ServerManager.getInstance(mockConfig, mockCapabilities, mockClients, mockTransports);
+            expect(instance1).toBe(instance2);
+        });
+    });
+    describe('connectTransport', () => {
+        let serverManager;
+        const sessionId = 'test-session';
+        const tags = ['tag1', 'tag2'];
+        beforeEach(() => {
+            serverManager = ServerManager.getInstance(mockConfig, mockCapabilities, mockClients, mockTransports);
+        });
+        it('should successfully connect a transport', async () => {
+            await serverManager.connectTransport(mockTransport, sessionId, tags);
+            expect(Server).toHaveBeenCalledWith(mockConfig, mockCapabilities);
+            expect(enhanceServerWithLogging).toHaveBeenCalledWith(mockServer);
+            expect(setupCapabilities).toHaveBeenCalled();
+            expect(configReloadService.initialize).toHaveBeenCalled();
+            expect(mockServer.connect).toHaveBeenCalledWith(mockTransport);
+            expect(logger.info).toHaveBeenCalledWith(`Connected transport for session ${sessionId}`);
+        });
+        it('should handle connection errors', async () => {
+            const error = new Error('Connection failed');
+            mockServer.connect.mockRejectedValueOnce(error);
+            await expect(serverManager.connectTransport(mockTransport, sessionId, tags)).rejects.toThrow('Connection failed');
+            expect(logger.error).toHaveBeenCalled();
+        });
+    });
+    describe('disconnectTransport', () => {
+        let serverManager;
+        const sessionId = 'test-session';
+        beforeEach(() => {
+            serverManager = ServerManager.getInstance(mockConfig, mockCapabilities, mockClients, mockTransports);
+        });
+        it('should successfully disconnect a transport', async () => {
+            await serverManager.connectTransport(mockTransport, sessionId);
+            jest.clearAllMocks(); // Clear the logs from connectTransport
+            serverManager.disconnectTransport(sessionId);
+            expect(logger.info).toHaveBeenCalledWith(`Disconnected transport for session ${sessionId}`);
+        });
+        it('should handle non-existent session gracefully', () => {
+            serverManager.disconnectTransport('non-existent');
+            expect(logger.info).not.toHaveBeenCalled();
+        });
+    });
+    describe('transport management methods', () => {
+        let serverManager;
+        const sessionId = 'test-session';
+        beforeEach(async () => {
+            serverManager = ServerManager.getInstance(mockConfig, mockCapabilities, mockClients, mockTransports);
+            await serverManager.connectTransport(mockTransport, sessionId);
+        });
+        it('should get transport by session id', () => {
+            const transport = serverManager.getTransport(sessionId);
+            expect(transport).toBe(mockTransport);
+        });
+        it('should return undefined for non-existent session', () => {
+            const transport = serverManager.getTransport('non-existent');
+            expect(transport).toBeUndefined();
+        });
+        it('should get all transports', () => {
+            const transports = serverManager.getTransports();
+            expect(transports.size).toBe(1);
+            expect(transports.get(sessionId)).toBe(mockTransport);
+        });
+        it('should get client transports', () => {
+            const clientTransports = serverManager.getClientTransports();
+            expect(clientTransports).toEqual(mockTransports);
+        });
+        it('should get active transports count', () => {
+            expect(serverManager.getActiveTransportsCount()).toBe(1);
+        });
+    });
+    describe('getServer', () => {
+        let serverManager;
+        const sessionId = 'test-session';
+        const tags = ['tag1', 'tag2'];
+        beforeEach(async () => {
+            serverManager = ServerManager.getInstance(mockConfig, mockCapabilities, mockClients, mockTransports);
+            await serverManager.connectTransport(mockTransport, sessionId, tags);
+        });
+        it('should return server info for existing session', () => {
+            const serverInfo = serverManager.getServer(sessionId);
+            expect(serverInfo).toBeDefined();
+            expect(serverInfo?.server).toBe(mockServer);
+            expect(serverInfo?.tags).toEqual(tags);
+        });
+        it('should return undefined for non-existent session', () => {
+            const serverInfo = serverManager.getServer('non-existent');
+            expect(serverInfo).toBeUndefined();
+        });
+    });
+});