codecrucible-synth/dist/core/performance/active-process-manager.d.ts

Production-Ready AI Development Platform with Multi-Voice Synthesis, Smithery MCP Integration, Enterprise Security, and Zero-Timeout Reliability

/**
 * Active Process Manager
 * Monitors system resources and actively terminates/switches processes when needed
 */
import { EventEmitter } from 'events';
import { HardwareAwareModelSelector } from './hardware-aware-model-selector.js';
export interface ActiveProcess {
    id: string;
    type: 'model_inference' | 'analysis' | 'generation' | 'streaming';
    modelName: string;
    startTime: Date;
    estimatedMemoryUsage: number;
    abortController: AbortController;
    promise: Promise<any>;
    priority: 'low' | 'medium' | 'high' | 'critical';
}
export interface ResourceThresholds {
    memoryWarning: number;
    memoryCritical: number;
    memoryEmergency: number;
    cpuWarning: number;
    cpuCritical: number;
}
export interface ProcessTerminationEvent {
    processId: string;
    reason: 'memory_pressure' | 'cpu_pressure' | 'timeout' | 'model_switch';
    resourceUsage: {
        memory: number;
        cpu: number;
    };
    newModel?: string;
    timestamp: Date;
}
export declare class ActiveProcessManager extends EventEmitter {
    private logger;
    private hardwareSelector;
    private userWarningSystem;
    private activeProcesses;
    private resourceMonitorIntervalId;
    private thresholds;
    private isTerminating;
    private modelSwitchInProgress;
    private lastCriticalWarning;
    private lastEmergencyWarning;
    constructor(hardwareSelector: HardwareAwareModelSelector);
    /**
     * Register a new active process for monitoring
     */
    registerProcess(process: Omit<ActiveProcess, 'id' | 'startTime' | 'abortController'>): ActiveProcess;
    /**
     * Unregister a completed process
     */
    unregisterProcess(processId: string): void;
    /**
     * Start monitoring system resources
     */
    private startResourceMonitoring;
    /**
     * Check current resource usage and warn user if needed (NEVER TERMINATE)
     */
    private checkResourcePressure;
    /**
     * Handle emergency memory pressure (95%+) - terminate all and switch models
     */
    private handleEmergencyMemoryPressure;
    /**
     * Handle critical memory pressure (90%+) - terminate low priority processes
     */
    private handleCriticalMemoryPressure;
    /**
     * Handle memory warning (75%+) - log warning and prepare for potential action
     */
    private handleMemoryWarning;
    /**
     * Handle critical CPU pressure
     */
    private handleCriticalCpuPressure;
    /**
     * Terminate a specific process
     */
    private terminateProcess;
    /**
     * Terminate all active processes
     */
    private terminateAllProcesses;
    /**
     * Get current memory usage as percentage
     */
    private getCurrentMemoryUsage;
    /**
     * Get current CPU usage (simplified estimation)
     */
    private getCurrentCpuUsage;
    /**
     * Setup event listeners for model selector
     */
    private setupModelSelectorEvents;
    /**
     * Get process statistics
     */
    getProcessStats(): any;
    /**
     * Force terminate all processes (for emergency shutdown)
     */
    emergencyShutdown(): Promise<void>;
    /**
     * Update resource thresholds
     */
    updateThresholds(newThresholds: Partial<ResourceThresholds>): void;
    /**
     * Get current resource usage
     */
    getCurrentResourceUsage(): {
        memory: number;
        cpu: number;
        processes: number;
    };
    /**
     * Destroy and cleanup
     */
    destroy(): void;
    private generateProcessId;
    private lastWarningTime;
    private getLastWarningTime;
    private setLastWarningTime;
}
export default ActiveProcessManager;
//# sourceMappingURL=active-process-manager.d.ts.map