@juspay/neurolink 7.29.1 → 7.29.3

package/dist/lib/core/evaluation.js

@@ -1,13 +1,14 @@
 /**
- * NeuroLink Unified Evaluation System
+ * NeuroLink Evaluation System
  */
 import { logger } from "../utils/logger.js";
 import { AIProviderFactory } from "./factory.js";
 import { z } from "zod";
 import { ProviderRegistry } from "../factories/providerRegistry.js";
 import { modelConfig } from "./modelConfiguration.js";
+import { normalizeEvaluationData } from "../utils/evaluationUtils.js";
 // Zod schema for validation
-const UnifiedEvaluationSchema = z.object({
+const EvaluationSchema = z.object({
     relevance: z.number().min(1).max(10),
     accuracy: z.number().min(1).max(10),
     completeness: z.number().min(1).max(10),
@@ -19,8 +20,8 @@ const UnifiedEvaluationSchema = z.object({
 /**
  * Get default evaluation when evaluation fails
  */
-function getDefaultUnifiedEvaluation(reason, evaluationTime, context) {
-    const functionTag = "getDefaultUnifiedEvaluation";
+function getDefaultEvaluation(reason, evaluationTime, context) {
+    const functionTag = "getDefaultEvaluation";
     logger.debug(`[${functionTag}] Creating default evaluation`, {
         reason,
         evaluationTime,
@@ -61,11 +62,14 @@ function getDefaultUnifiedEvaluation(reason, evaluationTime, context) {
 /**
  * Parse unified evaluation result from text response
  */
-function parseUnifiedEvaluationResult(response, context) {
-    const functionTag = "parseUnifiedEvaluationResult";
+function parseEvaluationResult(response, context) {
+    const functionTag = "parseEvaluationResult";
     try {
         logger.debug(`[${functionTag}] Parsing evaluation response`, {
             responseLength: response.length,
+            domain: context.primaryDomain,
+            hasToolUsage: !!context.toolUsage?.length,
+            hasConversationHistory: !!context.conversationHistory?.length,
         });
         // Try JSON parsing first
         const jsonMatch = response.match(/\{[^}]*\}/s);
@@ -74,8 +78,11 @@ function parseUnifiedEvaluationResult(response, context) {
                 const parsed = JSON.parse(jsonMatch[0]);
                 return parsed;
             }
-            catch (e) {
-                logger.debug(`[${functionTag}] JSON parsing failed, trying regex`);
+            catch (jsonError) {
+                logger.debug(`[${functionTag}] JSON parsing failed, trying regex`, {
+                    error: jsonError instanceof Error ? jsonError.message : String(jsonError),
+                    jsonContent: jsonMatch[0].substring(0, 100), // First 100 chars for debugging
+                });
             }
         }
         // Fallback to regex parsing
@@ -115,14 +122,49 @@ function parseUnifiedEvaluationResult(response, context) {
                 }
             }
         }
-        // Ensure minimum valid scores
-        return {
+        // Ensure minimum valid scores and validate with schema
+        // Use context to enhance evaluation data
+        const evaluationData = {
             relevance: result.relevance || 1,
             accuracy: result.accuracy || 1,
             completeness: result.completeness || 1,
             overall: result.overall || 1,
-            reasoning: result.reasoning || "No detailed reasoning provided",
+            domainAlignment: result.domainAlignment || (context.primaryDomain ? 5 : undefined), // Default to 5 if domain-specific
+            terminologyAccuracy: result.terminologyAccuracy || (context.primaryDomain ? 5 : undefined),
+            toolEffectiveness: result.toolEffectiveness || (context.toolUsage?.length ? 5 : undefined), // Default to 5 if tools were used
         };
+        // Validate against schema
+        try {
+            const validated = EvaluationSchema.parse(evaluationData);
+            // Enhance reasoning with context information
+            let enhancedReasoning = result.reasoning || "No detailed reasoning provided";
+            if (context.primaryDomain) {
+                enhancedReasoning += ` (Domain: ${context.primaryDomain})`;
+            }
+            if (context.toolUsage?.length) {
+                enhancedReasoning += ` (Tools used: ${context.toolUsage.map((t) => t.toolName).join(", ")})`;
+            }
+            if (context.conversationHistory?.length) {
+                enhancedReasoning += ` (Conversation turns: ${context.conversationHistory.length})`;
+            }
+            return {
+                ...validated,
+                reasoning: enhancedReasoning,
+            };
+        }
+        catch (validationError) {
+            logger.warn(`[${functionTag}] Schema validation failed, using fallback`, {
+                validationError,
+                originalData: evaluationData,
+            });
+            return {
+                relevance: Math.max(1, Math.min(10, result.relevance || 1)),
+                accuracy: Math.max(1, Math.min(10, result.accuracy || 1)),
+                completeness: Math.max(1, Math.min(10, result.completeness || 1)),
+                overall: Math.max(1, Math.min(10, result.overall || 1)),
+                reasoning: result.reasoning || "No detailed reasoning provided",
+            };
+        }
     }
     catch (error) {
         logger.error(`[${functionTag}] Failed to parse evaluation result`, {
@@ -140,8 +182,8 @@ function parseUnifiedEvaluationResult(response, context) {
 /**
  * Main unified evaluation function
  */
-export async function generateUnifiedEvaluation(context) {
-    const functionTag = "generateUnifiedEvaluation";
+export async function generateEvaluation(context) {
+    const functionTag = "generateEvaluation";
     const startTime = Date.now();
     logger.debug(`[${functionTag}] Starting evaluation`, {
         hasUserQuery: !!context.userQuery,
@@ -161,7 +203,7 @@ export async function generateUnifiedEvaluation(context) {
         const provider = await AIProviderFactory.createProvider(evaluationProvider, evaluationModel);
         if (!provider) {
             logger.debug(`[${functionTag}] No evaluation provider available, returning defaults`);
-            return getDefaultUnifiedEvaluation("no-provider", Date.now() - startTime, context);
+            return getDefaultEvaluation("no-provider", Date.now() - startTime, context);
         }
         // Create evaluation prompt
         const prompt = `
@@ -187,68 +229,78 @@ Reasoning: [Provide a detailed explanation of your evaluation, explaining why yo
         const result = await provider.generate(prompt);
         if (!result) {
             logger.debug(`[${functionTag}] No response from provider`);
-            return getDefaultUnifiedEvaluation("no-response", Date.now() - startTime, context);
+            return getDefaultEvaluation("no-response", Date.now() - startTime, context);
         }
         // Extract text from result
         const response = typeof result === "string" ? result : result?.content || String(result);
         // Parse evaluation result
-        const parsed = parseUnifiedEvaluationResult(response, context);
-        // Validate and enhance result
-        const validatedResult = {
-            ...parsed,
-            evaluationModel: `${evaluationProvider}/${evaluationModel}`,
-            evaluationTime: Date.now() - startTime,
-            evaluationProvider,
-            evaluationAttempt: 1,
-            evaluationConfig: {
-                mode: "standard",
-                fallbackUsed: false,
-                costEstimate: 0.001, // Rough estimate
-            },
+        const parsed = parseEvaluationResult(response, context);
+        // Validate and enhance result using schema
+        const baseResult = {
+            relevance: parsed.relevance || 1,
+            accuracy: parsed.accuracy || 1,
+            completeness: parsed.completeness || 1,
+            overall: parsed.overall || 1,
+            domainAlignment: parsed.domainAlignment,
+            terminologyAccuracy: parsed.terminologyAccuracy,
+            toolEffectiveness: parsed.toolEffectiveness,
         };
-        logger.debug(`[${functionTag}] Evaluation completed`, {
-            relevance: validatedResult.relevance,
-            accuracy: validatedResult.accuracy,
-            completeness: validatedResult.completeness,
-            overall: validatedResult.overall,
-            evaluationTime: validatedResult.evaluationTime,
-        });
-        return validatedResult;
+        // Validate against schema before finalizing
+        try {
+            const validatedScores = EvaluationSchema.parse(baseResult);
+            const validatedResult = normalizeEvaluationData({
+                ...parsed,
+                ...validatedScores,
+                evaluationModel: `${evaluationProvider}/${evaluationModel}`,
+                evaluationTime: Date.now() - startTime,
+                evaluationProvider,
+                evaluationAttempt: 1,
+                evaluationConfig: {
+                    mode: "standard",
+                    fallbackUsed: false,
+                    costEstimate: 0.001, // Rough estimate
+                },
+            });
+            logger.debug(`[${functionTag}] Schema validation passed`, {
+                validatedScores,
+            });
+            return validatedResult;
+        }
+        catch (validationError) {
+            logger.warn(`[${functionTag}] Schema validation failed in main evaluation`, {
+                validationError,
+                baseResult,
+            });
+            // Fallback with clamped values using normalizer
+            const validatedResult = normalizeEvaluationData({
+                ...parsed,
+                relevance: parsed.relevance || 1,
+                accuracy: parsed.accuracy || 1,
+                completeness: parsed.completeness || 1,
+                overall: parsed.overall || 1,
+                evaluationModel: `${evaluationProvider}/${evaluationModel}`,
+                evaluationTime: Date.now() - startTime,
+                evaluationProvider,
+                evaluationAttempt: 1,
+                evaluationConfig: {
+                    mode: "standard",
+                    fallbackUsed: false,
+                    costEstimate: 0.001, // Rough estimate
+                },
+            });
+            return validatedResult;
+        }
     }
     catch (error) {
         logger.error(`[${functionTag}] Evaluation failed`, {
             error: error instanceof Error ? error.message : String(error),
         });
-        return getDefaultUnifiedEvaluation(error instanceof Error ? error.message : "unknown-error", Date.now() - startTime, context);
+        return getDefaultEvaluation(error instanceof Error ? error.message : "unknown-error", Date.now() - startTime, context);
     }
 }
-// Legacy compatibility function with flexible arguments
-export async function evaluateResponse(responseOrContext, contextOrUserQuery, userQuery, providedContexts, options, additionalArgs) {
-    // Handle different call patterns for backward compatibility
-    let aiResponse;
-    let context;
-    if (typeof responseOrContext === "string") {
-        // Normal call: evaluateResponse(response, context, ...)
-        aiResponse = responseOrContext;
-        context = contextOrUserQuery;
-    }
-    else {
-        // Provider call pattern: evaluateResponse(contextObject, userQuery, ...)
-        context = responseOrContext;
-        aiResponse =
-            context?.aiResponse ||
-                context?.response ||
-                String(contextOrUserQuery || "");
-    }
-    const evalContext = {
-        userQuery: (typeof userQuery === "string" ? userQuery : "") ||
-            context?.userQuery ||
-            (typeof contextOrUserQuery === "string" ? contextOrUserQuery : "") ||
-            "Generated response",
-        aiResponse,
-        context: context,
-    };
-    return generateUnifiedEvaluation(evalContext);
+// Simplified evaluation function
+export async function evaluateResponse(context) {
+    return generateEvaluation(context);
 }
 // Export additional utilities
-export { getDefaultUnifiedEvaluation, parseUnifiedEvaluationResult };
+export { getDefaultEvaluation, parseEvaluationResult };

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

@@ -1,4 +1,19 @@
-import type { ProviderModelConfig } from "./types.js";
+interface ProviderModelConfig {
+    provider: string;
+    models: string[];
+    costPerToken?: number | {
+        input: number;
+        output: number;
+    };
+    requiresApiKey?: string[];
+    performance?: {
+        averageLatency?: number;
+        reliability?: number;
+        speed?: number;
+        quality?: number;
+        cost?: number;
+    };
+}
 /**
  * Dynamic provider configurations for evaluation
  * Now uses configurable system instead of hardcoded values
@@ -22,7 +37,7 @@ export declare function sortProvidersByPreference(providers: ProviderModelConfig
  * Estimate cost for a specific provider and token usage
  * Now uses the configurable system
  */
-export declare function estimateProviderCost(providerName: string, inputTokens: number, outputTokens: number): number;
+export declare function estimateProviderCost(providerName: string, input: number, output: number): number;
 /**
  * Check if a provider is available (has required API keys)
  * Now uses the configurable system
@@ -58,3 +73,4 @@ export declare function getProviderPerformanceAnalytics(): Record<string, {
  * @param providerName - (Optional) The name of the provider to reset. If omitted, resets all providers.
  */
 export declare function resetProviderMetrics(providerName?: string): void;
+export {};

package/dist/lib/core/evaluationProviders.js

@@ -12,7 +12,7 @@ const providerMetrics = new Map();
 function convertToLegacyFormat(config) {
     return {
         provider: config.provider,
-        models: config.models,
+        models: Object.keys(config.models || {}),
         costPerToken: config.defaultCost,
         requiresApiKey: config.requiredEnvVars,
         performance: config.performance,
@@ -57,25 +57,27 @@ export function getAvailableProviders() {
  */
 export function sortProvidersByPreference(providers, preferCheap = true) {
     return providers.sort((a, b) => {
+        const aPerf = a.performance || { cost: 0, speed: 0, quality: 0 };
+        const bPerf = b.performance || { cost: 0, speed: 0, quality: 0 };
         if (preferCheap) {
             // Cost > Speed > Quality for cheap preference
-            if (a.performance.cost !== b.performance.cost) {
-                return b.performance.cost - a.performance.cost;
+            if ((aPerf.cost || 0) !== (bPerf.cost || 0)) {
+                return (bPerf.cost || 0) - (aPerf.cost || 0);
             }
-            if (a.performance.speed !== b.performance.speed) {
-                return b.performance.speed - a.performance.speed;
+            if ((aPerf.speed || 0) !== (bPerf.speed || 0)) {
+                return (bPerf.speed || 0) - (aPerf.speed || 0);
             }
-            return b.performance.quality - a.performance.quality;
+            return (bPerf.quality || 0) - (aPerf.quality || 0);
         }
         else {
             // Quality > Speed > Cost for quality preference
-            if (a.performance.quality !== b.performance.quality) {
-                return b.performance.quality - a.performance.quality;
+            if ((aPerf.quality || 0) !== (bPerf.quality || 0)) {
+                return (bPerf.quality || 0) - (aPerf.quality || 0);
             }
-            if (a.performance.speed !== b.performance.speed) {
-                return b.performance.speed - a.performance.speed;
+            if ((aPerf.speed || 0) !== (bPerf.speed || 0)) {
+                return (bPerf.speed || 0) - (aPerf.speed || 0);
             }
-            return b.performance.cost - a.performance.cost;
+            return (bPerf.cost || 0) - (aPerf.cost || 0);
         }
     });
 }
@@ -83,12 +85,12 @@ 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) {
+export function estimateProviderCost(providerName, input, output) {
     const costInfo = modelConfig.getCostInfo(providerName);
     if (!costInfo) {
         return 0;
     }
-    return inputTokens * costInfo.input + outputTokens * costInfo.output;
+    return input * costInfo.input + output * costInfo.output;
 }
 /**
  * Check if a provider is available (has required API keys)

package/dist/lib/core/factory.js

@@ -55,12 +55,18 @@ export class AIProviderFactory {
      * @returns AIProvider instance
      */
     static async createProvider(providerName, modelName, enableMCP = true, sdk) {
-        const functionTag = "AIawait ProviderFactory.createProvider";
+        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",
+            },
         });
         try {
             // DYNAMIC MODEL PROVIDER STATUS (2025): Enhanced with timeout handling
@@ -73,12 +79,57 @@ export class AIProviderFactory {
             //
             // The dynamic model provider now provides reliable functionality without hanging
             let resolvedModelName = modelName;
-            // Enable dynamic model resolution with timeout-protected initialization
+            // 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 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 {
+                    logger.debug(`[${functionTag}] Provider ${providerName} - no environment variable check implemented`);
+                }
+            }
+            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();
                     }
                     const dynamicModel = dynamicModelProvider.resolveModel(normalizedProvider, modelName || undefined);
@@ -92,6 +143,12 @@ export class AIProviderFactory {
                             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`, {
@@ -102,6 +159,12 @@ export class AIProviderFactory {
                     // Continue with static model name - no functionality loss
                 }
             }
+            else {
+                logger.debug(`[${functionTag}] Skipping dynamic model resolution`, {
+                    resolvedModelName: resolvedModelName || "none",
+                    reason: "Model already resolved from environment variables or explicit parameter",
+                });
+            }
             // CRITICAL FIX: Initialize providers before using them
             await ProviderRegistry.registerAllProviders();
             // PURE FACTORY PATTERN: No switch statements - use ProviderFactory exclusively
@@ -109,8 +172,18 @@ export class AIProviderFactory {
             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
             const provider = await ProviderFactory.createProvider(normalizedName, finalModelName, sdk);
+            // 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,
@@ -153,7 +226,7 @@ export class AIProviderFactory {
      * @returns AIProvider instance
      */
     static async createProviderWithModel(provider, model) {
-        const functionTag = "AIawait ProviderFactory.createProviderWithModel";
+        const functionTag = "AIProviderFactory.createProviderWithModel";
         logger.debug(`[${functionTag}] Provider model creation started`, {
             provider,
             model,
@@ -214,7 +287,7 @@ export class AIProviderFactory {
      * @returns Object with primary and fallback providers
      */
     static async createProviderWithFallback(primaryProvider, fallbackProvider, modelName, enableMCP = true) {
-        const functionTag = "AIawait ProviderFactory.createProviderWithFallback";
+        const functionTag = "AIProviderFactory.createProviderWithFallback";
         logger.debug(`[${functionTag}] Fallback provider setup started`, {
             primaryProvider,
             fallbackProvider,

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

@@ -132,6 +132,50 @@ export declare class ModelConfigurationManager {
     private lastUpdated;
     private constructor();
     static getInstance(): ModelConfigurationManager;
+    /**
+     * Create Google AI provider configuration
+     */
+    private createGoogleAIConfig;
+    /**
+     * Create Google Vertex AI provider configuration
+     */
+    private createVertexConfig;
+    /**
+     * Create OpenAI provider configuration
+     */
+    private createOpenAIConfig;
+    /**
+     * Create all provider configurations - centralized approach
+     */
+    private createAllProviderConfigs;
+    /**
+     * Create Anthropic provider configuration
+     */
+    private createAnthropicConfig;
+    /**
+     * Create Vertex alternative provider configuration
+     */
+    private createVertexAlternativeConfig;
+    /**
+     * Create Bedrock provider configuration
+     */
+    private createBedrockConfig;
+    /**
+     * Create Azure provider configuration
+     */
+    private createAzureConfig;
+    /**
+     * Create Ollama provider configuration
+     */
+    private createOllamaConfig;
+    /**
+     * Create HuggingFace provider configuration
+     */
+    private createHuggingFaceConfig;
+    /**
+     * Create Mistral provider configuration
+     */
+    private createMistralConfig;
     /**
      * Load default configurations (replaces hardcoded values)
      */
@@ -174,6 +218,25 @@ export declare class ModelConfigurationManager {
      * Update provider configuration (runtime updates)
      */
     updateProviderConfig(provider: string, config: ProviderConfig): void;
+    /**
+     * Parse YAML content with basic support
+     * For full YAML support, would need a proper YAML library
+     */
+    private parseYAMLContent;
+    /**
+     * Convert simple YAML to JSON object
+     * Handles basic key-value pairs only
+     */
+    private convertSimpleYAMLToJSON;
+    /**
+     * Process a single YAML line
+     * Returns key-value pair if valid, null otherwise
+     */
+    private processYAMLLine;
+    /**
+     * Convert YAML value to appropriate JavaScript type
+     */
+    private convertYAMLValue;
     /**
      * Load configurations from external source
      */