@1mcp/agent 0.7.0 → 0.8.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@1mcp/agent",
-  "version": "0.7.0",
+  "version": "0.8.2",
   "description": "One MCP server to aggregate them all - A unified Model Context Protocol server implementation",
   "keywords": [
     "mcp",
@@ -49,7 +49,7 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.7.0",
-    "express": "^4.21.2",
+    "express": "^5.1.0",
     "uuid": "^11.1.0",
     "winston": "^3.17.0",
     "winston-transport": "^4.9.0",
@@ -61,25 +61,24 @@
     "@eslint/js": "^9.22.0",
     "@testing-library/jest-dom": "^6.6.3",
     "@types/express": "^5.0.0",
-    "@types/jest": "^29.5.14",
     "@types/node": "^22.13.10",
     "@types/uuid": "^10.0.0",
     "@types/yargs": "^17.0.33",
     "@typescript-eslint/eslint-plugin": "^8.27.0",
     "@typescript-eslint/parser": "^8.27.0",
+    "@vitest/coverage-v8": "^1.4.0",
     "eslint": "^9.22.0",
     "eslint-config-prettier": "^10.1.1",
     "eslint-plugin-prettier": "^5.2.3",
     "globals": "^16.0.0",
     "husky": "^9.1.7",
-    "jest": "^29.7.0",
     "jiti": "^2.4.2",
     "lint-staged": "^15.5.0",
     "prettier": "^3.5.3",
-    "ts-jest": "^29.2.6",
     "ts-node": "^10.9.2",
     "tsc-watch": "^6.2.1",
-    "typescript": "^5.3.3"
+    "typescript": "^5.3.3",
+    "vitest": "^1.4.0"
   },
   "scripts": {
     "dev": "tsc-watch --onSuccess \"node build/index.js --config ./mcp.json\"",
@@ -88,8 +87,8 @@
     "inspector": "npx -y @modelcontextprotocol/inspector",
     "lint": "eslint . --ext .ts",
     "lint:fix": "eslint . --ext .ts --fix",
-    "test": "jest",
-    "test:watch": "jest --watch",
-    "test:coverage": "jest --coverage"
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage"
   }
 }

package/build/clients/clientManager.test.js

@@ -1,172 +0,0 @@
-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,92 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-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(),
-    writeFileSync: jest.fn(),
-    readFileSync: jest.fn(),
-    watch: jest.fn(() => ({ close: jest.fn() })),
-}));
-// Setup common mocks
-setupCommonJestMocks();
-// Mock constants
-jest.mock('../constants.js', () => ({
-    __esModule: true,
-    DEFAULT_CONFIG: { mcpServers: {} },
-    getGlobalConfigPath: jest.fn(),
-    getGlobalConfigDir: jest.fn().mockReturnValue('/test'),
-}));
-describe('ConfigManager', () => {
-    const testConfigPath = '/test/config.json';
-    beforeEach(() => {
-        // Reset all mocks and timers
-        clearAllMocks();
-        // Reset singleton instance
-        ConfigManager.instance = undefined;
-        // Default mock implementations
-        fs.existsSync.mockReturnValue(true);
-        fs.readFileSync.mockReturnValue(JSON.stringify({ mcpServers: {} }));
-    });
-    describe('getInstance', () => {
-        it('should create singleton instance', () => {
-            const instance1 = ConfigManager.getInstance(testConfigPath);
-            const instance2 = ConfigManager.getInstance(testConfigPath);
-            expect(instance1).toBe(instance2);
-        });
-        it('should use provided config path', () => {
-            const instance = ConfigManager.getInstance(testConfigPath);
-            expect(instance.configFilePath).toBe(testConfigPath);
-        });
-    });
-    describe('ensureConfigExists', () => {
-        it('should create config directory and file if they do not exist', () => {
-            fs.existsSync
-                .mockReturnValueOnce(false) // Directory doesn't exist
-                .mockReturnValueOnce(false); // File doesn't exist
-            ConfigManager.getInstance(testConfigPath);
-            expect(fs.mkdirSync).toHaveBeenCalledWith(path.dirname(testConfigPath), { recursive: true });
-            expect(fs.writeFileSync).toHaveBeenCalledWith(testConfigPath, JSON.stringify(DEFAULT_CONFIG, null, 2));
-        });
-    });
-    describe('config watching', () => {
-        it('should start and stop watching config file', () => {
-            const instance = ConfigManager.getInstance(testConfigPath);
-            instance.startWatching();
-            expect(fs.watch).toHaveBeenCalledWith(testConfigPath, expect.any(Function));
-            instance.stopWatching();
-            expect(instance['configWatcher']).toBeNull();
-        });
-        it('should reload config on file change', () => {
-            const instance = ConfigManager.getInstance(testConfigPath);
-            const mockWatcher = { close: jest.fn() };
-            let watchCallback = () => { };
-            fs.watch.mockImplementation((path, callback) => {
-                watchCallback = callback;
-                return mockWatcher;
-            });
-            instance.startWatching();
-            // Setup spy for event emission
-            const emitSpy = createEventEmitterSpy(instance);
-            // Mock new config data
-            fs.readFileSync.mockReturnValueOnce(JSON.stringify(testConfig));
-            // Simulate file change
-            watchCallback('change', path.basename(testConfigPath));
-            expect(emitSpy).toHaveBeenCalledWith(ConfigChangeEvent.TRANSPORT_CONFIG_CHANGED, testConfig.mcpServers);
-        });
-    });
-    describe('getTransportConfig', () => {
-        it('should return copy of transport config', () => {
-            fs.readFileSync.mockReturnValueOnce(JSON.stringify(testConfig));
-            const instance = ConfigManager.getInstance(testConfigPath);
-            const config = instance.getTransportConfig();
-            expect(config).toEqual(testConfig.mcpServers);
-            expect(config).not.toBe(instance['transportConfig']); // Should be a copy
-        });
-    });
-});

