@juspay/neurolink 7.33.1 → 7.33.2

package/CHANGELOG.md

@@ -1,3 +1,9 @@
+## [7.33.2](https://github.com/juspay/neurolink/compare/v7.33.1...v7.33.2) (2025-09-04)
+
+### Bug Fixes
+
+- **(latency):** Reduced Tool Latency via Concurrent Server Init ([eb36fc9](https://github.com/juspay/neurolink/commit/eb36fc9a0ba32bb9b23c0ea163aadf2aa918d323))
+
 ## [7.33.1](https://github.com/juspay/neurolink/compare/v7.33.0...v7.33.1) (2025-09-03)
 
 ## [7.33.0](https://github.com/juspay/neurolink/compare/v7.32.0...v7.33.0) (2025-09-03)

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

@@ -22,12 +22,27 @@ export declare class ExternalServerManager extends EventEmitter {
         enableMainRegistryIntegration?: boolean;
     });
     /**
-     * Load MCP server configurations from .mcp-config.json file
+     * Load MCP server configurations from .mcp-config.json file with parallel loading support
      * 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
+     * @param options Loading options including parallel support
+     * @returns Promise resolving to { serversLoaded, errors }
      */
-    loadMCPConfiguration(configPath?: string): Promise<ServerLoadResult>;
+    loadMCPConfiguration(configPath?: string, options?: {
+        parallel?: boolean;
+    }): Promise<ServerLoadResult>;
+    /**
+     * Load MCP servers in parallel for improved performance
+     * @param configPath Optional path to config file (defaults to .mcp-config.json in cwd)
+     * @returns Promise resolving to batch operation result
+     */
+    loadMCPConfigurationParallel(configPath?: string | null): Promise<ServerLoadResult>;
+    /**
+     * Load MCP servers sequentially (original implementation for backward compatibility)
+     * @param configPath Optional path to config file (defaults to .mcp-config.json in cwd)
+     * @returns Promise resolving to batch operation result
+     */
+    loadMCPConfigurationSequential(configPath?: string): Promise<ServerLoadResult>;
     /**
      * Validate external MCP server configuration
      */

package/dist/lib/mcp/externalServerManager.js

@@ -107,12 +107,134 @@ export class ExternalServerManager extends EventEmitter {
         process.on("beforeExit", () => this.shutdown());
     }
     /**
-     * Load MCP server configurations from .mcp-config.json file
+     * Load MCP server configurations from .mcp-config.json file with parallel loading support
      * 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
+     * @param options Loading options including parallel support
+     * @returns Promise resolving to { serversLoaded, errors }
      */
-    async loadMCPConfiguration(configPath) {
+    async loadMCPConfiguration(configPath, options = {}) {
+        if (options.parallel) {
+            return this.loadMCPConfigurationParallel(configPath);
+        }
+        return this.loadMCPConfigurationSequential(configPath);
+    }
+    /**
+     * Load MCP servers in parallel for improved performance
+     * @param configPath Optional path to config file (defaults to .mcp-config.json in cwd)
+     * @returns Promise resolving to batch operation result
+     */
+    async loadMCPConfigurationParallel(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 in PARALLEL mode 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: [] };
+            }
+            // Create promises for all servers to start them concurrently
+            const serverPromises = Object.entries(config.mcpServers).map(async ([serverId, serverConfig]) => {
+                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: isNonNullObject(serverConfig.env)
+                            ? 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);
+                    return { serverId, result };
+                }
+                catch (error) {
+                    const errorMsg = `Failed to load MCP server ${serverId}: ${error instanceof Error ? error.message : String(error)}`;
+                    mcpLogger.warn(`[ExternalServerManager] ${errorMsg}`);
+                    return { serverId, error: errorMsg };
+                }
+            });
+            // Start all servers concurrently and wait for completion
+            const results = await Promise.allSettled(serverPromises);
+            // Process results to count successes and collect errors
+            let serversLoaded = 0;
+            const errors = [];
+            for (const result of results) {
+                if (result.status === "fulfilled") {
+                    const { serverId, result: serverResult, error } = result.value;
+                    if (serverResult && serverResult.success) {
+                        serversLoaded++;
+                        mcpLogger.debug(`[ExternalServerManager] Successfully loaded MCP server in parallel: ${serverId}`);
+                    }
+                    else if (error) {
+                        errors.push(error);
+                    }
+                    else if (serverResult && !serverResult.success) {
+                        const errorMsg = `Failed to load server ${serverId}: ${serverResult.error}`;
+                        errors.push(errorMsg);
+                        mcpLogger.warn(`[ExternalServerManager] ${errorMsg}`);
+                    }
+                }
+                else {
+                    // Promise.allSettled rejected - this shouldn't happen with our error handling
+                    const errorMsg = `Unexpected error during parallel loading: ${result.reason}`;
+                    errors.push(errorMsg);
+                    mcpLogger.error(`[ExternalServerManager] ${errorMsg}`);
+                }
+            }
+            mcpLogger.info(`[ExternalServerManager] PARALLEL MCP configuration loading complete: ${serversLoaded} servers loaded, ${errors.length} errors`);
+            return { serversLoaded, errors };
+        }
+        catch (error) {
+            const errorMsg = `Failed to load MCP configuration in parallel mode: ${error instanceof Error ? error.message : String(error)}`;
+            mcpLogger.error(`[ExternalServerManager] ${errorMsg}`);
+            return { serversLoaded: 0, errors: [errorMsg] };
+        }
+    }
+    /**
+     * Load MCP servers sequentially (original implementation for backward compatibility)
+     * @param configPath Optional path to config file (defaults to .mcp-config.json in cwd)
+     * @returns Promise resolving to batch operation result
+     */
+    async loadMCPConfigurationSequential(configPath) {
         const fs = await import("fs");
         const path = await import("path");
         const finalConfigPath = configPath || path.join(process.cwd(), ".mcp-config.json");

package/dist/lib/neurolink.d.ts

@@ -146,7 +146,7 @@ export declare class NeuroLink {
      */
     private registerDirectToolsServerInternal;
     /**
-     * Load MCP configuration from .mcp-config.json
+     * Load MCP configuration from .mcp-config.json with parallel loading for improved performance
      */
     private loadMCPConfigurationInternal;
     /**

package/dist/lib/neurolink.js

@@ -705,7 +705,7 @@ export class NeuroLink {
         }
     }
     /**
-     * Load MCP configuration from .mcp-config.json
+     * Load MCP configuration from .mcp-config.json with parallel loading for improved performance
      */
     async loadMCPConfigurationInternal(mcpInitId, mcpInitStartTime, mcpInitHrTimeStart) {
         const mcpConfigStartTime = process.hrtime.bigint();
@@ -720,7 +720,8 @@ export class NeuroLink {
             message: "Starting MCP configuration loading from .mcp-config.json",
         });
         try {
-            const configResult = await this.externalServerManager.loadMCPConfiguration();
+            const configResult = await this.externalServerManager.loadMCPConfiguration(undefined, // Use default config path
+            { parallel: true });
             const mcpConfigSuccessTime = process.hrtime.bigint();
             const mcpConfigDurationNs = mcpConfigSuccessTime - mcpConfigStartTime;
             logger.debug(`[NeuroLink] ✅ LOG_POINT_M015_MCP_CONFIG_SUCCESS`, {

package/dist/mcp/externalServerManager.d.ts

@@ -22,12 +22,27 @@ export declare class ExternalServerManager extends EventEmitter {
         enableMainRegistryIntegration?: boolean;
     });
     /**
-     * Load MCP server configurations from .mcp-config.json file
+     * Load MCP server configurations from .mcp-config.json file with parallel loading support
      * 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
+     * @param options Loading options including parallel support
+     * @returns Promise resolving to { serversLoaded, errors }
      */
-    loadMCPConfiguration(configPath?: string): Promise<ServerLoadResult>;
+    loadMCPConfiguration(configPath?: string, options?: {
+        parallel?: boolean;
+    }): Promise<ServerLoadResult>;
+    /**
+     * Load MCP servers in parallel for improved performance
+     * @param configPath Optional path to config file (defaults to .mcp-config.json in cwd)
+     * @returns Promise resolving to batch operation result
+     */
+    loadMCPConfigurationParallel(configPath?: string | null): Promise<ServerLoadResult>;
+    /**
+     * Load MCP servers sequentially (original implementation for backward compatibility)
+     * @param configPath Optional path to config file (defaults to .mcp-config.json in cwd)
+     * @returns Promise resolving to batch operation result
+     */
+    loadMCPConfigurationSequential(configPath?: string): Promise<ServerLoadResult>;
     /**
      * Validate external MCP server configuration
      */

package/dist/mcp/externalServerManager.js

@@ -107,12 +107,134 @@ export class ExternalServerManager extends EventEmitter {
         process.on("beforeExit", () => this.shutdown());
     }
     /**
-     * Load MCP server configurations from .mcp-config.json file
+     * Load MCP server configurations from .mcp-config.json file with parallel loading support
      * 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
+     * @param options Loading options including parallel support
+     * @returns Promise resolving to { serversLoaded, errors }
      */
-    async loadMCPConfiguration(configPath) {
+    async loadMCPConfiguration(configPath, options = {}) {
+        if (options.parallel) {
+            return this.loadMCPConfigurationParallel(configPath);
+        }
+        return this.loadMCPConfigurationSequential(configPath);
+    }
+    /**
+     * Load MCP servers in parallel for improved performance
+     * @param configPath Optional path to config file (defaults to .mcp-config.json in cwd)
+     * @returns Promise resolving to batch operation result
+     */
+    async loadMCPConfigurationParallel(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 in PARALLEL mode 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: [] };
+            }
+            // Create promises for all servers to start them concurrently
+            const serverPromises = Object.entries(config.mcpServers).map(async ([serverId, serverConfig]) => {
+                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: isNonNullObject(serverConfig.env)
+                            ? 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);
+                    return { serverId, result };
+                }
+                catch (error) {
+                    const errorMsg = `Failed to load MCP server ${serverId}: ${error instanceof Error ? error.message : String(error)}`;
+                    mcpLogger.warn(`[ExternalServerManager] ${errorMsg}`);
+                    return { serverId, error: errorMsg };
+                }
+            });
+            // Start all servers concurrently and wait for completion
+            const results = await Promise.allSettled(serverPromises);
+            // Process results to count successes and collect errors
+            let serversLoaded = 0;
+            const errors = [];
+            for (const result of results) {
+                if (result.status === "fulfilled") {
+                    const { serverId, result: serverResult, error } = result.value;
+                    if (serverResult && serverResult.success) {
+                        serversLoaded++;
+                        mcpLogger.debug(`[ExternalServerManager] Successfully loaded MCP server in parallel: ${serverId}`);
+                    }
+                    else if (error) {
+                        errors.push(error);
+                    }
+                    else if (serverResult && !serverResult.success) {
+                        const errorMsg = `Failed to load server ${serverId}: ${serverResult.error}`;
+                        errors.push(errorMsg);
+                        mcpLogger.warn(`[ExternalServerManager] ${errorMsg}`);
+                    }
+                }
+                else {
+                    // Promise.allSettled rejected - this shouldn't happen with our error handling
+                    const errorMsg = `Unexpected error during parallel loading: ${result.reason}`;
+                    errors.push(errorMsg);
+                    mcpLogger.error(`[ExternalServerManager] ${errorMsg}`);
+                }
+            }
+            mcpLogger.info(`[ExternalServerManager] PARALLEL MCP configuration loading complete: ${serversLoaded} servers loaded, ${errors.length} errors`);
+            return { serversLoaded, errors };
+        }
+        catch (error) {
+            const errorMsg = `Failed to load MCP configuration in parallel mode: ${error instanceof Error ? error.message : String(error)}`;
+            mcpLogger.error(`[ExternalServerManager] ${errorMsg}`);
+            return { serversLoaded: 0, errors: [errorMsg] };
+        }
+    }
+    /**
+     * Load MCP servers sequentially (original implementation for backward compatibility)
+     * @param configPath Optional path to config file (defaults to .mcp-config.json in cwd)
+     * @returns Promise resolving to batch operation result
+     */
+    async loadMCPConfigurationSequential(configPath) {
         const fs = await import("fs");
         const path = await import("path");
         const finalConfigPath = configPath || path.join(process.cwd(), ".mcp-config.json");

package/dist/neurolink.d.ts

@@ -146,7 +146,7 @@ export declare class NeuroLink {
      */
     private registerDirectToolsServerInternal;
     /**
-     * Load MCP configuration from .mcp-config.json
+     * Load MCP configuration from .mcp-config.json with parallel loading for improved performance
      */
     private loadMCPConfigurationInternal;
     /**

package/dist/neurolink.js

@@ -705,7 +705,7 @@ export class NeuroLink {
         }
     }
     /**
-     * Load MCP configuration from .mcp-config.json
+     * Load MCP configuration from .mcp-config.json with parallel loading for improved performance
      */
     async loadMCPConfigurationInternal(mcpInitId, mcpInitStartTime, mcpInitHrTimeStart) {
         const mcpConfigStartTime = process.hrtime.bigint();
@@ -720,7 +720,8 @@ export class NeuroLink {
             message: "Starting MCP configuration loading from .mcp-config.json",
         });
         try {
-            const configResult = await this.externalServerManager.loadMCPConfiguration();
+            const configResult = await this.externalServerManager.loadMCPConfiguration(undefined, // Use default config path
+            { parallel: true });
             const mcpConfigSuccessTime = process.hrtime.bigint();
             const mcpConfigDurationNs = mcpConfigSuccessTime - mcpConfigStartTime;
             logger.debug(`[NeuroLink] ✅ LOG_POINT_M015_MCP_CONFIG_SUCCESS`, {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "7.33.1",
+  "version": "7.33.2",
   "description": "Universal AI Development Platform with working MCP integration, multi-provider support, and professional CLI. Built-in tools operational, 58+ external MCP servers discoverable. Connect to filesystem, GitHub, database operations, and more. Build, test, and deploy AI applications with 9 major providers: OpenAI, Anthropic, Google AI, AWS Bedrock, Azure, Hugging Face, Ollama, and Mistral AI.",
   "author": {
     "name": "Juspay Technologies",