agentic-qe 2.6.1 → 2.6.2

package/dist/providers/HybridRouter.js

@@ -24,6 +24,8 @@ const ClaudeProvider_1 = require("./ClaudeProvider");
 const RuvllmProvider_1 = require("./RuvllmProvider");
 const RuVectorClient_1 = require("./RuVectorClient");
 const Logger_1 = require("../utils/Logger");
+const ComplexityClassifier_1 = require("../routing/ComplexityClassifier");
+const CostOptimizationStrategies_1 = require("./CostOptimizationStrategies");
 /**
  * Request priority levels
  */
@@ -100,7 +102,12 @@ class HybridRouter {
             },
             claude: config.claude,
             ruvllm: config.ruvllm,
-            ruvector: config.ruvector
+            ruvector: config.ruvector,
+            // Phase 2 integration config
+            complexityClassifier: config.complexityClassifier,
+            costOptimization: config.costOptimization,
+            useMLClassifier: config.useMLClassifier ?? true,
+            useCostOptimization: config.useCostOptimization ?? true
         };
         this.circuitBreakers = new Map();
         this.routingHistory = [];
@@ -111,6 +118,9 @@ class HybridRouter {
         this.cloudRequestCount = 0;
         this.cacheHitCount = 0;
         this.cacheMissCount = 0;
+        this.costHistory = [];
+        this.trackingStartDate = new Date();
+        this.compressionStats = { totalSaved: 0, totalOriginal: 0, count: 0 };
     }
     /**
      * Initialize the hybrid router and its providers
@@ -184,11 +194,49 @@ class HybridRouter {
         if (!this.localProvider && !this.cloudProvider) {
             throw new ILLMProvider_1.LLMProviderError('Failed to initialize any providers', 'hybrid-router', 'INIT_ERROR', false);
         }
+        // Initialize ML-based complexity classifier (Phase 2.1.2)
+        if (this.config.useMLClassifier) {
+            try {
+                this.complexityClassifier = new ComplexityClassifier_1.ComplexityClassifier(this.config.complexityClassifier ?? {
+                    enableLearning: true,
+                    learningRate: 0.05
+                });
+                this.logger.info('ML ComplexityClassifier initialized', {
+                    enableLearning: this.config.complexityClassifier?.enableLearning ?? true
+                });
+            }
+            catch (error) {
+                this.logger.warn('Failed to initialize ComplexityClassifier, using heuristics', {
+                    error: error.message
+                });
+            }
+        }
+        // Initialize cost optimization manager (Phase 2.3.2)
+        if (this.config.useCostOptimization) {
+            try {
+                this.costOptimizationManager = new CostOptimizationStrategies_1.CostOptimizationManager(this.config.costOptimization ?? {
+                    enableCompression: true,
+                    enableBatching: true,
+                    enableSmartCaching: true
+                });
+                this.logger.info('CostOptimizationManager initialized', {
+                    compression: this.config.costOptimization?.enableCompression ?? true,
+                    batching: this.config.costOptimization?.enableBatching ?? true
+                });
+            }
+            catch (error) {
+                this.logger.warn('Failed to initialize CostOptimizationManager', {
+                    error: error.message
+                });
+            }
+        }
         this.isInitialized = true;
         this.logger.info('HybridRouter initialized', {
             hasLocal: !!this.localProvider,
             hasCloud: !!this.cloudProvider,
             hasRuVectorCache: !!this.ruVectorClient,
+            hasMLClassifier: !!this.complexityClassifier,
+            hasCostOptimization: !!this.costOptimizationManager,
             strategy: this.config.defaultStrategy
         });
     }
@@ -208,7 +256,47 @@ class HybridRouter {
         const startTime = Date.now();
         const priority = options.priority ?? RequestPriority.NORMAL;
         const strategy = options.routingStrategy ?? this.config.defaultStrategy;
-        const complexity = this.analyzeComplexity(options);
+        // Apply cost optimization: prompt compression (Phase 2.3.2)
+        let optimizedOptions = options;
+        let compressionResult;
+        if (this.costOptimizationManager && this.config.useCostOptimization) {
+            try {
+                const originalContent = this.extractQueryFromOptions(options) || '';
+                const compressor = this.costOptimizationManager.getCompressor();
+                compressionResult = compressor.compress(originalContent);
+                if (compressionResult.tokensSaved > 0) {
+                    // Track compression stats for benchmarking
+                    // Estimate original tokens from ratio: ratio = tokensSaved / originalTokens
+                    // So originalTokens ≈ tokensSaved / ratio (if ratio > 0)
+                    const estimatedOriginalTokens = compressionResult.ratio > 0
+                        ? Math.round(compressionResult.tokensSaved / compressionResult.ratio)
+                        : compressionResult.original.split(/\s+/).length;
+                    this.compressionStats.totalOriginal += estimatedOriginalTokens;
+                    this.compressionStats.totalSaved += compressionResult.tokensSaved;
+                    this.compressionStats.count++;
+                    // Apply compressed content to options
+                    optimizedOptions = this.applyCompressedContent(options, compressionResult.compressed);
+                    if (this.config.debug) {
+                        this.logger.debug('Prompt compressed', {
+                            tokensSaved: compressionResult.tokensSaved,
+                            ratio: compressionResult.ratio,
+                            techniques: compressionResult.techniques
+                        });
+                    }
+                }
+            }
+            catch (error) {
+                this.logger.warn('Prompt compression failed, using original', {
+                    error: error.message
+                });
+            }
+        }
+        const complexity = this.analyzeComplexity(optimizedOptions);
+        // Check budget before proceeding
+        const estimatedCost = strategy === RoutingStrategy.COST_OPTIMIZED ? 0 : 0.01;
+        if (!this.checkBudget(estimatedCost)) {
+            throw new ILLMProvider_1.LLMProviderError('Request rejected: budget limit exceeded', 'hybrid-router', 'BUDGET_EXCEEDED', false);
+        }
         // Phase 0.5: Try RuVector cache first (sub-ms pattern matching)
         if (this.ruVectorClient && this.shouldUseCache(options, complexity)) {
             try {
@@ -427,6 +515,8 @@ class HybridRouter {
             // Track cost
             const actualCost = this.calculateCost(response, decision.provider);
             this.totalCost += actualCost;
+            // Track detailed cost information
+            this.trackCostByProvider(decision.providerName, actualCost, response.model, decision.complexity, response.usage.input_tokens + response.usage.output_tokens);
             // Record outcome for learning
             if (this.config.enableLearning) {
                 this.recordOutcome({
@@ -658,15 +748,55 @@ class HybridRouter {
      * Get cost savings report including RuVector cache savings
      */
     getCostSavingsReport() {
-        // Estimate what cloud cost would have been for all requests
+        return this.getDetailedCostReport();
+    }
+    /**
+     * Get detailed cost report with optional date filtering
+     */
+    getDetailedCostReport(startDate, endDate) {
+        const start = startDate || this.trackingStartDate;
+        const end = endDate || new Date();
+        // Filter cost history by date range
+        const filteredHistory = this.costHistory.filter(entry => entry.timestamp >= start && entry.timestamp <= end);
+        // Calculate cost by provider
+        const costByProvider = {};
+        const costByTaskType = {};
+        const costByModel = {};
+        const taskTypeCounts = {};
+        for (const entry of filteredHistory) {
+            // By provider
+            costByProvider[entry.provider] = (costByProvider[entry.provider] || 0) + entry.cost;
+            // By task type
+            costByTaskType[entry.taskType] = (costByTaskType[entry.taskType] || 0) + entry.cost;
+            // By model
+            costByModel[entry.model] = (costByModel[entry.model] || 0) + entry.cost;
+            // Task type counts for top costly tasks
+            if (!taskTypeCounts[entry.taskType]) {
+                taskTypeCounts[entry.taskType] = { cost: 0, count: 0 };
+            }
+            taskTypeCounts[entry.taskType].cost += entry.cost;
+            taskTypeCounts[entry.taskType].count++;
+        }
+        // Calculate top costly tasks
+        const topCostlyTasks = Object.entries(taskTypeCounts)
+            .map(([taskType, data]) => ({
+            taskType,
+            cost: data.cost,
+            count: data.count
+        }))
+            .sort((a, b) => b.cost - a.cost)
+            .slice(0, 10);
+        // Calculate totals and estimates
         const cloudCostPerRequest = 0.01; // Rough estimate
         const estimatedCloudCost = this.requestCount * cloudCostPerRequest;
         const savings = estimatedCloudCost - this.totalCost;
         const savingsPercentage = estimatedCloudCost > 0
             ? (savings / estimatedCloudCost) * 100
             : 0;
-        // Cache hits are essentially free
         const cacheSavings = this.cacheHitCount * cloudCostPerRequest;
+        const averageCostPerRequest = this.requestCount > 0 ? this.totalCost / this.requestCount : 0;
+        // Project monthly cost based on current usage rate
+        const monthlyCostProjection = this.projectMonthlyCost();
         return {
             totalRequests: this.requestCount,
             localRequests: this.localRequestCount,
@@ -676,8 +806,190 @@ class HybridRouter {
             savings,
             savingsPercentage,
             cacheHits: this.cacheHitCount,
-            cacheSavings
+            cacheSavings,
+            costByProvider,
+            costByTaskType,
+            costByModel,
+            averageCostPerRequest,
+            topCostlyTasks,
+            monthlyCostProjection,
+            periodStart: start,
+            periodEnd: end
+        };
+    }
+    /**
+     * Get top costly operations
+     */
+    getTopCostlyOperations(limit = 10) {
+        const taskTypeCosts = {};
+        for (const entry of this.costHistory) {
+            taskTypeCosts[entry.taskType] = (taskTypeCosts[entry.taskType] || 0) + entry.cost;
+        }
+        return Object.entries(taskTypeCosts)
+            .map(([taskType, cost]) => ({ taskType, cost }))
+            .sort((a, b) => b.cost - a.cost)
+            .slice(0, limit);
+    }
+    /**
+     * Project monthly cost based on current usage rate
+     */
+    projectMonthlyCost() {
+        if (this.costHistory.length === 0) {
+            return 0;
+        }
+        const now = new Date();
+        const timeElapsed = now.getTime() - this.trackingStartDate.getTime();
+        const daysElapsed = timeElapsed / (1000 * 60 * 60 * 24);
+        if (daysElapsed < 0.1) {
+            // Less than 2.4 hours, not enough data
+            return this.totalCost * 30; // Rough estimate
+        }
+        // Calculate daily average and project to 30 days
+        const dailyAverage = this.totalCost / daysElapsed;
+        return dailyAverage * 30;
+    }
+    /**
+     * Set budget configuration
+     */
+    setBudget(config) {
+        this.budgetConfig = config;
+        this.logger.info('Budget configuration updated', {
+            monthlyBudget: config.monthlyBudget,
+            dailyBudget: config.dailyBudget,
+            alertThreshold: config.alertThreshold,
+            enforceLimit: config.enforceLimit
+        });
+    }
+    /**
+     * Get current budget status
+     */
+    getBudgetStatus() {
+        if (!this.budgetConfig) {
+            return {
+                dailySpent: this.totalCost,
+                dailyRemaining: Infinity,
+                monthlySpent: this.totalCost,
+                monthlyRemaining: Infinity,
+                utilizationPercentage: 0,
+                isOverBudget: false,
+                alertTriggered: false
+            };
+        }
+        const now = new Date();
+        const today = new Date(now.getFullYear(), now.getMonth(), now.getDate());
+        const monthStart = new Date(now.getFullYear(), now.getMonth(), 1);
+        // Calculate daily spending
+        const dailyHistory = this.costHistory.filter(entry => entry.timestamp >= today);
+        const dailySpent = dailyHistory.reduce((sum, entry) => sum + entry.cost, 0);
+        // Calculate monthly spending
+        const monthlyHistory = this.costHistory.filter(entry => entry.timestamp >= monthStart);
+        const monthlySpent = monthlyHistory.reduce((sum, entry) => sum + entry.cost, 0);
+        const dailyBudget = this.budgetConfig.dailyBudget ?? Infinity;
+        const monthlyBudget = this.budgetConfig.monthlyBudget ?? Infinity;
+        const dailyRemaining = Math.max(0, dailyBudget - dailySpent);
+        const monthlyRemaining = Math.max(0, monthlyBudget - monthlySpent);
+        // Calculate utilization based on the most restrictive budget
+        let utilizationPercentage = 0;
+        if (monthlyBudget !== Infinity) {
+            utilizationPercentage = (monthlySpent / monthlyBudget) * 100;
+        }
+        else if (dailyBudget !== Infinity) {
+            utilizationPercentage = (dailySpent / dailyBudget) * 100;
+        }
+        const isOverBudget = dailySpent > dailyBudget || monthlySpent > monthlyBudget;
+        const alertTriggered = utilizationPercentage >= (this.budgetConfig.alertThreshold * 100);
+        if (alertTriggered && !isOverBudget) {
+            this.logger.warn('Budget alert threshold reached', {
+                utilizationPercentage,
+                threshold: this.budgetConfig.alertThreshold * 100,
+                dailySpent,
+                monthlySpent
+            });
+        }
+        if (isOverBudget) {
+            this.logger.error('Budget limit exceeded', {
+                dailySpent,
+                dailyBudget,
+                monthlySpent,
+                monthlyBudget
+            });
+        }
+        return {
+            dailySpent,
+            dailyRemaining,
+            monthlySpent,
+            monthlyRemaining,
+            utilizationPercentage,
+            isOverBudget,
+            alertTriggered
+        };
+    }
+    /**
+     * Check if budget allows this request
+     */
+    checkBudget(estimatedCost) {
+        if (!this.budgetConfig || !this.budgetConfig.enforceLimit) {
+            return true;
+        }
+        const status = this.getBudgetStatus();
+        if (status.isOverBudget) {
+            this.logger.error('Request rejected: budget exceeded', {
+                estimatedCost,
+                dailySpent: status.dailySpent,
+                monthlySpent: status.monthlySpent
+            });
+            return false;
+        }
+        // Check if this request would exceed budget
+        if (this.budgetConfig.dailyBudget !== undefined) {
+            if (status.dailySpent + estimatedCost > this.budgetConfig.dailyBudget) {
+                this.logger.error('Request rejected: would exceed daily budget', {
+                    estimatedCost,
+                    dailySpent: status.dailySpent,
+                    dailyBudget: this.budgetConfig.dailyBudget
+                });
+                return false;
+            }
+        }
+        if (this.budgetConfig.monthlyBudget !== undefined) {
+            if (status.monthlySpent + estimatedCost > this.budgetConfig.monthlyBudget) {
+                this.logger.error('Request rejected: would exceed monthly budget', {
+                    estimatedCost,
+                    monthlySpent: status.monthlySpent,
+                    monthlyBudget: this.budgetConfig.monthlyBudget
+                });
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Track cost by provider
+     */
+    trackCostByProvider(provider, cost, model, taskType, tokens) {
+        const entry = {
+            timestamp: new Date(),
+            provider,
+            model,
+            taskType,
+            cost,
+            tokens
         };
+        this.costHistory.push(entry);
+        // Keep only last 10,000 entries to prevent unbounded growth
+        if (this.costHistory.length > 10000) {
+            this.costHistory.shift();
+        }
+        if (this.config.debug) {
+            this.logger.debug('Cost tracked', {
+                provider,
+                model,
+                taskType,
+                cost,
+                tokens,
+                historySize: this.costHistory.length
+            });
+        }
     }
     /**
      * Get routing statistics including cache metrics
@@ -872,9 +1184,36 @@ class HybridRouter {
         return options;
     }
     /**
-     * Analyze task complexity
+     * Analyze task complexity using ML classifier or heuristics fallback
      */
     analyzeComplexity(options) {
+        // Use ML-based classifier if available (Phase 2.1.2)
+        if (this.complexityClassifier && this.config.useMLClassifier) {
+            try {
+                const mlComplexity = this.complexityClassifier.classifyTask(options);
+                const confidence = this.complexityClassifier.getClassificationConfidence();
+                if (this.config.debug) {
+                    this.logger.debug('ML complexity classification', {
+                        complexity: mlComplexity,
+                        confidence: confidence.toFixed(3)
+                    });
+                }
+                // Map ComplexityClassifier output to TaskComplexity enum
+                return mlComplexity;
+            }
+            catch (error) {
+                this.logger.warn('ML classifier failed, using heuristics', {
+                    error: error.message
+                });
+            }
+        }
+        // Fallback to heuristics
+        return this.analyzeComplexityHeuristics(options);
+    }
+    /**
+     * Heuristic-based complexity analysis (fallback)
+     */
+    analyzeComplexityHeuristics(options) {
         const maxTokens = options.maxTokens || 0;
         const messageCount = options.messages.length;
         const totalContent = options.messages
@@ -911,6 +1250,27 @@ class HybridRouter {
             return TaskComplexity.MODERATE;
         return TaskComplexity.SIMPLE;
     }
+    /**
+     * Apply compressed content to options
+     */
+    applyCompressedContent(options, compressed) {
+        if (!options.messages || options.messages.length === 0) {
+            return options;
+        }
+        // Clone options to avoid mutation
+        const newOptions = { ...options, messages: [...options.messages] };
+        // Find and replace last user message with compressed version
+        for (let i = newOptions.messages.length - 1; i >= 0; i--) {
+            if (newOptions.messages[i].role === 'user') {
+                newOptions.messages[i] = {
+                    ...newOptions.messages[i],
+                    content: compressed
+                };
+                break;
+            }
+        }
+        return newOptions;
+    }
     /**
      * Check for privacy-sensitive data
      */
@@ -1061,6 +1421,112 @@ class HybridRouter {
             throw new ILLMProvider_1.LLMProviderError('HybridRouter not initialized. Call initialize() first.', 'hybrid-router', 'NOT_INITIALIZED', false);
         }
     }
+    // ============================================================
+    // Phase 2 Integration: Public Methods for Benchmarking & Stats
+    // ============================================================
+    /**
+     * Get compression statistics for benchmarking (Phase 2.3.2)
+     *
+     * Returns actual measured compression savings, not estimated values.
+     */
+    getCompressionStats() {
+        const avgSavings = this.compressionStats.totalOriginal > 0
+            ? (this.compressionStats.totalSaved / this.compressionStats.totalOriginal) * 100
+            : 0;
+        return {
+            totalRequests: this.compressionStats.count,
+            totalOriginalTokens: this.compressionStats.totalOriginal,
+            totalSavedTokens: this.compressionStats.totalSaved,
+            averageSavingsPercent: avgSavings,
+            compressionEnabled: !!this.costOptimizationManager && !!this.config.useCostOptimization
+        };
+    }
+    /**
+     * Get ML classifier statistics (Phase 2.1.2)
+     *
+     * Returns classifier performance metrics if ML classifier is enabled.
+     */
+    getMLClassifierStats() {
+        if (!this.complexityClassifier) {
+            return null;
+        }
+        try {
+            const stats = this.complexityClassifier.getStatistics();
+            return {
+                enabled: true,
+                totalClassifications: stats.totalClassifications,
+                averageConfidence: stats.averageConfidence,
+                successRate: stats.successRate,
+                complexityDistribution: stats.complexityDistribution
+            };
+        }
+        catch {
+            return {
+                enabled: true,
+                totalClassifications: 0,
+                averageConfidence: 0,
+                successRate: 0,
+                complexityDistribution: {
+                    [TaskComplexity.SIMPLE]: 0,
+                    [TaskComplexity.MODERATE]: 0,
+                    [TaskComplexity.COMPLEX]: 0,
+                    [TaskComplexity.VERY_COMPLEX]: 0
+                }
+            };
+        }
+    }
+    /**
+     * Train classifier from routing outcome (Phase 2.1.2)
+     *
+     * Allows manual training feedback for the complexity classifier.
+     */
+    trainClassifierFromOutcome(entry) {
+        if (!this.complexityClassifier) {
+            this.logger.warn('Cannot train: ML classifier not enabled');
+            return;
+        }
+        this.complexityClassifier.recordOutcome(entry);
+        if (this.config.debug) {
+            this.logger.debug('Classifier trained from outcome', {
+                complexity: entry.selectedComplexity,
+                success: entry.actualOutcome.success
+            });
+        }
+    }
+    /**
+     * Get feature weights from the ML classifier (Phase 2.1.2)
+     */
+    getClassifierWeights() {
+        if (!this.complexityClassifier) {
+            return null;
+        }
+        const weights = this.complexityClassifier.getWeights();
+        // Convert typed object to generic Record
+        return { ...weights };
+    }
+    /**
+     * Get complexity thresholds from the ML classifier (Phase 2.1.2)
+     */
+    getComplexityThresholds() {
+        if (!this.complexityClassifier) {
+            return null;
+        }
+        const thresholds = this.complexityClassifier.getThresholds();
+        // Convert typed object to generic Record
+        return { ...thresholds };
+    }
+    /**
+     * Check if ML classifier is enabled and active
+     */
+    isMLClassifierEnabled() {
+        return !!this.complexityClassifier && !!this.config.useMLClassifier;
+    }
+    /**
+     * Check if cost optimization is enabled and active
+     */
+    isCostOptimizationEnabled() {
+        return !!this.costOptimizationManager && !!this.config.useCostOptimization;
+    }
 }
 exports.HybridRouter = HybridRouter;
 //# sourceMappingURL=HybridRouter.js.map