@juspay/neurolink 7.33.0 → 7.33.2

package/dist/lib/core/factory.js

@@ -316,4 +316,3 @@ export class AIProviderFactory {
         }
     }
 }
-export { componentIdentifier };

package/dist/lib/core/modelConfiguration.d.ts

@@ -4,7 +4,7 @@
  * Replaces hardcoded model-specific logic with configurable, runtime-updateable configurations.
  * This addresses GitHub Copilot review comment about making model-specific logic configuration-based.
  */
-import type { JsonValue } from "../types/common.js";
+import type { ModelTier, ProviderConfiguration, ConfigSource } from "../types/modelTypes.js";
 /**
  * Model name constants - extracted from hardcoded values for better maintainability
  * These constants can be overridden by environment variables
@@ -61,67 +61,6 @@ export declare const MODEL_NAMES: {
         readonly QUALITY: "mistral-large-latest";
     };
 };
-/**
- * Model performance tier definition
- */
-export type ModelTier = "fast" | "balanced" | "quality";
-/**
- * Model configuration for a specific provider
- */
-export interface ModelConfig {
-    /** Model identifier */
-    id: string;
-    /** Display name */
-    name: string;
-    /** Performance tier */
-    tier: ModelTier;
-    /** Cost per 1K tokens */
-    cost: {
-        input: number;
-        output: number;
-    };
-    /** Model capabilities */
-    capabilities: string[];
-    /** Model-specific options */
-    options?: Record<string, JsonValue>;
-}
-/**
- * Provider configuration with models
- */
-export interface ProviderConfig {
-    /** Provider name */
-    provider: string;
-    /** Available models by tier */
-    models: Record<ModelTier, string>;
-    /** Default cost per token (fallback) */
-    defaultCost: {
-        input: number;
-        output: number;
-    };
-    /** Required environment variables */
-    requiredEnvVars: string[];
-    /** Provider-specific performance metrics */
-    performance: {
-        speed: number;
-        quality: number;
-        cost: number;
-    };
-    /** Provider-specific model configurations */
-    modelConfigs?: Record<string, ModelConfig>;
-    /** Provider-specific model behavior configurations */
-    modelBehavior?: {
-        /** Models that have issues with maxTokens parameter */
-        maxTokensIssues?: string[];
-        /** Models that require special handling */
-        specialHandling?: Record<string, JsonValue>;
-        /** Models that support tool calling (Ollama-specific) */
-        toolCapableModels?: string[];
-    };
-}
-/**
- * Configuration source type
- */
-export type ConfigSource = "default" | "environment" | "file" | "dynamic";
 /**
  * Model configuration manager
  */
