recoder-analytics/dist/monitoring/performance-cost-analyzer.d.ts

Comprehensive analytics and monitoring for the Recoder.xyz ecosystem

/**
 * Performance vs Cost Analysis System
 *
 * Advanced analytics for comparing model performance against cost,
 * optimizing value delivery, and providing intelligent recommendations
 * for cost-effective AI model selection in recoder.xyz.
 */
import { EventEmitter } from 'events';
export interface PerformanceCostMetrics {
    modelName: string;
    provider: string;
    period: {
        start: Date;
        end: Date;
        duration: string;
    };
    performance: {
        quality: number;
        latency: number;
        reliability: number;
        throughput: number;
        errorRate: number;
    };
    cost: {
        totalCost: number;
        costPerToken: number;
        costPerRequest: number;
        costPerSecond: number;
    };
    efficiency: {
        valueScore: number;
        costEfficiencyRating: string;
        performancePerDollar: number;
        qualityPerDollar: number;
        speedPerDollar: number;
    };
    roi: {
        returnOnInvestment: number;
        valueCreated: number;
        paybackPeriod: number;
        netPresentValue: number;
    };
    ranking: {
        overallRank: number;
        performanceRank: number;
        costRank: number;
        efficiencyRank: number;
    };
    trends: {
        valueImprovement: 'improving' | 'stable' | 'declining';
        costTrend: 'decreasing' | 'stable' | 'increasing';
        performanceTrend: 'improving' | 'stable' | 'declining';
        efficiencyTrend: 'improving' | 'stable' | 'declining';
    };
}
export interface ValueOptimizationRecommendation {
    id: string;
    type: 'model_switch' | 'workload_optimization' | 'cost_reduction' | 'performance_boost';
    priority: 'low' | 'medium' | 'high' | 'critical';
    confidence: number;
    title: string;
    description: string;
    currentModel: string;
    recommendedModel?: string;
    impact: {
        costSavings: number;
        performanceChange: number;
        qualityChange: number;
        latencyChange: number;
        reliabilityChange: number;
    };
    implementation: {
        effort: 'trivial' | 'low' | 'medium' | 'high' | 'complex';
        timeToImplement: number;
        riskLevel: 'low' | 'medium' | 'high';
        prerequisites: string[];
        steps: string[];
    };
    tradeoffs: {
        pros: string[];
        cons: string[];
        risks: string[];
    };
    metrics: {
        currentValueScore: number;
        projectedValueScore: number;
        valueImprovement: number;
    };
}
export interface ModelComparison {
    comparisonId: string;
    timestamp: Date;
    taskType: string;
    models: Array<{
        modelName: string;
        provider: string;
        metrics: PerformanceCostMetrics;
        suitabilityScore: number;
    }>;
    winner: {
        overall: string;
        performance: string;
        cost: string;
        efficiency: string;
    };
    insights: {
        keyFindings: string[];
        surprises: string[];
        caveats: string[];
    };
    recommendations: ValueOptimizationRecommendation[];
}
export interface CostOptimizationScenario {
    scenarioId: string;
    name: string;
    description: string;
    targetBudgetReduction: number;
    constraints: {
        minQualityThreshold: number;
        maxLatencyIncrease: number;
        minReliabilityThreshold: number;
        excludedModels: string[];
        requiredCapabilities: string[];
    };
    optimizations: Array<{
        description: string;
        models: string[];
        expectedSavings: number;
        qualityImpact: number;
        performanceImpact: number;
        implementationComplexity: 'low' | 'medium' | 'high';
    }>;
    results: {
        totalSavings: number;
        budgetReductionAchieved: number;
        averageQualityChange: number;
        averagePerformanceChange: number;
        feasibilityScore: number;
    };
}
export interface TaskTypeAnalysis {
    taskType: string;
    description: string;
    volume: {
        requestsPerDay: number;
        tokensPerDay: number;
        costPerDay: number;
    };
    requirements: {
        minQuality: number;
        maxLatency: number;
        minReliability: number;
        securityLevel: 'low' | 'medium' | 'high' | 'critical';
    };
    modelSuitability: Array<{
        modelName: string;
        suitabilityScore: number;
        reasoning: string[];
        pros: string[];
        cons: string[];
    }>;
    currentOptimalModel: string;
    alternativeModels: string[];
    costOptimizationPotential: number;
}
export declare class PerformanceCostAnalyzer extends EventEmitter {
    private performanceMetrics;
    private comparisons;
    private optimizationScenarios;
    private taskAnalyses;
    private config;
    private benchmarkTimer;
    private isRunning;
    constructor();
    private initializeTaskTypes;
    /**
     * Start performance-cost analysis system
     */
    start(): Promise<void>;
    /**
     * Stop performance-cost analysis system
     */
    stop(): Promise<void>;
    /**
     * Analyze performance vs cost for a specific model
     */
    analyzeModelPerformanceCost(modelName: string, period?: string): Promise<PerformanceCostMetrics>;
    /**
     * Compare multiple models for value optimization
     */
    compareModelsForTask(taskType: string, modelNames: string[], period?: string): Promise<ModelComparison>;
    /**
     * Generate cost optimization scenarios
     */
    generateOptimizationScenarios(targetBudgetReduction: number, constraints?: {
        minQualityThreshold?: number;
        maxLatencyIncrease?: number;
        minReliabilityThreshold?: number;
        excludedModels?: string[];
    }): Promise<CostOptimizationScenario[]>;
    /**
     * Get value optimization recommendations
     */
    getValueOptimizationRecommendations(modelName?: string, taskType?: string): Promise<ValueOptimizationRecommendation[]>;
    /**
     * Get task-specific analysis and recommendations
     */
    getTaskTypeAnalysis(taskType: string): TaskTypeAnalysis | null;
    /**
     * Update task type requirements and optimal models
     */
    updateTaskTypeAnalysis(taskType: string, updates: Partial<TaskTypeAnalysis>): Promise<void>;
    private performInitialAnalysis;
    private updateBenchmarks;
    private calculateEfficiencyMetrics;
    private calculateROIMetrics;
    private calculateCostPerSecond;
    private analyzeTrends;
    private calculateTaskSuitability;
    private rankModels;
    private calculatePerformanceScore;
    private generateComparisonInsights;
    private generateValueOptimizationRecommendations;
    private calculatePerformanceChange;
    private calculateLatencyChange;
    private generateOptimizationScenario;
    private optimizeTaskType;
    private calculateFeasibilityScore;
    private getModelSpecificRecommendations;
    private getGeneralOptimizationRecommendations;
    private reanalyzeTaskSuitability;
    private parsePeriodMs;
    private getModelHealthMetrics;
    private getCostMetrics;
    private getLatencyMetrics;
    private getProviderFromModel;
}
export declare const performanceCostAnalyzer: PerformanceCostAnalyzer;
//# sourceMappingURL=performance-cost-analyzer.d.ts.map