@juspay/neurolink 3.0.1 → 4.0.0

package/dist/neurolink.d.ts

@@ -15,6 +15,15 @@ export interface TextGenerationOptions {
     schema?: any;
     timeout?: number | string;
     disableTools?: boolean;
+    enableAnalytics?: boolean;
+    enableEvaluation?: boolean;
+    context?: Record<string, any>;
+    evaluationDomain?: string;
+    toolUsageContext?: string;
+    conversationHistory?: Array<{
+        role: string;
+        content: string;
+    }>;
 }
 export interface StreamTextOptions {
     prompt: string;
@@ -23,7 +32,12 @@ export interface StreamTextOptions {
     temperature?: number;
     maxTokens?: number;
     systemPrompt?: string;
+    schema?: any;
     timeout?: number | string;
+    disableTools?: boolean;
+    enableAnalytics?: boolean;
+    enableEvaluation?: boolean;
+    context?: Record<string, any>;
 }
 export interface TextGenerationResult {
     content: string;
@@ -115,4 +129,16 @@ export declare class NeuroLink {
             hasServer: boolean;
         }[];
     }>;
+    /**
+     * Alias for generateText() - CLI-SDK consistency
+     * @param options - Text generation options
+     * @returns Promise resolving to text generation result
+     */
+    generate(options: TextGenerationOptions): Promise<TextGenerationResult>;
+    /**
+     * Short alias for generateText() - CLI-SDK consistency
+     * @param options - Text generation options
+     * @returns Promise resolving to text generation result
+     */
+    gen(options: TextGenerationOptions): Promise<TextGenerationResult>;
 }

package/dist/neurolink.js

@@ -135,6 +135,14 @@ export class NeuroLink {
                 maxTokens: options.maxTokens,
                 systemPrompt: enhancedSystemPrompt,
                 timeout: options.timeout,
+                // NEW: Pass enhancement options
+                enableAnalytics: options.enableAnalytics,
+                enableEvaluation: options.enableEvaluation,
+                context: options.context,
+                // NEW: Lighthouse-compatible domain-aware evaluation
+                evaluationDomain: options.evaluationDomain,
+                toolUsageContext: options.toolUsageContext,
+                conversationHistory: options.conversationHistory,
             }, options.schema);
             if (!result) {
                 throw new Error("No response received from AI provider");
@@ -166,6 +174,9 @@ export class NeuroLink {
                 toolsUsed: metadata.toolsUsed || [],
                 enhancedWithTools: metadata.enhancedWithTools || false,
                 availableTools: availableTools.length > 0 ? availableTools : undefined,
+                // NEW: Preserve enhancement data from provider
+                ...(result.analytics && { analytics: result.analytics }),
+                ...(result.evaluation && { evaluation: result.evaluation }),
             };
         }
         catch (error) {
@@ -225,6 +236,14 @@ export class NeuroLink {
                     maxTokens: options.maxTokens,
                     systemPrompt: options.systemPrompt,
                     timeout: options.timeout,
+                    // NEW: Pass enhancement options
+                    enableAnalytics: options.enableAnalytics,
+                    enableEvaluation: options.enableEvaluation,
+                    context: options.context,
+                    // NEW: Lighthouse-compatible domain-aware evaluation
+                    evaluationDomain: options.evaluationDomain,
+                    toolUsageContext: options.toolUsageContext,
+                    conversationHistory: options.conversationHistory,
                 }, options.schema);
                 if (!result) {
                     throw new Error("No response received from AI provider");
@@ -250,6 +269,9 @@ export class NeuroLink {
                     provider: providerName,
                     usage: result.usage,
                     responseTime,
+                    // NEW: Preserve enhancement data from provider
+                    ...(result.analytics && { analytics: result.analytics }),
+                    ...(result.evaluation && { evaluation: result.evaluation }),
                 };
             }
             catch (error) {
@@ -409,7 +431,11 @@ Note: Tool integration is currently in development. Please provide helpful respo
     async testProvider(providerName, testPrompt = "test") {
         try {
             const provider = await AIProviderFactory.createProvider(providerName);
-            await provider.generateText(testPrompt);
+            await provider.generateText({
+                prompt: testPrompt,
+                enableAnalytics: false,
+                enableEvaluation: false,
+            });
             return true;
         }
         catch (error) {
@@ -446,4 +472,20 @@ Note: Tool integration is currently in development. Please provide helpful respo
             })),
         };
     }
