@loop_ouroboros/mcp-hub-lite 1.0.0

package/dist/server/src/utils/transports/transport-factory.d.ts

@@ -0,0 +1,26 @@
+import type { ServerConfig } from '../../config/config.schema.js';
+/**
+ * Transport Factory - creates appropriate transport client based on server configuration
+ */
+export declare class TransportFactory {
+    /**
+     * Create transport client
+     * @param server Server configuration, including base configuration and instance configuration
+     * @param serverId Optional server ID for log storage integration
+     * @returns Transport client instance
+     * @throws Error if server type is not supported or configuration is invalid
+     */
+    static createTransport(server: ServerConfig & {
+        name: string;
+    }, serverId?: string): import('@modelcontextprotocol/sdk/shared/transport.js').Transport;
+    /**
+     * Build system environment variables
+     * Add necessary system environment variables for stdio transport
+     */
+    private static buildSystemEnv;
+    /**
+     * Validate and convert server configuration to transport configuration
+     */
+    private static validateAndConvertConfig;
+}
+//# sourceMappingURL=transport-factory.d.ts.map

package/dist/server/src/utils/transports/transport-factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transport-factory.d.ts","sourceRoot":"","sources":["../../../../../src/utils/transports/transport-factory.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAG7D;;GAEG;AACH,qBAAa,gBAAgB;IAC3B;;;;;;OAMG;IACH,MAAM,CAAC,eAAe,CACpB,MAAM,EAAE,YAAY,GAAG;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,EACvC,QAAQ,CAAC,EAAE,MAAM,GAChB,OAAO,+CAA+C,EAAE,SAAS;IAmDpE;;;OAGG;IACH,OAAO,CAAC,MAAM,CAAC,cAAc;IAI7B;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,wBAAwB;CA4CxC"}

package/dist/server/src/utils/transports/transport-factory.js

@@ -0,0 +1,104 @@
+import { StdioTransport } from './stdio-transport.js';
+import { SseTransport } from './sse-transport.js';
+import { StreamableHttpTransport } from './streamable-http-transport.js';
+import { logStorage } from '../../services/log-storage.service.js';
+/**
+ * Transport Factory - creates appropriate transport client based on server configuration
+ */
+export class TransportFactory {
+    /**
+     * Create transport client
+     * @param server Server configuration, including base configuration and instance configuration
+     * @param serverId Optional server ID for log storage integration
+     * @returns Transport client instance
+     * @throws Error if server type is not supported or configuration is invalid
+     */
+    static createTransport(server, serverId) {
+        const transportConfig = this.validateAndConvertConfig(server);
+        // Use type assertion to ensure TypeScript can correctly infer types
+        const config = transportConfig;
+        switch (config.type) {
+            case 'stdio':
+                if (!config.command) {
+                    throw new Error('STDIO transport requires a command');
+                }
+                return new StdioTransport({
+                    command: config.command,
+                    args: config.args,
+                    env: config.env,
+                    cwd: process.cwd(),
+                    stderr: 'pipe'
+                }, server.name, {
+                    serverId,
+                    logStorage: serverId ? logStorage : undefined
+                });
+            case 'sse':
+                if (!config.url) {
+                    throw new Error('SSE transport requires a URL');
+                }
+                return new SseTransport(config.url, config.headers, config.reconnectInterval, config.maxReconnectAttempts);
+            case 'streamable-http':
+            case 'http': // Compatibility with http type, treat as streamable-http
+                if (!config.url) {
+                    throw new Error('Streamable HTTP transport requires a URL');
+                }
+                return new StreamableHttpTransport(config.url, config.headers, config.timeout);
+            default:
+                throw new Error(`Unsupported transport type: ${config.type || 'undefined'}`);
+        }
+    }
+    /**
+     * Build system environment variables
+     * Add necessary system environment variables for stdio transport
+     */
+    static buildSystemEnv() {
+        return {};
+    }
+    /**
+     * Validate and convert server configuration to transport configuration
+     */
+    static validateAndConvertConfig(server) {
+        const type = server.type || 'stdio';
+        if (type === 'stdio') {
+            return {
+                type: 'stdio',
+                command: server.command || '',
+                args: server.args,
+                env: {
+                    ...this.buildSystemEnv(), // System environment variables
+                    ...(server.env || {}) // User-defined environment variables (can override system defaults)
+                },
+                cwd: process.cwd(),
+                stderr: 'pipe'
+            };
+        }
+        else if (type === 'sse') {
+            return {
+                type: 'sse',
+                url: server.url || '',
+                headers: server.env, // Reuse env as headers for simplicity
+                reconnectInterval: 3000,
+                maxReconnectAttempts: 5
+            };
+        }
+        else if (type === 'streamable-http' || type === 'http') {
+            return {
+                type: 'streamable-http', // Unified conversion to streamable-http
+                url: server.url || '',
+                headers: server.env,
+                timeout: server.timeout || 30000
+            };
+        }
+        else {
+            // Default to stdio type to avoid returning never type
+            return {
+                type: 'stdio',
+                command: '',
+                args: [],
+                env: this.buildSystemEnv(),
+                cwd: process.cwd(),
+                stderr: 'pipe'
+            };
+        }
+    }
+}

