@juspay/neurolink 7.29.2 → 7.30.0

package/dist/core/conversationMemoryManager.js

@@ -3,14 +3,14 @@
  * Handles in-memory conversation storage, session management, and context injection
  */
 import { ConversationMemoryError } from "../types/conversationTypes.js";
-import { DEFAULT_MAX_TURNS_PER_SESSION, DEFAULT_MAX_SESSIONS, MESSAGES_PER_TURN, } from "../config/conversationMemoryConfig.js";
+import { DEFAULT_MAX_TURNS_PER_SESSION, DEFAULT_MAX_SESSIONS, MESSAGES_PER_TURN } from "../config/conversationMemoryConfig.js";
 import { logger } from "../utils/logger.js";
+import { NeuroLink } from "../neurolink.js";
 export class ConversationMemoryManager {
     sessions = new Map();
     config;
     isInitialized = false;
     constructor(config) {
-        // Trust that config is already complete from applyConversationMemoryDefaults()
         this.config = config;
     }
     /**
@@ -48,21 +48,19 @@ export class ConversationMemoryManager {
             // ULTRA-OPTIMIZED: Direct message storage - no intermediate objects
             session.messages.push({ role: "user", content: userMessage }, { role: "assistant", content: aiResponse });
             session.lastActivity = Date.now();
-            // Enforce per-session turn limit (each turn = MESSAGES_PER_TURN messages: user + assistant)
-            const maxMessages = (this.config.maxTurnsPerSession || DEFAULT_MAX_TURNS_PER_SESSION) *
-                MESSAGES_PER_TURN;
-            if (session.messages.length > maxMessages) {
-                session.messages = session.messages.slice(-maxMessages);
+            if (this.config.enableSummarization) {
+                const currentTurnCount = session.messages.length / MESSAGES_PER_TURN;
+                if (currentTurnCount > (this.config.summarizationThresholdTurns || 20)) {
+                    await this._summarizeSession(session);
+                }
+            }
+            else {
+                const maxMessages = (this.config.maxTurnsPerSession || DEFAULT_MAX_TURNS_PER_SESSION) * MESSAGES_PER_TURN;
+                if (session.messages.length > maxMessages) {
+                    session.messages = session.messages.slice(-maxMessages);
+                }
             }
-            // Enforce global session limit
             this.enforceSessionLimit();
-            logger.debug("Conversation turn stored", {
-                sessionId,
-                messageCount: session.messages.length,
-                turnCount: session.messages.length / MESSAGES_PER_TURN, // Each turn = MESSAGES_PER_TURN messages
-                userMessageLength: userMessage.length,
-                aiResponseLength: aiResponse.length,
-            });
         }
         catch (error) {
             throw new ConversationMemoryError(`Failed to store conversation turn for session ${sessionId}`, "STORAGE_ERROR", {
@@ -77,48 +75,74 @@ export class ConversationMemoryManager {
      */
     buildContextMessages(sessionId) {
         const session = this.sessions.get(sessionId);
-        if (!session || session.messages.length === 0) {
-            return [];
-        }
-        // ULTRA-OPTIMIZED: Direct return - no processing needed!
-        return session.messages;
+        return session ? session.messages : [];
     }
-    /**
-     * Get memory statistics (simplified for pure in-memory storage)
-     * ULTRA-OPTIMIZED: Calculate turns from message count (each turn = MESSAGES_PER_TURN messages)
-     */
-    async getStats() {
-        await this.ensureInitialized();
-        const sessions = Array.from(this.sessions.values());
-        const totalTurns = sessions.reduce((sum, session) => sum + session.messages.length / MESSAGES_PER_TURN, 0);
+    getSession(sessionId) {
+        return this.sessions.get(sessionId);
+    }
+    createSummarySystemMessage(content) {
         return {
-            totalSessions: sessions.length,
-            totalTurns,
+            role: "system",
+            content: `Summary of previous conversation turns:\n\n${content}`,
         };
     }
-    /**
-     * Clear all conversations for a specific session
-     */
-    async clearSession(sessionId) {
-        const session = this.sessions.get(sessionId);
-        if (!session) {
-            return false;
+    async _summarizeSession(session) {
+        logger.info(`[ConversationMemory] Summarizing session ${session.sessionId}...`);
+        const targetTurns = this.config.summarizationTargetTurns || 10;
+        const splitIndex = Math.max(0, session.messages.length - targetTurns * MESSAGES_PER_TURN);
+        const messagesToSummarize = session.messages.slice(0, splitIndex);
+        const recentMessages = session.messages.slice(splitIndex);
+        if (messagesToSummarize.length === 0) {
+            return;
+        }
+        const summarizationPrompt = this._createSummarizationPrompt(messagesToSummarize);
+        const summarizer = new NeuroLink({ conversationMemory: { enabled: false } });
+        try {
+            const providerName = this.config.summarizationProvider;
+            // Map provider names to correct format
+            let mappedProvider = providerName;
+            if (providerName === 'vertex') {
+                mappedProvider = 'googlevertex';
+            }
+            if (!mappedProvider) {
+                logger.error(`[ConversationMemory] Missing summarization provider`);
+                return;
+            }
+            logger.debug(`[ConversationMemory] Using provider: ${mappedProvider} for summarization`);
+            const summaryResult = await summarizer.generate({
+                input: { text: summarizationPrompt },
+                provider: mappedProvider,
+                model: this.config.summarizationModel,
+                disableTools: true,
+            });
+            if (summaryResult.content) {
+                session.messages = [
+                    this.createSummarySystemMessage(summaryResult.content),
+                    ...recentMessages
+                ];
+                logger.info(`[ConversationMemory] Summarization complete for session ${session.sessionId}.`);
+            }
+            else {
+                logger.warn(`[ConversationMemory] Summarization failed for session ${session.sessionId}. History not modified.`);
+            }
+        }
+        catch (error) {
+            logger.error(`[ConversationMemory] Error during summarization for session ${session.sessionId}`, { error });
         }
-        // Remove from memory
-        this.sessions.delete(sessionId);
-        logger.info("Session cleared", { sessionId });
-        return true;
     }
-    /**
-     * Clear all conversations (reset memory)
-     */
-    async clearAllSessions() {
-        const sessionIds = Array.from(this.sessions.keys());
-        // Clear memory
-        this.sessions.clear();
-        logger.info("All sessions cleared", { clearedCount: sessionIds.length });
+    _createSummarizationPrompt(history) {
+        const formattedHistory = history.map(msg => `${msg.role}: ${msg.content}`).join('\n\n');
+        return `
+You are a context summarization AI. Your task is to condense the following conversation history for another AI assistant.
+The summary must be a concise, third-person narrative that retains all critical information, including key entities, technical details, decisions made, and any specific dates or times mentioned.
+Ensure the summary flows logically and is ready to be used as context for the next turn in the conversation.
+
+Conversation History to Summarize:
+---
+${formattedHistory}
+---
+`.trim();
     }
-    // Private methods
     async ensureInitialized() {
         if (!this.isInitialized) {
             await this.initialize();
@@ -138,16 +162,33 @@ export class ConversationMemoryManager {
         if (this.sessions.size <= maxSessions) {
             return;
         }
-        // Sort sessions by last activity (oldest first)
         const sessions = Array.from(this.sessions.entries()).sort(([, a], [, b]) => a.lastActivity - b.lastActivity);
-        // Remove oldest sessions
-        const sessionsToRemove = sessions.slice(0, sessions.length - maxSessions);
+        const sessionsToRemove = sessions.slice(0, this.sessions.size - maxSessions);
         for (const [sessionId] of sessionsToRemove) {
             this.sessions.delete(sessionId);
         }
-        logger.debug("Session limit enforced", {
-            removedSessions: sessionsToRemove.length,
-            remainingSessions: this.sessions.size,
-        });
+    }
+    async getStats() {
+        await this.ensureInitialized();
+        const sessions = Array.from(this.sessions.values());
+        const totalTurns = sessions.reduce((sum, session) => sum + session.messages.length / MESSAGES_PER_TURN, 0);
+        return {
+            totalSessions: sessions.length,
+            totalTurns,
+        };
+    }
+    async clearSession(sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (!session) {
+            return false;
+        }
+        this.sessions.delete(sessionId);
+        logger.info("Session cleared", { sessionId });
+        return true;
+    }
+    async clearAllSessions() {
+        const sessionIds = Array.from(this.sessions.keys());
+        this.sessions.clear();
+        logger.info("All sessions cleared", { clearedCount: sessionIds.length });
     }
 }

package/dist/core/dynamicModels.d.ts

@@ -88,6 +88,8 @@ declare const ModelRegistrySchema: z.ZodObject<{
     aliases: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
     defaults: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
 }, "strip", z.ZodTypeAny, {
+    version: string;
+    lastUpdated: string;
     models: Record<string, Record<string, {
         capabilities: string[];
         id: string;
@@ -100,11 +102,11 @@ declare const ModelRegistrySchema: z.ZodObject<{
         contextWindow: number;
         releaseDate: string;
     }>>;
-    version: string;
-    lastUpdated: string;
     defaults?: Record<string, string> | undefined;
     aliases?: Record<string, string> | undefined;
 }, {
+    version: string;
+    lastUpdated: string;
     models: Record<string, Record<string, {
         capabilities: string[];
         id: string;
@@ -117,8 +119,6 @@ declare const ModelRegistrySchema: z.ZodObject<{
         contextWindow: number;
         releaseDate: string;
     }>>;
-    version: string;
-    lastUpdated: string;
     defaults?: Record<string, string> | undefined;
     aliases?: Record<string, string> | undefined;
 }>;

package/dist/core/dynamicModels.js

@@ -100,12 +100,6 @@ export class DynamicModelProvider {
             // Setup timeout and abort controller
             const controller = new AbortController();
             const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
-            // Load from URL
-            const response = await fetch(source, {
-                headers: {
-                    "User-Agent": "NeuroLink/1.0 (+https://github.com/juspay/neurolink)",
-                },
-            });
             try {
                 // Add health check for localhost before attempting full request
                 if (source.includes("localhost") || source.includes("127.0.0.1")) {
@@ -113,7 +107,7 @@ export class DynamicModelProvider {
                 }
                 const response = await fetch(source, {
                     headers: {
-                        "User-Agent": "NeuroLink/1.0 (+https://github.com/sachinsharma92/neurolink)",
+                        "User-Agent": "NeuroLink/1.0 (+https://github.com/juspay/neurolink)",
                         Accept: "application/json",
                         "Cache-Control": "no-cache",
                     },
@@ -242,6 +236,9 @@ export class DynamicModelProvider {
     searchByCapability(capability, options = {}) {
         this.ensureInitialized();
         const results = [];
+        if (!this.modelRegistry) {
+            return results;
+        }
         for (const [providerName, models] of Object.entries(this.modelRegistry.models)) {
             if (options.provider && providerName !== options.provider) {
                 continue;
@@ -301,6 +298,9 @@ export class DynamicModelProvider {
     getAllModels() {
         this.ensureInitialized();
         const results = [];
+        if (!this.modelRegistry) {
+            return results;
+        }
         for (const [providerName, models] of Object.entries(this.modelRegistry.models)) {
             for (const [modelName, modelConfig] of Object.entries(models)) {
                 results.push({

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 {};