@juspay/neurolink 9.15.0 → 9.16.0

package/dist/core/factory.js

@@ -1,12 +1,16 @@
 // ✅ CIRCULAR DEPENDENCY FIX: Remove barrel export import
 // Providers are now managed via ProviderFactory instead of direct imports
+import { SpanKind, SpanStatusCode } from "@opentelemetry/api";
+import { tracers } from "../telemetry/tracers.js";
 import { ProviderFactory } from "../factories/providerFactory.js";
 import { ProviderRegistry } from "../factories/providerRegistry.js";
 import { getBestProvider } from "../utils/providerUtils.js";
 import { logger } from "../utils/logger.js";
 import { dynamicModelProvider } from "./dynamicModels.js";
+import { withTimeout } from "../utils/errorHandling.js";
 import { AIProviderName } from "../constants/enums.js";
 const componentIdentifier = "aiProviderFactory";
+const factoryTracer = tracers.factory;
 /**
  * Factory for creating AI provider instances with centralized configuration
  */
@@ -31,11 +35,7 @@ export class AIProviderFactory {
         const functionTag = "AIProviderFactory.initializeDynamicProviderWithTimeout";
         const INIT_TIMEOUT = 10000; // 10 seconds total timeout for initialization
         try {
-            // Race the initialization against a timeout
-            await Promise.race([
-                dynamicModelProvider.initialize(),
-                new Promise((_, reject) => setTimeout(() => reject(new Error("Dynamic provider initialization timeout")), INIT_TIMEOUT)),
-            ]);
+            await withTimeout(dynamicModelProvider.initialize(), INIT_TIMEOUT, new Error("Dynamic provider initialization timeout"));
             logger.debug(`[${functionTag}] Dynamic model provider initialized successfully`);
         }
         catch (error) {
@@ -60,186 +60,259 @@ export class AIProviderFactory {
     static async createProvider(providerName, modelName, enableMCP = true, sdk, region) {
         const functionTag = "AIProviderFactory.createProvider";
         // Providers are registered via ProviderFactory.initialize() on first use
-        logger.debug(`[${functionTag}] Provider creation started`, {
-            providerName,
-            modelName: modelName || "default",
-            enableMCP,
-            environmentVariables: {
-                BEDROCK_MODEL: process.env.BEDROCK_MODEL || "not set",
-                BEDROCK_MODEL_ID: process.env.BEDROCK_MODEL_ID || "not set",
-                VERTEX_MODEL: process.env.VERTEX_MODEL || "not set",
-                OPENAI_MODEL: process.env.OPENAI_MODEL || "not set",
+        return factoryTracer.startActiveSpan("neurolink.factory.createProvider", {
+            kind: SpanKind.INTERNAL,
+            attributes: {
+                "provider.name": providerName,
+                "model.name": modelName || "default",
+                "mcp.enabled": enableMCP,
             },
-        });
-        try {
-            // DYNAMIC MODEL PROVIDER STATUS (2025): Enhanced with timeout handling
-            //
-            // ✅ FIXED: Hanging issues resolved with comprehensive timeout implementation
-            // - Added robust timeout handling (3s localhost, 5s GitHub, 1s local file)
-            // - Implemented health checks for localhost endpoints
-            // - Added graceful degradation when all sources fail
-            // - Enhanced error handling and logging for debugging
-            //
-            // The dynamic model provider now provides reliable functionality without hanging
-            let resolvedModelName = modelName;
-            // PRIORITY 1: Check environment variables BEFORE dynamic resolution
-            if (!modelName || modelName === "default") {
-                logger.debug(`[${functionTag}] Checking environment variables for provider: ${providerName}`);
-                // Check for provider-specific environment variables first
-                if (providerName.toLowerCase().includes("bedrock")) {
-                    const envModel = process.env.BEDROCK_MODEL || process.env.BEDROCK_MODEL_ID;
-                    if (envModel) {
-                        resolvedModelName = envModel;
-                        logger.debug(`[${functionTag}] Environment variable found for Bedrock`, {
-                            envVariable: process.env.BEDROCK_MODEL
-                                ? "BEDROCK_MODEL"
-                                : "BEDROCK_MODEL_ID",
-                            resolvedModel: envModel,
-                        });
+        }, async (span) => {
+            logger.debug(`[${functionTag}] Provider creation started`, {
+                providerName,
+                modelName: modelName || "default",
+                enableMCP,
+                environmentVariables: {
+                    BEDROCK_MODEL: process.env.BEDROCK_MODEL || "not set",
+                    BEDROCK_MODEL_ID: process.env.BEDROCK_MODEL_ID || "not set",
+                    VERTEX_MODEL: process.env.VERTEX_MODEL || "not set",
+                    OPENAI_MODEL: process.env.OPENAI_MODEL || "not set",
+                },
+            });
+            try {
+                // DYNAMIC MODEL PROVIDER STATUS (2025): Enhanced with timeout handling
+                //
+                // ✅ FIXED: Hanging issues resolved with comprehensive timeout implementation
+                // - Added robust timeout handling (3s localhost, 5s GitHub, 1s local file)
+                // - Implemented health checks for localhost endpoints
+                // - Added graceful degradation when all sources fail
+                // - Enhanced error handling and logging for debugging
+                //
+                // The dynamic model provider now provides reliable functionality without hanging
+                let resolvedModelName = modelName;
+                // PRIORITY 1: Check environment variables BEFORE dynamic resolution
+                if (!modelName || modelName === "default") {
+                    logger.debug(`[${functionTag}] Checking environment variables for provider: ${providerName}`);
+                    // Check for provider-specific environment variables first
+                    if (providerName.toLowerCase().includes("bedrock")) {
+                        const envModel = process.env.BEDROCK_MODEL || process.env.BEDROCK_MODEL_ID;
+                        if (envModel) {
+                            resolvedModelName = envModel;
+                            logger.debug(`[${functionTag}] Environment variable found for Bedrock`, {
+                                envVariable: process.env.BEDROCK_MODEL
+                                    ? "BEDROCK_MODEL"
+                                    : "BEDROCK_MODEL_ID",
+                                resolvedModel: envModel,
+                            });
+                        }
+                        else {
+                            logger.debug(`[${functionTag}] No Bedrock environment variables found (BEDROCK_MODEL, BEDROCK_MODEL_ID)`);
+                        }
                     }
-                    else {
-                        logger.debug(`[${functionTag}] No Bedrock environment variables found (BEDROCK_MODEL, BEDROCK_MODEL_ID)`);
+                    else if (providerName.toLowerCase().includes("vertex")) {
+                        const envModel = process.env.VERTEX_MODEL;
+                        if (envModel) {
+                            resolvedModelName = envModel;
+                            logger.debug(`[${functionTag}] Environment variable found for Vertex`, {
+                                envVariable: "VERTEX_MODEL",
+                                resolvedModel: envModel,
+                            });
+                        }
+                        else {
+                            logger.debug(`[${functionTag}] No Vertex environment variables found (VERTEX_MODEL)`);
+                        }
                     }
-                }
-                else if (providerName.toLowerCase().includes("vertex")) {
-                    const envModel = process.env.VERTEX_MODEL;
-                    if (envModel) {
-                        resolvedModelName = envModel;
-                        logger.debug(`[${functionTag}] Environment variable found for Vertex`, {
-                            envVariable: "VERTEX_MODEL",
-                            resolvedModel: envModel,
-                        });
+                    else if (providerName.toLowerCase().includes("azure")) {
+                        const envModel = process.env.AZURE_OPENAI_MODEL ||
+                            process.env.AZURE_OPENAI_DEPLOYMENT ||
+                            process.env.AZURE_OPENAI_DEPLOYMENT_ID;
+                        if (envModel) {
+                            resolvedModelName = envModel;
+                            logger.debug(`[${functionTag}] Environment variable found for Azure`, {
+                                envVariable: process.env.AZURE_OPENAI_MODEL
+                                    ? "AZURE_OPENAI_MODEL"
+                                    : process.env.AZURE_OPENAI_DEPLOYMENT
+                                        ? "AZURE_OPENAI_DEPLOYMENT"
+                                        : "AZURE_OPENAI_DEPLOYMENT_ID",
+                                resolvedModel: envModel,
+                            });
+                        }
+                        else {
+                            logger.debug(`[${functionTag}] No Azure environment variables found (AZURE_OPENAI_MODEL, AZURE_OPENAI_DEPLOYMENT, AZURE_OPENAI_DEPLOYMENT_ID)`);
+                        }
                     }
-                    else {
-                        logger.debug(`[${functionTag}] No Vertex environment variables found (VERTEX_MODEL)`);
+                    else if (providerName.toLowerCase().includes("openai")) {
+                        const envModel = process.env.OPENAI_MODEL;
+                        if (envModel) {
+                            resolvedModelName = envModel;
+                            logger.debug(`[${functionTag}] Environment variable found for OpenAI`, {
+                                envVariable: "OPENAI_MODEL",
+                                resolvedModel: envModel,
+                            });
+                        }
+                        else {
+                            logger.debug(`[${functionTag}] No OpenAI environment variables found (OPENAI_MODEL)`);
+                        }
                     }
-                }
-                else if (providerName.toLowerCase().includes("azure")) {
-                    const envModel = process.env.AZURE_OPENAI_MODEL ||
-                        process.env.AZURE_OPENAI_DEPLOYMENT ||
-                        process.env.AZURE_OPENAI_DEPLOYMENT_ID;
-                    if (envModel) {
-                        resolvedModelName = envModel;
-                        logger.debug(`[${functionTag}] Environment variable found for Azure`, {
-                            envVariable: process.env.AZURE_OPENAI_MODEL
-                                ? "AZURE_OPENAI_MODEL"
-                                : process.env.AZURE_OPENAI_DEPLOYMENT
-                                    ? "AZURE_OPENAI_DEPLOYMENT"
-                                    : "AZURE_OPENAI_DEPLOYMENT_ID",
-                            resolvedModel: envModel,
-                        });
+                    else if (providerName.toLowerCase().includes("anthropic")) {
+                        const envModel = process.env.ANTHROPIC_MODEL;
+                        if (envModel) {
+                            resolvedModelName = envModel;
+                            logger.debug(`[${functionTag}] Environment variable found for Anthropic`, {
+                                envVariable: "ANTHROPIC_MODEL",
+                                resolvedModel: envModel,
+                            });
+                        }
+                        else {
+                            logger.debug(`[${functionTag}] No Anthropic environment variables found (ANTHROPIC_MODEL)`);
+                        }
+                    }
+                    else if (providerName.toLowerCase().includes("google") ||
+                        providerName.toLowerCase().includes("gemini")) {
+                        const envModel = process.env.GOOGLE_AI_MODEL;
+                        if (envModel) {
+                            resolvedModelName = envModel;
+                            logger.debug(`[${functionTag}] Environment variable found for Google AI`, {
+                                envVariable: "GOOGLE_AI_MODEL",
+                                resolvedModel: envModel,
+                            });
+                        }
+                        else {
+                            logger.debug(`[${functionTag}] No Google AI environment variables found (GOOGLE_AI_MODEL)`);
+                        }
+                    }
+                    else if (providerName.toLowerCase().includes("mistral")) {
+                        const envModel = process.env.MISTRAL_MODEL;
+                        if (envModel) {
+                            resolvedModelName = envModel;
+                            logger.debug(`[${functionTag}] Environment variable found for Mistral`, {
+                                envVariable: "MISTRAL_MODEL",
+                                resolvedModel: envModel,
+                            });
+                        }
+                        else {
+                            logger.debug(`[${functionTag}] No Mistral environment variables found (MISTRAL_MODEL)`);
+                        }
+                    }
+                    else if (providerName.toLowerCase().includes("ollama")) {
+                        const envModel = process.env.OLLAMA_MODEL;
+                        if (envModel) {
+                            resolvedModelName = envModel;
+                            logger.debug(`[${functionTag}] Environment variable found for Ollama`, {
+                                envVariable: "OLLAMA_MODEL",
+                                resolvedModel: envModel,
+                            });
+                        }
+                        else {
+                            logger.debug(`[${functionTag}] No Ollama environment variables found (OLLAMA_MODEL)`);
+                        }
                     }
                     else {
-                        logger.debug(`[${functionTag}] No Azure environment variables found (AZURE_OPENAI_MODEL, AZURE_OPENAI_DEPLOYMENT, AZURE_OPENAI_DEPLOYMENT_ID)`);
+                        logger.debug(`[${functionTag}] Provider ${providerName} - no environment variable check implemented`);
                     }
                 }
                 else {
-                    logger.debug(`[${functionTag}] Provider ${providerName} - no environment variable check implemented`);
+                    logger.debug(`[${functionTag}] Skipping environment variable check - explicit model provided: ${modelName}`);
                 }
-            }
-            else {
-                logger.debug(`[${functionTag}] Skipping environment variable check - explicit model provided: ${modelName}`);
-            }
-            // PRIORITY 2: Enable dynamic model resolution only if no env var found
-            if ((!resolvedModelName || resolvedModelName === "default") &&
-                (!modelName || modelName === "default")) {
-                logger.debug(`[${functionTag}] Attempting dynamic model resolution`, {
-                    currentResolvedModel: resolvedModelName || "none",
-                    reason: "No environment variable found and no explicit model provided",
-                });
-                try {
-                    const normalizedProvider = this.normalizeProviderName(providerName);
-                    // Initialize with timeout protection - won't hang anymore
-                    if (dynamicModelProvider.needsRefresh()) {
-                        logger.debug(`[${functionTag}] Dynamic model provider needs refresh - initializing`);
-                        await this.initializeDynamicProviderWithTimeout();
+                // PRIORITY 2: Enable dynamic model resolution only if no env var found
+                if ((!resolvedModelName || resolvedModelName === "default") &&
+                    (!modelName || modelName === "default")) {
+                    logger.debug(`[${functionTag}] Attempting dynamic model resolution`, {
+                        currentResolvedModel: resolvedModelName || "none",
+                        reason: "No environment variable found and no explicit model provided",
+                    });
+                    try {
+                        const normalizedProvider = this.normalizeProviderName(providerName);
+                        // Initialize with timeout protection - won't hang anymore
+                        if (dynamicModelProvider.needsRefresh()) {
+                            logger.debug(`[${functionTag}] Dynamic model provider needs refresh - initializing`);
+                            await this.initializeDynamicProviderWithTimeout();
+                        }
+                        const dynamicModel = dynamicModelProvider.resolveModel(normalizedProvider, modelName || undefined);
+                        if (dynamicModel) {
+                            resolvedModelName = dynamicModel.id;
+                            logger.debug(`[${functionTag}] Resolved dynamic model`, {
+                                provider: normalizedProvider,
+                                requestedModel: modelName || "default",
+                                resolvedModel: resolvedModelName,
+                                displayName: dynamicModel.displayName,
+                                pricing: dynamicModel.pricing.input,
+                            });
+                        }
+                        else {
+                            logger.debug(`[${functionTag}] Dynamic model resolution returned null`, {
+                                provider: normalizedProvider,
+                                requestedModel: modelName || "default",
+                            });
+                        }
                     }
-                    const dynamicModel = dynamicModelProvider.resolveModel(normalizedProvider, modelName || undefined);
-                    if (dynamicModel) {
-                        resolvedModelName = dynamicModel.id;
-                        logger.debug(`[${functionTag}] Resolved dynamic model`, {
-                            provider: normalizedProvider,
-                            requestedModel: modelName || "default",
-                            resolvedModel: resolvedModelName,
-                            displayName: dynamicModel.displayName,
-                            pricing: dynamicModel.pricing.input,
-                        });
-                    }
-                    else {
-                        logger.debug(`[${functionTag}] Dynamic model resolution returned null`, {
-                            provider: normalizedProvider,
-                            requestedModel: modelName || "default",
+                    catch (resolveError) {
+                        logger.debug(`[${functionTag}] Dynamic model resolution failed, using static fallback`, {
+                            error: resolveError instanceof Error
+                                ? resolveError.message
+                                : String(resolveError),
                         });
+                        // Continue with static model name - no functionality loss
                     }
                 }
-                catch (resolveError) {
-                    logger.debug(`[${functionTag}] Dynamic model resolution failed, using static fallback`, {
-                        error: resolveError instanceof Error
-                            ? resolveError.message
-                            : String(resolveError),
+                else {
+                    logger.debug(`[${functionTag}] Skipping dynamic model resolution`, {
+                        resolvedModelName: resolvedModelName || "none",
+                        reason: "Model already resolved from environment variables or explicit parameter",
                     });
-                    // Continue with static model name - no functionality loss
                 }
+                // CRITICAL FIX: Initialize providers before using them
+                await withTimeout(ProviderRegistry.registerAllProviders(), 30_000, new Error("Provider registration timed out"));
+                // PURE FACTORY PATTERN: No switch statements - use ProviderFactory exclusively
+                const normalizedName = this.normalizeProviderName(providerName);
+                const finalModelName = resolvedModelName === "default" || resolvedModelName === null
+                    ? undefined
+                    : resolvedModelName;
+                logger.debug(`[${functionTag}] Final provider configuration`, {
+                    originalProviderName: providerName,
+                    normalizedProviderName: normalizedName,
+                    originalModelName: modelName || "not provided",
+                    resolvedModelName: resolvedModelName || "not resolved",
+                    finalModelName: finalModelName || "using provider default",
+                });
+                // Create provider with enhanced SDK and region support
+                const provider = await withTimeout(ProviderFactory.createProvider(normalizedName, finalModelName, sdk, region), 30_000, new Error(`Provider creation timed out for ${normalizedName}`));
+                // Summary logging in format expected by debugging tools
+                logger.debug(`[AIProviderFactory] Provider creation completed { providerName: '${normalizedName}', modelName: '${finalModelName}' }`);
+                logger.debug(`[AIProviderFactory] Resolved model: ${finalModelName}`);
+                logger.debug(componentIdentifier, "Pure factory pattern provider created", {
+                    providerName: normalizedName,
+                    modelName: finalModelName,
+                    factoryUsed: true,
+                });
+                span.setAttribute("provider.resolved_name", normalizedName);
+                if (finalModelName) {
+                    span.setAttribute("model.resolved_name", finalModelName);
+                }
+                logger.debug(`[${functionTag}] Provider creation succeeded`, {
+                    providerName,
+                    modelName: finalModelName || "default",
+                    providerType: provider.constructor.name,
+                    mcpEnabled: enableMCP,
+                });
+                span.setStatus({ code: SpanStatusCode.OK });
+                return provider;
             }
-            else {
-                logger.debug(`[${functionTag}] Skipping dynamic model resolution`, {
-                    resolvedModelName: resolvedModelName || "none",
-                    reason: "Model already resolved from environment variables or explicit parameter",
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                span.setStatus({ code: SpanStatusCode.ERROR, message: errorMessage });
+                span.recordException(error instanceof Error ? error : new Error(String(error)));
+                logger.debug(`[${functionTag}] Provider creation failed`, {
+                    providerName,
+                    modelName: modelName || "default",
+                    error: errorMessage,
                 });
+                throw error;
             }
-            // CRITICAL FIX: Initialize providers before using them
-            await ProviderRegistry.registerAllProviders();
-            // PURE FACTORY PATTERN: No switch statements - use ProviderFactory exclusively
-            const normalizedName = this.normalizeProviderName(providerName);
-            const finalModelName = resolvedModelName === "default" || resolvedModelName === null
-                ? undefined
-                : resolvedModelName;
-            logger.debug(`[${functionTag}] Final provider configuration`, {
-                originalProviderName: providerName,
-                normalizedProviderName: normalizedName,
-                originalModelName: modelName || "not provided",
-                resolvedModelName: resolvedModelName || "not resolved",
-                finalModelName: finalModelName || "using provider default",
-            });
-            // Create provider with enhanced SDK and region support
-            const provider = await ProviderFactory.createProvider(normalizedName, finalModelName, sdk, region);
-            // Summary logging in format expected by debugging tools
-            logger.debug(`[AIProviderFactory] Provider creation completed { providerName: '${normalizedName}', modelName: '${finalModelName}' }`);
-            logger.debug(`[AIProviderFactory] Resolved model: ${finalModelName}`);
-            logger.debug(componentIdentifier, "Pure factory pattern provider created", {
-                providerName: normalizedName,
-                modelName: finalModelName,
-                factoryUsed: true,
-            });
-            // Wrap with MCP if enabled
-            if (enableMCP) {
-                try {
-                    logger.debug(`[${functionTag}] MCP wrapping disabled - functionCalling removed`);
-                    // MCP wrapping simplified - removed functionCalling dependency
-                }
-                catch (mcpError) {
-                    logger.warn(`[${functionTag}] Failed to wrap with MCP, using base provider`, {
-                        error: mcpError instanceof Error ? mcpError.message : String(mcpError),
-                    });
-                }
+            finally {
+                span.end();
             }
-            logger.debug(`[${functionTag}] Provider creation succeeded`, {
-                providerName,
-                modelName: finalModelName || "default",
-                providerType: provider.constructor.name,
-                mcpEnabled: enableMCP,
-            });
-            return provider;
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            logger.debug(`[${functionTag}] Provider creation failed`, {
-                providerName,
-                modelName: modelName || "default",
-                error: errorMessage,
-            });
-            throw error;
-        }
+        });
     }
     /**
      * Create a provider instance with specific provider enum and model