+    /**
+     * Alias for generateText() - CLI-SDK consistency
+     * @param options - Text generation options
+     * @returns Promise resolving to text generation result
+     */
+    async generate(options) {
+        return this.generateText(options);
+    }
+    /**
+     * Short alias for generateText() - CLI-SDK consistency
+     * @param options - Text generation options
+     * @returns Promise resolving to text generation result
+     */
+    async gen(options) {
+        return this.generateText(options);
+    }
 }

package/dist/providers/agent-enhanced-provider.d.ts

@@ -3,7 +3,7 @@
  * Integrates direct tools with AI providers for true agent functionality
  */
 import { type GenerateTextResult, type StreamTextResult, type ToolSet } from "ai";
-import type { AIProvider, TextGenerationOptions, StreamTextOptions } from "../core/types.js";
+import type { AIProvider, TextGenerationOptions, EnhancedGenerateTextResult, EnhancedStreamTextOptions } from "../core/types.js";
 /**
  * Agent configuration options
  */
@@ -30,6 +30,7 @@ interface AgentConfig {
 export declare class AgentEnhancedProvider implements AIProvider {
     private config;
     private model;
+    private resolvedModelName;
     private mcpSystem;
     private mcpInitialized;
     private mcpInitializing;
@@ -45,7 +46,7 @@ export declare class AgentEnhancedProvider implements AIProvider {
      */
     private getCombinedTools;
     generateText(optionsOrPrompt: TextGenerationOptions | string): Promise<GenerateTextResult<ToolSet, unknown> | null>;
-    streamText(optionsOrPrompt: StreamTextOptions | string): Promise<StreamTextResult<ToolSet, unknown> | null>;
+    streamText(optionsOrPrompt: EnhancedStreamTextOptions | string): Promise<StreamTextResult<ToolSet, unknown> | null>;
     /**
      * Determine if we should force tool usage based on prompt patterns
      */
@@ -68,6 +69,14 @@ export declare class AgentEnhancedProvider implements AIProvider {
      * Create multiple agent providers for comparison
      */
     static createMultiProviderAgents(): Record<string, AgentEnhancedProvider>;
+    /**
+     * Alias for generateText() - CLI-SDK consistency
+     */
+    generate(optionsOrPrompt: TextGenerationOptions | string, analysisSchema?: any): Promise<EnhancedGenerateTextResult | null>;
+    /**
+     * Short alias for generateText() - CLI-SDK consistency
+     */
+    gen(optionsOrPrompt: TextGenerationOptions | string, analysisSchema?: any): Promise<EnhancedGenerateTextResult | null>;
 }
 /**
  * Helper function to create agent provider

package/dist/providers/agent-enhanced-provider.js

@@ -7,9 +7,13 @@ import { google } from "@ai-sdk/google";
 import { openai } from "@ai-sdk/openai";
 import { anthropic } from "@ai-sdk/anthropic";
 import { directAgentTools, getToolsForCategory, } from "../agent/direct-tools.js";
+import { StreamingEnhancer, StreamingMonitor, } from "../utils/streaming-utils.js";
 import { UnifiedMCPSystem } from "../mcp/unified-mcp.js";
 import { mcpLogger } from "../mcp/logging.js";
 import { parseTimeout } from "../utils/timeout.js";
+import { evaluateResponse } from "../core/evaluation.js";
+import { createAnalytics } from "../core/analytics.js";
+import { logger } from "../utils/logger.js";
 /**
  * Agent-Enhanced Provider Class
  * Provides AI generation with tool calling capabilities
@@ -18,6 +22,7 @@ import { parseTimeout } from "../utils/timeout.js";
 export class AgentEnhancedProvider {
     config;
     model;
+    resolvedModelName = "default";
     mcpSystem = null;
     mcpInitialized = false;
     mcpInitializing = false;
@@ -35,7 +40,7 @@ export class AgentEnhancedProvider {
             },
             ...config,
         };
-        // Initialize the AI model based on provider
+        // Initialize the AI model based on provider and store resolved model name
         this.model = this.createModel();
         // Initialize MCP registry if enabled
         if (this.config.enableMCP) {
@@ -46,11 +51,16 @@ export class AgentEnhancedProvider {
         const { provider, model } = this.config;
         switch (provider) {
             case "google-ai":
-                return google(model || process.env.GOOGLE_AI_MODEL || "gemini-2.0-flash-exp");
+                this.resolvedModelName =
+                    model || process.env.GOOGLE_AI_MODEL || "gemini-2.5-flash";
+                return google(this.resolvedModelName);
             case "openai":
-                return openai(model || process.env.OPENAI_MODEL || "gpt-4o");
+                this.resolvedModelName = model || process.env.OPENAI_MODEL || "gpt-4o";
+                return openai(this.resolvedModelName);
             case "anthropic":
-                return anthropic(model || process.env.ANTHROPIC_MODEL || "claude-3-5-sonnet-20241022");
+                this.resolvedModelName =
+                    model || process.env.ANTHROPIC_MODEL || "claude-3-5-sonnet-20241022";
+                return anthropic(this.resolvedModelName);
             default:
                 throw new Error(`Unsupported provider: ${provider}`);
         }
@@ -249,6 +259,7 @@ export class AgentEnhancedProvider {
         return { ...directTools, ...mcpTools };
     }
     async generateText(optionsOrPrompt) {
+        const startTime = Date.now();
         const options = typeof optionsOrPrompt === "string"
             ? { prompt: optionsOrPrompt }
             : optionsOrPrompt;
@@ -352,6 +363,14 @@ export class AgentEnhancedProvider {
                     };
                 }
             }
+            // Add analytics if enabled
+            if (options.enableAnalytics) {
+                result.analytics = createAnalytics(this.config.provider, this.resolvedModelName, result, Date.now() - startTime, options.context);
+            }
+            // Add evaluation if enabled
+            if (options.enableEvaluation) {
+                result.evaluation = await evaluateResponse(prompt, result.text, options.context);
+            }
             // Return the full result - the AI SDK has already handled tool execution and integration
             return result;
         }
@@ -364,7 +383,15 @@ export class AgentEnhancedProvider {
         const options = typeof optionsOrPrompt === "string"
             ? { prompt: optionsOrPrompt }
             : optionsOrPrompt;
-        const { prompt, temperature = 0.7, maxTokens = 1000, systemPrompt, timeout, } = options;
+        const { prompt, temperature = 0.7, maxTokens = 1000, systemPrompt, timeout, 
+        // Phase 2: Enhanced streaming options
+        enableProgressTracking, progressCallback, includeStreamingMetadata, streamingBufferSize, enableStreamingHeaders, customStreamingConfig, } = options;
+        // Phase 2.1: Setup streaming enhancements
+        const streamId = `agent_stream_${Date.now()}`;
+        const streamingConfig = StreamingEnhancer.createStreamingConfig(options);
+        if (enableProgressTracking) {
+            StreamingMonitor.registerStream(streamId);
+        }
         // Get combined tools (direct + MCP) if enabled
         const tools = this.config.enableTools ? await this.getCombinedTools() : {};
         try {
@@ -388,6 +415,38 @@ export class AgentEnhancedProvider {
                 toolChoice: this.shouldForceToolUsage(prompt) ? "required" : "auto",
                 abortSignal, // Pass abort signal for timeout support
             });
+            // Phase 2.1: Apply streaming enhancements if enabled
+            if (streamingConfig.progressTracking && result.textStream) {
+                const enhancedCallback = streamingConfig.callback
+                    ? (progress) => {
+                        StreamingMonitor.updateStream(streamId, progress);
+                        streamingConfig.callback(progress);
+                        if (progress.phase === "complete") {
+                            StreamingMonitor.completeStream(streamId);
+                        }
+                    }
+                    : undefined;
+                // Enhance the stream with progress tracking
+                const enhancedStream = StreamingEnhancer.addProgressTracking(result.textStream, enhancedCallback, { streamId, bufferSize: streamingConfig.bufferSize });
+                // Return enhanced result with tracking
+                return {
+                    ...result,
+                    textStream: enhancedStream,
+                    // Phase 2.1: Add streaming metadata
+                    streamingMetadata: streamingConfig.metadata
+                        ? {
+                            streamId,
+                            provider: this.getProviderName(),
+                            model: this.getModelName(),
+                            enabledFeatures: {
+                                progressTracking: true,
+                                metadata: streamingConfig.metadata,
+                                headers: streamingConfig.headers,
+                            },
+                        }
+                        : undefined,
+                };
+            }
             return result;
         }
         catch (error) {
@@ -440,7 +499,7 @@ export class AgentEnhancedProvider {
         let successCount = 0;
         for (const prompt of testPrompts) {
             try {
-                console.log(`Testing: "${prompt}"`);
+                logger.debug(`Testing: "${prompt}"`);
                 const result = await this.generateText(prompt);
                 if (!result) {
                     results.push({
@@ -448,7 +507,7 @@ export class AgentEnhancedProvider {
                         success: false,
                         error: "No result returned from generateText",
                     });
-                    console.log(`❌ No result returned`);
+                    logger.warn(`❌ No result returned`);
                     continue;
                 }
                 const toolsCalled = result.toolCalls?.length || 0;
@@ -462,7 +521,7 @@ export class AgentEnhancedProvider {
                     toolsCalled,
                     response: result.text.substring(0, 100) + "...",
                 });
-                console.log(`✅ Tools called: ${toolsCalled}, Response: ${result.text.substring(0, 50)}...`);
+                logger.debug(`✅ Tools called: ${toolsCalled}, Response: ${result.text.substring(0, 50)}...`);
             }
             catch (error) {
                 results.push({
@@ -470,7 +529,7 @@ export class AgentEnhancedProvider {
                     success: false,
                     error: error instanceof Error ? error.message : String(error),
                 });
-                console.log(`❌ Error: ${error}`);
+                logger.error(`❌ Error: ${error}`);
             }
         }
         return {
@@ -505,6 +564,18 @@ export class AgentEnhancedProvider {
         }
         return providers;
     }
+    /**
+     * Alias for generateText() - CLI-SDK consistency
+     */
+    async generate(optionsOrPrompt, analysisSchema) {
+        return this.generateText(optionsOrPrompt);
+    }
+    /**
+     * Short alias for generateText() - CLI-SDK consistency
+     */
+    async gen(optionsOrPrompt, analysisSchema) {
+        return this.generateText(optionsOrPrompt);
+    }
 }
 /**
  * Helper function to create agent provider
@@ -519,25 +590,25 @@ export function createAgentProvider(provider, options) {
  * Test all available agent providers
  */
 export async function testAllAgentProviders() {
-    console.log("🧪 Testing All Agent Providers\n");
+    logger.info("🧪 Testing All Agent Providers\n");
     const providers = AgentEnhancedProvider.createMultiProviderAgents();
     if (Object.keys(providers).length === 0) {
-        console.log("❌ No API keys found. Please configure at least one provider.");
+        logger.warn("❌ No API keys found. Please configure at least one provider.");
         return;
     }
     for (const [name, provider] of Object.entries(providers)) {
-        console.log(`\n🔬 Testing ${name.toUpperCase()} Agent Provider:`);
+        logger.info(`\n🔬 Testing ${name.toUpperCase()} Agent Provider:`);
         try {
             const testResult = await provider.testAgentCapabilities();
             if (testResult.success) {
-                console.log(`✅ ${name} agent provider working correctly`);
+                logger.info(`✅ ${name} agent provider working correctly`);
             }
             else {
-                console.log(`❌ ${name} agent provider failed tests`);
+                logger.warn(`❌ ${name} agent provider failed tests`);
             }
         }
         catch (error) {
-            console.log(`❌ ${name} provider error:`, error);
+            logger.error(`❌ ${name} provider error:`, error);
         }
     }
 }

package/dist/providers/amazonBedrock.d.ts

@@ -1,6 +1,6 @@
 import type { ZodType, ZodTypeDef } from "zod";
 import { type StreamTextResult, type ToolSet, type Schema, type GenerateTextResult } from "ai";
-import type { AIProvider, TextGenerationOptions, StreamTextOptions } from "../core/types.js";
+import type { AIProvider, TextGenerationOptions, StreamTextOptions, EnhancedGenerateTextResult } from "../core/types.js";
 export declare class AmazonBedrock implements AIProvider {
     private modelName;
     private model;
@@ -8,4 +8,12 @@ export declare class AmazonBedrock implements AIProvider {
     constructor(modelName?: string | null);
     streamText(optionsOrPrompt: StreamTextOptions | string, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<StreamTextResult<ToolSet, unknown> | null>;
     generateText(optionsOrPrompt: TextGenerationOptions | string, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<GenerateTextResult<ToolSet, unknown> | null>;
+    /**
+     * Alias for generateText() - CLI-SDK consistency
+     */
+    generate(optionsOrPrompt: TextGenerationOptions | string, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<EnhancedGenerateTextResult | null>;
+    /**
+     * Short alias for generateText() - CLI-SDK consistency
+     */
+    gen(optionsOrPrompt: TextGenerationOptions | string, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<EnhancedGenerateTextResult | null>;
 }

package/dist/providers/amazonBedrock.js

@@ -2,6 +2,9 @@ import { createAmazonBedrock } from "@ai-sdk/amazon-bedrock";
 import { streamText, generateText, Output, } from "ai";
 import { logger } from "../utils/logger.js";
 import { createTimeoutController, TimeoutError, getDefaultTimeout, } from "../utils/timeout.js";
+import { DEFAULT_MAX_TOKENS } from "../core/constants.js";
+import { evaluateResponse } from "../core/evaluation.js";
+import { createAnalytics } from "../core/analytics.js";
 // Default system context
 const DEFAULT_SYSTEM_CONTEXT = {
     systemPrompt: "You are a helpful AI assistant.",
@@ -129,7 +132,7 @@ export class AmazonBedrock {
             const options = typeof optionsOrPrompt === "string"
                 ? { prompt: optionsOrPrompt }
                 : optionsOrPrompt;
-            const { prompt, temperature = 0.7, maxTokens = 1000, systemPrompt = DEFAULT_SYSTEM_CONTEXT.systemPrompt, schema, timeout = getDefaultTimeout(provider, "stream"), } = options;
+            const { prompt, temperature = 0.7, maxTokens = DEFAULT_MAX_TOKENS, systemPrompt = DEFAULT_SYSTEM_CONTEXT.systemPrompt, schema, timeout = getDefaultTimeout(provider, "stream"), } = options;
             // Use schema from options or fallback parameter
             const finalSchema = schema || analysisSchema;
             logger.debug(`[${functionTag}] Stream request started`, {
@@ -231,12 +234,13 @@ export class AmazonBedrock {
     async generateText(optionsOrPrompt, analysisSchema) {
         const functionTag = "AmazonBedrock.generateText";
         const provider = "bedrock";
+        const startTime = Date.now();
         try {
             // Parse parameters - support both string and options object
             const options = typeof optionsOrPrompt === "string"
                 ? { prompt: optionsOrPrompt }
                 : optionsOrPrompt;
-            const { prompt, temperature = 0.7, maxTokens = 1000, systemPrompt = DEFAULT_SYSTEM_CONTEXT.systemPrompt, schema, timeout = getDefaultTimeout(provider, "generate"), } = options;
+            const { prompt, temperature = 0.7, maxTokens = DEFAULT_MAX_TOKENS, systemPrompt = DEFAULT_SYSTEM_CONTEXT.systemPrompt, schema, timeout = getDefaultTimeout(provider, "generate"), } = options;
             // Use schema from options or fallback parameter
             const finalSchema = schema || analysisSchema;
             logger.debug(`[${functionTag}] Generate text started`, {
@@ -278,6 +282,14 @@ export class AmazonBedrock {
                     responseLength: result.text?.length || 0,
                     timeout,
                 });
+                // Add analytics if enabled
+                if (options.enableAnalytics) {
+                    result.analytics = createAnalytics(provider, this.modelName, result, Date.now() - startTime, options.context);
+                }
+                // Add evaluation if enabled
+                if (options.enableEvaluation) {
+                    result.evaluation = await evaluateResponse(prompt, result.text, options.context);
+                }
                 return result;
             }
             finally {
@@ -307,4 +319,16 @@ export class AmazonBedrock {
             throw err; // Re-throw error to trigger fallback instead of returning null
         }
     }
+    /**
+     * Alias for generateText() - CLI-SDK consistency
+     */
+    async generate(optionsOrPrompt, analysisSchema) {
+        return this.generateText(optionsOrPrompt, analysisSchema);
+    }
+    /**
+     * Short alias for generateText() - CLI-SDK consistency
+     */
+    async gen(optionsOrPrompt, analysisSchema) {
+        return this.generateText(optionsOrPrompt, analysisSchema);
+    }
 }

package/dist/providers/analytics-helper.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Enhanced Analytics Helper for All Providers
+ * Ensures consistent analytics data format across providers
+ * Integrates with Universal Evaluation System
+ */
+export interface AnalyticsData {
+    provider: string;
+    model: string;
+    tokens: {
+        input: number;
+        output: number;
+        total: number;
+    };
+    cost?: number;
+    responseTime: number;
+    timestamp: string;
+    context?: Record<string, any>;
+    evaluation?: {
+        relevanceScore: number;
+        accuracyScore: number;
+        completenessScore: number;
+        overall: number;
+        evaluationProvider?: string;
+        evaluationTime?: number;
+        evaluationAttempt?: number;
+    };
+    costDetails?: {
+        inputCost: number;
+        outputCost: number;
+        evaluationCost?: number;
+        totalCost: number;
+        currency: string;
+    };
+}
+/**
+ * Create standardized analytics data from provider response
+ */
+export declare function createAnalytics(provider: string, model: string, result: any, responseTime: number, context?: Record<string, any>): AnalyticsData;
+/**
+ * Create enhanced analytics data with accurate cost calculations (async version)
+ */
+export declare function createEnhancedAnalytics(provider: string, model: string, result: any, responseTime: number, context?: Record<string, any>): Promise<AnalyticsData>;
+/**
+ * Calculate enhanced cost details using provider configurations
+ */
+export declare function calculateEnhancedCost(provider: string, inputTokens: number, outputTokens: number): Promise<{
+    costDetails: any;
+    estimatedCost: number;
+}>;
+/**
+ * Enhance analytics with evaluation data
+ */
+export declare function enhanceAnalyticsWithEvaluation(analytics: AnalyticsData, evaluationResult: any): AnalyticsData;

package/dist/providers/analytics-helper.js

@@ -0,0 +1,151 @@
+/**
+ * Enhanced Analytics Helper for All Providers
+ * Ensures consistent analytics data format across providers
+ * Integrates with Universal Evaluation System
+ */
+/**
+ * Create standardized analytics data from provider response
+ */
+export function createAnalytics(provider, model, result, responseTime, context) {
+    // Handle different token usage formats across providers
+    const tokenUsage = result.usage || {};
+    // Standardize token field names across providers
+    const inputTokens = tokenUsage.promptTokens ||
+        tokenUsage.input_tokens ||
+        tokenUsage.inputTokens ||
+        0;
+    const outputTokens = tokenUsage.completionTokens ||
+        tokenUsage.output_tokens ||
+        tokenUsage.outputTokens ||
+        0;
+    const totalTokens = tokenUsage.totalTokens ||
+        tokenUsage.total_tokens ||
+        inputTokens + outputTokens ||
+        0;
+    // Simple cost estimation for synchronous use
+    const estimatedCost = totalTokens > 0 ? totalTokens * 0.00001 : 0;
+    return {
+        provider,
+        model,
+        tokens: {
+            input: inputTokens,
+            output: outputTokens,
+            total: totalTokens,
+        },
+        cost: estimatedCost,
+        responseTime,
+        timestamp: new Date().toISOString(),
+        context,
+    };
+}
+/**
+ * Create enhanced analytics data with accurate cost calculations (async version)
+ */
+export async function createEnhancedAnalytics(provider, model, result, responseTime, context) {
+    // Handle different token usage formats across providers
+    const tokenUsage = result.usage || {};
+    // Standardize token field names across providers
+    const inputTokens = tokenUsage.promptTokens ||
+        tokenUsage.input_tokens ||
+        tokenUsage.inputTokens ||
+        0;
+    const outputTokens = tokenUsage.completionTokens ||
+        tokenUsage.output_tokens ||
+        tokenUsage.outputTokens ||
+        0;
+    const totalTokens = tokenUsage.totalTokens ||
+        tokenUsage.total_tokens ||
+        inputTokens + outputTokens ||
+        0;
+    // Enhanced cost calculation using provider configuration
+    const { costDetails, estimatedCost } = await calculateEnhancedCost(provider, inputTokens, outputTokens);
+    return {
+        provider,
+        model,
+        tokens: {
+            input: inputTokens,
+            output: outputTokens,
+            total: totalTokens,
+        },
+        cost: estimatedCost,
+        responseTime,
+        timestamp: new Date().toISOString(),
+        context,
+        costDetails,
+    };
+}
+/**
+ * Calculate enhanced cost details using provider configurations
+ */
+export async function calculateEnhancedCost(provider, inputTokens, outputTokens) {
+    try {
+        // Import provider configuration dynamically
+        const { getProviderConfig } = await import("../core/evaluation-providers.js");
+        const providerConfig = getProviderConfig(provider);
+        if (!providerConfig?.costPerToken) {
+            // Fallback to rough estimation
+            const estimatedCost = (inputTokens + outputTokens) * 0.00001;
+            return {
+                costDetails: {
+                    inputCost: inputTokens * 0.00001,
+                    outputCost: outputTokens * 0.00001,
+                    totalCost: estimatedCost,
+                    currency: "USD",
+                },
+                estimatedCost,
+            };
+        }
+        // Use accurate provider costs
+        const inputCost = inputTokens * providerConfig.costPerToken.input;
+        const outputCost = outputTokens * providerConfig.costPerToken.output;
+        const totalCost = inputCost + outputCost;
+        return {
+            costDetails: {
+                inputCost,
+                outputCost,
+                totalCost,
+                currency: "USD",
+            },
+            estimatedCost: totalCost,
+        };
+    }
+    catch (error) {
+        // Fallback on error
+        const estimatedCost = (inputTokens + outputTokens) * 0.00001;
+        return {
+            costDetails: {
+                inputCost: inputTokens * 0.00001,
+                outputCost: outputTokens * 0.00001,
+                totalCost: estimatedCost,
+                currency: "USD",
+            },
+            estimatedCost,
+        };
+    }
+}
+/**
+ * Enhance analytics with evaluation data
+ */
+export function enhanceAnalyticsWithEvaluation(analytics, evaluationResult) {
+    return {
+        ...analytics,
+        evaluation: {
+            relevanceScore: evaluationResult.relevanceScore || 0,
+            accuracyScore: evaluationResult.accuracyScore || 0,
+            completenessScore: evaluationResult.completenessScore || 0,
+            overall: evaluationResult.overall || 0,
+            evaluationProvider: evaluationResult.evaluationProvider,
+            evaluationTime: evaluationResult.evaluationTime,
+            evaluationAttempt: evaluationResult.evaluationAttempt,
+        },
+        // Add evaluation cost if available
+        costDetails: analytics.costDetails
+            ? {
+                ...analytics.costDetails,
+                evaluationCost: evaluationResult.evaluationConfig?.costEstimate || 0,
+                totalCost: (analytics.costDetails.totalCost || 0) +
+                    (evaluationResult.evaluationConfig?.costEstimate || 0),
+            }
+            : undefined,
+    };
+}