@juspay/neurolink 7.0.0 → 7.2.0

package/dist/core/evaluation.js

@@ -84,24 +84,32 @@ function parseUnifiedEvaluationResult(response, context) {
             accuracy: /accuracy[:\s]*([0-9]+(?:\.[0-9]+)?)/i,
             completeness: /completeness[:\s]*([0-9]+(?:\.[0-9]+)?)/i,
             overall: /overall[:\s]*([0-9]+(?:\.[0-9]+)?)/i,
+            reasoning: /reasoning[:\s]*(.+?)(?=\n\s*\w+:|\n\s*$|$)/is,
         };
         for (const [key, pattern] of Object.entries(patterns)) {
             const match = response.match(pattern);
             if (match) {
-                const value = parseFloat(match[1]);
-                if (value >= 1 && value <= 10) {
-                    const roundedValue = Math.round(value);
-                    if (key === "relevance") {
-                        result.relevance = roundedValue;
-                    }
-                    else if (key === "accuracy") {
-                        result.accuracy = roundedValue;
-                    }
-                    else if (key === "completeness") {
-                        result.completeness = roundedValue;
-                    }
-                    else if (key === "overall") {
-                        result.overall = roundedValue;
+                if (key === "reasoning") {
+                    // Extract reasoning text
+                    result.reasoning = match[1].trim();
+                }
+                else {
+                    // Extract numerical scores
+                    const value = parseFloat(match[1]);
+                    if (value >= 1 && value <= 10) {
+                        const roundedValue = Math.round(value);
+                        if (key === "relevance") {
+                            result.relevance = roundedValue;
+                        }
+                        else if (key === "accuracy") {
+                            result.accuracy = roundedValue;
+                        }
+                        else if (key === "completeness") {
+                            result.completeness = roundedValue;
+                        }
+                        else if (key === "overall") {
+                            result.overall = roundedValue;
+                        }
                     }
                 }
             }
@@ -112,6 +120,7 @@ function parseUnifiedEvaluationResult(response, context) {
             accuracy: result.accuracy || 1,
             completeness: result.completeness || 1,
             overall: result.overall || 1,
+            reasoning: result.reasoning || "No detailed reasoning provided",
         };
     }
     catch (error) {
@@ -123,6 +132,7 @@ function parseUnifiedEvaluationResult(response, context) {
             accuracy: 1,
             completeness: 1,
             overall: 1,
+            reasoning: "Error occurred during evaluation parsing",
         };
     }
 }
@@ -167,6 +177,7 @@ Relevance: [score]
 Accuracy: [score]
 Completeness: [score]
 Overall: [score]
+Reasoning: [Provide a detailed explanation of your evaluation, explaining why you gave these scores. Include specific observations about the response's strengths and any areas for improvement.]
 `;
         // Generate evaluation
         const result = await provider.generate(prompt);

package/dist/core/factory.js

@@ -38,24 +38,25 @@ export class AIProviderFactory {
             enableMCP,
         });
         try {
-            // EMERGENCY FIX: Skip dynamic model provider initialization to prevent hanging
-            // TODO: Fix the hanging dynamic model provider.initialize()
-            // Initialize dynamic model provider if not already done
-            // try {
-            //   if (dynamicModelProvider.needsRefresh()) {
-            //     // Add timeout to prevent hanging
-            //     await Promise.race([
-            //       dynamicModelProvider.initialize(),
-            //       new Promise((_, reject) =>
-            //         setTimeout(() => reject(new Error('Dynamic model provider timeout')), 3000)
-            //       )
-            //     ]);
-            //   }
-            // } catch (dynamicError) {
-            //   logger.warn(`[${functionTag}] Dynamic model provider initialization failed, using fallback`, {
-            //     error: dynamicError instanceof Error ? dynamicError.message : String(dynamicError),
-            //   });
-            // }
+            // 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
+            //
+            // Current Behavior: Static model resolution works reliably
+            // Impact: No functionality loss - providers use built-in model defaults
+            //
+            // 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;
@@ -89,6 +90,8 @@ export class AIProviderFactory {
             //     );
             //   }
             // }
+            // 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

package/dist/core/streamAnalytics.d.ts

@@ -0,0 +1,65 @@
+import type { AnalyticsData } from "./types.js";
+import type { TokenUsage } from "../types/providers.js";
+import type { ToolCall, ToolResult } from "../types/streamTypes.js";
+/**
+ * Stream analytics result from Vercel AI SDK streamText
+ */
+export interface StreamTextResult {
+    textStream: AsyncIterable<string>;
+    text: Promise<string>;
+    usage: Promise<{
+        promptTokens: number;
+        completionTokens: number;
+        totalTokens: number;
+    } | undefined>;
+    response: Promise<{
+        id?: string;
+        model?: string;
+        timestamp?: number | Date;
+    } | undefined>;
+    finishReason: Promise<"stop" | "length" | "content-filter" | "tool-calls" | "error" | "other" | "unknown">;
+    toolResults?: Promise<ToolResult[]>;
+    toolCalls?: Promise<ToolCall[]>;
+}
+/**
+ * Interface for collecting analytics from streaming results
+ */
+export interface StreamAnalyticsCollector {
+    collectUsage(result: StreamTextResult): Promise<TokenUsage>;
+    collectMetadata(result: StreamTextResult): Promise<ResponseMetadata>;
+    createAnalytics(provider: string, model: string, result: StreamTextResult, responseTime: number, metadata?: Record<string, unknown>): Promise<AnalyticsData>;
+}
+/**
+ * Response metadata from stream result
+ */
+export interface ResponseMetadata {
+    id?: string;
+    model?: string;
+    timestamp?: number;
+    finishReason?: string;
+}
+/**
+ * Base implementation for collecting analytics from Vercel AI SDK stream results
+ */
+export declare class BaseStreamAnalyticsCollector implements StreamAnalyticsCollector {
+    /**
+     * Collect token usage from stream result
+     */
+    collectUsage(result: StreamTextResult): Promise<TokenUsage>;
+    /**
+     * Collect response metadata from stream result
+     */
+    collectMetadata(result: StreamTextResult): Promise<ResponseMetadata>;
+    /**
+     * Create comprehensive analytics from stream result
+     */
+    createAnalytics(provider: string, model: string, result: StreamTextResult, responseTime: number, metadata?: Record<string, unknown>): Promise<AnalyticsData>;
+    /**
+     * Clean up resources and force garbage collection if needed
+     */
+    cleanup(): void;
+}
+/**
+ * Global instance of stream analytics collector
+ */
+export declare const streamAnalyticsCollector: BaseStreamAnalyticsCollector;

package/dist/core/streamAnalytics.js

@@ -0,0 +1,125 @@
+import { createAnalytics } from "./analytics.js";
+import { logger } from "../utils/logger.js";
+/**
+ * Base implementation for collecting analytics from Vercel AI SDK stream results
+ */
+export class BaseStreamAnalyticsCollector {
+    /**
+     * Collect token usage from stream result
+     */
+    async collectUsage(result) {
+        try {
+            const usage = await result.usage;
+            if (!usage) {
+                logger.debug("No usage data available from stream result");
+                return {
+                    inputTokens: 0,
+                    outputTokens: 0,
+                    totalTokens: 0,
+                };
+            }
+            return {
+                inputTokens: usage.promptTokens || 0,
+                outputTokens: usage.completionTokens || 0,
+                totalTokens: usage.totalTokens ||
+                    (usage.promptTokens || 0) + (usage.completionTokens || 0),
+            };
+        }
+        catch (error) {
+            logger.warn("Failed to collect usage from stream result", { error });
+            return {
+                inputTokens: 0,
+                outputTokens: 0,
+                totalTokens: 0,
+            };
+        }
+    }
+    /**
+     * Collect response metadata from stream result
+     */
+    async collectMetadata(result) {
+        try {
+            const [response, finishReason] = await Promise.all([
+                result.response,
+                result.finishReason,
+            ]);
+            return {
+                id: response?.id,
+                model: response?.model,
+                timestamp: response?.timestamp instanceof Date
+                    ? response.timestamp.getTime()
+                    : response?.timestamp || Date.now(),
+                finishReason: finishReason,
+            };
+        }
+        catch (error) {
+            logger.warn("Failed to collect metadata from stream result", { error });
+            const finishReason = await result.finishReason.catch(() => "error");
+            return {
+                timestamp: Date.now(),
+                finishReason: finishReason,
+            };
+        }
+    }
+    /**
+     * Create comprehensive analytics from stream result
+     */
+    async createAnalytics(provider, model, result, responseTime, metadata) {
+        try {
+            // Collect analytics data in parallel
+            const [usage, responseMetadata] = await Promise.all([
+                this.collectUsage(result),
+                this.collectMetadata(result),
+            ]);
+            // Get final text content and finish reason
+            const [content, finishReason, toolResults, toolCalls] = await Promise.all([
+                result.text,
+                result.finishReason,
+                result.toolResults || Promise.resolve([]),
+                result.toolCalls || Promise.resolve([]),
+            ]);
+            // Create comprehensive analytics
+            return createAnalytics(provider, model, {
+                usage,
+                content,
+                response: responseMetadata,
+                finishReason: finishReason,
+                toolResults: toolResults,
+                toolCalls: toolCalls,
+            }, responseTime, {
+                ...metadata,
+                streamingMode: true,
+                responseId: responseMetadata.id,
+                finishReason: finishReason,
+            });
+        }
+        catch (error) {
+            logger.error("Failed to create analytics from stream result", {
+                provider,
+                model,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            // Return minimal analytics on error
+            return createAnalytics(provider, model, { usage: { inputTokens: 0, outputTokens: 0, totalTokens: 0 } }, responseTime, {
+                ...metadata,
+                streamingMode: true,
+                analyticsError: true,
+            });
+        }
+    }
+    /**
+     * Clean up resources and force garbage collection if needed
+     */
+    cleanup() {
+        // Only force garbage collection if memory usage exceeds 500 MB
+        const heapUsed = process.memoryUsage().heapUsed;
+        const GC_THRESHOLD = 500 * 1024 * 1024; // 500 MB
+        if (typeof global !== "undefined" && global.gc && heapUsed > GC_THRESHOLD) {
+            global.gc();
+        }
+    }
+}
+/**
+ * Global instance of stream analytics collector
+ */
+export const streamAnalyticsCollector = new BaseStreamAnalyticsCollector();

package/dist/factories/providerRegistry.js

@@ -48,7 +48,9 @@ export class ProviderRegistry {
             ProviderFactory.registerProvider(AIProviderName.AZURE, async (modelName) => {
                 const { AzureOpenAIProvider } = await import("../providers/azureOpenai.js");
                 return new AzureOpenAIProvider(modelName);
-            }, "gpt-4o-mini", ["azure", "azureOpenai"]);
+            }, process.env.AZURE_MODEL ||
+                process.env.AZURE_OPENAI_DEPLOYMENT_ID ||
+                "gpt-4o-mini", ["azure", "azureOpenai"]);
             // Register Google Vertex AI provider
             ProviderFactory.registerProvider(AIProviderName.VERTEX, async (modelName) => {
                 const { GoogleVertexProvider } = await import("../providers/googleVertex.js");

package/dist/lib/core/analytics.js

@@ -50,52 +50,39 @@ export function createAnalytics(provider, model, result, responseTime, context)
  * Extract token usage from various AI result formats
  */
 function extractTokenUsage(result) {
-    // Handle different response formats
+    // Use properly typed usage object from BaseProvider or direct AI SDK
     if (result.usage &&
         typeof result.usage === "object" &&
         result.usage !== null) {
         const usage = result.usage;
-        // Standard format
-        if (typeof usage.promptTokens === "number" &&
-            typeof usage.completionTokens === "number") {
-            return {
-                input: usage.promptTokens || 0,
-                output: usage.completionTokens || 0,
-                total: typeof usage.totalTokens === "number"
-                    ? usage.totalTokens
-                    : usage.promptTokens + usage.completionTokens,
-            };
+        // Try BaseProvider normalized format first (inputTokens/outputTokens)
+        if (typeof usage.inputTokens === "number" ||
+            typeof usage.outputTokens === "number") {
+            const input = typeof usage.inputTokens === "number" ? usage.inputTokens : 0;
+            const output = typeof usage.outputTokens === "number" ? usage.outputTokens : 0;
+            const total = typeof usage.totalTokens === "number"
+                ? usage.totalTokens
+                : input + output;
+            return { input, output, total };
         }
-        // Alternative formats
-        if (typeof usage.input_tokens === "number" &&
-            typeof usage.output_tokens === "number") {
-            return {
-                input: usage.input_tokens || 0,
-                output: usage.output_tokens || 0,
-                total: typeof usage.total_tokens === "number"
-                    ? usage.total_tokens
-                    : usage.input_tokens + usage.output_tokens,
-            };
+        // Try OpenAI/Mistral format (promptTokens/completionTokens)
+        if (typeof usage.promptTokens === "number" ||
+            typeof usage.completionTokens === "number") {
+            const input = typeof usage.promptTokens === "number" ? usage.promptTokens : 0;
+            const output = typeof usage.completionTokens === "number" ? usage.completionTokens : 0;
+            const total = typeof usage.totalTokens === "number"
+                ? usage.totalTokens
+                : input + output;
+            return { input, output, total };
         }
-        // Generic tokens field
-        if (typeof usage.tokens === "number") {
-            return {
-                input: 0,
-                output: 0,
-                total: usage.tokens,
-            };
+        // Handle total-only case
+        if (typeof usage.totalTokens === "number") {
+            return { input: 0, output: 0, total: usage.totalTokens };
         }
     }
-    // Fallback: estimate from text length
-    const textLength = (typeof result.text === "string" ? result.text.length : 0) ||
-        (typeof result.content === "string" ? result.content.length : 0) ||
-        0;
-    const estimatedTokens = Math.ceil(textLength / 4); // ~4 chars per token
-    return {
-        input: 0,
-        output: estimatedTokens,
-        total: estimatedTokens,
-    };
+    // Fallback for edge cases
+    logger.debug("Token extraction failed: unknown usage format", { result });
+    return { input: 0, output: 0, total: 0 };
 }
 /**
  * Estimate cost based on provider, model, and token usage

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

@@ -447,5 +447,13 @@ export declare abstract class BaseProvider implements AIProvider {
      * Get timeout value in milliseconds
      */
     getTimeout(options: TextGenerationOptions | StreamOptions): number;
+    /**
+     * Utility method to chunk large prompts into smaller pieces
+     * @param prompt The prompt to chunk
+     * @param maxChunkSize Maximum size per chunk (default: 900,000 characters)
+     * @param overlap Overlap between chunks to maintain context (default: 100 characters)
+     * @returns Array of prompt chunks
+     */
+    static chunkPrompt(prompt: string, maxChunkSize?: number, overlap?: number): string[];
 }
 export {};