package/dist/server/src/utils/transports/transport.interface.d.ts

@@ -0,0 +1,35 @@
+/**
+ * STDIO transport configuration
+ */
+export interface StdioTransportConfig {
+    type: 'stdio';
+    command: string;
+    args?: string[];
+    env?: Record<string, string>;
+    cwd?: string;
+    stderr?: 'inherit' | 'pipe' | 'ignore';
+}
+/**
+ * SSE transport configuration
+ */
+export interface SseTransportConfig {
+    type: 'sse';
+    url: string;
+    headers?: Record<string, string>;
+    reconnectInterval?: number;
+    maxReconnectAttempts?: number;
+}
+/**
+ * Streamable HTTP transport configuration
+ */
+export interface StreamableHttpTransportConfig {
+    type: 'streamable-http' | 'http';
+    url: string;
+    headers?: Record<string, string>;
+    timeout?: number;
+}
+/**
+ * Generic server configuration
+ */
+export type ServerTransportConfig = StdioTransportConfig | SseTransportConfig | StreamableHttpTransportConfig;
+//# sourceMappingURL=transport.interface.d.ts.map

package/dist/server/src/utils/transports/transport.interface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transport.interface.d.ts","sourceRoot":"","sources":["../../../../../src/utils/transports/transport.interface.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,IAAI,EAAE,OAAO,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC7B,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,SAAS,GAAG,MAAM,GAAG,QAAQ,CAAC;CACxC;AAED;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,KAAK,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,oBAAoB,CAAC,EAAE,MAAM,CAAC;CAC/B;AAED;;GAEG;AACH,MAAM,WAAW,6BAA6B;IAC5C,IAAI,EAAE,iBAAiB,GAAG,MAAM,CAAC;IACjC,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;GAEG;AACH,MAAM,MAAM,qBAAqB,GAC7B,oBAAoB,GACpB,kBAAkB,GAClB,6BAA6B,CAAC"}

package/dist/server/src/utils/transports/transport.interface.js

@@ -0,0 +1 @@
+export {};

package/dist/server/tests/contract/mcp-protocol/initialize.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=initialize.test.d.ts.map

package/dist/server/tests/contract/mcp-protocol/initialize.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"initialize.test.d.ts","sourceRoot":"","sources":["../../../../../tests/contract/mcp-protocol/initialize.test.ts"],"names":[],"mappings":""}

package/dist/server/tests/contract/mcp-protocol/initialize.test.js

