codecrucible-synth/dist/core/execution/request-execution-manager.d.ts

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

/**
 * Request Execution Manager - Extracted from UnifiedModelClient
 * Manages request processing, execution strategies, and fallback logic following Living Spiral methodology
 *
 * Council Perspectives Applied:
 * - Performance Engineer: Optimized execution strategies and timeout handling
 * - Maintainer: Reliable request processing and error recovery
 * - Security Guardian: Safe request validation and execution sandboxing
 * - Explorer: Flexible execution modes and strategy adaptation
 * - Architect: Clean separation between strategy, execution, and coordination
 */
import { EventEmitter } from 'events';
import { ProjectContext, ModelRequest, ModelResponse } from '../types.js';
import { ActiveProcessManager } from '../performance/active-process-manager.js';
export type ExecutionMode = 'fast' | 'quality' | 'balanced';
export type ProviderType = 'ollama' | 'lm-studio' | 'huggingface' | 'auto';
export interface ExecutionStrategy {
    mode: ExecutionMode;
    provider: ProviderType;
    timeout: number;
    complexity: string;
}
export interface RequestMetrics {
    provider: ProviderType;
    model: string;
    startTime: number;
    endTime?: number;
    success: boolean;
    tokenCount?: number;
    error?: string;
}
export interface ExecutionConfig {
    maxConcurrentRequests: number;
    defaultTimeout: number;
    complexityTimeouts: {
        simple: number;
        medium: number;
        complex: number;
    };
    memoryThresholds: {
        low: number;
        medium: number;
        high: number;
    };
}
export interface IRequestExecutionManager {
    processRequest(request: ModelRequest, context?: ProjectContext): Promise<ModelResponse>;
    executeWithFallback(requestId: string, request: ModelRequest, context: ProjectContext | undefined, strategy: ExecutionStrategy, abortSignal?: AbortSignal): Promise<ModelResponse>;
    determineExecutionStrategy(request: ModelRequest, context?: ProjectContext): ExecutionStrategy;
    getActiveRequests(): Map<string, RequestMetrics>;
}
export declare class RequestExecutionManager extends EventEmitter implements IRequestExecutionManager {
    private config;
    private activeRequests;
    private requestQueue;
    private processManager;
    private providerRepository;
    private isShuttingDown;
    private queueProcessor;
    constructor(config: ExecutionConfig, processManager: ActiveProcessManager, providerRepository: any);
    /**
     * Main request processing method
     */
    processRequest(request: ModelRequest, context?: ProjectContext): Promise<ModelResponse>;
    /**
     * Execute request with fallback chain
     */
    executeWithFallback(requestId: string, request: ModelRequest, context: ProjectContext | undefined, strategy: ExecutionStrategy, abortSignal?: AbortSignal): Promise<ModelResponse>;
    /**
     * Determine execution strategy based on request characteristics
     */
    determineExecutionStrategy(request: ModelRequest, context?: ProjectContext): ExecutionStrategy;
    /**
     * Get currently active requests
     */
    getActiveRequests(): Map<string, RequestMetrics>;
    /**
     * Assess request complexity quickly
     */
    private assessComplexityFast;
    /**
     * Estimate memory usage for request
     */
    private estimateMemoryUsage;
    /**
     * Determine process type for process manager
     */
    private getProcessType;
    /**
     * Get request priority
     */
    private getRequestPriority;
    /**
     * Create timeout promise for race conditions
     */
    private createTimeoutPromise;
    /**
     * Create optimized timeout promise with abort controller
     */
    private createOptimizedTimeoutPromise;
    /**
     * Generate unique request ID
     */
    private generateRequestId;
    /**
     * Schedule queue processor (event-driven, not infinite loop)
     */
    private scheduleQueueProcessor;
    /**
     * Process queue batch efficiently
     */
    private processQueueBatch;
    /**
     * Queue request if at capacity
     */
    queueRequest(request: ModelRequest, context?: ProjectContext): Promise<ModelResponse>;
    /**
     * Graceful shutdown
     */
    shutdown(): Promise<void>;
    /**
     * Check if provider/model combination supports tools
     */
    private modelSupportsTools;
    /**
     * Get execution statistics
     */
    getExecutionStats(): any;
}
//# sourceMappingURL=request-execution-manager.d.ts.map