@juspay/neurolink 7.0.0 → 7.2.0

package/dist/lib/core/baseProvider.js

@@ -1,4 +1,5 @@
 import { logger } from "../utils/logger.js";
+import { SYSTEM_LIMITS } from "../core/constants.js";
 import { directAgentTools } from "../agent/directTools.js";
 /**
  * Validates if a result contains a valid toolsObject structure
@@ -49,80 +50,96 @@ export class BaseProvider {
      */
     async stream(optionsOrPrompt, analysisSchema) {
         const options = this.normalizeStreamOptions(optionsOrPrompt);
-        // If tools are not disabled AND provider supports tools, use generate() and create synthetic stream
-        if (!options.disableTools && this.supportsTools()) {
-            try {
-                // Convert stream options to text generation options
-                const textOptions = {
-                    prompt: options.input?.text || "",
-                    systemPrompt: options.systemPrompt,
-                    temperature: options.temperature,
-                    maxTokens: options.maxTokens,
-                    disableTools: false,
-                    maxSteps: options.maxSteps || 5,
-                    provider: options.provider,
-                    model: options.model,
-                };
-                const result = await this.generate(textOptions, analysisSchema);
-                // Create a synthetic stream from the generate result that simulates progressive delivery
-                return {
-                    stream: (async function* () {
-                        if (result?.content) {
-                            // Split content into words for more natural streaming
-                            const words = result.content.split(/(\s+)/); // Keep whitespace
-                            let buffer = "";
-                            for (let i = 0; i < words.length; i++) {
-                                buffer += words[i];
-                                // Yield chunks of roughly 5-10 words or at punctuation
-                                const shouldYield = i === words.length - 1 || // Last word
-                                    buffer.length > 50 || // Buffer getting long
-                                    /[.!?;,]\s*$/.test(buffer); // End of sentence/clause
-                                if (shouldYield && buffer.trim()) {
+        // CRITICAL FIX: Always prefer real streaming over fake streaming
+        // Try real streaming first, use fake streaming only as fallback
+        try {
+            const realStreamResult = await this.executeStream(options, analysisSchema);
+            // If real streaming succeeds, return it (with tools support via Vercel AI SDK)
+            return realStreamResult;
+        }
+        catch (realStreamError) {
+            logger.warn(`Real streaming failed for ${this.providerName}, falling back to fake streaming:`, realStreamError);
+            // Fallback to fake streaming only if real streaming fails AND tools are enabled
+            if (!options.disableTools && this.supportsTools()) {
+                try {
+                    // Convert stream options to text generation options
+                    const textOptions = {
+                        prompt: options.input?.text || "",
+                        systemPrompt: options.systemPrompt,
+                        temperature: options.temperature,
+                        maxTokens: options.maxTokens,
+                        disableTools: false,
+                        maxSteps: options.maxSteps || 5,
+                        provider: options.provider,
+                        model: options.model,
+                        // 🔧 FIX: Include analytics and evaluation options from stream options
+                        enableAnalytics: options.enableAnalytics,
+                        enableEvaluation: options.enableEvaluation,
+                        evaluationDomain: options.evaluationDomain,
+                        toolUsageContext: options.toolUsageContext,
+                        context: options.context,
+                    };
+                    const result = await this.generate(textOptions, analysisSchema);
+                    // Create a synthetic stream from the generate result that simulates progressive delivery
+                    return {
+                        stream: (async function* () {
+                            if (result?.content) {
+                                // Split content into words for more natural streaming
+                                const words = result.content.split(/(\s+)/); // Keep whitespace
+                                let buffer = "";
+                                for (let i = 0; i < words.length; i++) {
+                                    buffer += words[i];
+                                    // Yield chunks of roughly 5-10 words or at punctuation
+                                    const shouldYield = i === words.length - 1 || // Last word
+                                        buffer.length > 50 || // Buffer getting long
+                                        /[.!?;,]\s*$/.test(buffer); // End of sentence/clause
+                                    if (shouldYield && buffer.trim()) {
+                                        yield { content: buffer };
+                                        buffer = "";
+                                        // Small delay to simulate streaming (1-10ms)
+                                        await new Promise((resolve) => setTimeout(resolve, Math.random() * 9 + 1));
+                                    }
+                                }
+                                // Yield any remaining content
+                                if (buffer.trim()) {
                                     yield { content: buffer };
-                                    buffer = "";
-                                    // Small delay to simulate streaming (1-10ms)
-                                    await new Promise((resolve) => setTimeout(resolve, Math.random() * 9 + 1));
                                 }
                             }
-                            // Yield any remaining content
-                            if (buffer.trim()) {
-                                yield { content: buffer };
-                            }
-                        }
-                    })(),
-                    usage: result?.usage,
-                    provider: result?.provider,
-                    model: result?.model,
-                    toolCalls: result?.toolCalls?.map((call) => ({
-                        toolName: call.toolName,
-                        parameters: call.args,
-                        id: call.toolCallId,
-                    })),
-                    toolResults: result?.toolResults
-                        ? result.toolResults.map((tr) => ({
-                            toolName: tr.toolName || "unknown",
-                            status: (tr.status === "error"
-                                ? "failure"
-                                : "success"),
-                            result: tr.result,
-                            error: tr.error,
-                        }))
-                        : undefined,
-                };
+                        })(),
+                        usage: result?.usage,
+                        provider: result?.provider,
+                        model: result?.model,
+                        toolCalls: result?.toolCalls?.map((call) => ({
+                            toolName: call.toolName,
+                            parameters: call.args,
+                            id: call.toolCallId,
+                        })),
+                        toolResults: result?.toolResults
+                            ? result.toolResults.map((tr) => ({
+                                toolName: tr.toolName || "unknown",
+                                status: (tr.status === "error"
+                                    ? "failure"
+                                    : "success"),
+                                result: tr.result,
+                                error: tr.error,
+                            }))
+                            : undefined,
+                        // 🔧 FIX: Include analytics and evaluation from generate result
+                        analytics: result?.analytics,
+                        evaluation: result?.evaluation,
+                    };
+                }
+                catch (error) {
+                    logger.error(`Fake streaming fallback failed for ${this.providerName}:`, error);
+                    throw this.handleProviderError(error);
+                }
             }
-            catch (error) {
-                logger.error(`Stream with tools failed for ${this.providerName}:`, error);
-                throw this.handleProviderError(error);
+            else {
+                // If real streaming failed and no tools are enabled, re-throw the original error
+                logger.error(`Real streaming failed for ${this.providerName}:`, realStreamError);
+                throw this.handleProviderError(realStreamError);
             }
         }
-        // Traditional streaming without tools
-        try {
-            return await this.executeStream(options, analysisSchema);
-        }
-        catch (error) {
-            logger.error(`Stream failed for ${this.providerName}:`, error);
-            throw this.handleProviderError(error);
-        }
     }
     /**
      * Text generation method - implements AIProvider interface
@@ -150,6 +167,31 @@ export class BaseProvider {
                 temperature: options.temperature,
                 maxTokens: options.maxTokens || 8192,
             });
+            // Extract tool names from tool calls for tracking
+            // AI SDK puts tool calls in steps array for multi-step generation
+            const toolsUsed = [];
+            // First check direct tool calls (fallback)
+            if (result.toolCalls && result.toolCalls.length > 0) {
+                toolsUsed.push(...result.toolCalls.map((tc) => {
+                    return (tc.toolName ||
+                        tc.name ||
+                        "unknown");
+                }));
+            }
+            // Then check steps for tool calls (primary source for multi-step)
+            if (result.steps &&
+                Array.isArray(result.steps)) {
+                for (const step of result.steps ||
+                    []) {
+                    if (step?.toolCalls && Array.isArray(step.toolCalls)) {
+                        toolsUsed.push(...step.toolCalls.map((tc) => {
+                            return tc.toolName || tc.name || "unknown";
+                        }));
+                    }
+                }
+            }
+            // Remove duplicates
+            const uniqueToolsUsed = [...new Set(toolsUsed)];
             // Format the result with tool executions included
             const enhancedResult = {
                 content: result.text,
@@ -174,6 +216,7 @@ export class BaseProvider {
                     }))
                     : [],
                 toolResults: result.toolResults,
+                toolsUsed: uniqueToolsUsed,
             };
             // Enhanced result with analytics and evaluation
             return await this.enhanceResult(enhancedResult, options, startTime);
@@ -348,9 +391,43 @@ export class BaseProvider {
         return evaluation;
     }
     validateOptions(options) {
+        // 🔧 EDGE CASE: Basic prompt validation
         if (!options.prompt || options.prompt.trim().length === 0) {
             throw new Error("Prompt is required and cannot be empty");
         }
+        // 🔧 EDGE CASE: Handle very large prompts (>1M characters)
+        if (options.prompt.length > SYSTEM_LIMITS.MAX_PROMPT_LENGTH) {
+            throw new Error(`Prompt too large: ${options.prompt.length} characters (max: ${SYSTEM_LIMITS.MAX_PROMPT_LENGTH}). Consider breaking into smaller chunks. Use BaseProvider.chunkPrompt(prompt, maxSize, overlap) static method for chunking.`);
+        }
+        // 🔧 EDGE CASE: Validate token limits
+        if (options.maxTokens && options.maxTokens > 200000) {
+            throw new Error(`Max tokens too high: ${options.maxTokens} (recommended max: 200,000). This may cause timeouts or API errors.`);
+        }
+        if (options.maxTokens && options.maxTokens < 1) {
+            throw new Error("Max tokens must be at least 1");
+        }
+        // 🔧 EDGE CASE: Validate temperature range
+        if (options.temperature !== undefined) {
+            if (options.temperature < 0 || options.temperature > 2) {
+                throw new Error(`Temperature must be between 0 and 2, got: ${options.temperature}`);
+            }
+        }
+        // 🔧 EDGE CASE: Validate timeout values
+        if (options.timeout !== undefined) {
+            const timeoutMs = typeof options.timeout === "string"
+                ? parseInt(options.timeout, 10)
+                : options.timeout;
+            if (isNaN(timeoutMs) || timeoutMs < 1000) {
+                throw new Error(`Timeout must be at least 1000ms (1 second), got: ${options.timeout}`);
+            }
+            if (timeoutMs > SYSTEM_LIMITS.LONG_TIMEOUT_WARNING) {
+                logger.warn(`⚠️ Very long timeout: ${timeoutMs}ms. This may cause the CLI to hang.`);
+            }
+        }
+        // 🔧 EDGE CASE: Validate maxSteps for tool execution
+        if (options.maxSteps !== undefined && options.maxSteps > 20) {
+            throw new Error(`Max steps too high: ${options.maxSteps} (recommended max: 20). This may cause long execution times.`);
+        }
     }
     getProviderInfo() {
         return {
@@ -382,4 +459,36 @@ export class BaseProvider {
         }
         return this.defaultTimeout;
     }
+    /**
+     * 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, maxChunkSize = 900000, overlap = 100) {
+        if (prompt.length <= maxChunkSize) {
+            return [prompt];
+        }
+        const chunks = [];
+        let start = 0;
+        while (start < prompt.length) {
+            const end = Math.min(start + maxChunkSize, prompt.length);
+            chunks.push(prompt.slice(start, end));
+            // Break if we've reached the end
+            if (end >= prompt.length) {
+                break;
+            }
+            // Move start forward, accounting for overlap
+            const nextStart = end - overlap;
+            // Ensure we make progress (avoid infinite loops)
+            if (nextStart <= start) {
+                start = end;
+            }
+            else {
+                start = Math.max(nextStart, 0);
+            }
+        }
+        return chunks;
+    }
 }

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

@@ -36,6 +36,17 @@ export declare const CLI_LIMITS: {
         default: number;
     };
 };
+export declare const SYSTEM_LIMITS: {
+    MAX_PROMPT_LENGTH: number;
+    HIGH_MEMORY_THRESHOLD: number;
+    LONG_TIMEOUT_WARNING: number;
+    DEFAULT_CONCURRENCY_LIMIT: number;
+    MAX_CONCURRENCY_LIMIT: number;
+    DEFAULT_RETRY_ATTEMPTS: number;
+    DEFAULT_INITIAL_DELAY: number;
+    DEFAULT_MAX_DELAY: number;
+    DEFAULT_BACKOFF_MULTIPLIER: number;
+};
 export declare const ENV_DEFAULTS: {
     maxTokens: number;
     temperature: number;

package/dist/lib/core/constants.js

@@ -40,6 +40,23 @@ export const CLI_LIMITS = {
         default: DEFAULT_TEMPERATURE,
     },
 };
+// Performance and System Limits
+export const SYSTEM_LIMITS = {
+    // Prompt size limits (baseProvider.ts magic number fix)
+    MAX_PROMPT_LENGTH: 1000000, // 1M characters - prevents memory issues
+    // Memory monitoring thresholds (performance.ts)
+    HIGH_MEMORY_THRESHOLD: 100, // MB - when to warn about memory usage
+    // Timeout warnings (baseProvider.ts)
+    LONG_TIMEOUT_WARNING: 300000, // 5 minutes - when to warn about long timeouts
+    // Concurrency control (neurolink.ts provider testing)
+    DEFAULT_CONCURRENCY_LIMIT: 3, // Max parallel provider tests
+    MAX_CONCURRENCY_LIMIT: 5, // Upper bound for concurrency
+    // Retry system defaults (retryHandler.ts)
+    DEFAULT_RETRY_ATTEMPTS: 3,
+    DEFAULT_INITIAL_DELAY: 1000, // 1 second
+    DEFAULT_MAX_DELAY: 30000, // 30 seconds
+    DEFAULT_BACKOFF_MULTIPLIER: 2,
+};
 // Environment Variable Support (for future use)
 export const ENV_DEFAULTS = {
     maxTokens: process.env.NEUROLINK_DEFAULT_MAX_TOKENS

package/dist/lib/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/lib/core/factory.js

@@ -1,6 +1,7 @@
 // ✅ CIRCULAR DEPENDENCY FIX: Remove barrel export import
 // Providers are now managed via ProviderFactory instead of direct imports
 import { ProviderFactory } from "../factories/providerFactory.js";
+import { ProviderRegistry } from "../factories/providerRegistry.js";
 import { getBestProvider } from "../utils/providerUtils.js";
 import { logger } from "../utils/logger.js";
 const componentIdentifier = "aiProviderFactory";
@@ -36,24 +37,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;
@@ -87,6 +89,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/lib/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/lib/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();