@juspay/neurolink 7.33.1 → 7.33.3

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

@@ -0,0 +1,268 @@
+import type { Tool, Schema } from "ai";
+import type { ZodUnknownSchema, ValidationSchema } from "../types/typeAliases.js";
+import type { GenerateResult } from "../types/generateTypes.js";
+import type { StreamOptions, StreamResult } from "../types/streamTypes.js";
+import type { JsonValue } from "../types/common.js";
+import type { ChatMessage, ConversationMemoryConfig } from "../types/conversationTypes.js";
+import type { TokenUsage, AnalyticsData } from "../types/analytics.js";
+import type { EvaluationData } from "../index.js";
+export type { EvaluationData };
+import type { MiddlewareFactoryOptions } from "../types/middlewareTypes.js";
+export interface TextGenerationResult {
+    content: string;
+    provider?: string;
+    model?: string;
+    usage?: TokenUsage;
+    responseTime?: number;
+    toolsUsed?: string[];
+    toolExecutions?: Array<{
+        toolName: string;
+        executionTime: number;
+        success: boolean;
+        serverId?: string;
+    }>;
+    enhancedWithTools?: boolean;
+    availableTools?: Array<{
+        name: string;
+        description: string;
+        server: string;
+        category?: string;
+    }>;
+    analytics?: AnalyticsData;
+    evaluation?: EvaluationData;
+}
+/**
+ * Supported AI Provider Names
+ */
+export declare enum AIProviderName {
+    BEDROCK = "bedrock",
+    OPENAI = "openai",
+    OPENAI_COMPATIBLE = "openai-compatible",
+    VERTEX = "vertex",
+    ANTHROPIC = "anthropic",
+    AZURE = "azure",
+    GOOGLE_AI = "google-ai",
+    HUGGINGFACE = "huggingface",
+    OLLAMA = "ollama",
+    MISTRAL = "mistral",
+    LITELLM = "litellm",
+    SAGEMAKER = "sagemaker",
+    AUTO = "auto"
+}
+/**
+ * Supported Models for Amazon Bedrock
+ */
+export declare enum BedrockModels {
+    CLAUDE_3_SONNET = "anthropic.claude-3-sonnet-20240229-v1:0",
+    CLAUDE_3_HAIKU = "anthropic.claude-3-haiku-20240307-v1:0",
+    CLAUDE_3_5_SONNET = "anthropic.claude-3-5-sonnet-20240620-v1:0",
+    CLAUDE_3_7_SONNET = "arn:aws:bedrock:us-east-2:225681119357:inference-profile/us.anthropic.claude-3-7-sonnet-20250219-v1:0"
+}
+/**
+ * Supported Models for OpenAI
+ */
+export declare enum OpenAIModels {
+    GPT_4 = "gpt-4",
+    GPT_4_TURBO = "gpt-4-turbo",
+    GPT_4O = "gpt-4o",
+    GPT_4O_MINI = "gpt-4o-mini",
+    GPT_3_5_TURBO = "gpt-3.5-turbo",
+    O1_PREVIEW = "o1-preview",
+    O1_MINI = "o1-mini"
+}
+/**
+ * Supported Models for Google Vertex AI
+ */
+export declare enum VertexModels {
+    CLAUDE_4_0_SONNET = "claude-sonnet-4@20250514",
+    CLAUDE_4_0_OPUS = "claude-opus-4@20250514",
+    CLAUDE_3_5_SONNET = "claude-3-5-sonnet-20241022",
+    CLAUDE_3_5_HAIKU = "claude-3-5-haiku-20241022",
+    CLAUDE_3_SONNET = "claude-3-sonnet-20240229",
+    CLAUDE_3_OPUS = "claude-3-opus-20240229",
+    CLAUDE_3_HAIKU = "claude-3-haiku-20240307",
+    GEMINI_2_5_PRO = "gemini-2.5-pro",
+    GEMINI_2_5_FLASH = "gemini-2.5-flash",
+    GEMINI_2_5_FLASH_LITE = "gemini-2.5-flash-lite",
+    GEMINI_2_0_FLASH_001 = "gemini-2.0-flash-001",
+    GEMINI_1_5_PRO = "gemini-1.5-pro",
+    GEMINI_1_5_FLASH = "gemini-1.5-flash"
+}
+/**
+ * Supported Models for Google AI Studio
+ */
+export declare enum GoogleAIModels {
+    GEMINI_2_5_PRO = "gemini-2.5-pro",
+    GEMINI_2_5_FLASH = "gemini-2.5-flash",
+    GEMINI_2_5_FLASH_LITE = "gemini-2.5-flash-lite",
+    GEMINI_2_0_FLASH_001 = "gemini-2.0-flash-001",
+    GEMINI_1_5_PRO = "gemini-1.5-pro",
+    GEMINI_1_5_FLASH = "gemini-1.5-flash",
+    GEMINI_1_5_FLASH_LITE = "gemini-1.5-flash-lite"
+}
+/**
+ * Supported Models for Anthropic (Direct API)
+ */
+export declare enum AnthropicModels {
+    CLAUDE_3_5_SONNET = "claude-3-5-sonnet-20241022",
+    CLAUDE_3_5_HAIKU = "claude-3-5-haiku-20241022",
+    CLAUDE_3_SONNET = "claude-3-sonnet-20240229",
+    CLAUDE_3_OPUS = "claude-3-opus-20240229",
+    CLAUDE_3_HAIKU = "claude-3-haiku-20240307"
+}
+/**
+ * API Versions for various providers
+ */
+export declare enum APIVersions {
+    AZURE_LATEST = "2025-04-01-preview",
+    AZURE_STABLE = "2024-10-21",
+    AZURE_LEGACY = "2023-12-01-preview",
+    OPENAI_CURRENT = "v1",
+    OPENAI_BETA = "v1-beta",
+    GOOGLE_AI_CURRENT = "v1",
+    GOOGLE_AI_BETA = "v1beta",
+    ANTHROPIC_CURRENT = "2023-06-01"
+}
+/**
+ * Default model aliases for easy reference
+ */
+export declare const DEFAULT_MODEL_ALIASES: {
+    readonly LATEST_OPENAI: OpenAIModels.GPT_4O;
+    readonly FASTEST_OPENAI: OpenAIModels.GPT_4O_MINI;
+    readonly LATEST_ANTHROPIC: AnthropicModels.CLAUDE_3_5_SONNET;
+    readonly FASTEST_ANTHROPIC: AnthropicModels.CLAUDE_3_5_HAIKU;
+    readonly LATEST_GOOGLE: GoogleAIModels.GEMINI_2_5_PRO;
+    readonly FASTEST_GOOGLE: GoogleAIModels.GEMINI_2_5_FLASH;
+    readonly BEST_CODING: AnthropicModels.CLAUDE_3_5_SONNET;
+    readonly BEST_ANALYSIS: GoogleAIModels.GEMINI_2_5_PRO;
+    readonly BEST_CREATIVE: AnthropicModels.CLAUDE_3_5_SONNET;
+    readonly BEST_VALUE: GoogleAIModels.GEMINI_2_5_FLASH;
+};
+/**
+ * @deprecated Use DEFAULT_MODEL_ALIASES instead. Will be removed in future version.
+ */
+export declare const ModelAliases: {
+    readonly LATEST_OPENAI: OpenAIModels.GPT_4O;
+    readonly FASTEST_OPENAI: OpenAIModels.GPT_4O_MINI;
+    readonly LATEST_ANTHROPIC: AnthropicModels.CLAUDE_3_5_SONNET;
+    readonly FASTEST_ANTHROPIC: AnthropicModels.CLAUDE_3_5_HAIKU;
+    readonly LATEST_GOOGLE: GoogleAIModels.GEMINI_2_5_PRO;
+    readonly FASTEST_GOOGLE: GoogleAIModels.GEMINI_2_5_FLASH;
+    readonly BEST_CODING: AnthropicModels.CLAUDE_3_5_SONNET;
+    readonly BEST_ANALYSIS: GoogleAIModels.GEMINI_2_5_PRO;
+    readonly BEST_CREATIVE: AnthropicModels.CLAUDE_3_5_SONNET;
+    readonly BEST_VALUE: GoogleAIModels.GEMINI_2_5_FLASH;
+};
+/**
+ * Union type of all supported model names
+ */
+export type SupportedModelName = BedrockModels | OpenAIModels | VertexModels | GoogleAIModels | AnthropicModels;
+/**
+ * Provider configuration specifying provider and its available models
+ */
+export interface ProviderConfig {
+    provider: AIProviderName;
+    models: SupportedModelName[];
+}
+/**
+ * Options for AI requests with unified provider configuration
+ */
+export interface StreamingOptions {
+    providers: ProviderConfig[];
+    temperature?: number;
+    maxTokens?: number;
+    systemPrompt?: string;
+}
+/**
+ * Text generation options interface
+ */
+export interface TextGenerationOptions {
+    prompt?: string;
+    input?: {
+        text: string;
+    };
+    provider?: AIProviderName;
+    model?: string;
+    temperature?: number;
+    maxTokens?: number;
+    systemPrompt?: string;
+    schema?: ZodUnknownSchema | Schema<unknown>;
+    tools?: Record<string, Tool>;
+    timeout?: number | string;
+    disableTools?: boolean;
+    maxSteps?: number;
+    enableEvaluation?: boolean;
+    enableAnalytics?: boolean;
+    context?: Record<string, JsonValue>;
+    evaluationDomain?: string;
+    toolUsageContext?: string;
+    conversationHistory?: Array<{
+        role: string;
+        content: string;
+    }>;
+    conversationMessages?: ChatMessage[];
+    conversationMemoryConfig?: Partial<ConversationMemoryConfig>;
+    originalPrompt?: string;
+    middleware?: MiddlewareFactoryOptions;
+    expectedOutcome?: string;
+    evaluationCriteria?: string[];
+}
+export type { AnalyticsData } from "../types/analytics.js";
+/**
+ * Enhanced result interfaces with optional analytics/evaluation
+ */
+export interface EnhancedGenerateResult extends GenerateResult {
+    analytics?: AnalyticsData;
+    evaluation?: EvaluationData;
+}
+/**
+ * Phase 2: Enhanced Streaming Infrastructure
+ * Progress tracking and metadata for streaming operations
+ */
+export interface StreamingProgressData {
+    chunkCount: number;
+    totalBytes: number;
+    chunkSize: number;
+    elapsedTime: number;
+    estimatedRemaining?: number;
+    streamId?: string;
+    phase: "initializing" | "streaming" | "processing" | "complete" | "error";
+}
+export interface StreamingMetadata {
+    startTime: number;
+    endTime?: number;
+    totalDuration?: number;
+    averageChunkSize: number;
+    maxChunkSize: number;
+    minChunkSize: number;
+    throughputBytesPerSecond?: number;
+    streamingProvider: string;
+    modelUsed: string;
+}
+export type ProgressCallback = (progress: StreamingProgressData) => void;
+/**
+ * AI Provider interface with flexible parameter support
+ */
+export interface AIProvider {
+    stream(optionsOrPrompt: StreamOptions | string, analysisSchema?: ValidationSchema): Promise<StreamResult>;
+    generate(optionsOrPrompt: TextGenerationOptions | string, analysisSchema?: ValidationSchema): Promise<EnhancedGenerateResult | null>;
+    gen(optionsOrPrompt: TextGenerationOptions | string, analysisSchema?: ValidationSchema): Promise<EnhancedGenerateResult | null>;
+    setupToolExecutor(sdk: {
+        customTools: Map<string, unknown>;
+        executeTool: (toolName: string, params: unknown) => Promise<unknown>;
+    }, functionTag: string): void;
+}
+/**
+ * Provider attempt result for iteration tracking
+ */
+export interface ProviderAttempt {
+    provider: AIProviderName;
+    model: SupportedModelName;
+    success: boolean;
+    error?: string;
+    stack?: string;
+}
+/**
+ * Default provider configurations
+ */
+export declare const DEFAULT_PROVIDER_CONFIGS: ProviderConfig[];

