@loop_ouroboros/mcp-hub-lite 1.0.2 → 1.1.1

package/dist/server/src/utils/transports/streamable-http-transport.js

@@ -1,6 +1,7 @@
 import { logger, LOG_MODULES } from '../logger.js';
 import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
 import { URL } from 'url';
+import { ProxyAgent, fetch as undiciFetch } from 'undici';
 /**
  * Streamable HTTP Transport implementation for MCP (Model Context Protocol)
  *
@@ -30,6 +31,7 @@ export class StreamableHttpTransport {
     url;
     headers;
     timeout;
+    proxy;
     /**
      * Internal reference to the underlying MCP SDK transport instance
      * @private
@@ -41,6 +43,16 @@ export class StreamableHttpTransport {
      * @private
      */
     isClosing = false;
+    /**
+     * Server name for logging context
+     * @private
+     */
+    _serverName;
+    /**
+     * Composite key (serverName-serverIndex) for logging context
+     * @private
+     */
+    _compositeKey;
     /**
      * Event handler called when a JSON-RPC message is received from the server
      * @public
@@ -64,11 +76,34 @@ export class StreamableHttpTransport {
      *                 Commonly used for authentication tokens, API keys, or custom headers
      * @param timeout - Request timeout in milliseconds (default: 30000 = 30 seconds)
      *                  Controls how long to wait for HTTP responses before timing out
+     * @param proxy - Optional proxy configuration
+     * @param serverName - Optional server name for logging
+     * @param compositeKey - Optional composite key (serverName-serverIndex) for logging
      */