@@ -0,0 +1,103 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { mcpConnectionManager } from '../../../src/services/mcp-connection-manager.js';
+import { hubManager } from '../../../src/services/hub-manager.service.js';
+// Mock MCP SDK
+vi.mock('@modelcontextprotocol/sdk/client/index.js', () => {
+    return {
+        Client: class {
+            connect = vi.fn().mockResolvedValue(undefined);
+            close = vi.fn().mockResolvedValue(undefined);
+            listTools = vi.fn().mockResolvedValue({
+                tools: [
+                    {
+                        name: 'echo',
+                        description: 'Echo the input',
+                        inputSchema: {
+                            type: 'object',
+                            properties: { message: { type: 'string' } }
+                        }
+                    }
+                ]
+            });
+            getServerVersion = vi.fn().mockReturnValue({ name: 'Test SDK Server', version: '1.0.0' });
+        }
+    };
+});
+// Mock transport
+vi.mock('@utils/transports/transport-factory.js', () => {
+    return {
+        TransportFactory: {
+            createTransport: vi.fn().mockReturnValue({
+                onclose: null,
+                onstdout: null,
+                onstderr: null,
+                close: vi.fn().mockResolvedValue(undefined)
+            })
+        }
+    };
+});
+describe('MCP Protocol Contract - initialize (with SDK)', () => {
+    const serverName = 'test-sdk-server';
+    let serverId;
+    beforeEach(async () => {
+        // Add to hub manager
+        await hubManager.addServer(serverName, {
+            command: 'node',
+            args: [],
+            enabled: true,
+            type: 'stdio',
+            timeout: 60000,
+            allowedTools: []
+        });
+        // Add server instance
+        const instance = await hubManager.addServerInstance(serverName, {});
+        serverId = instance.id;
+    });
+    afterEach(async () => {
+        await mcpConnectionManager.disconnect(serverId);
+        hubManager.removeServer(serverName);
+    });
+    it('should correctly initialize MCP connection with SDK', async () => {
+        // Get server configuration and instance configuration
+        const serverInfo = hubManager.getServerById(serverId);
+        if (!serverInfo) {
+            throw new Error('Server not found');
+        }
+        await mcpConnectionManager.connect({
+            id: serverId,
+            command: serverInfo.config.command,
+            args: serverInfo.config.args,
+            enabled: serverInfo.config.enabled,
+            type: serverInfo.config.type,
+            timeout: serverInfo.config.timeout,
+            allowedTools: serverInfo.config.allowedTools,
+            timestamp: serverInfo.instance.timestamp,
+            hash: serverInfo.instance.hash
+        });
+        const status = mcpConnectionManager.getStatus(serverId);
+        expect(status?.connected).toBe(true);
+        expect(status?.version).toBe('1.0.0');
+    });
+    it('should list tools using SDK Client', async () => {
+        // Get server configuration and instance configuration
+        const serverInfo = hubManager.getServerById(serverId);
+        if (!serverInfo) {
+            throw new Error('Server not found');
+        }
+        await mcpConnectionManager.connect({
+            id: serverId,
+            command: serverInfo.config.command,
+            args: serverInfo.config.args,
+            enabled: serverInfo.config.enabled,
+            type: serverInfo.config.type,
+            timeout: serverInfo.config.timeout,
+            allowedTools: serverInfo.config.allowedTools,
+            timestamp: serverInfo.instance.timestamp,
+            hash: serverInfo.instance.hash
+        });
+        const tools = mcpConnectionManager.getTools(serverId);
+        expect(tools).toHaveLength(1);
+        expect(tools[0].name).toBe('echo');
+        expect(tools[0].description).toBe('Echo the input');
+    });
+});

package/dist/server/tests/contract/mcp-protocol/tools-call.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=tools-call.test.d.ts.map

package/dist/server/tests/contract/mcp-protocol/tools-call.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tools-call.test.d.ts","sourceRoot":"","sources":["../../../../../tests/contract/mcp-protocol/tools-call.test.ts"],"names":[],"mappings":""}

package/dist/server/tests/contract/mcp-protocol/tools-call.test.js

