@juspay/neurolink 7.14.0 → 7.14.2

package/dist/lib/mcp/externalServerManager.js

@@ -10,16 +10,74 @@ import { EventEmitter } from "events";
 import { mcpLogger } from "../utils/logger.js";
 import { MCPClientFactory } from "./mcpClientFactory.js";
 import { ToolDiscoveryService } from "./toolDiscoveryService.js";
+import { toolRegistry } from "./toolRegistry.js";
+import { detectCategory } from "../utils/mcpDefaults.js";
 /**
- * ExternalServerManager
- * Core class for managing external MCP servers
+ * Type guard to validate if an object can be safely used as Record<string, JsonValue>
  */
+function isValidJsonRecord(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return false;
+    }
+    const record = value;
+    return Object.values(record).every((val) => {
+        // JsonValue = string | number | boolean | null | JsonValue[] | { [key: string]: JsonValue }
+        if (val === null ||
+            typeof val === "string" ||
+            typeof val === "number" ||
+            typeof val === "boolean") {
+            return true;
+        }
+        if (Array.isArray(val)) {
+            return val.every((item) => isValidJsonRecord(item) ||
+                typeof item === "string" ||
+                typeof item === "number" ||
+                typeof item === "boolean" ||
+                item === null);
+        }
+        if (typeof val === "object" && val !== null) {
+            return isValidJsonRecord(val);
+        }
+        return false;
+    });
+}
+/**
+ * Safely converts unknown metadata to Record<string, JsonValue> or returns undefined
+ */
+function safeMetadataConversion(metadata) {
+    return isValidJsonRecord(metadata) ? metadata : undefined;
+}
+/**
+ * Type guard to validate external MCP server configuration
+ */
+function isValidExternalMCPServerConfig(config) {
+    if (typeof config !== "object" || config === null) {
+        return false;
+    }
+    const record = config;
+    return (typeof record.command === "string" &&
+        (record.args === undefined || Array.isArray(record.args)) &&
+        (record.env === undefined ||
+            (typeof record.env === "object" && record.env !== null)) &&
+        (record.transport === undefined || typeof record.transport === "string") &&
+        (record.timeout === undefined || typeof record.timeout === "number") &&
+        (record.retries === undefined || typeof record.retries === "number") &&
+        (record.healthCheckInterval === undefined ||
+            typeof record.healthCheckInterval === "number") &&
+        (record.autoRestart === undefined ||
+            typeof record.autoRestart === "boolean") &&
+        (record.cwd === undefined || typeof record.cwd === "string") &&
+        (record.url === undefined || typeof record.url === "string") &&
+        (record.metadata === undefined ||
+            (typeof record.metadata === "object" && record.metadata !== null)));
+}
 export class ExternalServerManager extends EventEmitter {
     servers = new Map();
     config;
     isShuttingDown = false;
     toolDiscovery;
-    constructor(config = {}) {
+    enableMainRegistryIntegration;
+    constructor(config = {}, options = {}) {
         super();
         // Set defaults for configuration
         this.config = {
@@ -32,6 +90,9 @@ export class ExternalServerManager extends EventEmitter {
             enablePerformanceMonitoring: config.enablePerformanceMonitoring ?? true,
             logLevel: config.logLevel ?? "info",
         };
+        // Enable main tool registry integration by default
+        this.enableMainRegistryIntegration =
+            options.enableMainRegistryIntegration ?? true;
         // Initialize tool discovery service
         this.toolDiscovery = new ToolDiscoveryService();
         // Forward tool discovery events
@@ -46,6 +107,99 @@ export class ExternalServerManager extends EventEmitter {
         process.on("SIGTERM", () => this.shutdown());
         process.on("beforeExit", () => this.shutdown());
     }
+    /**
+     * Load MCP server configurations from .mcp-config.json file
+     * Automatically registers servers found in the configuration
+     * @param configPath Optional path to config file (defaults to .mcp-config.json in cwd)
+     * @returns Promise resolving to number of servers loaded
+     */
+    async loadMCPConfiguration(configPath) {
+        const fs = await import("fs");
+        const path = await import("path");
+        const finalConfigPath = configPath || path.join(process.cwd(), ".mcp-config.json");
+        if (!fs.existsSync(finalConfigPath)) {
+            mcpLogger.debug(`[ExternalServerManager] No MCP config found at ${finalConfigPath}`);
+            return { serversLoaded: 0, errors: [] };
+        }
+        mcpLogger.debug(`[ExternalServerManager] Loading MCP configuration from ${finalConfigPath}`);
+        try {
+            const configContent = fs.readFileSync(finalConfigPath, "utf8");
+            const config = JSON.parse(configContent);
+            if (!config.mcpServers || typeof config.mcpServers !== "object") {
+                mcpLogger.debug("[ExternalServerManager] No mcpServers found in configuration");
+                return { serversLoaded: 0, errors: [] };
+            }
+            let serversLoaded = 0;
+            const errors = [];
+            for (const [serverId, serverConfig] of Object.entries(config.mcpServers)) {
+                try {
+                    // Validate and convert config format to MCPServerInfo
+                    if (!isValidExternalMCPServerConfig(serverConfig)) {
+                        throw new Error(`Invalid server config for ${serverId}: missing required properties or wrong types`);
+                    }
+                    const externalConfig = {
+                        id: serverId,
+                        name: serverId,
+                        description: `External MCP server: ${serverId}`,
+                        transport: typeof serverConfig.transport === "string"
+                            ? serverConfig.transport
+                            : "stdio",
+                        status: "initializing",
+                        tools: [],
+                        command: serverConfig.command,
+                        args: Array.isArray(serverConfig.args)
+                            ? serverConfig.args
+                            : [],
+                        env: typeof serverConfig.env === "object" && serverConfig.env !== null
+                            ? serverConfig.env
+                            : {},
+                        timeout: typeof serverConfig.timeout === "number"
+                            ? serverConfig.timeout
+                            : undefined,
+                        retries: typeof serverConfig.retries === "number"
+                            ? serverConfig.retries
+                            : undefined,
+                        healthCheckInterval: typeof serverConfig.healthCheckInterval === "number"
+                            ? serverConfig.healthCheckInterval
+                            : undefined,
+                        autoRestart: typeof serverConfig.autoRestart === "boolean"
+                            ? serverConfig.autoRestart
+                            : undefined,
+                        cwd: typeof serverConfig.cwd === "string"
+                            ? serverConfig.cwd
+                            : undefined,
+                        url: typeof serverConfig.url === "string"
+                            ? serverConfig.url
+                            : undefined,
+                        metadata: safeMetadataConversion(serverConfig.metadata),
+                    };
+                    const result = await this.addServer(serverId, externalConfig);
+                    if (result.success) {
+                        serversLoaded++;
+                        mcpLogger.debug(`[ExternalServerManager] Successfully loaded MCP server: ${serverId}`);
+                    }
+                    else {
+                        const error = `Failed to load server ${serverId}: ${result.error}`;
+                        errors.push(error);
+                        mcpLogger.warn(`[ExternalServerManager] ${error}`);
+                    }
+                }
+                catch (error) {
+                    const errorMsg = `Failed to load MCP server ${serverId}: ${error instanceof Error ? error.message : String(error)}`;
+                    errors.push(errorMsg);
+                    mcpLogger.warn(`[ExternalServerManager] ${errorMsg}`);
+                    // Continue with other servers - don't let one failure break everything
+                }
+            }
+            mcpLogger.info(`[ExternalServerManager] MCP configuration loading complete: ${serversLoaded} servers loaded, ${errors.length} errors`);
+            return { serversLoaded, errors };
+        }
+        catch (error) {
+            const errorMsg = `Failed to load MCP configuration: ${error instanceof Error ? error.message : String(error)}`;
+            mcpLogger.error(`[ExternalServerManager] ${errorMsg}`);
+            return { serversLoaded: 0, errors: [errorMsg] };
+        }
+    }
     /**
      * Validate external MCP server configuration
      */
@@ -93,11 +247,42 @@ export class ExternalServerManager extends EventEmitter {
         };
     }
     /**
-     * Add a new external MCP server
+     * Convert MCPServerInfo format (keeping for backward compatibility)
+     * Helper function for transitioning to zero-conversion architecture
      */
-    async addServer(serverId, config) {
+    convertConfigToMCPServerInfo(serverId, config) {
+        return {
+            id: serverId,
+            name: String(config.metadata?.title || serverId),
+            description: `External MCP server (${config.transport})`,
+            status: "initializing",
+            transport: config.transport,
+            command: config.command,
+            args: config.args,
+            env: config.env,
+            tools: [], // Will be populated after server connection
+            metadata: {
+                category: "external",
+                // Store additional ExternalMCPServerConfig fields in metadata
+                timeout: config.timeout,
+                retries: config.retries,
+                healthCheckInterval: config.healthCheckInterval,
+                autoRestart: config.autoRestart,
+                cwd: config.cwd,
+                url: config.url,
+                ...(safeMetadataConversion(config.metadata) || {}),
+            },
+        };
+    }
+    async addServer(serverId, configOrServerInfo) {
         const startTime = Date.now();
         try {
+            // Use MCPServerInfo directly (zero-conversion architecture)
+            const serverInfo = "transport" in configOrServerInfo &&
+                "command" in configOrServerInfo &&
+                !("tools" in configOrServerInfo)
+                ? this.convertConfigToMCPServerInfo(serverId, configOrServerInfo)
+                : configOrServerInfo;
             // Check server limit
             if (this.servers.size >= this.config.maxServers) {
                 return {
@@ -107,8 +292,26 @@ export class ExternalServerManager extends EventEmitter {
                     duration: Date.now() - startTime,
                 };
             }
-            // Validate configuration
-            const validation = this.validateConfig(config);
+            // Validate configuration (for backward compatibility, create temporary config)
+            const tempConfig = {
+                id: serverId,
+                name: serverInfo.name,
+                description: serverInfo.description,
+                transport: serverInfo.transport,
+                status: serverInfo.status,
+                tools: serverInfo.tools,
+                command: serverInfo.command || "",
+                args: serverInfo.args || [],
+                env: serverInfo.env || {},
+                timeout: serverInfo.metadata?.timeout,
+                retries: serverInfo.metadata?.retries,
+                healthCheckInterval: serverInfo.metadata?.healthCheckInterval,
+                autoRestart: serverInfo.metadata?.autoRestart,
+                cwd: serverInfo.metadata?.cwd,
+                url: serverInfo.metadata?.url,
+                metadata: safeMetadataConversion(serverInfo.metadata),
+            };
+            const validation = this.validateConfig(tempConfig);
             if (!validation.isValid) {
                 return {
                     success: false,
@@ -127,19 +330,19 @@ export class ExternalServerManager extends EventEmitter {
                 };
             }
             mcpLogger.info(`[ExternalServerManager] Adding server: ${serverId}`, {
-                command: config.command,
-                transport: config.transport,
+                command: serverInfo.command,
+                transport: serverInfo.transport,
             });
-            // Create server instance
+            // Create server instance as RuntimeMCPServerInfo (transition to zero-conversion)
             const instance = {
-                config: { ...config, id: serverId },
+                ...serverInfo,
                 process: null,
                 client: null,
-                transport: null,
+                transportInstance: null,
                 status: "initializing",
                 reconnectAttempts: 0,
                 maxReconnectAttempts: this.config.maxRestartAttempts,
-                tools: new Map(),
+                toolsMap: new Map(),
                 metrics: {
                     totalConnections: 0,
                     totalDisconnections: 0,
@@ -148,21 +351,41 @@ export class ExternalServerManager extends EventEmitter {
                     averageResponseTime: 0,
                     lastResponseTime: 0,
                 },
+                config: tempConfig,
             };
             // Store the instance
             this.servers.set(serverId, instance);
             // Start the server
             await this.startServer(serverId);
             const finalInstance = this.servers.get(serverId);
+            // Convert RuntimeMCPServerInfo to ExternalMCPServerInstance for return
+            const convertedInstance = {
+                config: finalInstance.config,
+                process: finalInstance.process,
+                client: finalInstance.client,
+                transport: finalInstance.transportInstance,
+                status: finalInstance.status,
+                lastError: finalInstance.lastError,
+                startTime: finalInstance.startTime,
+                lastHealthCheck: finalInstance.lastHealthCheck,
+                reconnectAttempts: finalInstance.reconnectAttempts,
+                maxReconnectAttempts: finalInstance.maxReconnectAttempts,
+                tools: finalInstance.toolsMap,
+                toolsArray: finalInstance.toolsArray,
+                capabilities: finalInstance.capabilities,
+                healthTimer: finalInstance.healthTimer,
+                restartTimer: finalInstance.restartTimer,
+                metrics: finalInstance.metrics,
+            };
             return {
                 success: true,
-                data: finalInstance,
+                data: convertedInstance,
                 serverId,
                 duration: Date.now() - startTime,
                 metadata: {
                     timestamp: Date.now(),
                     operation: "addServer",
-                    toolsDiscovered: finalInstance.tools.size,
+                    toolsDiscovered: finalInstance.tools.length,
                 },
             };
         }
@@ -249,9 +472,9 @@ export class ExternalServerManager extends EventEmitter {
             }
             // Store client components
             instance.client = clientResult.client;
-            instance.transport = clientResult.transport;
+            instance.transportInstance = clientResult.transport;
             instance.process = clientResult.process || null;
-            instance.capabilities = clientResult.capabilities;
+            instance.capabilities = safeMetadataConversion(clientResult.capabilities);
             instance.startTime = new Date();
             instance.lastHealthCheck = new Date();
             instance.metrics.totalConnections++;
@@ -279,12 +502,16 @@ export class ExternalServerManager extends EventEmitter {
             this.updateServerStatus(serverId, "connected");
             // Discover tools from the server
             await this.discoverServerTools(serverId);
+            // Register tools with main registry if integration is enabled
+            if (this.enableMainRegistryIntegration) {
+                await this.registerServerToolsWithMainRegistry(serverId);
+            }
             // Start health monitoring
             this.startHealthMonitoring(serverId);
             // Emit connected event
             this.emit("connected", {
                 serverId,
-                toolCount: instance.tools.size,
+                toolCount: instance.toolsMap.size,
                 timestamp: new Date(),
             });
             mcpLogger.info(`[ExternalServerManager] Server started successfully: ${serverId}`);
@@ -316,18 +543,22 @@ export class ExternalServerManager extends EventEmitter {
                 clearTimeout(instance.restartTimer);
                 instance.restartTimer = undefined;
             }
+            // Unregister tools from main registry if integration is enabled
+            if (this.enableMainRegistryIntegration) {
+                this.unregisterServerToolsFromMainRegistry(serverId);
+            }
             // Clear server tools from discovery service
             this.toolDiscovery.clearServerTools(serverId);
             // Close MCP client using factory cleanup
-            if (instance.client && instance.transport) {
+            if (instance.client && instance.transportInstance) {
                 try {
-                    await MCPClientFactory.closeClient(instance.client, instance.transport, instance.process || undefined);
+                    await MCPClientFactory.closeClient(instance.client, instance.transportInstance, instance.process || undefined);
                 }
                 catch (error) {
                     mcpLogger.debug(`[ExternalServerManager] Error closing client for ${serverId}:`, error);
                 }
                 instance.client = null;
-                instance.transport = null;
+                instance.transportInstance = null;
                 instance.process = null;
             }
             this.updateServerStatus(serverId, "stopped");
@@ -347,7 +578,17 @@ export class ExternalServerManager extends EventEmitter {
             return;
         }
         const oldStatus = instance.status;
-        instance.status = newStatus;
+        // Map ExternalMCPServerStatus to MCPServerInfo status
+        const mappedStatus = newStatus === "connecting" || newStatus === "restarting"
+            ? "initializing"
+            : newStatus === "stopping" || newStatus === "stopped"
+                ? "stopping"
+                : newStatus === "connected"
+                    ? "connected"
+                    : newStatus === "disconnected"
+                        ? "disconnected"
+                        : "failed";
+        instance.status = mappedStatus;
         // Emit status change event
         this.emit("statusChanged", {
             serverId,
@@ -476,7 +717,7 @@ export class ExternalServerManager extends EventEmitter {
                 status: instance.status,
                 checkedAt: new Date(),
                 responseTime,
-                toolCount: instance.tools.size,
+                toolCount: instance.toolsMap.size,
                 issues,
                 performance: {
                     uptime: instance.startTime
@@ -502,16 +743,64 @@ export class ExternalServerManager extends EventEmitter {
         }
     }
     /**
-     * Get server instance
+     * Get server instance - converted to ExternalMCPServerInstance for compatibility
      */
     getServer(serverId) {
-        return this.servers.get(serverId);
+        const runtime = this.servers.get(serverId);
+        if (!runtime) {
+            return undefined;
+        }
+        return {
+            config: runtime.config,
+            process: runtime.process,
+            client: runtime.client,
+            transport: runtime.transportInstance,
+            status: runtime.status,
+            lastError: runtime.lastError,
+            startTime: runtime.startTime,
+            lastHealthCheck: runtime.lastHealthCheck,
+            reconnectAttempts: runtime.reconnectAttempts,
+            maxReconnectAttempts: runtime.maxReconnectAttempts,
+            tools: runtime.toolsMap,
+            toolsArray: runtime.toolsArray,
+            capabilities: runtime.capabilities,
+            healthTimer: runtime.healthTimer,
+            restartTimer: runtime.restartTimer,
+            metrics: runtime.metrics,
+        };
     }
     /**
-     * Get all servers
+     * Get all servers - converted to ExternalMCPServerInstance for compatibility
      */
     getAllServers() {
-        return new Map(this.servers);
+        const converted = new Map();
+        for (const [serverId, runtime] of this.servers.entries()) {
+            converted.set(serverId, {
+                config: runtime.config,
+                process: runtime.process,
+                client: runtime.client,
+                transport: runtime.transportInstance,
+                status: runtime.status,
+                lastError: runtime.lastError,
+                startTime: runtime.startTime,
+                lastHealthCheck: runtime.lastHealthCheck,
+                reconnectAttempts: runtime.reconnectAttempts,
+                maxReconnectAttempts: runtime.maxReconnectAttempts,
+                tools: runtime.toolsMap,
+                toolsArray: runtime.toolsArray,
+                capabilities: runtime.capabilities,
+                healthTimer: runtime.healthTimer,
+                restartTimer: runtime.restartTimer,
+                metrics: runtime.metrics,
+            });
+        }
+        return converted;
+    }
+    /**
+     * List servers as MCPServerInfo - ZERO conversion needed
+     */
+    listServers() {
+        return Array.from(this.servers.values());
     }
     /**
      * Get server statuses
@@ -527,7 +816,7 @@ export class ExternalServerManager extends EventEmitter {
                 isHealthy: instance.status === "connected",
                 status: instance.status,
                 checkedAt: instance.lastHealthCheck || new Date(),
-                toolCount: instance.tools.size,
+                toolCount: instance.toolsMap.size,
                 issues: instance.lastError ? [instance.lastError] : [],
                 performance: {
                     uptime,
@@ -569,7 +858,7 @@ export class ExternalServerManager extends EventEmitter {
             else if (instance.status === "failed") {
                 failedServers++;
             }
-            totalTools += instance.tools.size;
+            totalTools += instance.toolsMap.size;
             totalConnections += instance.metrics.totalConnections;
             totalErrors += instance.metrics.totalErrors;
         }
@@ -594,10 +883,16 @@ export class ExternalServerManager extends EventEmitter {
             mcpLogger.debug(`[ExternalServerManager] Discovering tools for server: ${serverId}`);
             const discoveryResult = await this.toolDiscovery.discoverTools(serverId, instance.client, this.config.defaultTimeout);
             if (discoveryResult.success) {
-                // Update instance tools
-                instance.tools.clear();
+                instance.toolsMap.clear();
+                instance.toolsArray = undefined;
+                instance.tools = [];
                 for (const tool of discoveryResult.tools) {
-                    instance.tools.set(tool.name, tool);
+                    instance.toolsMap.set(tool.name, tool);
+                    instance.tools.push({
+                        name: tool.name,
+                        description: tool.description,
+                        inputSchema: tool.inputSchema,
+                    });
                 }
                 mcpLogger.info(`[ExternalServerManager] Discovered ${discoveryResult.toolCount} tools for ${serverId}`);
             }
@@ -609,6 +904,72 @@ export class ExternalServerManager extends EventEmitter {
             mcpLogger.error(`[ExternalServerManager] Tool discovery error for ${serverId}:`, error);
         }
     }
+    /**
+     * Register server tools with main tool registry for unified access
+     * This enables external MCP tools to be accessed via the main toolRegistry.executeTool()
+     */
+    async registerServerToolsWithMainRegistry(serverId) {
+        const instance = this.servers.get(serverId);
+        if (!instance) {
+            throw new Error(`Server '${serverId}' not found`);
+        }
+        try {
+            mcpLogger.debug(`[ExternalServerManager] Registering ${instance.toolsMap.size} tools with main registry for server: ${serverId}`);
+            for (const [toolName, tool] of instance.toolsMap.entries()) {
+                const toolId = `${serverId}.${toolName}`;
+                const toolInfo = {
+                    name: toolName,
+                    description: tool.description || toolName,
+                    inputSchema: tool.inputSchema || {},
+                    serverId: serverId,
+                    category: detectCategory({ isExternal: true, serverId }),
+                };
+                // Register with main tool registry
+                try {
+                    toolRegistry.registerTool(toolId, toolInfo, {
+                        execute: async (params, context) => {
+                            // Execute tool via ExternalServerManager for proper lifecycle management
+                            return await this.executeTool(serverId, toolName, params, { timeout: this.config.defaultTimeout });
+                        },
+                    });
+                    mcpLogger.debug(`[ExternalServerManager] Registered tool with main registry: ${toolId}`);
+                }
+                catch (registrationError) {
+                    mcpLogger.warn(`[ExternalServerManager] Failed to register tool ${toolId} with main registry:`, registrationError);
+                }
+            }
+            mcpLogger.info(`[ExternalServerManager] Successfully registered ${instance.toolsMap.size} tools with main registry for ${serverId}`);
+        }
+        catch (error) {
+            mcpLogger.error(`[ExternalServerManager] Failed to register tools with main registry for ${serverId}:`, error);
+        }
+    }
+    /**
+     * Unregister server tools from main tool registry
+     */
+    unregisterServerToolsFromMainRegistry(serverId) {
+        const instance = this.servers.get(serverId);
+        if (!instance || !this.enableMainRegistryIntegration) {
+            return;
+        }
+        try {
+            mcpLogger.debug(`[ExternalServerManager] Unregistering tools from main registry for server: ${serverId}`);
+            for (const [toolName] of instance.toolsMap.entries()) {
+                const toolId = `${serverId}.${toolName}`;
+                try {
+                    toolRegistry.removeTool(toolId);
+                    mcpLogger.debug(`[ExternalServerManager] Unregistered tool from main registry: ${toolId}`);
+                }
+                catch (error) {
+                    mcpLogger.debug(`[ExternalServerManager] Failed to unregister tool ${toolId}:`, error);
+                }
+            }
+            mcpLogger.debug(`[ExternalServerManager] Completed unregistering tools from main registry for ${serverId}`);
+        }
+        catch (error) {
+            mcpLogger.error(`[ExternalServerManager] Error unregistering tools from main registry for ${serverId}:`, error);
+        }
+    }
     /**
      * Execute a tool on a specific server
      */

package/dist/lib/mcp/mcpClientFactory.d.ts

@@ -7,7 +7,8 @@ import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import type { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
 import type { ClientCapabilities } from "@modelcontextprotocol/sdk/types.js";
 import { ChildProcess } from "child_process";
-import type { ExternalMCPServerConfig, MCPTransportType } from "../types/externalMcp.js";
+import type { MCPTransportType } from "../types/externalMcp.js";
+import type { MCPServerInfo } from "../types/mcpTypes.js";
 /**
  * MCP client creation result
  */
@@ -37,7 +38,7 @@ export declare class MCPClientFactory {
     /**
      * Create an MCP client for the given server configuration
      */
-    static createClient(config: ExternalMCPServerConfig, timeout?: number): Promise<MCPClientResult>;
+    static createClient(config: MCPServerInfo, timeout?: number): Promise<MCPClientResult>;
     /**
      * Internal client creation logic
      */
@@ -81,7 +82,7 @@ export declare class MCPClientFactory {
     /**
      * Test connection to an MCP server
      */
-    static testConnection(config: ExternalMCPServerConfig, timeout?: number): Promise<{
+    static testConnection(config: MCPServerInfo, timeout?: number): Promise<{
         success: boolean;
         error?: string;
         capabilities?: ClientCapabilities;
@@ -89,7 +90,7 @@ export declare class MCPClientFactory {
     /**
      * Validate MCP server configuration for client creation
      */
-    static validateClientConfig(config: ExternalMCPServerConfig): {
+    static validateClientConfig(config: MCPServerInfo): {
         isValid: boolean;
         errors: string[];
     };

package/dist/lib/mcp/mcpClientFactory.js

@@ -133,8 +133,12 @@ export class MCPClientFactory {
             command: config.command,
             args: config.args,
         });
+        // Validate command is present
+        if (!config.command) {
+            throw new Error(`Command is required for stdio transport`);
+        }
         // Spawn the process
-        const childProcess = spawn(config.command, config.args, {
+        const childProcess = spawn(config.command, config.args || [], {
             stdio: ["pipe", "pipe", "pipe"],
             env: {
                 ...process.env,
@@ -159,13 +163,14 @@ export class MCPClientFactory {
             processErrorPromise,
         ]);
         // Check if process is still running
-        if (childProcess.killed || childProcess.exitCode !== null) {
+        if (childProcess.killed ||
+            childProcess.exitCode !== null) {
             throw new Error("Process failed to start or exited immediately");
         }
         // Create transport
         const transport = new StdioClientTransport({
             command: config.command,
-            args: config.args,
+            args: config.args || [],
             env: Object.fromEntries(Object.entries({
                 ...process.env,
                 ...config.env,

package/dist/lib/mcp/toolDiscoveryService.d.ts

@@ -94,6 +94,7 @@ export interface ToolRegistryEvents {
  * Handles automatic tool discovery and registration from external MCP servers
  */
 export declare class ToolDiscoveryService extends EventEmitter {
+    private serverToolStorage;
     private toolRegistry;
     private serverTools;
     private discoveryInProgress;