@juspay/neurolink 7.29.2 → 7.29.3

package/dist/core/evaluation.d.ts

@@ -1,8 +1,8 @@
 /**
- * NeuroLink Unified Evaluation System
+ * NeuroLink Evaluation System
  */
-import type { EvaluationData } from "./types.js";
-export interface UnifiedEvaluationResult extends EvaluationData {
+import type { EvaluationData } from "../index.js";
+export interface EvaluationResult extends EvaluationData {
     domainAlignment?: number;
     terminologyAccuracy?: number;
     toolEffectiveness?: number;
@@ -20,7 +20,7 @@ export interface UnifiedEvaluationResult extends EvaluationData {
     alertSeverity: "low" | "medium" | "high" | "none";
     reasoning: string;
 }
-export interface UnifiedEvaluationContext {
+export interface EvaluationContext {
     userQuery: string;
     aiResponse: string;
     context?: Record<string, unknown>;
@@ -43,14 +43,14 @@ export interface UnifiedEvaluationContext {
 /**
  * Get default evaluation when evaluation fails
  */
-declare function getDefaultUnifiedEvaluation(reason: string, evaluationTime: number, context: UnifiedEvaluationContext): UnifiedEvaluationResult;
+declare function getDefaultEvaluation(reason: string, evaluationTime: number, context: EvaluationContext): EvaluationResult;
 /**
  * Parse unified evaluation result from text response
  */
-declare function parseUnifiedEvaluationResult(response: string, context: UnifiedEvaluationContext): Partial<UnifiedEvaluationResult>;
+declare function parseEvaluationResult(response: string, context: EvaluationContext): Partial<EvaluationResult>;
 /**
  * Main unified evaluation function
  */
-export declare function generateUnifiedEvaluation(context: UnifiedEvaluationContext): Promise<UnifiedEvaluationResult>;
-export declare function evaluateResponse(responseOrContext: unknown, contextOrUserQuery?: unknown, userQuery?: unknown, providedContexts?: unknown, options?: unknown, additionalArgs?: unknown): Promise<unknown>;
-export { getDefaultUnifiedEvaluation, parseUnifiedEvaluationResult };
+export declare function generateEvaluation(context: EvaluationContext): Promise<EvaluationResult>;
+export declare function evaluateResponse(context: EvaluationContext): Promise<EvaluationResult>;
+export { getDefaultEvaluation, parseEvaluationResult };

package/dist/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/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/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/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
      */