@@ -0,0 +1,181 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { mcpConnectionManager } from '../../../src/services/mcp-connection-manager.js';
+import { hubManager } from '../../../src/services/hub-manager.service.js';
+// Mock MCP SDK
+vi.mock('@modelcontextprotocol/sdk/client/index.js', () => {
+    return {
+        Client: class {
+            connect = vi.fn().mockResolvedValue(undefined);
+            close = vi.fn().mockResolvedValue(undefined);
+            callTool = vi.fn().mockImplementation((toolCall) => {
+                if (toolCall.name === 'calculator') {
+                    const { a, b, operation } = toolCall.arguments;
+                    // Validate parameter types
+                    if (typeof a !== 'number' || typeof b !== 'number') {
+                        throw new Error('Invalid parameters: a and b must be numbers');
+                    }
+                    if (typeof operation !== 'string') {
+                        throw new Error('Invalid parameters: operation must be a string');
+                    }
+                    let result;
+                    switch (operation) {
+                        case 'add':
+                            result = a + b;
+                            break;
+                        case 'subtract':
+                            result = a - b;
+                            break;
+                        case 'multiply':
+                            result = a * b;
+                            break;
+                        case 'divide':
+                            if (b === 0) {
+                                throw new Error('Division by zero');
+                            }
+                            result = a / b;
+                            break;
+                        default:
+                            throw new Error('Invalid operation');
+                    }
+                    return Promise.resolve({ result });
+                }
+                if (toolCall.name === 'get_weather') {
+                    return Promise.resolve({ temperature: 25, condition: 'sunny' });
+                }
+                if (toolCall.name === 'search_news') {
+                    return Promise.resolve({ articles: ['News 1', 'News 2'] });
+                }
+                throw new Error('Unknown tool');
+            });
+            getServerVersion = vi.fn().mockReturnValue({ name: 'Test SDK Server', version: '1.0.0' });
+        }
+    };
+});
+// Mock transport
+vi.mock('@utils/transports/transport-factory.js', () => {
+    return {
+        TransportFactory: {
+            createTransport: vi.fn().mockReturnValue({
+                onclose: null,
+                onstdout: null,
+                onstderr: null,
+                close: vi.fn().mockResolvedValue(undefined)
+            })
+        }
+    };
+});
+describe('MCP Protocol Contract - tools/call (with SDK)', () => {
+    const serverName = 'test-sdk-server';
+    let serverId;
+    beforeEach(async () => {
+        // Add to hub manager
+        await hubManager.addServer(serverName, {
+            command: 'node',
+            args: [],
+            enabled: true,
+            type: 'stdio',
+            timeout: 60000,
+            allowedTools: []
+        });
+        // Add server instance
+        const instance = await hubManager.addServerInstance(serverName, {});
+        serverId = instance.id;
+    });
+    afterEach(async () => {
+        await mcpConnectionManager.disconnect(serverId);
+        hubManager.removeServer(serverName);
+    });
+    it('should execute tool with correct arguments', async () => {
+        // Get server configuration and instance configuration
+        const serverInfo = hubManager.getServerById(serverId);
+        if (!serverInfo) {
+            throw new Error('Server not found');
+        }
+        await mcpConnectionManager.connect({
+            id: serverId,
+            command: serverInfo.config.command,
+            args: serverInfo.config.args,
+            enabled: serverInfo.config.enabled,
+            type: serverInfo.config.type,
+            timeout: serverInfo.config.timeout,
+            allowedTools: serverInfo.config.allowedTools,
+            timestamp: serverInfo.instance.timestamp,
+            hash: serverInfo.instance.hash
+        });
+        const result = (await mcpConnectionManager.callTool(serverId, 'calculator', {
+            a: 5,
+            b: 3,
+            operation: 'add'
+        }));
+        expect(result).toHaveProperty('result');
+        expect(result.result).toBe(8);
+    });
+    it('should handle invalid parameters', async () => {
+        // Get server configuration and instance configuration
+        const serverInfo = hubManager.getServerById(serverId);
+        if (!serverInfo) {
+            throw new Error('Server not found');
+        }
+        await mcpConnectionManager.connect({
+            id: serverId,
+            command: serverInfo.config.command,
+            args: serverInfo.config.args,
+            enabled: serverInfo.config.enabled,
+            type: serverInfo.config.type,
+            timeout: serverInfo.config.timeout,
+            allowedTools: serverInfo.config.allowedTools,
+            timestamp: serverInfo.instance.timestamp,
+            hash: serverInfo.instance.hash
+        });
+        await expect(mcpConnectionManager.callTool(serverId, 'calculator', {
+            a: 'invalid',
+            b: 3,
+            operation: 'add'
+        })).rejects.toThrow();
+    });
+    it('should handle unknown tool', async () => {
+        // Get server configuration and instance configuration
+        const serverInfo = hubManager.getServerById(serverId);
+        if (!serverInfo) {
+            throw new Error('Server not found');
+        }
+        await mcpConnectionManager.connect({
+            id: serverId,
+            command: serverInfo.config.command,
+            args: serverInfo.config.args,
+            enabled: serverInfo.config.enabled,
+            type: serverInfo.config.type,
+            timeout: serverInfo.config.timeout,
+            allowedTools: serverInfo.config.allowedTools,
+            timestamp: serverInfo.instance.timestamp,
+            hash: serverInfo.instance.hash
+        });
+        await expect(mcpConnectionManager.callTool(serverId, 'unknown_tool', {})).rejects.toThrow();
+    });
+    it('should support multiple concurrent tool calls', async () => {
+        // Get server configuration and instance configuration
+        const serverInfo = hubManager.getServerById(serverId);
+        if (!serverInfo) {
+            throw new Error('Server not found');
+        }
+        await mcpConnectionManager.connect({
+            id: serverId,
+            command: serverInfo.config.command,
+            args: serverInfo.config.args,
+            enabled: serverInfo.config.enabled,
+            type: serverInfo.config.type,
+            timeout: serverInfo.config.timeout,
+            allowedTools: serverInfo.config.allowedTools,
+            timestamp: serverInfo.instance.timestamp,
+            hash: serverInfo.instance.hash
+        });
+        const [result1, result2] = await Promise.all([
+            mcpConnectionManager.callTool(serverId, 'get_weather', { location: 'New York' }),
+            mcpConnectionManager.callTool(serverId, 'search_news', { query: 'technology' })
+        ]);
+        expect(result1).toHaveProperty('temperature');
+        expect(result1).toHaveProperty('condition');
+        expect(result2).toHaveProperty('articles');
+        expect(Array.isArray(result2.articles)).toBe(true);
+    });
+});