package/build/logger/mcpTransport.js

@@ -1,150 +0,0 @@
-import Transport from 'winston-transport';
-// Map Winston log levels to MCP log levels
-const LOG_LEVEL_MAP = {
-    error: 'error',
-    warn: 'warning',
-    info: 'info',
-    verbose: 'debug',
-    debug: 'debug',
-    silly: 'debug',
-};
-/**
- * Winston transport for sending logs to MCP clients
- */
-export class MCPTransport extends Transport {
-    server;
-    loggerName;
-    connected = false;
-    constructor(options) {
-        super(options);
-        this.server = options.server;
-        this.loggerName = options.loggerName || '1mcp';
-        // Set up connection status handlers
-        this.setupConnectionHandlers();
-    }
-    /**
-     * Set up handlers for connection status changes
-     */
-    setupConnectionHandlers() {
-        // Handle connection close
-        this.server.onclose = () => {
-            this.setConnected(false);
-        };
-    }
-    /**
-     * Set the connection status of the transport
-     * @param connected Whether the server is connected
-     */
-    setConnected(connected) {
-        const previousState = this.connected;
-        this.connected = connected;
-        // Log connection state changes
-        if (previousState !== connected) {
-            console.debug(`MCP Transport connection state changed to: ${connected ? 'connected' : 'disconnected'}`);
-        }
-    }
-    /**
-     * Send a log notification to the MCP client
-     * @param info The log info object
-     * @returns true if the notification was sent, false otherwise
-     */
-    sendLogNotification(info) {
-        if (!this.server || !this.connected) {
-            return false;
-        }
-        // Map Winston log level to MCP log level
-        const level = LOG_LEVEL_MAP[info.level] || 'info';
-        const sanitizedData = this.sanitizeData(info);
-        // Extract message and metadata
-        const { message, level: _, ...meta } = sanitizedData;
-        // Create MCP logging notification
-        const notification = {
-            method: 'notifications/message',
-            params: {
-                level,
-                message: typeof message === 'string' ? message : JSON.stringify(message),
-                logger: this.loggerName,
-                data: Object.keys(meta).length > 0 ? meta : undefined,
-            },
-        };
-        // Send notification to MCP clients
-        try {
-            this.server.notification(notification);
-            return true;
-        }
-        catch (error) {
-            console.error('Failed to send log notification to MCP client:', error);
-            return false;
-        }
-    }
-    /**
-     * Sanitize log data to remove sensitive information
-     * @param data The data to sanitize
-     * @returns Sanitized data
-     */
-    sanitizeData(data) {
-        if (typeof data !== 'object' || data === null) {
-            return data;
-        }
-        // List of potentially sensitive field names
-        const sensitiveFields = [
-            'password',
-            'token',
-            'secret',
-            'key',
-            'credential',
-            'auth',
-            'apiKey',
-            'api_key',
-            'accessToken',
-            'access_token',
-            'jwt',
-            'ssn',
-            'creditCard',
-            'credit_card',
-            'cvv',
-            'pin',
-        ];
-        if (Array.isArray(data)) {
-            return data.map((item) => this.sanitizeData(item));
-        }
-        const sanitized = {};
-        for (const [key, value] of Object.entries(data)) {
-            // Check if this is a sensitive field
-            const isSensitive = sensitiveFields.some((field) => key.toLowerCase().includes(field.toLowerCase()));
-            if (isSensitive) {
-                sanitized[key] = '[REDACTED]';
-            }
-            else if (typeof value === 'object' && value !== null) {
-                sanitized[key] = this.sanitizeData(value);
-            }
-            else {
-                sanitized[key] = value;
-            }
-        }
-        return sanitized;
-    }
-    log(info, callback) {
-        setImmediate(() => {
-            this.emit('logged', info);
-        });
-        // Only try to send if connected
-        if (this.connected) {
-            try {
-                this.sendLogNotification(info);
-            }
-            catch (_) {
-                // Ignore any errors during log sending
-            }
-        }
-        // Always call the callback to prevent blocking
-        callback();
-    }
-    /**
-     * Clean up resources when the transport is closed
-     */
-    close() {
-        this.setConnected(false);
-        this.server.onclose = undefined;
-    }
-}

package/build/serverManager.test.js

@@ -1,158 +0,0 @@
-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();
-        });
-    });
-});

package/build/test-utils/fixtures/commonFixtures.js

@@ -1,44 +0,0 @@
-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,
-};