@1mcp/agent 0.4.0 → 0.7.0

package/README.md

@@ -229,10 +229,10 @@ pnpm dev
 
 ### Debugging
 
-Since MCP servers communicate over stdio, debugging can be challenging. We recommend using the [MCP Inspector](https://github.com/modelcontextprotocol/inspector), which is available as a package script:
+Using the [MCP Inspector](https://github.com/modelcontextprotocol/inspector), which is available as a package script:
 
 ```bash
-pnpm run inspector
+pnpm inspector
 ```
 
 The Inspector will provide a URL to access debugging tools in your browser.

package/build/capabilities/capabilityManager.js

@@ -15,7 +15,7 @@ export async function setupCapabilities(clients, serverInfo) {
     setupClientToServerNotifications(clients, serverInfo);
     setupServerToClientNotifications(clients, serverInfo);
     // Register request handlers based on capabilities
-    registerRequestHandlers(clients, serverInfo, capabilities);
+    registerRequestHandlers(clients, serverInfo);
     return capabilities;
 }
 /**
@@ -24,12 +24,19 @@ export async function setupCapabilities(clients, serverInfo) {
  * @returns The combined server capabilities
  */
 function collectCapabilities(clients) {
-    let capabilities = {};
+    const capabilities = {};
     for (const [name, clientInfo] of Object.entries(clients)) {
         try {
-            const clientCapabilities = clientInfo.client.getServerCapabilities() || {};
-            logger.debug(`Capabilities from ${name}: ${JSON.stringify(clientCapabilities)}`);
-            capabilities = { ...capabilities, ...clientCapabilities };
+            const serverCapabilities = clientInfo.client.getServerCapabilities() || {};
+            logger.debug(`Capabilities from ${name}: ${JSON.stringify(serverCapabilities)}`);
+            // Store capabilities per client
+            clientInfo.capabilities = serverCapabilities;
+            // Aggregate capabilities
+            capabilities.resources = { ...capabilities.resources, ...serverCapabilities.resources };
+            capabilities.tools = { ...capabilities.tools, ...serverCapabilities.tools };
+            capabilities.prompts = { ...capabilities.prompts, ...serverCapabilities.prompts };
+            capabilities.experimental = { ...capabilities.experimental, ...serverCapabilities.experimental };
+            capabilities.logging = { ...capabilities.logging, ...serverCapabilities.logging };
         }
         catch (error) {
             logger.error(`Failed to get capabilities from ${name}: ${error}`);

package/build/clients/clientManager.js

@@ -1,8 +1,7 @@
 import createClient from '../client.js';
 import logger from '../logger/logger.js';
-import { CONNECTION_RETRY, MCP_SERVER_NAME } from '../constants.js';
-import { withErrorHandling } from '../utils/errorHandling.js';
-import { ClientConnectionError, ClientNotFoundError } from '../utils/errorTypes.js';
+import { CONNECTION_RETRY, MCP_SERVER_NAME, ERROR_CODES } from '../constants.js';
+import { ClientConnectionError, ClientNotFoundError, MCPError } from '../utils/errorTypes.js';
 import { ClientStatus } from '../types.js';
 /**
  * Creates client instances for all transports with retry logic
@@ -85,30 +84,54 @@ export function getClient(clients, clientName) {
     return client;
 }
 /**
- * Executes a client operation with error handling and timeout
- * @param clients Record of client instances
- * @param clientName The name of the client to use
+ * Executes an operation with error handling and retry logic
  * @param operation The operation to execute
+ * @param context The execution context (client info or server info)
  * @param options Operation options including timeout and retry settings
  * @returns The result of the operation
  */
-export async function executeClientOperation(clients, clientName, operation, options = {}) {
-    const clientInfo = getClient(clients, clientName);
+export async function executeOperation(operation, contextName, options = {}) {
     const { retryCount = 0, retryDelay = 1000 } = options;
-    return withErrorHandling(async () => {
-        let lastError;
-        for (let i = 0; i <= retryCount; i++) {
-            try {
-                return await operation(clientInfo);
-            }
-            catch (error) {
-                lastError = error instanceof Error ? error : new Error(String(error));
-                if (i < retryCount) {
-                    logger.info(`Retrying operation ${operation.name} on client ${clientName} after ${retryDelay}ms`);
-                    await new Promise((resolve) => setTimeout(resolve, retryDelay));
-                }
+    let lastError;
+    for (let i = 0; i <= retryCount; i++) {
+        try {
+            return await operation();
+        }
+        catch (error) {
+            lastError = error instanceof Error ? error : new Error(String(error));
+            if (i < retryCount) {
+                logger.info(`Retrying operation ${operation.name} on ${contextName} after ${retryDelay}ms`);
+                await new Promise((resolve) => setTimeout(resolve, retryDelay));
             }
         }
+    }
+    // If we get here, we've exhausted all retries
+    logger.error(`Operation failed on ${contextName} after ${retryCount + 1} attempts: ${lastError}`);
+    if (lastError instanceof MCPError) {
         throw lastError;
-    }, `Error executing operation on client ${clientName}`)();
+    }
+    const mcpError = new MCPError(`Error executing operation on ${contextName}`, ERROR_CODES.INTERNAL_SERVER_ERROR, {
+        originalError: lastError,
+    });
+    throw mcpError;
+}
+/**
+ * Executes a client operation with error handling and retry logic
+ * @param clients Record of client instances
+ * @param clientName The name of the client to use
+ * @param operation The operation to execute
+ * @param options Operation options including timeout and retry settings
+ */
+export async function executeClientOperation(clients, clientName, operation, options = {}) {
+    const clientInfo = getClient(clients, clientName);
+    return executeOperation(() => operation(clientInfo), `client ${clientName}`, options);
+}
+/**
+ * Executes a server operation with error handling and retry logic
+ * @param server The server to execute the operation on
+ * @param operation The operation to execute
+ * @param options Operation options including timeout and retry settings
+ */
+export async function executeServerOperation(server, operation, options = {}) {
+    return executeOperation(() => operation(server), 'server', options);
 }

package/build/clients/clientManager.test.js

@@ -0,0 +1,172 @@
+import { createClients, getClient, executeOperation, executeClientOperation, executeServerOperation, } from './clientManager.js';
+import createClientFn from '../client.js';
+import logger from '../logger/logger.js';
+import { ClientStatus } from '../types.js';
+import { ClientConnectionError, ClientNotFoundError, MCPError } from '../utils/errorTypes.js';
+import { MCP_SERVER_NAME, CONNECTION_RETRY } from '../constants.js';
+// Mock dependencies
+jest.mock('@modelcontextprotocol/sdk/client/index.js', () => ({
+    Client: jest.fn(),
+}));
+jest.mock('../client.js', () => ({
+    __esModule: true,
+    default: jest.fn(),
+}));
+jest.mock('../logger/logger.js', () => ({
+    __esModule: true,
+    default: {
+        info: jest.fn(),
+        error: jest.fn(),
+    },
+}));
+describe('clientManager', () => {
+    let mockTransport;
+    let mockClient;
+    let mockTransports;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        jest.useFakeTimers();
+        mockTransport = {
+            name: 'test-transport',
+            start: jest.fn(),
+            send: jest.fn(),
+            close: jest.fn(),
+        };
+        mockClient = {
+            connect: jest.fn(),
+            getServerVersion: jest.fn(),
+        };
+        mockTransports = {
+            'test-client': mockTransport,
+        };
+        createClientFn.mockResolvedValue(mockClient);
+    });
+    afterEach(() => {
+        jest.useRealTimers();
+    });
+    describe('createClients', () => {
+        it('should create clients successfully', async () => {
+            mockClient.connect.mockResolvedValue(undefined);
+            mockClient.getServerVersion.mockResolvedValue({ name: 'test-server', version: '1.0.0' });
+            const clientsPromise = createClients(mockTransports);
+            await jest.runAllTimersAsync();
+            const clients = await clientsPromise;
+            expect(clients['test-client']).toBeDefined();
+            expect(clients['test-client'].status).toBe(ClientStatus.Connected);
+            expect(clients['test-client'].transport).toBe(mockTransport);
+            expect(logger.info).toHaveBeenCalledWith('Client created for test-client');
+        });
+        it('should handle client connection failure after retries', async () => {
+            const error = new Error('Connection failed');
+            mockClient.connect.mockRejectedValue(error);
+            const clientsPromise = createClients(mockTransports);
+            // Run through all retry attempts
+            for (let i = 0; i < CONNECTION_RETRY.MAX_ATTEMPTS; i++) {
+                await jest.advanceTimersByTimeAsync(CONNECTION_RETRY.INITIAL_DELAY_MS * Math.pow(2, i));
+            }
+            const clients = await clientsPromise;
+            expect(clients['test-client'].status).toBe(ClientStatus.Error);
+            expect(clients['test-client'].lastError).toBeInstanceOf(ClientConnectionError);
+            expect(clients['test-client'].lastError?.message).toContain('Connection failed');
+            expect(mockClient.connect).toHaveBeenCalledTimes(CONNECTION_RETRY.MAX_ATTEMPTS);
+        });
+        it('should prevent circular dependency with MCP server', async () => {
+            mockClient.connect.mockResolvedValue(undefined);
+            mockClient.getServerVersion.mockResolvedValue({ name: MCP_SERVER_NAME, version: '1.0.0' });
+            const clientsPromise = createClients(mockTransports);
+            await jest.runAllTimersAsync();
+            const clients = await clientsPromise;
+            expect(clients['test-client'].status).toBe(ClientStatus.Error);
+            expect(clients['test-client'].lastError).toBeInstanceOf(ClientConnectionError);
+            expect(clients['test-client'].lastError?.message).toContain('circular dependency');
+        });
+    });
+    describe('getClient', () => {
+        let clients;
+        beforeEach(async () => {
+            clients = await createClients(mockTransports);
+        });
+        it('should return client info for existing client', () => {
+            const clientInfo = getClient(clients, 'test-client');
+            expect(clientInfo).toBeDefined();
+            expect(clientInfo.name).toBe('test-client');
+        });
+        it('should throw ClientNotFoundError for non-existent client', () => {
+            expect(() => getClient(clients, 'non-existent')).toThrow(ClientNotFoundError);
+        });
+    });
+    describe('executeOperation', () => {
+        it('should execute operation successfully', async () => {
+            const operation = jest.fn().mockResolvedValue('result');
+            const result = await executeOperation(operation, 'test-context');
+            expect(result).toBe('result');
+            expect(operation).toHaveBeenCalled();
+        });
+        it('should retry failed operations', async () => {
+            const error = new Error('Operation failed');
+            const operation = jest.fn().mockRejectedValueOnce(error).mockResolvedValueOnce('result');
+            const operationPromise = executeOperation(operation, 'test-context', { retryCount: 1, retryDelay: 1000 });
+            // Advance timer by retry delay
+            await jest.advanceTimersByTimeAsync(1000);
+            const result = await operationPromise;
+            expect(result).toBe('result');
+            expect(operation).toHaveBeenCalledTimes(2);
+            expect(logger.info).toHaveBeenCalledWith(expect.stringContaining('Retrying operation'));
+        });
+        it('should throw error after max retries', async () => {
+            const error = new Error('Operation failed');
+            const operation = jest.fn().mockRejectedValue(error);
+            const operationPromise = executeOperation(operation, 'test-context', { retryCount: 2, retryDelay: 1000 });
+            // Create rejection assertion before advancing timers
+            const rejection = expect(operationPromise).rejects.toMatchObject({
+                message: 'Error executing operation on test-context',
+                data: { originalError: error },
+            });
+            // Advance timer for each retry
+            for (let i = 0; i < 2; i++) {
+                await jest.advanceTimersByTimeAsync(1000);
+            }
+            // Wait for the rejection assertion
+            await rejection;
+            expect(operation).toHaveBeenCalledTimes(3); // Initial try + 2 retries
+            expect(logger.error).toHaveBeenCalled();
+        });
+    });
+    describe('executeClientOperation', () => {
+        let clients;
+        beforeEach(async () => {
+            clients = await createClients(mockTransports);
+        });
+        it('should execute client operation successfully', async () => {
+            const operation = jest.fn().mockResolvedValue('result');
+            const result = await executeClientOperation(clients, 'test-client', operation);
+            expect(result).toBe('result');
+            expect(operation).toHaveBeenCalledWith(clients['test-client']);
+        });
+        it('should throw error for non-existent client', async () => {
+            const operation = jest.fn();
+            await expect(executeClientOperation(clients, 'non-existent', operation)).rejects.toThrow(ClientNotFoundError);
+        });
+    });
+    describe('executeServerOperation', () => {
+        let mockServer;
+        beforeEach(() => {
+            mockServer = {
+                server: {
+                    request: jest.fn().mockResolvedValue('result'),
+                },
+            };
+        });
+        it('should execute server operation successfully', async () => {
+            const operation = jest.fn().mockResolvedValue('result');
+            const result = await executeServerOperation(mockServer, operation);
+            expect(result).toBe('result');
+            expect(operation).toHaveBeenCalledWith(mockServer);
+        });
+        it('should handle server operation failure', async () => {
+            const error = new Error('Server operation failed');
+            const operation = jest.fn().mockRejectedValue(error);
+            await expect(executeServerOperation(mockServer, operation)).rejects.toThrow(MCPError);
+        });
+    });
+});

package/build/config/configManager.test.js

@@ -1,6 +1,11 @@
 import fs from 'fs';
 import path from 'path';
-// Mock modules before importing ConfigManager
+import { ConfigManager, ConfigChangeEvent } from './configManager.js';
+import { DEFAULT_CONFIG } from '../constants.js';
+import { setupCommonJestMocks } from '../test-utils/mocks/commonMocks.js';
+import { testConfig } from '../test-utils/fixtures/commonFixtures.js';
+import { clearAllMocks, createEventEmitterSpy } from '../test-utils/helpers/testHelpers.js';
+// Mock modules
 jest.mock('fs', () => ({
     existsSync: jest.fn(),
     mkdirSync: jest.fn(),
@@ -8,33 +13,20 @@ jest.mock('fs', () => ({
     readFileSync: jest.fn(),
     watch: jest.fn(() => ({ close: jest.fn() })),
 }));
-const mockLogger = {
-    error: jest.fn(),
-    warn: jest.fn(),
-    info: jest.fn(),
-    debug: jest.fn(),
-    level: 'info',
-    transports: [],
-};
-jest.doMock('../logger/logger.js', () => ({
-    __esModule: true,
-    default: mockLogger,
-}));
+// Setup common mocks
+setupCommonJestMocks();
 // Mock constants
-jest.doMock('../constants.js', () => ({
+jest.mock('../constants.js', () => ({
     __esModule: true,
     DEFAULT_CONFIG: { mcpServers: {} },
     getGlobalConfigPath: jest.fn(),
     getGlobalConfigDir: jest.fn().mockReturnValue('/test'),
 }));
-// Import after mocks are set up
-import { ConfigManager, ConfigChangeEvent } from './configManager.js';
-import { DEFAULT_CONFIG } from '../constants.js';
 describe('ConfigManager', () => {
     const testConfigPath = '/test/config.json';
     beforeEach(() => {
-        // Reset all mocks
-        jest.clearAllMocks();
+        // Reset all mocks and timers
+        clearAllMocks();
         // Reset singleton instance
         ConfigManager.instance = undefined;
         // Default mock implementations
@@ -80,22 +72,16 @@ describe('ConfigManager', () => {
             });
             instance.startWatching();
             // Setup spy for event emission
-            const emitSpy = jest.spyOn(instance, 'emit');
+            const emitSpy = createEventEmitterSpy(instance);
             // Mock new config data
-            const newConfig = { mcpServers: { test: { url: 'test-url' } } };
-            fs.readFileSync.mockReturnValueOnce(JSON.stringify(newConfig));
+            fs.readFileSync.mockReturnValueOnce(JSON.stringify(testConfig));
             // Simulate file change
             watchCallback('change', path.basename(testConfigPath));
-            expect(emitSpy).toHaveBeenCalledWith(ConfigChangeEvent.TRANSPORT_CONFIG_CHANGED, newConfig.mcpServers);
+            expect(emitSpy).toHaveBeenCalledWith(ConfigChangeEvent.TRANSPORT_CONFIG_CHANGED, testConfig.mcpServers);
         });
     });
     describe('getTransportConfig', () => {
         it('should return copy of transport config', () => {
-            const testConfig = {
-                mcpServers: {
-                    test: { url: 'test-url' },
-                },
-            };
             fs.readFileSync.mockReturnValueOnce(JSON.stringify(testConfig));
             const instance = ConfigManager.getInstance(testConfigPath);
             const config = instance.getTransportConfig();

package/build/constants.js

@@ -23,7 +23,7 @@ export const ERROR_CODES = {
 // MCP constants
 export const MCP_CONFIG_FILE = 'mcp.json';
 export const MCP_SERVER_NAME = '1mcp';
-export const MCP_SERVER_VERSION = '0.4.0';
+export const MCP_SERVER_VERSION = '0.7.0';
 export const MCP_URI_SEPARATOR = '_1mcp_';
 // Global config paths
 export const CONFIG_DIR_NAME = '1mcp';

package/build/handlers/requestHandlers.js

@@ -1,11 +1,10 @@
-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 { 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 } from '../clients/clientManager.js';
+import { executeClientOperation, executeServerOperation } from '../clients/clientManager.js';
 import { parseUri, withErrorHandling } from '../utils/errorHandling.js';
 import { MCPError } from '../utils/errorTypes.js';
-import { filterClientsByTags } from '../utils/clientFiltering.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
@@ -29,6 +28,25 @@ function sendPartialFailureNotification(serverInfo, 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
@@ -36,24 +54,20 @@ function sendPartialFailureNotification(serverInfo, operation, failedClients) {
  * @param capabilities The server capabilities
  * @param tags Array of tags to filter clients by
  */
-export function registerRequestHandlers(clients, serverInfo, capabilities) {
+export function registerRequestHandlers(clients, serverInfo) {
     // Register logging level handler
     serverInfo.server.setRequestHandler(SetLevelRequestSchema, async (request) => {
         setLogLevel(request.params.level);
         return {};
     });
-    // Register resource-related handlers if capability is available
-    if (capabilities.resources) {
-        registerResourceHandlers(clients, serverInfo);
-    }
-    // Register tool-related handlers if capability is available
-    if (capabilities.tools) {
-        registerToolHandlers(clients, serverInfo);
-    }
-    // Register prompt-related handlers if capability is available
-    if (capabilities.prompts) {
-        registerPromptHandlers(clients, serverInfo);
-    }
+    // 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
@@ -65,7 +79,7 @@ function registerResourceHandlers(clients, serverInfo) {
     serverInfo.server.setRequestHandler(ListResourcesRequestSchema, withErrorHandling(async (request) => {
         const resources = [];
         const failedClients = [];
-        const filteredClients = filterClientsByTags(clients, serverInfo.tags);
+        const filteredClients = filterClients(byCapabilities({ resources: {} }), byTags(serverInfo.tags))(clients);
         for (const [name, clientInfo] of Object.entries(filteredClients)) {
             logger.info(`Listing resources for ${name}`);
             try {
@@ -84,9 +98,9 @@ function registerResourceHandlers(clients, serverInfo) {
                 failedClients.push({ name, error: error instanceof Error ? error.message : String(error) });
             }
         }
-        // If all clients failed, throw an error
+        // 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 clients', ERROR_CODES.INTERNAL_SERVER_ERROR, {
+            throw new MCPError('Failed to list resources from all capable clients', ERROR_CODES.INTERNAL_SERVER_ERROR, {
                 failedClients,
             });
         }
@@ -100,8 +114,8 @@ function registerResourceHandlers(clients, serverInfo) {
     serverInfo.server.setRequestHandler(ListResourceTemplatesRequestSchema, withErrorHandling(async (request) => {
         const resourceTemplates = [];
         const failedClients = [];
-        const filteredClients = filterClientsByTags(clients, serverInfo.tags);
-        for (const [name, clientInfo] of Object.entries(filteredClients)) {
+        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 clientInfo.client.listResourceTemplates(request.params, {
@@ -120,7 +134,7 @@ function registerResourceHandlers(clients, serverInfo) {
             }
         }
         // If all clients failed, throw an error
-        if (failedClients.length === Object.keys(filteredClients).length && Object.keys(filteredClients).length > 0) {
+        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,
             });
@@ -163,8 +177,8 @@ function registerToolHandlers(clients, serverInfo) {
     serverInfo.server.setRequestHandler(ListToolsRequestSchema, withErrorHandling(async (request) => {
         const tools = [];
         const failedClients = [];
-        const filteredClients = filterClientsByTags(clients, serverInfo.tags);
-        for (const [name, clientInfo] of Object.entries(filteredClients)) {
+        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 clientInfo.client.listTools(request.params, {
@@ -182,7 +196,7 @@ function registerToolHandlers(clients, serverInfo) {
             }
         }
         // If all clients failed, throw an error
-        if (failedClients.length === Object.keys(filteredClients).length && Object.keys(filteredClients).length > 0) {
+        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,
             });
@@ -211,8 +225,8 @@ function registerPromptHandlers(clients, serverInfo) {
     serverInfo.server.setRequestHandler(ListPromptsRequestSchema, withErrorHandling(async (request) => {
         const prompts = [];
         const failedClients = [];
-        const filteredClients = filterClientsByTags(clients, serverInfo.tags);
-        for (const [name, clientInfo] of Object.entries(filteredClients)) {
+        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 clientInfo.client.listPrompts(request.params);
@@ -228,7 +242,7 @@ function registerPromptHandlers(clients, serverInfo) {
             }
         }
         // If all clients failed, throw an error
-        if (failedClients.length === Object.keys(filteredClients).length && Object.keys(filteredClients).length > 0) {
+        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,
             });

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,7 +27,9 @@ 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,
         }),
     ],
@@ -54,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/test-utils/fixtures/commonFixtures.js

@@ -0,0 +1,44 @@
+import { createMockTransport } from '../mocks/commonMocks.js';
+// Common test clients fixture
+export const createTestClients = () => ({
+    client1: {
+        capabilities: {
+            resources: {},
+            tools: {},
+        },
+        transport: createMockTransport(),
+    },
+    client2: {
+        capabilities: {
+            resources: {},
+        },
+        transport: createMockTransport(),
+    },
+    client3: {
+        capabilities: {
+            tools: {},
+        },
+        transport: createMockTransport(),
+    },
+    clientNoCapabilities: {
+        transport: createMockTransport(),
+    },
+    clientNoTags: {
+        capabilities: {
+            resources: {},
+        },
+        transport: createMockTransport(),
+    },
+});
+// Common test config fixture
+export const testConfig = {
+    mcpServers: {
+        test: { url: 'test-url' },
+    },
+};
+// Common test capabilities fixture
+export const testCapabilities = {
+    resources: {},
+    tools: {},
+    test: true,
+};

package/build/test-utils/helpers/testHelpers.js

@@ -0,0 +1,23 @@
+// Helper to clear all mocks in a test
+export const clearAllMocks = () => {
+    jest.clearAllMocks();
+    jest.useRealTimers();
+};
+// Helper to setup fake timers
+export const setupFakeTimers = () => {
+    jest.useFakeTimers();
+};
+// Helper to advance timers by time
+export const advanceTimersByTime = async (ms) => {
+    await jest.advanceTimersByTimeAsync(ms);
+};
+// Helper to run all timers
+export const runAllTimers = async () => {
+    await jest.runAllTimersAsync();
+};
+// Helper to create a mock event emitter spy
+export const createEventEmitterSpy = (instance) => {
+    return jest.spyOn(instance, 'emit');
+};
+// Helper to wait for next tick
+export const waitForNextTick = () => new Promise((resolve) => process.nextTick(resolve));

package/build/test-utils/mocks/commonMocks.js

@@ -0,0 +1,65 @@
+// Mock Logger
+export const mockLogger = {
+    info: jest.fn(),
+    error: jest.fn(),
+    warn: jest.fn(),
+    debug: jest.fn(),
+    level: 'info',
+    transports: [],
+};
+// Mock Transport
+export const createMockTransport = () => ({
+    start: jest.fn(),
+    send: jest.fn(),
+    close: jest.fn(),
+});
+// Mock Server
+export const createMockServer = (overrides = {}) => ({
+    connect: jest.fn().mockResolvedValue(undefined),
+    transport: createMockTransport(),
+    ...overrides,
+});
+// Mock Client
+export const createMockClient = (overrides = {}) => ({
+    connect: jest.fn(),
+    getServerVersion: jest.fn(),
+    ...overrides,
+});
+// Mock File System
+export const createMockFs = () => ({
+    existsSync: jest.fn(),
+    mkdirSync: jest.fn(),
+    writeFileSync: jest.fn(),
+    readFileSync: jest.fn(),
+    watch: jest.fn(() => ({ close: jest.fn() })),
+});
+// Mock Config
+export const createMockConfig = (overrides = {}) => ({
+    name: 'test-server',
+    version: '1.0.0',
+    ...overrides,
+});
+// Mock Capabilities
+export const createMockCapabilities = (overrides = {}) => ({
+    capabilities: {
+        resources: {},
+        tools: {},
+        ...overrides,
+    },
+});
+// Jest module mocks setup helper
+export const setupCommonJestMocks = () => {
+    jest.mock('@modelcontextprotocol/sdk/server/index.js', () => ({
+        Server: jest.fn(),
+    }));
+    jest.mock('@modelcontextprotocol/sdk/client/index.js', () => ({
+        Client: jest.fn(),
+    }));
+    jest.mock('@modelcontextprotocol/sdk/shared/transport.js', () => ({
+        Transport: jest.fn(),
+    }));
+    jest.mock('../../logger/logger.js', () => ({
+        __esModule: true,
+        default: mockLogger,
+    }));
+};

package/build/utils/clientFiltering.js

@@ -27,3 +27,75 @@ export function filterClientsByTags(clients, tags) {
     }
     return Object.freeze(filteredClients);
 }
+/**
+ * Filters clients by capabilities
+ * @param clients Record of client instances
+ * @param capabilities Object containing capabilities to filter by
+ * @returns Filtered record of client instances
+ */
+export function filterClientsByCapabilities(clients, capabilities) {
+    const filteredClients = {};
+    let matchedClients = 0;
+    for (const [name, clientInfo] of Object.entries(clients)) {
+        const clientCapabilities = clientInfo.capabilities || {};
+        const hasMatchingCapabilities = Object.keys(capabilities).every((capability) => {
+            const clientCapability = clientCapabilities[capability];
+            return clientCapability !== undefined;
+        });
+        if (hasMatchingCapabilities) {
+            filteredClients[name] = clientInfo;
+            matchedClients++;
+        }
+    }
+    if (matchedClients === 0) {
+        logger.warn(`No clients found matching capabilities: ${JSON.stringify(capabilities)}`);
+    }
+    else {
+        logger.debug(`Found ${matchedClients} clients matching capabilities: ${JSON.stringify(capabilities)}`);
+    }
+    return Object.freeze(filteredClients);
+}
+/**
+ * Filters clients by multiple criteria
+ * @param filters Array of client filters
+ * @returns Filtered record of client instances
+ */
+export function filterClients(...filters) {
+    return (clients) => {
+        return filters.reduce((filteredClients, filter) => filter(filteredClients), clients);
+    };
+}
+/**
+ * Filters clients by capabilities
+ * @param requiredCapabilities Object containing capabilities to filter by
+ * @returns Filtered record of client instances
+ */
+export function byCapabilities(requiredCapabilities) {
+    return (clients) => {
+        return Object.entries(clients).reduce((filtered, [name, clientInfo]) => {
+            const hasCapabilities = Object.keys(requiredCapabilities).every((cap) => clientInfo.capabilities && cap in clientInfo.capabilities);
+            if (hasCapabilities) {
+                filtered[name] = clientInfo;
+            }
+            return filtered;
+        }, {});
+    };
+}
+/**
+ * Filters clients by tags
+ * @param tags Array of tags to filter by
+ * @returns Filtered record of client instances
+ */
+export function byTags(tags) {
+    return (clients) => {
+        if (!tags || tags.length === 0)
+            return clients;
+        return Object.entries(clients).reduce((filtered, [name, clientInfo]) => {
+            const hasMatchingTags = tags.every((tag) => clientInfo.transport.tags?.includes(tag));
+            if (hasMatchingTags) {
+                filtered[name] = clientInfo;
+            }
+            return filtered;
+        }, {});
+    };
+}

package/build/utils/clientFiltering.test.js

@@ -0,0 +1,124 @@
+import { filterClients, byCapabilities, byTags, filterClientsByCapabilities, filterClientsByTags, } from './clientFiltering.js';
+describe('Client Filtering Utils', () => {
+    const mockClients = {
+        client1: {
+            capabilities: {
+                resources: {},
+                tools: {},
+            },
+            transport: {
+                tags: ['tag1', 'tag2'],
+            },
+        },
+        client2: {
+            capabilities: {
+                resources: {},
+            },
+            transport: {
+                tags: ['tag1'],
+            },
+        },
+        client3: {
+            capabilities: {
+                tools: {},
+            },
+            transport: {
+                tags: ['tag3'],
+            },
+        },
+        clientNoCapabilities: {
+            transport: {
+                tags: ['tag1'],
+            },
+        },
+        clientNoTags: {
+            capabilities: {
+                resources: {},
+            },
+            transport: {},
+        },
+    };
+    describe('filterClientsByCapabilities', () => {
+        it('should filter clients by single capability', () => {
+            const filtered = filterClientsByCapabilities(mockClients, { resources: {} });
+            expect(Object.keys(filtered)).toEqual(['client1', 'client2', 'clientNoTags']);
+        });
+        it('should filter clients by multiple capabilities', () => {
+            const filtered = filterClientsByCapabilities(mockClients, { resources: {}, tools: {} });
+            expect(Object.keys(filtered)).toEqual(['client1']);
+        });
+        it('should handle clients with no capabilities', () => {
+            const filtered = filterClientsByCapabilities(mockClients, { resources: {} });
+            expect(filtered).not.toHaveProperty('clientNoCapabilities');
+        });
+        it('should return empty object when no matches found', () => {
+            const filtered = filterClientsByCapabilities(mockClients, { nonexistent: {} });
+            expect(Object.keys(filtered)).toHaveLength(0);
+        });
+    });
+    describe('filterClientsByTags', () => {
+        it('should return all clients when no tags provided', () => {
+            const filtered = filterClientsByTags(mockClients, undefined);
+            expect(Object.keys(filtered)).toEqual(Object.keys(mockClients));
+        });
+        it('should filter clients by single tag', () => {
+            const filtered = filterClientsByTags(mockClients, ['tag1']);
+            expect(Object.keys(filtered)).toEqual(['client1', 'client2', 'clientNoCapabilities']);
+        });
+        it('should filter clients by multiple tags', () => {
+            const filtered = filterClientsByTags(mockClients, ['tag1', 'tag2']);
+            expect(Object.keys(filtered)).toEqual(['client1']);
+        });
+        it('should handle clients with no tags', () => {
+            const filtered = filterClientsByTags(mockClients, ['tag1']);
+            expect(filtered).not.toHaveProperty('clientNoTags');
+        });
+        it('should return empty object when no matches found', () => {
+            const filtered = filterClientsByTags(mockClients, ['nonexistent']);
+            expect(Object.keys(filtered)).toHaveLength(0);
+        });
+    });
+    describe('filterClients (composed filters)', () => {
+        it('should chain multiple filters together', () => {
+            const filtered = filterClients(byCapabilities({ resources: {} }), byTags(['tag1']))(mockClients);
+            expect(Object.keys(filtered)).toEqual(['client1', 'client2']);
+        });
+        it('should handle empty filters array', () => {
+            const filtered = filterClients()(mockClients);
+            expect(Object.keys(filtered)).toEqual(Object.keys(mockClients));
+        });
+        it('should handle no matching results', () => {
+            const filtered = filterClients(byCapabilities({ resources: {} }), byTags(['tag3']))(mockClients);
+            expect(Object.keys(filtered)).toHaveLength(0);
+        });
+    });
+    describe('byCapabilities', () => {
+        it('should create a filter function for capabilities', () => {
+            const filter = byCapabilities({ resources: {} });
+            const filtered = filter(mockClients);
+            expect(Object.keys(filtered)).toEqual(['client1', 'client2', 'clientNoTags']);
+        });
+        it('should handle undefined capabilities safely', () => {
+            const filter = byCapabilities({ resources: {} });
+            const filtered = filter({ ...mockClients, unsafeClient: { transport: {} } });
+            expect(filtered).not.toHaveProperty('unsafeClient');
+        });
+    });
+    describe('byTags', () => {
+        it('should create a filter function for tags', () => {
+            const filter = byTags(['tag1']);
+            const filtered = filter(mockClients);
+            expect(Object.keys(filtered)).toEqual(['client1', 'client2', 'clientNoCapabilities']);
+        });
+        it('should handle undefined tags array', () => {
+            const filter = byTags(undefined);
+            const filtered = filter(mockClients);
+            expect(Object.keys(filtered)).toEqual(Object.keys(mockClients));
+        });
+        it('should handle empty tags array', () => {
+            const filter = byTags([]);
+            const filtered = filter(mockClients);
+            expect(Object.keys(filtered)).toEqual(Object.keys(mockClients));
+        });
+    });
+});

package/package.json

@@ -1,8 +1,26 @@
 {
   "name": "@1mcp/agent",
-  "version": "0.4.0",
+  "version": "0.7.0",
   "description": "One MCP server to aggregate them all - A unified Model Context Protocol server implementation",
-  "homepage": "https://1mcp.app",
+  "keywords": [
+    "mcp",
+    "mcp-server",
+    "mcp-client",
+    "model-context-protocol",
+    "agent",
+    "proxy",
+    "server",
+    "cli",
+    "ai",
+    "llm",
+    "model-aggregation",
+    "typescript"
+  ],
+  "author": "William Xu <xuzp@1mcp.app>",
+  "homepage": "https://github.com/1mcp-app/agent",
+  "bugs": {
+    "url": "https://github.com/1mcp-app/agent/issues"
+  },
   "license": "Apache-2.0",
   "repository": {
     "type": "git",
@@ -67,7 +85,7 @@
     "dev": "tsc-watch --onSuccess \"node build/index.js --config ./mcp.json\"",
     "build": "tsc && node -e \"require('fs').chmodSync('build/index.js', '755')\"",
     "watch": "tsc --watch",
-    "inspector": "npx @modelcontextprotocol/inspector build/index.js",
+    "inspector": "npx -y @modelcontextprotocol/inspector",
     "lint": "eslint . --ext .ts",
     "lint:fix": "eslint . --ext .ts --fix",
     "test": "jest",