package/dist/server/tests/contract/mcp-protocol/tools-list.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=tools-list.test.d.ts.map

package/dist/server/tests/contract/mcp-protocol/tools-list.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tools-list.test.d.ts","sourceRoot":"","sources":["../../../../../tests/contract/mcp-protocol/tools-list.test.ts"],"names":[],"mappings":""}

package/dist/server/tests/contract/mcp-protocol/tools-list.test.js

@@ -0,0 +1,155 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { mcpConnectionManager } from '../../../src/services/mcp-connection-manager.js';
+import { hubManager } from '../../../src/services/hub-manager.service.js';
+// Mock MCP SDK
+const mockListTools = vi.fn();
+vi.mock('@modelcontextprotocol/sdk/client/index.js', () => {
+    return {
+        Client: class {
+            connect = vi.fn().mockResolvedValue(undefined);
+            close = vi.fn().mockResolvedValue(undefined);
+            listTools = mockListTools;
+            getServerVersion = vi.fn().mockReturnValue({ name: 'Test SDK Server', version: '1.0.0' });
+        }
+    };
+});
+// Mock transport
+vi.mock('@utils/transports/transport-factory.js', () => {
+    return {
+        TransportFactory: {
+            createTransport: vi.fn().mockReturnValue({
+                onclose: null,
+                onstdout: null,
+                onstderr: null,
+                close: vi.fn().mockResolvedValue(undefined)
+            })
+        }
+    };
+});
+describe('MCP Protocol Contract - tools/list (with SDK)', () => {
+    const serverName = 'test-sdk-server';
+    let serverId;
+    beforeEach(async () => {
+        // Add to hub manager
+        await hubManager.addServer(serverName, {
+            command: 'node',
+            args: [],
+            enabled: true,
+            type: 'stdio',
+            timeout: 60000,
+            allowedTools: []
+        });
+        // Add server instance
+        const instance = await hubManager.addServerInstance(serverName, {});
+        serverId = instance.id;
+    });
+    afterEach(async () => {
+        await mcpConnectionManager.disconnect(serverId);
+        hubManager.removeServer(serverName);
+    });
+    it('should return tools with correct MCP schema', async () => {
+        // Mock returning 2 tools, including calculator tool
+        mockListTools.mockResolvedValueOnce({
+            tools: [
+                {
+                    name: 'calculator',
+                    description: 'Perform mathematical calculations',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            expression: { type: 'string' },
+                            precision: { type: 'number', default: 2 }
+                        },
+                        required: ['expression']
+                    }
+                },
+                {
+                    name: 'weather',
+                    description: 'Get current weather information',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            location: { type: 'string' },
+                            units: { type: 'string', enum: ['metric', 'imperial'], default: 'metric' }
+                        },
+                        required: ['location']
+                    }
+                }
+            ]
+        });
+        // Get server configuration and instance configuration
+        const serverInfo = hubManager.getServerById(serverId);
+        if (!serverInfo) {
+            throw new Error('Server not found');
+        }
+        await mcpConnectionManager.connect({
+            id: serverId,
+            command: serverInfo.config.command,
+            args: serverInfo.config.args,
+            enabled: serverInfo.config.enabled,
+            type: serverInfo.config.type,
+            timeout: serverInfo.config.timeout,
+            allowedTools: serverInfo.config.allowedTools,
+            timestamp: serverInfo.instance.timestamp,
+            hash: serverInfo.instance.hash
+        });
+        const tools = mcpConnectionManager.getTools(serverId);
+        expect(tools).toHaveLength(2);
+        // Verify calculator tool
+        const calculator = tools.find((t) => t.name === 'calculator');
+        expect(calculator).toBeDefined();
+        expect(calculator?.description).toBe('Perform mathematical calculations');
+        expect(calculator?.inputSchema).toMatchObject({
+            type: 'object',
+            properties: expect.objectContaining({
+                expression: { type: 'string' },
+                precision: { type: 'number', default: 2 }
+            }),
+            required: ['expression']
+        });
+    });
+    it('should maintain tool identity across calls', async () => {
+        // Get server configuration and instance configuration
+        const serverInfo = hubManager.getServerById(serverId);
+        if (!serverInfo) {
+            throw new Error('Server not found');
+        }
+        await mcpConnectionManager.connect({
+            id: serverId,
+            command: serverInfo.config.command,
+            args: serverInfo.config.args,
+            enabled: serverInfo.config.enabled,
+            type: serverInfo.config.type,
+            timeout: serverInfo.config.timeout,
+            allowedTools: serverInfo.config.allowedTools,
+            timestamp: serverInfo.instance.timestamp,
+            hash: serverInfo.instance.hash
+        });
+        const tools1 = mcpConnectionManager.getTools(serverId);
+        const tools2 = mcpConnectionManager.getTools(serverId);
+        expect(tools1).toEqual(tools2);
+        expect(tools1[0]).toBe(tools2[0]); // Reference equality
+    });
+    it('should handle empty tool list', async () => {
+        // Simulate empty tool list
+        mockListTools.mockResolvedValueOnce({ tools: [] });
+        // Get server configuration and instance configuration
+        const serverInfo = hubManager.getServerById(serverId);
+        if (!serverInfo) {
+            throw new Error('Server not found');
+        }
+        await mcpConnectionManager.connect({
+            id: serverId,
+            command: serverInfo.config.command,
+            args: serverInfo.config.args,
+            enabled: serverInfo.config.enabled,
+            type: serverInfo.config.type,
+            timeout: serverInfo.config.timeout,
+            allowedTools: serverInfo.config.allowedTools,
+            timestamp: serverInfo.instance.timestamp,
+            hash: serverInfo.instance.hash
+        });
+        const tools = mcpConnectionManager.getTools(serverId);
+        expect(tools).toHaveLength(0);
+    });
+});

package/dist/server/tests/evaluation/evaluation.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=evaluation.test.d.ts.map

package/dist/server/tests/evaluation/evaluation.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"evaluation.test.d.ts","sourceRoot":"","sources":["../../../../tests/evaluation/evaluation.test.ts"],"names":[],"mappings":""}