-    constructor(url, headers = {}, timeout = 30000) {
+    constructor(url, headers = {}, timeout = 30000, proxy, serverName, compositeKey) {
         this.url = url;
         this.headers = headers;
         this.timeout = timeout;
+        this.proxy = proxy;
+        this._serverName = serverName;
+        this._compositeKey = compositeKey;
+    }
+    /**
+     * Helper method to format log messages with server context.
+     *
+     * @param message - The base message
+     * @returns Formatted message with server context if available
+     */
+    formatLogMessage(message) {
+        if (this._compositeKey) {
+            return `${message} (compositeKey=${this._compositeKey}, url=${this.url})`;
+        }
+        else if (this._serverName) {
+            return `${message} (server=${this._serverName}, url=${this.url})`;
+        }
+        else {
+            return `${message} (url=${this.url})`;
+        }
     }
     /**
      * Initializes and starts the Streamable HTTP transport connection
@@ -101,6 +136,8 @@ export class StreamableHttpTransport {
             throw new Error('Streamable HTTP Transport already started!');
         }
         this.isClosing = false;
+        const proxyInfo = this.proxy?.url ? `, proxy=${this.proxy.url}` : '';
+        logger.info(this.formatLogMessage(`Attempting to connect to Streamable HTTP server: timeout=${this.timeout}ms, headers=${JSON.stringify(Object.keys(this.headers))}${proxyInfo}`), LOG_MODULES.HTTP_TRANSPORT);
         try {
             const url = new URL(this.url);
             const requestInit = {
@@ -110,19 +147,37 @@ export class StreamableHttpTransport {
                 },
                 signal: AbortSignal.timeout(this.timeout)
             };
-            this.transport = new StreamableHTTPClientTransport(url, {
+            // Create transport options
+            const transportOptions = {
                 requestInit
-            });
+            };
+            // Add proxy support if configured
+            if (this.proxy?.url) {
+                const agent = new ProxyAgent(this.proxy.url);
+                // Create custom fetch function with proxy
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                const customFetch = (input, init) => {
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    const fetchOptions = {
+                        ...init,
+                        dispatcher: agent
+                    };
+                    return undiciFetch(input, fetchOptions);
+                };
+                transportOptions.fetch = customFetch;
+                logger.info(this.formatLogMessage(`Streamable HTTP transport configured with proxy: ${this.proxy.url}`), LOG_MODULES.HTTP_TRANSPORT);
+            }
+            this.transport = new StreamableHTTPClientTransport(url, transportOptions);
             // Set up event handlers
             this.transport.onmessage = (message) => {
                 this.onmessage?.(message);
             };
             this.transport.onerror = (error) => {
-                logger.error('Streamable HTTP transport error:', error, LOG_MODULES.HTTP_TRANSPORT);
+                logger.error(this.formatLogMessage(`Streamable HTTP transport error occurred: errorType=${error.name || 'unknown'}, message=${error.message || 'no message'}`), error, LOG_MODULES.HTTP_TRANSPORT);
                 this.onerror?.(error);
             };
             this.transport.onclose = () => {
-                logger.info('Streamable HTTP transport closed', LOG_MODULES.HTTP_TRANSPORT);
+                logger.info(this.formatLogMessage('Streamable HTTP transport closed'), LOG_MODULES.HTTP_TRANSPORT);
                 if (!this.isClosing) {
                     // Unexpected close, trigger error
                     const error = new Error('Streamable HTTP transport closed unexpectedly');
@@ -130,11 +185,13 @@ export class StreamableHttpTransport {
                 }
                 this.onclose?.();
             };
+            logger.debug(this.formatLogMessage('Starting underlying transport connection...'), LOG_MODULES.HTTP_TRANSPORT);
             await this.transport.start();
-            logger.info(`Streamable HTTP transport initialized for ${this.url}`, LOG_MODULES.HTTP_TRANSPORT);
+            logger.info(this.formatLogMessage('Streamable HTTP transport successfully initialized'), LOG_MODULES.HTTP_TRANSPORT);
         }
         catch (error) {
-            logger.error('Failed to create Streamable HTTP transport:', error, LOG_MODULES.HTTP_TRANSPORT);
+            logger.error(this.formatLogMessage(`Failed to create Streamable HTTP transport: error=${error instanceof Error ? error.message : String(error)}`), LOG_MODULES.HTTP_TRANSPORT);
+            logger.error('Complete error details:', error, LOG_MODULES.HTTP_TRANSPORT);
             throw error;
         }
     }
@@ -201,11 +258,14 @@ export class StreamableHttpTransport {
         if (!this.transport) {
             throw new Error('Streamable HTTP transport not started');
         }
+        const method = 'method' in message ? message.method : 'notification';
+        const proxyInfo = this.proxy?.url ? `, proxy=${this.proxy.url}` : '';
+        logger.debug(this.formatLogMessage(`Sending message via Streamable HTTP: method=${method}${proxyInfo}`), LOG_MODULES.HTTP_TRANSPORT);
         try {
             await this.transport.send(message);
         }
         catch (error) {
-            logger.error('Failed to send message via Streamable HTTP:', error, LOG_MODULES.HTTP_TRANSPORT);
+            logger.error(this.formatLogMessage(`Failed to send message via Streamable HTTP: method=${method}${proxyInfo}, error=${error instanceof Error ? error.message : String(error)}`), error, LOG_MODULES.HTTP_TRANSPORT);
             throw error;
         }
     }

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

@@ -1,4 +1,4 @@
-import type { ServerConfig } from '../../config/config.schema.js';
+import type { ServerRuntimeConfig } from '../../../shared/models/server.model.js';
 /**
  * Transport Factory - creates appropriate transport client based on server configuration
  */
@@ -6,18 +6,23 @@ 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
+     * @param compositeKey Optional composite key (serverName-serverIndex) for log storage integration
      * @returns Transport client instance
      * @throws Error if server type is not supported or configuration is invalid
      */
-    static createTransport(server: ServerConfig & {
+    static createTransport(server: ServerRuntimeConfig & {
         name: string;
-    }, serverId?: string): import('@modelcontextprotocol/sdk/shared/transport.js').Transport;
+    }, compositeKey?: string): import('@modelcontextprotocol/sdk/shared/transport.js').Transport;
     /**
      * Build system environment variables
      * Add necessary system environment variables for stdio transport
      */
     private static buildSystemEnv;
+    /**
+     * Check if a command is related to Python execution
+     * Detects python, python3, py, uv, uvx, and similar commands
+     */
+    private static isPythonCommand;
     /**
      * Validate and convert server configuration to transport configuration
      */

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

@@ -1 +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"}
+{"version":3,"file":"transport-factory.d.ts","sourceRoot":"","sources":["../../../../../src/utils/transports/transport-factory.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,gCAAgC,CAAC;AAG1E;;GAEG;AACH,qBAAa,gBAAgB;IAC3B;;;;;;OAMG;IACH,MAAM,CAAC,eAAe,CACpB,MAAM,EAAE,mBAAmB,GAAG;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,EAC9C,YAAY,CAAC,EAAE,MAAM,GACpB,OAAO,+CAA+C,EAAE,SAAS;IA6DpE;;;OAGG;IACH,OAAO,CAAC,MAAM,CAAC,cAAc;IAW7B;;;OAGG;IACH,OAAO,CAAC,MAAM,CAAC,eAAe;IAW9B;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,wBAAwB;CA8CxC"}

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

@@ -9,11 +9,11 @@ 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
+     * @param compositeKey Optional composite key (serverName-serverIndex) for log storage integration
      * @returns Transport client instance
      * @throws Error if server type is not supported or configuration is invalid
      */
-    static createTransport(server, serverId) {
+    static createTransport(server, compositeKey) {
         const transportConfig = this.validateAndConvertConfig(server);
         // Use type assertion to ensure TypeScript can correctly infer types
         const config = transportConfig;
@@ -29,20 +29,20 @@ export class TransportFactory {
                     cwd: process.cwd(),
                     stderr: 'pipe'
                 }, server.name, {
-                    serverId,
-                    logStorage: serverId ? logStorage : undefined
+                    compositeKey,
+                    logStorage: compositeKey ? 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);
+                return new SseTransport(config.url, config.headers, config.reconnectInterval, config.maxReconnectAttempts, config.proxy, server.name, compositeKey);
             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);
+                return new StreamableHttpTransport(config.url, config.headers, config.timeout, config.proxy, server.name, compositeKey);
             default:
                 throw new Error(`Unsupported transport type: ${config.type || 'undefined'}`);
         }
@@ -51,8 +51,26 @@ export class TransportFactory {
      * Build system environment variables
      * Add necessary system environment variables for stdio transport
      */
-    static buildSystemEnv() {
-        return {};
+    static buildSystemEnv(command) {
+        const env = {};
+        // For Python-related commands, set PYTHONUTF8=1 to ensure proper UTF-8 handling
+        if (command && this.isPythonCommand(command)) {
+            env.PYTHONUTF8 = '1';
+        }
+        return env;
+    }
+    /**
+     * Check if a command is related to Python execution
+     * Detects python, python3, py, uv, uvx, and similar commands
+     */
+    static isPythonCommand(command) {
+        const trimmedCommand = command.trim();
+        if (!trimmedCommand)
+            return false;
+        // Extract the basename (last part after / or \)
+        const parts = trimmedCommand.split(/[\\/]/);
+        const basename = parts[parts.length - 1].toLowerCase();
+        return basename.includes('python') || basename.startsWith('uv') || basename.startsWith('py');
     }
     /**
      * Validate and convert server configuration to transport configuration
@@ -65,7 +83,7 @@ export class TransportFactory {
                 command: server.command || '',
                 args: server.args,
                 env: {
-                    ...this.buildSystemEnv(), // System environment variables
+                    ...this.buildSystemEnv(server.command), // System environment variables
                     ...(server.env || {}) // User-defined environment variables (can override system defaults)
                 },
                 cwd: process.cwd(),
@@ -78,7 +96,8 @@ export class TransportFactory {
                 url: server.url || '',
                 headers: server.headers || server.env, // Prefer headers, fallback to env for backward compatibility
                 reconnectInterval: 3000,
-                maxReconnectAttempts: 5
+                maxReconnectAttempts: 5,
+                proxy: server.proxy
             };
         }
         else if (type === 'streamable-http' || type === 'http') {
@@ -86,7 +105,8 @@ export class TransportFactory {
                 type: 'streamable-http', // Unified conversion to streamable-http
                 url: server.url || '',
                 headers: server.headers || server.env, // Prefer headers, fallback to env for backward compatibility
-                timeout: server.timeout || 30000
+                timeout: server.timeout || 30000,
+                proxy: server.proxy
             };
         }
         else {

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

@@ -18,6 +18,9 @@ export interface SseTransportConfig {
     headers?: Record<string, string>;
     reconnectInterval?: number;
     maxReconnectAttempts?: number;
+    proxy?: {
+        url: string;
+    };
 }
 /**
  * Streamable HTTP transport configuration
@@ -27,6 +30,9 @@ export interface StreamableHttpTransportConfig {
     url: string;
     headers?: Record<string, string>;
     timeout?: number;
+    proxy?: {
+        url: string;
+    };
 }
 /**
  * Generic server configuration

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

@@ -1 +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"}
+{"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;IAC9B,KAAK,CAAC,EAAE;QACN,GAAG,EAAE,MAAM,CAAC;KACb,CAAC;CACH;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;IACjB,KAAK,CAAC,EAAE;QACN,GAAG,EAAE,MAAM,CAAC;KACb,CAAC;CACH;AAED;;GAEG;AACH,MAAM,MAAM,qBAAqB,GAC7B,oBAAoB,GACpB,kBAAkB,GAClB,6BAA6B,CAAC"}

package/dist/server/src/utils/version.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Get the application version from package.json.
+ *
+ * @returns The package version string or a safe fallback on failure.
+ */
+export declare function getAppVersion(): string;
+/**
+ * Get the MCP protocol version used by the gateway.
+ */
+export declare function getProtocolVersion(): string;
+//# sourceMappingURL=version.d.ts.map

package/dist/server/src/utils/version.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../../../../src/utils/version.ts"],"names":[],"mappings":"AA8CA;;;;GAIG;AACH,wBAAgB,aAAa,IAAI,MAAM,CAMtC;AAED;;GAEG;AACH,wBAAgB,kBAAkB,IAAI,MAAM,CAE3C"}

package/dist/server/src/utils/version.js

@@ -0,0 +1,57 @@
+import fs from 'fs';
+import { fileURLToPath } from 'node:url';
+import path from 'node:path';
+const FALLBACK_VERSION = '0.0.0';
+const MCP_PROTOCOL_VERSION = '2024-11-05';
+let cachedAppVersion;
+/**
+ * Resolve package version from package.json with multiple fallback paths.
+ */
+function resolvePackageVersion() {
+    const baseDirs = [
+        process.cwd(),
+        path.dirname(fileURLToPath(import.meta.url)),
+        path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..')
+    ];
+    for (const baseDir of baseDirs) {
+        let currentDir = baseDir;
+        for (let depth = 0; depth < 6; depth += 1) {
+            const candidate = path.join(currentDir, 'package.json');
+            try {
+                if (fs.existsSync(candidate)) {
+                    const packageText = fs.readFileSync(candidate, 'utf-8');
+                    const parsed = JSON.parse(packageText);
+                    if (parsed.version && typeof parsed.version === 'string') {
+                        return parsed.version;
+                    }
+                }
+            }
+            catch {
+                // Ignore parsing/file read errors and continue searching.
+            }
+            const parent = path.dirname(currentDir);
+            if (parent === currentDir) {
+                break;
+            }
+            currentDir = parent;
+        }
+    }
+    return FALLBACK_VERSION;
+}
+/**
+ * Get the application version from package.json.
+ *
+ * @returns The package version string or a safe fallback on failure.
+ */
+export function getAppVersion() {
+    if (!cachedAppVersion) {
+        cachedAppVersion = resolvePackageVersion();
+    }
+    return cachedAppVersion;
+}
+/**
+ * Get the MCP protocol version used by the gateway.
+ */
+export function getProtocolVersion() {
+    return MCP_PROTOCOL_VERSION;
+}

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

@@ -1,6 +1,7 @@
 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';
+import { resolveInstanceConfig } from '../../../src/config/config-migrator.js';
 // Mock MCP SDK
 vi.mock('@modelcontextprotocol/sdk/client/index.js', () => {
     return {
@@ -39,22 +40,23 @@ vi.mock('@utils/transports/transport-factory.js', () => {
 describe('MCP Protocol Contract - initialize (with SDK)', () => {
     const serverName = 'test-sdk-server';
     let serverId;
+    let serverIndex;
     beforeEach(async () => {
-        // Add to hub manager
+        // Add to hub manager (v1.1 format)
         await hubManager.addServer(serverName, {
             command: 'node',
             args: [],
-            enabled: true,
             type: 'stdio',
             timeout: 60000,
-            allowedTools: []
+            aggregatedTools: []
         });
         // Add server instance
         const instance = await hubManager.addServerInstance(serverName, {});
         serverId = instance.id;
+        serverIndex = instance.index ?? 0;
     });
     afterEach(async () => {
-        await mcpConnectionManager.disconnect(serverId);
+        await mcpConnectionManager.disconnect(serverName, serverIndex);
         hubManager.removeServer(serverName);
     });
     it('should correctly initialize MCP connection with SDK', async () => {
@@ -63,18 +65,17 @@ describe('MCP Protocol Contract - initialize (with SDK)', () => {
         if (!serverInfo) {
             throw new Error('Server not found');
         }
-        await mcpConnectionManager.connect({
+        // Resolve the complete configuration using v1.1 resolveInstanceConfig
+        const resolvedConfig = resolveInstanceConfig(serverInfo.config, serverId);
+        if (!resolvedConfig) {
+            throw new Error('Failed to resolve server configuration');
+        }
+        await mcpConnectionManager.connect(serverName, serverIndex, {
+            ...resolvedConfig,
             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
+            timestamp: Date.now()
         });
-        const status = mcpConnectionManager.getStatus(serverId);
+        const status = mcpConnectionManager.getStatus(serverName, serverIndex);
         expect(status?.connected).toBe(true);
         expect(status?.version).toBe('1.0.0');
     });
@@ -84,18 +85,17 @@ describe('MCP Protocol Contract - initialize (with SDK)', () => {
         if (!serverInfo) {
             throw new Error('Server not found');
         }
-        await mcpConnectionManager.connect({
+        // Resolve the complete configuration using v1.1 resolveInstanceConfig
+        const resolvedConfig = resolveInstanceConfig(serverInfo.config, serverId);
+        if (!resolvedConfig) {
+            throw new Error('Failed to resolve server configuration');
+        }
+        await mcpConnectionManager.connect(serverName, serverIndex, {
+            ...resolvedConfig,
             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
+            timestamp: Date.now()
         });
-        const tools = mcpConnectionManager.getTools(serverId);
+        const tools = mcpConnectionManager.getTools(serverName, serverIndex);
         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.js

@@ -1,12 +1,15 @@
 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';
+import { resolveInstanceConfig } from '../../../src/config/config-migrator.js';
 // Mock MCP SDK
+const mockListTools = vi.fn().mockResolvedValue({ tools: [] });
 vi.mock('@modelcontextprotocol/sdk/client/index.js', () => {
     return {
         Client: class {
             connect = vi.fn().mockResolvedValue(undefined);
             close = vi.fn().mockResolvedValue(undefined);
+            listTools = mockListTools;
             callTool = vi.fn().mockImplementation((toolCall) => {
                 if (toolCall.name === 'calculator') {
                     const { a, b, operation } = toolCall.arguments;
@@ -67,22 +70,23 @@ vi.mock('@utils/transports/transport-factory.js', () => {
 describe('MCP Protocol Contract - tools/call (with SDK)', () => {
     const serverName = 'test-sdk-server';
     let serverId;
+    let serverIndex;
     beforeEach(async () => {
-        // Add to hub manager
+        // Add to hub manager (v1.1 format)
         await hubManager.addServer(serverName, {
             command: 'node',
             args: [],
-            enabled: true,
             type: 'stdio',
             timeout: 60000,
-            allowedTools: []
+            aggregatedTools: []
         });
         // Add server instance
         const instance = await hubManager.addServerInstance(serverName, {});
         serverId = instance.id;
+        serverIndex = instance.index ?? 0;
     });
     afterEach(async () => {
-        await mcpConnectionManager.disconnect(serverId);
+        await mcpConnectionManager.disconnect(serverName, serverIndex);
         hubManager.removeServer(serverName);
     });
     it('should execute tool with correct arguments', async () => {
@@ -91,18 +95,17 @@ describe('MCP Protocol Contract - tools/call (with SDK)', () => {
         if (!serverInfo) {
             throw new Error('Server not found');
         }
-        await mcpConnectionManager.connect({
+        // Resolve the complete configuration using v1.1 resolveInstanceConfig
+        const resolvedConfig = resolveInstanceConfig(serverInfo.config, serverId);
+        if (!resolvedConfig) {
+            throw new Error('Failed to resolve server configuration');
+        }
+        await mcpConnectionManager.connect(serverName, serverIndex, {
+            ...resolvedConfig,
             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
+            timestamp: Date.now()
         });
-        const result = (await mcpConnectionManager.callTool(serverId, 'calculator', {
+        const result = (await mcpConnectionManager.callTool(serverName, serverIndex, 'calculator', {
             a: 5,
             b: 3,
             operation: 'add'
@@ -116,18 +119,17 @@ describe('MCP Protocol Contract - tools/call (with SDK)', () => {
         if (!serverInfo) {
             throw new Error('Server not found');
         }
-        await mcpConnectionManager.connect({
+        // Resolve the complete configuration using v1.1 resolveInstanceConfig
+        const resolvedConfig = resolveInstanceConfig(serverInfo.config, serverId);
+        if (!resolvedConfig) {
+            throw new Error('Failed to resolve server configuration');
+        }
+        await mcpConnectionManager.connect(serverName, serverIndex, {
+            ...resolvedConfig,
             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
+            timestamp: Date.now()
         });
-        await expect(mcpConnectionManager.callTool(serverId, 'calculator', {
+        await expect(mcpConnectionManager.callTool(serverName, serverIndex, 'calculator', {
             a: 'invalid',
             b: 3,
             operation: 'add'
@@ -139,18 +141,17 @@ describe('MCP Protocol Contract - tools/call (with SDK)', () => {
         if (!serverInfo) {
             throw new Error('Server not found');
         }
-        await mcpConnectionManager.connect({
+        // Resolve the complete configuration using v1.1 resolveInstanceConfig
+        const resolvedConfig = resolveInstanceConfig(serverInfo.config, serverId);
+        if (!resolvedConfig) {
+            throw new Error('Failed to resolve server configuration');
+        }
+        await mcpConnectionManager.connect(serverName, serverIndex, {
+            ...resolvedConfig,
             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
+            timestamp: Date.now()
         });
-        await expect(mcpConnectionManager.callTool(serverId, 'unknown_tool', {})).rejects.toThrow();
+        await expect(mcpConnectionManager.callTool(serverName, serverIndex, 'unknown_tool', {})).rejects.toThrow();
     });
     it('should support multiple concurrent tool calls', async () => {
         // Get server configuration and instance configuration
@@ -158,20 +159,23 @@ describe('MCP Protocol Contract - tools/call (with SDK)', () => {
         if (!serverInfo) {
             throw new Error('Server not found');
         }
-        await mcpConnectionManager.connect({
+        // Resolve the complete configuration using v1.1 resolveInstanceConfig
+        const resolvedConfig = resolveInstanceConfig(serverInfo.config, serverId);
+        if (!resolvedConfig) {
+            throw new Error('Failed to resolve server configuration');
+        }
+        await mcpConnectionManager.connect(serverName, serverIndex, {
+            ...resolvedConfig,
             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
+            timestamp: Date.now()
         });
         const [result1, result2] = await Promise.all([
-            mcpConnectionManager.callTool(serverId, 'get_weather', { location: 'New York' }),
-            mcpConnectionManager.callTool(serverId, 'search_news', { query: 'technology' })
+            mcpConnectionManager.callTool(serverName, serverIndex, 'get_weather', {
+                location: 'New York'
+            }),
+            mcpConnectionManager.callTool(serverName, serverIndex, 'search_news', {
+                query: 'technology'
+            })
         ]);
         expect(result1).toHaveProperty('temperature');
         expect(result1).toHaveProperty('condition');