@@ -147,7 +86,7 @@ export declare class ModelConfigurationManager {
     /**
      * Create all provider configurations - centralized approach
      */
-    private createAllProviderConfigs;
+    private createAllProviderConfigurations;
     /**
      * Create Anthropic provider configuration
      */
@@ -209,15 +148,15 @@ export declare class ModelConfigurationManager {
     /**
      * Get provider configuration
      */
-    getProviderConfig(provider: string): ProviderConfig | null;
+    getProviderConfiguration(provider: string): ProviderConfiguration | null;
     /**
      * Get all provider configurations
      */
-    getAllConfigurations(): Map<string, ProviderConfig>;
+    getAllConfigurations(): Map<string, ProviderConfiguration>;
     /**
      * Update provider configuration (runtime updates)
      */
-    updateProviderConfig(provider: string, config: ProviderConfig): void;
+    updateProviderConfiguration(provider: string, config: ProviderConfiguration): void;
     /**
      * Parse YAML content with basic support
      * For full YAML support, would need a proper YAML library
@@ -244,7 +183,7 @@ export declare class ModelConfigurationManager {
     /**
      * Validate provider configuration structure
      */
-    private isValidProviderConfig;
+    private isValidProviderConfiguration;
     /**
      * Apply model name overrides from configuration file
      */
@@ -279,7 +218,7 @@ export declare class ModelConfigurationManager {
     /**
      * Get available providers
      */
-    getAvailableProviders(): ProviderConfig[];
+    getAvailableProviders(): ProviderConfiguration[];
 }
 /**
  * Global instance accessor
@@ -291,7 +230,7 @@ export declare const modelConfig: ModelConfigurationManager;
 /**
  * Get provider configuration (backwards compatible)
  */
-export declare function getProviderConfig(provider: string): ProviderConfig | null;
+export declare function getProviderConfiguration(provider: string): ProviderConfiguration | null;
 /**
  * Get model for tier (backwards compatible)
  */

package/dist/lib/core/modelConfiguration.js

@@ -175,7 +175,7 @@ export class ModelConfigurationManager {
     /**
      * Create all provider configurations - centralized approach
      */
-    createAllProviderConfigs() {
+    createAllProviderConfigurations() {
         return {
             "google-ai": this.createGoogleAIConfig(),
             "google-vertex": this.createVertexConfig(),
@@ -383,7 +383,7 @@ export class ModelConfigurationManager {
      */
     loadDefaultConfigurations() {
         // Load all provider configurations using centralized method
-        const defaultConfigs = this.createAllProviderConfigs();
+        const defaultConfigs = this.createAllProviderConfigurations();
         // Load configurations
         for (const [provider, config] of Object.entries(defaultConfigs)) {
             this.configurations.set(provider, config);
@@ -484,7 +484,7 @@ export class ModelConfigurationManager {
     /**
      * Get provider configuration
      */
-    getProviderConfig(provider) {
+    getProviderConfiguration(provider) {
         return this.configurations.get(provider) || null;
     }
     /**
@@ -496,7 +496,7 @@ export class ModelConfigurationManager {
     /**
      * Update provider configuration (runtime updates)
      */
-    updateProviderConfig(provider, config) {
+    updateProviderConfiguration(provider, config) {
         this.configurations.set(provider, config);
         this.lastUpdated = Date.now();
         this.configSource = "dynamic";
@@ -596,7 +596,7 @@ export class ModelConfigurationManager {
             if (config.providers && typeof config.providers === "object") {
                 const providers = config.providers;
                 for (const [providerName, providerConfig] of Object.entries(providers)) {
-                    if (this.isValidProviderConfig(providerConfig)) {
+                    if (this.isValidProviderConfiguration(providerConfig)) {
                         this.configurations.set(providerName, providerConfig);
                         logger.debug(`Loaded configuration for provider: ${providerName}`);
                     }
@@ -629,7 +629,7 @@ export class ModelConfigurationManager {
     /**
      * Validate provider configuration structure
      */
-    isValidProviderConfig(config) {
+    isValidProviderConfiguration(config) {
         if (!config || typeof config !== "object") {
             return false;
         }
@@ -769,14 +769,14 @@ export class ModelConfigurationManager {
      * Get model for specific tier and provider
      */
     getModelForTier(provider, tier) {
-        const config = this.getProviderConfig(provider);
+        const config = this.getProviderConfiguration(provider);
         return config?.models[tier] || null;
     }
     /**
      * Get cost information for provider and model
      */
     getCostInfo(provider, model) {
-        const config = this.getProviderConfig(provider);
+        const config = this.getProviderConfiguration(provider);
         if (!config) {
             return null;
         }
@@ -790,7 +790,7 @@ export class ModelConfigurationManager {
      * Check if provider is available (has required environment variables)
      */
     isProviderAvailable(provider) {
-        const config = this.getProviderConfig(provider);
+        const config = this.getProviderConfiguration(provider);
         if (!config) {
             return false;
         }
@@ -816,8 +816,8 @@ export const modelConfig = ModelConfigurationManager.getInstance();
 /**
  * Get provider configuration (backwards compatible)
  */
-export function getProviderConfig(provider) {
-    return modelConfig.getProviderConfig(provider);
+export function getProviderConfiguration(provider) {
+    return modelConfig.getProviderConfiguration(provider);
 }
 /**
  * Get model for tier (backwards compatible)

package/dist/lib/core/serviceRegistry.d.ts

@@ -2,14 +2,7 @@
  * Service Registry for Dependency Injection
  * Breaks circular dependencies by providing lazy loading and centralized service management
  */
-export interface ServiceFactory<T = unknown> {
-    (): T | Promise<T>;
-}
-export interface ServiceRegistration<T = unknown> {
-    factory: ServiceFactory<T>;
-    singleton: boolean;
-    instance?: T;
-}
+import type { ServiceFactory } from "../types/serviceTypes.js";
 export declare class ServiceRegistry {
     private static services;
     private static initializing;

package/dist/lib/core/streamAnalytics.d.ts

@@ -1,47 +1,5 @@
-import type { AnalyticsData } from "./types.js";
-import type { TokenUsage } from "../types/providers.js";
-import type { ToolCall, ToolResult } from "../types/streamTypes.js";
-/**
- * Raw usage data from Vercel AI SDK (uses different field names)
- */
-interface AISDKUsage {
-    promptTokens: number;
-    completionTokens: number;
-    totalTokens: number;
-}
-/**
- * Stream analytics result from Vercel AI SDK streamText
- */
-export interface StreamTextResult {
-    textStream: AsyncIterable<string>;
-    text: Promise<string>;
-    usage: Promise<AISDKUsage | undefined>;
-    response: Promise<{
-        id?: string;
-        model?: string;
-        timestamp?: number | Date;
-    } | undefined>;
-    finishReason: Promise<"stop" | "length" | "content-filter" | "tool-calls" | "error" | "other" | "unknown">;
-    toolResults?: Promise<ToolResult[]>;
-    toolCalls?: Promise<ToolCall[]>;
-}
-/**
- * Interface for collecting analytics from streaming results
- */
-export interface StreamAnalyticsCollector {
-    collectUsage(result: StreamTextResult): Promise<TokenUsage>;
-    collectMetadata(result: StreamTextResult): Promise<ResponseMetadata>;
-    createAnalytics(provider: string, model: string, result: StreamTextResult, responseTime: number, metadata?: Record<string, unknown>): Promise<AnalyticsData>;
-}
-/**
- * Response metadata from stream result
- */
-export interface ResponseMetadata {
-    id?: string;
-    model?: string;
-    timestamp?: number;
-    finishReason?: string;
-}
+import type { AnalyticsData, TokenUsage } from "../types/analytics.js";
+import type { StreamTextResult, StreamAnalyticsCollector, ResponseMetadata } from "../types/streamTypes.js";
 /**
  * Base implementation for collecting analytics from Vercel AI SDK stream results
  */
@@ -67,4 +25,3 @@ export declare class BaseStreamAnalyticsCollector implements StreamAnalyticsColl
  * Global instance of stream analytics collector
  */
 export declare const streamAnalyticsCollector: BaseStreamAnalyticsCollector;
-export {};

package/dist/lib/factories/providerFactory.d.ts

@@ -1,4 +1,4 @@
-import type { AIProvider, AIProviderName } from "../core/types.js";
+import type { AIProvider, AIProviderName } from "../types/index.js";
 import type { UnknownRecord } from "../types/common.js";
 /**
  * Provider constructor interface - supports both sync constructors and async factory functions

package/dist/lib/factories/providerRegistry.js

@@ -2,7 +2,7 @@ import { ProviderFactory } from "./providerFactory.js";
 // Lazy loading all providers to avoid circular dependencies
 // Removed all static imports - providers loaded dynamically when needed
 // This breaks the circular dependency chain completely
-import { AIProviderName, GoogleAIModels, OpenAIModels } from "../core/types.js";
+import { AIProviderName, GoogleAIModels, OpenAIModels, } from "../types/index.js";
 import { logger } from "../utils/logger.js";
 /**
  * Provider Registry - registers all providers with the factory

package/dist/lib/index.d.ts

@@ -8,15 +8,15 @@
  */
 import { AIProviderFactory } from "./core/factory.js";
 export { AIProviderFactory };
-export type { AIProvider, AIProviderName, ProviderConfig, StreamingOptions, ProviderAttempt, SupportedModelName, } from "./core/types.js";
+export type { AIProvider, AIProviderName, ProviderConfig, StreamingOptions, ProviderAttempt, SupportedModelName, } from "./types/index.js";
 export type { GenerateOptions, GenerateResult, EnhancedProvider, } from "./types/generateTypes.js";
 export type { ToolContext } from "./sdk/toolRegistration.js";
 export { validateTool } from "./sdk/toolRegistration.js";
 export type { ToolResult, ToolDefinition } from "./types/tools.js";
-export { BedrockModels, OpenAIModels, VertexModels, DEFAULT_PROVIDER_CONFIGS, } from "./core/types.js";
+export { BedrockModels, OpenAIModels, VertexModels, DEFAULT_PROVIDER_CONFIGS, } from "./types/index.js";
 export { getBestProvider, getAvailableProviders, isValidProvider, } from "./utils/providerUtils.js";
 export { dynamicModelProvider } from "./core/dynamicModels.js";
-export type { ModelConfig, ModelRegistry } from "./core/dynamicModels.js";
+export type { DynamicModelConfig, ModelRegistry } from "./types/modelTypes.js";
 export { NeuroLink } from "./neurolink.js";
 export type { ProviderStatus, MCPStatus } from "./neurolink.js";
 export type { MCPServerInfo } from "./types/mcpTypes.js";
@@ -85,8 +85,7 @@ export declare function getTelemetryStatus(): {
     enabled: boolean;
     initialized: boolean;
 };
-export type { TextGenerationOptions, TextGenerationResult, AnalyticsData, } from "./core/types.js";
-export type { EvaluationData } from "./types/providers.js";
+export type { TextGenerationOptions, TextGenerationResult, AnalyticsData, EvaluationData, } from "./types/index.js";
 /**
  * BACKWARD COMPATIBILITY: Legacy generateText function
  * Provides standalone generateText function for existing code that uses it
@@ -103,4 +102,4 @@ export type { EvaluationData } from "./types/providers.js";
  * console.log(result.content);
  * ```
  */
-export declare function generateText(options: import("./core/types.js").TextGenerationOptions): Promise<import("./core/types.js").TextGenerationResult>;
+export declare function generateText(options: import("./types/index.js").TextGenerationOptions): Promise<import("./types/index.js").TextGenerationResult>;

package/dist/lib/index.js

@@ -11,7 +11,7 @@ import { AIProviderFactory } from "./core/factory.js";
 export { AIProviderFactory };
 export { validateTool } from "./sdk/toolRegistration.js";
 // Model enums
-export { BedrockModels, OpenAIModels, VertexModels, DEFAULT_PROVIDER_CONFIGS, } from "./core/types.js";
+export { BedrockModels, OpenAIModels, VertexModels, DEFAULT_PROVIDER_CONFIGS, } from "./types/index.js";
 // Utility exports
 export { getBestProvider, getAvailableProviders, isValidProvider, } from "./utils/providerUtils.js";
 // Dynamic Models exports

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/models/modelRegistry.d.ts

@@ -3,7 +3,7 @@
  * Provides centralized model data for models command system
  * Part of Phase 4.1 - Models Command System
  */
-import { AIProviderName } from "../core/types.js";
+import { AIProviderName } from "../types/index.js";
 import type { JsonValue } from "../types/common.js";
 /**
  * Model capabilities interface

package/dist/lib/models/modelRegistry.js

@@ -3,7 +3,7 @@
  * Provides centralized model data for models command system
  * Part of Phase 4.1 - Models Command System
  */
-import { AIProviderName } from "../core/types.js";
+import { AIProviderName } from "../types/index.js";
 /**
  * Comprehensive model registry
  */

package/dist/lib/models/modelResolver.d.ts

@@ -3,7 +3,7 @@
  * Provides model resolution, search, and recommendation functionality
  * Part of Phase 4.1 - Models Command System
  */
-import { AIProviderName } from "../core/types.js";
+import { AIProviderName } from "../types/index.js";
 import type { JsonValue } from "../types/common.js";
 import { type ModelInfo, type ModelSearchFilters, type ModelSearchResult, type ModelCapabilities, type UseCaseSuitability } from "./modelRegistry.js";
 /**

package/dist/lib/neurolink.d.ts

@@ -5,7 +5,7 @@
  * Enhanced AI provider system with natural MCP tool access.
  * Uses real MCP infrastructure for tool discovery and execution.
  */
-import type { TextGenerationOptions, TextGenerationResult } from "./core/types.js";
+import type { TextGenerationOptions, TextGenerationResult } from "./types/index.js";
 import type { GenerateOptions, GenerateResult } from "./types/generateTypes.js";
 import type { StreamOptions, StreamResult } from "./types/streamTypes.js";
 import type { MCPServerInfo, MCPExecutableTool } from "./types/mcpTypes.js";
@@ -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

@@ -36,7 +36,7 @@ import { ExternalServerManager } from "./mcp/externalServerManager.js";
 // Import direct tools server for automatic registration
 import { directToolsServer } from "./mcp/servers/agent/directToolsServer.js";
 import { isNonNullObject } from "./utils/typeUtils.js";
-// Core types imported from core/types.js
+// Core types imported from "./types/index.js"
 export class NeuroLink {
     mcpInitialized = false;
     emitter = new EventEmitter();
@@ -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/lib/providers/amazonBedrock.d.ts

@@ -1,8 +1,7 @@
 import { BedrockRuntimeClient } from "@aws-sdk/client-bedrock-runtime";
 import { BaseProvider } from "../core/baseProvider.js";
-import type { AIProviderName, EnhancedGenerateResult } from "../core/types.js";
+import type { AIProviderName, EnhancedGenerateResult, TextGenerationOptions } from "../types/index.js";
 import type { StreamOptions, StreamResult } from "../types/streamTypes.js";
-import type { TextGenerationOptions } from "../core/types.js";
 import type { NeuroLink } from "../neurolink.js";
 export declare class AmazonBedrockProvider extends BaseProvider {
     private bedrockClient;

package/dist/lib/providers/amazonSagemaker.d.ts

@@ -6,7 +6,7 @@
  */
 import type { ZodType, ZodTypeDef } from "zod";
 import type { Schema, LanguageModelV1 } from "ai";
-import type { AIProviderName } from "../core/types.js";
+import type { AIProviderName } from "../types/index.js";
 import type { StreamOptions, StreamResult } from "../types/streamTypes.js";
 import { BaseProvider } from "../core/baseProvider.js";
 /**

package/dist/lib/providers/anthropic.d.ts

@@ -1,6 +1,6 @@
 import { type LanguageModelV1 } from "ai";
 import type { ValidationSchema } from "../types/typeAliases.js";
-import type { AIProviderName } from "../core/types.js";
+import type { AIProviderName } from "../types/index.js";
 import type { StreamOptions, StreamResult } from "../types/streamTypes.js";
 import { BaseProvider } from "../core/baseProvider.js";
 /**

package/dist/lib/providers/anthropic.js

@@ -1,6 +1,6 @@
 import { createAnthropic } from "@ai-sdk/anthropic";
 import { streamText } from "ai";
-import { AnthropicModels } from "../core/types.js";
+import { AnthropicModels } from "../types/index.js";
 import { BaseProvider } from "../core/baseProvider.js";
 import { logger } from "../utils/logger.js";
 import { createTimeoutController, TimeoutError } from "../utils/timeout.js";