package/dist/lib/core/types.js

@@ -0,0 +1,153 @@
+/**
+ * Supported AI Provider Names
+ */
+export var AIProviderName;
+(function (AIProviderName) {
+    AIProviderName["BEDROCK"] = "bedrock";
+    AIProviderName["OPENAI"] = "openai";
+    AIProviderName["OPENAI_COMPATIBLE"] = "openai-compatible";
+    AIProviderName["VERTEX"] = "vertex";
+    AIProviderName["ANTHROPIC"] = "anthropic";
+    AIProviderName["AZURE"] = "azure";
+    AIProviderName["GOOGLE_AI"] = "google-ai";
+    AIProviderName["HUGGINGFACE"] = "huggingface";
+    AIProviderName["OLLAMA"] = "ollama";
+    AIProviderName["MISTRAL"] = "mistral";
+    AIProviderName["LITELLM"] = "litellm";
+    AIProviderName["SAGEMAKER"] = "sagemaker";
+    AIProviderName["AUTO"] = "auto";
+})(AIProviderName || (AIProviderName = {}));
+/**
+ * Supported Models for Amazon Bedrock
+ */
+export var BedrockModels;
+(function (BedrockModels) {
+    BedrockModels["CLAUDE_3_SONNET"] = "anthropic.claude-3-sonnet-20240229-v1:0";
+    BedrockModels["CLAUDE_3_HAIKU"] = "anthropic.claude-3-haiku-20240307-v1:0";
+    BedrockModels["CLAUDE_3_5_SONNET"] = "anthropic.claude-3-5-sonnet-20240620-v1:0";
+    BedrockModels["CLAUDE_3_7_SONNET"] = "arn:aws:bedrock:us-east-2:225681119357:inference-profile/us.anthropic.claude-3-7-sonnet-20250219-v1:0";
+})(BedrockModels || (BedrockModels = {}));
+/**
+ * Supported Models for OpenAI
+ */
+export var OpenAIModels;
+(function (OpenAIModels) {
+    OpenAIModels["GPT_4"] = "gpt-4";
+    OpenAIModels["GPT_4_TURBO"] = "gpt-4-turbo";
+    OpenAIModels["GPT_4O"] = "gpt-4o";
+    OpenAIModels["GPT_4O_MINI"] = "gpt-4o-mini";
+    OpenAIModels["GPT_3_5_TURBO"] = "gpt-3.5-turbo";
+    OpenAIModels["O1_PREVIEW"] = "o1-preview";
+    OpenAIModels["O1_MINI"] = "o1-mini";
+})(OpenAIModels || (OpenAIModels = {}));
+/**
+ * Supported Models for Google Vertex AI
+ */
+export var VertexModels;
+(function (VertexModels) {
+    // Claude 4 Series (Latest - May 2025)
+    VertexModels["CLAUDE_4_0_SONNET"] = "claude-sonnet-4@20250514";
+    VertexModels["CLAUDE_4_0_OPUS"] = "claude-opus-4@20250514";
+    // Claude 3.5 Series (Still supported)
+    VertexModels["CLAUDE_3_5_SONNET"] = "claude-3-5-sonnet-20241022";
+    VertexModels["CLAUDE_3_5_HAIKU"] = "claude-3-5-haiku-20241022";
+    // Claude 3 Series (Legacy support)
+    VertexModels["CLAUDE_3_SONNET"] = "claude-3-sonnet-20240229";
+    VertexModels["CLAUDE_3_OPUS"] = "claude-3-opus-20240229";
+    VertexModels["CLAUDE_3_HAIKU"] = "claude-3-haiku-20240307";
+    // Gemini 2.5 Series (Latest - 2025)
+    VertexModels["GEMINI_2_5_PRO"] = "gemini-2.5-pro";
+    VertexModels["GEMINI_2_5_FLASH"] = "gemini-2.5-flash";
+    VertexModels["GEMINI_2_5_FLASH_LITE"] = "gemini-2.5-flash-lite";
+    // Gemini 2.0 Series
+    VertexModels["GEMINI_2_0_FLASH_001"] = "gemini-2.0-flash-001";
+    // Gemini 1.5 Series (Legacy support)
+    VertexModels["GEMINI_1_5_PRO"] = "gemini-1.5-pro";
+    VertexModels["GEMINI_1_5_FLASH"] = "gemini-1.5-flash";
+})(VertexModels || (VertexModels = {}));
+/**
+ * Supported Models for Google AI Studio
+ */
+export var GoogleAIModels;
+(function (GoogleAIModels) {
+    // Gemini 2.5 Series (Latest - 2025)
+    GoogleAIModels["GEMINI_2_5_PRO"] = "gemini-2.5-pro";
+    GoogleAIModels["GEMINI_2_5_FLASH"] = "gemini-2.5-flash";
+    GoogleAIModels["GEMINI_2_5_FLASH_LITE"] = "gemini-2.5-flash-lite";
+    // Gemini 2.0 Series
+    GoogleAIModels["GEMINI_2_0_FLASH_001"] = "gemini-2.0-flash-001";
+    // Gemini 1.5 Series (Legacy support)
+    GoogleAIModels["GEMINI_1_5_PRO"] = "gemini-1.5-pro";
+    GoogleAIModels["GEMINI_1_5_FLASH"] = "gemini-1.5-flash";
+    GoogleAIModels["GEMINI_1_5_FLASH_LITE"] = "gemini-1.5-flash-lite";
+})(GoogleAIModels || (GoogleAIModels = {}));
+/**
+ * Supported Models for Anthropic (Direct API)
+ */
+export var AnthropicModels;
+(function (AnthropicModels) {
+    // Claude 3.5 Series (Latest)
+    AnthropicModels["CLAUDE_3_5_SONNET"] = "claude-3-5-sonnet-20241022";
+    AnthropicModels["CLAUDE_3_5_HAIKU"] = "claude-3-5-haiku-20241022";
+    // Claude 3 Series (Legacy support)
+    AnthropicModels["CLAUDE_3_SONNET"] = "claude-3-sonnet-20240229";
+    AnthropicModels["CLAUDE_3_OPUS"] = "claude-3-opus-20240229";
+    AnthropicModels["CLAUDE_3_HAIKU"] = "claude-3-haiku-20240307";
+})(AnthropicModels || (AnthropicModels = {}));
+/**
+ * API Versions for various providers
+ */
+export var APIVersions;
+(function (APIVersions) {
+    // Azure OpenAI API versions
+    APIVersions["AZURE_LATEST"] = "2025-04-01-preview";
+    APIVersions["AZURE_STABLE"] = "2024-10-21";
+    APIVersions["AZURE_LEGACY"] = "2023-12-01-preview";
+    // OpenAI API versions
+    APIVersions["OPENAI_CURRENT"] = "v1";
+    APIVersions["OPENAI_BETA"] = "v1-beta";
+    // Google AI API versions
+    APIVersions["GOOGLE_AI_CURRENT"] = "v1";
+    APIVersions["GOOGLE_AI_BETA"] = "v1beta";
+    // Anthropic API versions
+    APIVersions["ANTHROPIC_CURRENT"] = "2023-06-01";
+    // Other provider versions can be added here
+})(APIVersions || (APIVersions = {}));
+/**
+ * Default model aliases for easy reference
+ */
+export const DEFAULT_MODEL_ALIASES = {
+    // Latest recommended models per provider
+    LATEST_OPENAI: OpenAIModels.GPT_4O,
+    FASTEST_OPENAI: OpenAIModels.GPT_4O_MINI,
+    LATEST_ANTHROPIC: AnthropicModels.CLAUDE_3_5_SONNET,
+    FASTEST_ANTHROPIC: AnthropicModels.CLAUDE_3_5_HAIKU,
+    LATEST_GOOGLE: GoogleAIModels.GEMINI_2_5_PRO,
+    FASTEST_GOOGLE: GoogleAIModels.GEMINI_2_5_FLASH,
+    // Best models by use case
+    BEST_CODING: AnthropicModels.CLAUDE_3_5_SONNET,
+    BEST_ANALYSIS: GoogleAIModels.GEMINI_2_5_PRO,
+    BEST_CREATIVE: AnthropicModels.CLAUDE_3_5_SONNET,
+    BEST_VALUE: GoogleAIModels.GEMINI_2_5_FLASH,
+};
+/**
+ * @deprecated Use DEFAULT_MODEL_ALIASES instead. Will be removed in future version.
+ */
+export const ModelAliases = DEFAULT_MODEL_ALIASES;
+/**
+ * Default provider configurations
+ */
+export const DEFAULT_PROVIDER_CONFIGS = [
+    {
+        provider: AIProviderName.BEDROCK,
+        models: [BedrockModels.CLAUDE_3_7_SONNET, BedrockModels.CLAUDE_3_5_SONNET],
+    },
+    {
+        provider: AIProviderName.VERTEX,
+        models: [VertexModels.CLAUDE_4_0_SONNET, VertexModels.GEMINI_2_5_FLASH],
+    },
+    {
+        provider: AIProviderName.OPENAI,
+        models: [OpenAIModels.GPT_4O, OpenAIModels.GPT_4O_MINI],
+    },
+];

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 "../types/index.js";
+import { AIProviderName } from "../core/types.js";
 import type { JsonValue } from "../types/common.js";
 /**
  * Model capabilities interface