@hivetechs/hive-ai/dist/lib/tools/performance-monitor.d.ts

Real-time streaming AI consensus platform with HTTP+SSE MCP integration for Claude Code, VS Code, Cursor, and Windsurf - powered by OpenRouter's unified API

/**
 * Performance Monitor - Expert-level performance monitoring and analysis
 *
 * Provides comprehensive performance metrics collection, analysis, and optimization
 * recommendations for the consensus pipeline and OpenRouter integrations.
 */
export interface PerformanceMetrics {
    timestamp: string;
    conversationId?: string;
    pipeline: {
        totalDuration: number;
        stageBreakdown: {
            generator: StagePerformance;
            refiner: StagePerformance;
            validator: StagePerformance;
            curator: StagePerformance;
        };
        overallEfficiency: number;
        bottleneckStage: string;
    };
    openRouter: {
        averageLatency: number;
        successRate: number;
        retryCount: number;
        circuitBreakerTrips: number;
        providerBreakdown: Record<string, ProviderMetrics>;
    };
    resources: {
        memoryUsage: number;
        cpuUsage: number;
        activeConnections: number;
        databaseQueries: number;
        queryLatency: number;
    };
    quality: {
        averageQualityScore: number;
        improvementRate: number;
        consensusEffectiveness: number;
    };
    cost: {
        totalCost: number;
        costPerRequest: number;
        budgetUtilization: number;
        costEfficiency: number;
    };
}
export interface StagePerformance {
    duration: number;
    tokensPerSecond: number;
    cost: number;
    retries: number;
    modelUsed: string;
    latency: number;
    efficiency: number;
}
export interface ProviderMetrics {
    requests: number;
    averageLatency: number;
    successRate: number;
    errorRate: number;
    costPerRequest: number;
}
export interface PerformanceReport {
    timeframe: string;
    summary: {
        totalRequests: number;
        averageResponseTime: number;
        overallEfficiency: number;
        costEfficiency: number;
    };
    trends: {
        performanceTrend: 'improving' | 'stable' | 'degrading';
        costTrend: 'decreasing' | 'stable' | 'increasing';
        qualityTrend: 'improving' | 'stable' | 'declining';
    };
    bottlenecks: BottleneckAnalysis[];
    recommendations: OptimizationRecommendation[];
}
export interface BottleneckAnalysis {
    component: string;
    issue: string;
    impact: 'low' | 'medium' | 'high' | 'critical';
    frequency: number;
    avgDelayMs: number;
    recommendation: string;
}
export interface OptimizationRecommendation {
    category: 'performance' | 'cost' | 'quality';
    priority: 'low' | 'medium' | 'high';
    description: string;
    expectedImprovement: string;
    implementation: string;
    estimatedEffort: string;
}
export declare class PerformanceMonitor {
    private metricsBuffer;
    private readonly BUFFER_SIZE;
    private readonly COLLECTION_INTERVAL;
    private collectionTimer?;
    private isMonitoring;
    constructor();
    /**
     * Start performance metrics collection
     */
    startCollection(): void;
    /**
     * Stop performance metrics collection
     */
    stopCollection(): void;
    /**
     * Collect real-time performance metrics
     */
    private collectMetrics;
    /**
     * Add metrics to buffer
     */
    addMetrics(metrics: PerformanceMetrics): void;
    /**
     * Record conversation performance
     */
    recordConversationPerformance(conversationId: string, stages: Record<string, StagePerformance>, totalDuration: number, totalCost: number, qualityScore?: number): Promise<void>;
    /**
     * Generate comprehensive performance report
     */
    generatePerformanceReport(timeframe?: string): Promise<PerformanceReport>;
    /**
     * Identify performance bottlenecks
     */
    identifyBottlenecks(timeframe?: string): Promise<BottleneckAnalysis[]>;
    /**
     * Get optimization recommendations
     */
    getOptimizationRecommendations(focus?: 'performance' | 'cost' | 'quality'): Promise<OptimizationRecommendation[]>;
    /**
     * Compare performance across time periods
     */
    comparePerformance(baselinePeriod: string, currentPeriod: string): Promise<{
        baseline: PerformanceReport;
        current: PerformanceReport;
        comparison: {
            performanceChange: number;
            costChange: number;
            qualityChange: number;
            summary: string;
        };
    }>;
    /**
     * Export metrics for external monitoring tools
     */
    exportMetrics(format?: 'json' | 'csv' | 'prometheus'): Promise<string>;
    /**
     * Private helper methods
     */
    private collectPipelineMetrics;
    private collectOpenRouterMetrics;
    private collectResourceMetrics;
    private collectQualityMetrics;
    private collectCostMetrics;
    private calculateOverallEfficiency;
    private identifyBottleneckStage;
    private calculateSummary;
    private analyzeTrends;
    private analyzeBottlenecks;
    private generateRecommendations;
    private generateComparisonSummary;
    private parseTimeframe;
    private formatMetricsAsCSV;
    private formatMetricsAsPrometheus;
    /**
     * Get metrics from database
     */
    private getMetricsFromDatabase;
    /**
     * Deduplicate metrics based on timestamp and conversation ID
     */
    private deduplicateMetrics;
    private saveMetricsToDatabase;
}
/**
 * Global performance monitor instance
 */
export declare const globalPerformanceMonitor: PerformanceMonitor;