@1mcp/agent 0.2.0 → 0.7.0

package/build/handlers/notificationHandlers.js

@@ -4,9 +4,9 @@ import { withErrorHandling } from '../utils/errorHandling.js';
 /**
  * Sets up client-to-server notification handlers
  * @param clients Record of client instances
- * @param server The MCP server instance
+ * @param serverInfo The MCP server instance
  */
-export function setupClientToServerNotifications(clients, server) {
+export function setupClientToServerNotifications(clients, serverInfo) {
     const clientNotificationSchemas = [
         CancelledNotificationSchema,
         ProgressNotificationSchema,
@@ -16,11 +16,11 @@ export function setupClientToServerNotifications(clients, server) {
         ToolListChangedNotificationSchema,
         PromptListChangedNotificationSchema,
     ];
-    for (const [name, client] of Object.entries(clients)) {
+    for (const [name, clientInfo] of Object.entries(clients)) {
         clientNotificationSchemas.forEach((schema) => {
-            client.setNotificationHandler(schema, withErrorHandling(async (notification) => {
+            clientInfo.client.setNotificationHandler(schema, withErrorHandling(async (notification) => {
                 logger.info(`Received notification in client: ${name} ${JSON.stringify(notification)}`);
-                server.notification({
+                serverInfo.server.notification({
                     ...notification,
                     params: {
                         ...notification.params,
@@ -34,20 +34,20 @@ export function setupClientToServerNotifications(clients, server) {
 /**
  * Sets up server-to-client notification handlers
  * @param clients Record of client instances
- * @param server The MCP server instance
+ * @param serverInfo The MCP server instance
  */
-export function setupServerToClientNotifications(clients, server) {
+export function setupServerToClientNotifications(clients, serverInfo) {
     const serverNotificationSchemas = [
         CancelledNotificationSchema,
         ProgressNotificationSchema,
         InitializedNotificationSchema,
         RootsListChangedNotificationSchema,
     ];
-    for (const [name, client] of Object.entries(clients)) {
+    for (const [name, clientInfo] of Object.entries(clients)) {
         serverNotificationSchemas.forEach((schema) => {
-            server.setNotificationHandler(schema, withErrorHandling(async (notification) => {
+            serverInfo.server.setNotificationHandler(schema, withErrorHandling(async (notification) => {
                 logger.info(`Received notification in server: ${name} ${JSON.stringify(notification)}`);
-                client.notification({
+                clientInfo.client.notification({
                     ...notification,
                     params: {
                         ...notification.params,

package/build/handlers/requestHandlers.js

@@ -1,19 +1,20 @@
-import { CallToolRequestSchema, ListResourcesRequestSchema, ListToolsRequestSchema, ReadResourceRequestSchema, ListPromptsRequestSchema, GetPromptRequestSchema, ListResourceTemplatesRequestSchema, SubscribeRequestSchema, UnsubscribeRequestSchema, SetLevelRequestSchema, } 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 { executeClientOperation } from '../clients/clientManager.js';
-import { ProxyError, parseUri, withErrorHandling } from '../utils/errorHandling.js';
+import { CallToolRequestSchema, ListResourcesRequestSchema, ListToolsRequestSchema, ReadResourceRequestSchema, ListPromptsRequestSchema, GetPromptRequestSchema, ListResourceTemplatesRequestSchema, SubscribeRequestSchema, UnsubscribeRequestSchema, SetLevelRequestSchema, CallToolResultSchema, CreateMessageRequestSchema, ListRootsRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
+import logger, { setLogLevel } from '../logger/logger.js';
+import { MCP_URI_SEPARATOR, MCP_SERVER_NAME, ERROR_CODES } from '../constants.js';
+import { executeClientOperation, executeServerOperation } from '../clients/clientManager.js';
+import { parseUri, withErrorHandling } from '../utils/errorHandling.js';
+import { MCPError } from '../utils/errorTypes.js';
+import { filterClients, byCapabilities, byTags } 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',
@@ -27,45 +28,64 @@ function sendPartialFailureNotification(server, operation, failedClients) {
         },
     });
 }
+/**
+ * Registers server-specific request handlers
+ * @param clients Record of client instances
+ * @param serverInfo The MCP server instance
+ */
+function registerServerRequestHandlers(clients, serverInfo) {
+    Object.entries(clients).forEach(([_, clientInfo]) => {
+        clientInfo.client.setRequestHandler(CreateMessageRequestSchema, withErrorHandling(async (request) => {
+            return executeServerOperation(serverInfo, (_server) => _server.server.createMessage(request.params, {
+                timeout: clientInfo.transport.timeout,
+            }));
+        }, 'Error creating message'));
+        clientInfo.client.setRequestHandler(ListRootsRequestSchema, withErrorHandling(async (request) => {
+            return executeServerOperation(serverInfo, (_server) => _server.server.listRoots(request.params, {
+                timeout: clientInfo.transport.timeout,
+            }));
+        }, 'Error listing roots'));
+    });
+}
 /**
  * Registers all request handlers based on available capabilities
  * @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) {
     // 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);
-    }
-    // Register tool-related handlers if capability is available
-    if (capabilities.tools) {
-        registerToolHandlers(clients, server);
-    }
-    // Register prompt-related handlers if capability is available
-    if (capabilities.prompts) {
-        registerPromptHandlers(clients, server);
-    }
+    // Register resource-related handlers
+    registerResourceHandlers(clients, serverInfo);
+    // Register tool-related handlers
+    registerToolHandlers(clients, serverInfo);
+    // Register prompt-related handlers
+    registerPromptHandlers(clients, serverInfo);
+    // Register server-specific request handlers
+    registerServerRequestHandlers(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 = filterClients(byCapabilities({ resources: {} }), byTags(serverInfo.tags))(clients);
+        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,
@@ -78,24 +98,29 @@ function registerResourceHandlers(clients, server) {
                 failedClients.push({ name, error: error instanceof Error ? error.message : String(error) });
             }
         }
-        // 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 all capable clients failed, throw an error
+        if (failedClients.length === Object.keys(filteredClients).length && Object.keys(filteredClients).length > 0) {
+            throw new MCPError('Failed to list resources from all capable 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 capableClients = filterClients(byCapabilities({ resources: {} }), byTags(serverInfo.tags))(clients);
+        for (const [name, clientInfo] of Object.entries(capableClients)) {
             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 +134,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(capableClients).length && Object.keys(capableClients).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 capableClients = filterClients(byCapabilities({ tools: {} }), byTags(serverInfo.tags))(clients);
+        for (const [name, clientInfo] of Object.entries(capableClients)) {
             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 +196,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(capableClients).length && Object.keys(capableClients).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 capableClients = filterClients(byCapabilities({ prompts: {} }), byTags(serverInfo.tags))(clients);
+        for (const [name, clientInfo] of Object.entries(capableClients)) {
             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 +242,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(capableClients).length && Object.keys(capableClients).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

@@ -1,12 +1,6 @@
-import fs from 'fs';
-import path from 'path';
 import winston from 'winston';
 import { MCPTransport } from './mcpTransport.js';
-// Ensure logs directory exists
-const logsDir = path.join(process.cwd(), 'logs');
-if (!fs.existsSync(logsDir)) {
-    fs.mkdirSync(logsDir, { recursive: true });
-}
+import { SSEServerTransport } from '@modelcontextprotocol/sdk/server/sse.js';
 // Map MCP log levels to Winston log levels
 const MCP_TO_WINSTON_LEVEL = {
     debug: 'debug',
@@ -33,26 +27,11 @@ const logger = winston.createLogger({
     level: 'info',
     format: customFormat,
     transports: [
+        // Add a silent transport by default to prevent "no transports" warnings
         new winston.transports.Console({
+            silent: true,
             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,
@@ -71,7 +50,15 @@ export function addMCPTransport(server, loggerName) {
         loggerName: loggerName || '1mcp',
         level: 'info',
     });
-    logger.add(mcpTransport);
+    logger.transports = [mcpTransport];
+    // Add appropriate transport based on server type
+    if (server instanceof SSEServerTransport) {
+        // For SSE server, add console transport for visibility
+        logger.add(new winston.transports.Console({
+            format: consoleFormat,
+            level: 'info',
+        }));
+    }
 }
 /**
  * Set the connection status of the MCP transport

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;
     }