@juspay/neurolink 7.6.1 → 7.7.0

package/dist/core/evaluationProviders.js

@@ -1,127 +1,49 @@
+import { modelConfig } from "./modelConfiguration.js";
 /**
- * Comprehensive provider configurations for evaluation
- * All 9 NeuroLink providers with cost and performance data
+ * Convert new configuration format to legacy format for backwards compatibility
  */
-export const EVALUATION_PROVIDER_CONFIGS = {
-    "google-ai": {
-        provider: "google-ai",
-        models: {
-            fast: "gemini-2.5-flash",
-            balanced: "gemini-2.5-pro",
-            quality: "gemini-2.5-pro",
-        },
-        costPerToken: { input: 0.000075, output: 0.0003 },
-        requiresApiKey: ["GOOGLE_AI_API_KEY", "GOOGLE_GENERATIVE_AI_API_KEY"],
-        performance: { speed: 3, quality: 3, cost: 3 },
-    },
-    openai: {
-        provider: "openai",
-        models: {
-            fast: "gpt-4o-mini",
-            balanced: "gpt-4o",
-            quality: "gpt-4o",
-        },
-        costPerToken: { input: 0.00015, output: 0.0006 },
-        requiresApiKey: ["OPENAI_API_KEY"],
-        performance: { speed: 2, quality: 3, cost: 2 },
-    },
-    anthropic: {
-        provider: "anthropic",
-        models: {
-            fast: "claude-3-haiku-20240307",
-            balanced: "claude-3-sonnet-20240229",
-            quality: "claude-3-opus-20240229",
-        },
-        costPerToken: { input: 0.00025, output: 0.00125 },
-        requiresApiKey: ["ANTHROPIC_API_KEY"],
-        performance: { speed: 2, quality: 3, cost: 2 },
-    },
-    vertex: {
-        provider: "vertex",
-        models: {
-            fast: "gemini-2.5-flash",
-            balanced: "gemini-2.5-pro",
-            quality: "gemini-2.5-pro",
-        },
-        costPerToken: { input: 0.000075, output: 0.0003 },
-        requiresApiKey: [
-            "GOOGLE_VERTEX_PROJECT",
-            "GOOGLE_APPLICATION_CREDENTIALS",
-        ],
-        performance: { speed: 2, quality: 3, cost: 3 },
-    },
-    bedrock: {
-        provider: "bedrock",
-        models: {
-            fast: "anthropic.claude-3-haiku-20240307-v1:0",
-            balanced: "anthropic.claude-3-sonnet-20240229-v1:0",
-            quality: "anthropic.claude-3-opus-20240229-v1:0",
-        },
-        costPerToken: { input: 0.00025, output: 0.00125 },
-        requiresApiKey: ["AWS_ACCESS_KEY_ID", "AWS_SECRET_ACCESS_KEY"],
-        performance: { speed: 2, quality: 3, cost: 2 },
-    },
-    azure: {
-        provider: "azure",
-        models: {
-            fast: "gpt-4o-mini",
-            balanced: "gpt-4o",
-            quality: "gpt-4o",
-        },
-        costPerToken: { input: 0.00015, output: 0.0006 },
-        requiresApiKey: ["AZURE_OPENAI_API_KEY", "AZURE_OPENAI_ENDPOINT"],
-        performance: { speed: 2, quality: 3, cost: 2 },
-    },
-    ollama: {
-        provider: "ollama",
-        models: {
-            fast: "llama3.2:latest",
-            balanced: "llama3.1:8b",
-            quality: "llama3.1:70b",
-        },
-        costPerToken: { input: 0, output: 0 }, // Local model
-        requiresApiKey: [], // No API key needed
-        performance: { speed: 1, quality: 2, cost: 3 },
-    },
-    huggingface: {
-        provider: "huggingface",
-        models: {
-            fast: "microsoft/DialoGPT-medium",
-            balanced: "microsoft/DialoGPT-large",
-            quality: "meta-llama/Llama-2-7b-chat-hf",
-        },
-        costPerToken: { input: 0.0002, output: 0.0006 },
-        requiresApiKey: ["HUGGINGFACE_API_KEY"],
-        performance: { speed: 1, quality: 2, cost: 2 },
-    },
-    mistral: {
-        provider: "mistral",
-        models: {
-            fast: "mistral-small-latest",
-            balanced: "mistral-medium-latest",
-            quality: "mistral-large-latest",
-        },
-        costPerToken: { input: 0.0002, output: 0.0006 },
-        requiresApiKey: ["MISTRAL_API_KEY"],
-        performance: { speed: 2, quality: 2, cost: 2 },
-    },
-};
+function convertToLegacyFormat(config) {
+    return {
+        provider: config.provider,
+        models: config.models,
+        costPerToken: config.defaultCost,
+        requiresApiKey: config.requiredEnvVars,
+        performance: config.performance,
+    };
+}
+/**
+ * Get all provider configurations using the new configuration system
+ * Replaces hardcoded EVALUATION_PROVIDER_CONFIGS with configurable system
+ */
+function getEvaluationProviderConfigs() {
+    const configs = {};
+    const allConfigs = modelConfig.getAllConfigurations();
+    for (const [provider, config] of allConfigs) {
+        configs[provider] = convertToLegacyFormat(config);
+    }
+    return configs;
+}
+/**
+ * Dynamic provider configurations for evaluation
+ * Now uses configurable system instead of hardcoded values
+ */
+export const EVALUATION_PROVIDER_CONFIGS = getEvaluationProviderConfigs();
 /**
  * Get provider configuration by name
+ * Now uses the configurable system
  */
 export function getProviderConfig(providerName) {
-    return EVALUATION_PROVIDER_CONFIGS[providerName] || null;
+    const config = modelConfig.getProviderConfig(providerName);
+    return config ? convertToLegacyFormat(config) : null;
 }
 /**
  * Get all available providers with required API keys present
+ * Now uses the configurable system
  */
 export function getAvailableProviders() {
-    return Object.values(EVALUATION_PROVIDER_CONFIGS).filter((config) => {
-        if (config.requiresApiKey.length === 0) {
-            return true;
-        } // Ollama
-        return config.requiresApiKey.some((key) => process.env[key]);
-    });
+    return modelConfig
+        .getAvailableProviders()
+        .map((config) => convertToLegacyFormat(config));
 }
 /**
  * Sort providers by preference (cost, speed, quality)
@@ -152,27 +74,21 @@ export function sortProvidersByPreference(providers, preferCheap = true) {
 }
 /**
  * Estimate cost for a specific provider and token usage
+ * Now uses the configurable system
  */
 export function estimateProviderCost(providerName, inputTokens, outputTokens) {
-    const config = getProviderConfig(providerName);
-    if (!config || !config.costPerToken) {
+    const costInfo = modelConfig.getCostInfo(providerName);
+    if (!costInfo) {
         return 0;
     }
-    return (inputTokens * config.costPerToken.input +
-        outputTokens * config.costPerToken.output);
+    return inputTokens * costInfo.input + outputTokens * costInfo.output;
 }
 /**
  * Check if a provider is available (has required API keys)
+ * Now uses the configurable system
  */
 export function isProviderAvailable(providerName) {
-    const config = getProviderConfig(providerName);
-    if (!config) {
-        return false;
-    }
-    if (config.requiresApiKey.length === 0) {
-        return true;
-    } // Ollama
-    return config.requiresApiKey.some((key) => process.env[key]);
+    return modelConfig.isProviderAvailable(providerName);
 }
 /**
  * Get the best available provider based on preference

package/dist/core/factory.d.ts

@@ -9,6 +9,11 @@ export declare class AIProviderFactory {
      * Normalize provider name using ProviderFactory
      */
     private static normalizeProviderName;
+    /**
+     * Initialize dynamic model provider with timeout protection
+     * Prevents hanging on non-responsive endpoints
+     */
+    private static initializeDynamicProviderWithTimeout;
     /**
      * Create a provider instance for the specified provider type
      * @param providerName - Name of the provider ('vertex', 'bedrock', 'openai')

package/dist/core/factory.js

@@ -22,6 +22,31 @@ export class AIProviderFactory {
         // If not found in factory, return as-is (will be handled by factory error handling)
         return providerName.toLowerCase();
     }
+    /**
+     * Initialize dynamic model provider with timeout protection
+     * Prevents hanging on non-responsive endpoints
+     */
+    static async initializeDynamicProviderWithTimeout() {
+        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)),
+            ]);
+            logger.debug(`[${functionTag}] Dynamic model provider initialized successfully`);
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            logger.warn(`[${functionTag}] Dynamic model provider initialization failed`, {
+                error: errorMessage,
+                fallback: "Using static model defaults",
+            });
+            // Don't throw - graceful degradation to static models
+            // This ensures the factory continues to work even if dynamic models fail
+        }
+    }
     /**
      * Create a provider instance for the specified provider type
      * @param providerName - Name of the provider ('vertex', 'bedrock', 'openai')
@@ -38,58 +63,45 @@ export class AIProviderFactory {
             enableMCP,
         });
         try {
-            // DYNAMIC MODEL PROVIDER STATUS (2025): Disabled due to reliability issues
-            //
-            // Root Cause: Dynamic model provider initialization can hang when:
-            // - Local model server (localhost:3001) is not running or responding
-            // - GitHub raw URL requests timeout due to network issues
-            // - Local config file doesn't exist
+            // DYNAMIC MODEL PROVIDER STATUS (2025): Enhanced with timeout handling
             //
-            // Current Behavior: Static model resolution works reliably
-            // Impact: No functionality loss - providers use built-in model defaults
+            // ✅ 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
             //
-            // Implementation Requirements (if re-enabling):
-            // 1. Add robust timeout handling (3s max per source)
-            // 2. Implement exponential backoff for network requests
-            // 3. Add graceful degradation when all sources fail
-            // 4. Create health check for localhost:3001 before attempting connection
-            // 5. Add comprehensive error handling and logging
-            //
-            // Until these improvements are implemented, dynamic model provider remains disabled
-            // for system reliability. Static model defaults provide stable functionality.
-            // COMPREHENSIVE FIX: Disable dynamic model resolution completely until provider is fixed
-            // This prevents stale gemini-1.5-pro-latest from overriding correct gemini-2.5-pro defaults
-            const resolvedModelName = modelName;
-            // COMMENTED OUT: Dynamic model resolution causing 1.5 vs 2.5 Pro issues
-            // if (!modelName || modelName === "default") {
-            //   try {
-            //     const normalizedProvider = this.normalizeProviderName(providerName);
-            //     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,
-            //       });
-            //     }
-            //   } catch (resolveError) {
-            //     logger.debug(
-            //       `[${functionTag}] Dynamic model resolution failed, using fallback`,
-            //       {
-            //         error:
-            //           resolveError instanceof Error
-            //             ? resolveError.message
-            //             : String(resolveError),
-            //       },
-            //     );
-            //   }
-            // }
+            // The dynamic model provider now provides reliable functionality without hanging
+            let resolvedModelName = modelName;
+            // Enable dynamic model resolution with timeout-protected initialization
+            if (!modelName || modelName === "default") {
+                try {
+                    const normalizedProvider = this.normalizeProviderName(providerName);
+                    // Initialize with timeout protection - won't hang anymore
+                    if (dynamicModelProvider.needsRefresh()) {
+                        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,
+                        });
+                    }
+                }
+                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
+                }
+            }
             // CRITICAL FIX: Initialize providers before using them
             await ProviderRegistry.registerAllProviders();
             // PURE FACTORY PATTERN: No switch statements - use ProviderFactory exclusively

package/dist/core/modelConfiguration.d.ts

@@ -0,0 +1,246 @@
+/**
+ * Model Configuration System
+ *
+ * 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";
+/**
+ * Model name constants - extracted from hardcoded values for better maintainability
+ * These constants can be overridden by environment variables
+ */
+export declare const MODEL_NAMES: {
+    readonly GOOGLE_AI: {
+        readonly FAST: "gemini-2.5-flash";
+        readonly BALANCED: "gemini-2.5-pro";
+        readonly QUALITY: "gemini-2.5-pro";
+    };
+    readonly GOOGLE_VERTEX: {
+        readonly FAST: "gemini-2.5-flash";
+        readonly BALANCED: "gemini-2.5-pro";
+        readonly QUALITY: "gemini-2.5-pro";
+    };
+    readonly OPENAI: {
+        readonly FAST: "gpt-4o-mini";
+        readonly BALANCED: "gpt-4o";
+        readonly QUALITY: "gpt-4o";
+    };
+    readonly ANTHROPIC: {
+        readonly FAST: "claude-3-haiku-20240307";
+        readonly BALANCED: "claude-3-sonnet-20240229";
+        readonly QUALITY: "claude-3-5-sonnet-20241022";
+    };
+    readonly VERTEX: {
+        readonly FAST: "gemini-2.5-flash";
+        readonly BALANCED: "gemini-2.5-pro";
+        readonly QUALITY: "gemini-2.5-pro";
+    };
+    readonly BEDROCK: {
+        readonly FAST: "anthropic.claude-3-haiku-20240307-v1:0";
+        readonly BALANCED: "anthropic.claude-3-sonnet-20240229-v1:0";
+        readonly QUALITY: "anthropic.claude-3-opus-20240229-v1:0";
+    };
+    readonly AZURE: {
+        readonly FAST: "gpt-4o-mini";
+        readonly BALANCED: "gpt-4o";
+        readonly QUALITY: "gpt-4o";
+    };
+    readonly OLLAMA: {
+        readonly FAST: "llama3.2:latest";
+        readonly BALANCED: "llama3.1:8b";
+        readonly QUALITY: "llama3.1:70b";
+    };
+    readonly HUGGINGFACE: {
+        readonly FAST: "microsoft/DialoGPT-medium";
+        readonly BALANCED: "microsoft/DialoGPT-large";
+        readonly QUALITY: "meta-llama/Llama-2-7b-chat-hf";
+    };
+    readonly MISTRAL: {
+        readonly FAST: "mistral-small-latest";
+        readonly BALANCED: "mistral-medium-latest";
+        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
+ */
+export declare class ModelConfigurationManager {
+    private static instance;
+    private configurations;
+    private configSource;
+    private lastUpdated;
+    private constructor();
+    static getInstance(): ModelConfigurationManager;
+    /**
+     * Load default configurations (replaces hardcoded values)
+     */
+    private loadDefaultConfigurations;
+    /**
+     * Helper method to get configuration value with fallback and validation
+     */
+    private getConfigValue;
+    /**
+     * Validate configuration values for security and correctness
+     */
+    private isValidConfigValue;
+    /**
+     * Helper method to get configuration array with fallback
+     * Parses comma-separated environment variable values
+     */
+    private getConfigArray;
+    /**
+     * Helper method to parse float with fallback
+     */
+    private parseFloat;
+    /**
+     * Helper method to parse int with fallback
+     */
+    private parseInt;
+    /**
+     * Helper method to get configuration object with fallback
+     * Parses JSON environment variable values
+     */
+    private getConfigObject;
+    /**
+     * Get provider configuration
+     */
+    getProviderConfig(provider: string): ProviderConfig | null;
+    /**
+     * Get all provider configurations
+     */
+    getAllConfigurations(): Map<string, ProviderConfig>;
+    /**
+     * Update provider configuration (runtime updates)
+     */
+    updateProviderConfig(provider: string, config: ProviderConfig): void;
+    /**
+     * Load configurations from external source
+     */
+    loadConfigurationsFromFile(configPath: string): void;
+    /**
+     * Validate provider configuration structure
+     */
+    private isValidProviderConfig;
+    /**
+     * Apply model name overrides from configuration file
+     */
+    private applyModelNameOverrides;
+    /**
+     * Apply global default configurations
+     */
+    private applyGlobalDefaults;
+    /**
+     * Get configuration metadata
+     */
+    getConfigurationMeta(): {
+        source: ConfigSource;
+        lastUpdated: number;
+        providerCount: number;
+    };
+    /**
+     * Get model for specific tier and provider
+     */
+    getModelForTier(provider: string, tier: ModelTier): string | null;
+    /**
+     * Get cost information for provider and model
+     */
+    getCostInfo(provider: string, model?: string): {
+        input: number;
+        output: number;
+    } | null;
+    /**
+     * Check if provider is available (has required environment variables)
+     */
+    isProviderAvailable(provider: string): boolean;
+    /**
+     * Get available providers
+     */
+    getAvailableProviders(): ProviderConfig[];
+}
+/**
+ * Global instance accessor
+ */
+export declare const modelConfig: ModelConfigurationManager;
+/**
+ * Convenience functions for common operations
+ */
+/**
+ * Get provider configuration (backwards compatible)
+ */
+export declare function getProviderConfig(provider: string): ProviderConfig | null;
+/**
+ * Get model for tier (backwards compatible)
+ */
+export declare function getModelForTier(provider: string, tier: ModelTier): string | null;
+/**
+ * Get cost information (backwards compatible)
+ */
+export declare function getCostInfo(provider: string, model?: string): {
+    input: number;
+    output: number;
+} | null;
+/**
+ * Check provider availability (backwards compatible)
+ */
+export declare function isProviderAvailable(provider: string): boolean;