/**
 * Priority Queue / Fast Mode — Route requests through priority tiers
 * for lower latency on supported providers.
 *
 * Inspired by Hermes Agent's /fast mode. Provides a priority-aware request
 * queue that separates normal and fast-mode requests, ensuring fast-mode
 * requests are processed first and routed to provider priority endpoints.
 *
 * Usage:
 *   const pq = new PriorityQueue();
 *   pq.enqueue({ id: 'req1', priority: 'fast', provider: 'openai', ... });
 *   const next = pq.dequeue(); // Always returns highest priority first
 */
import { EventEmitter } from 'events';
export type PriorityLevel = 'fast' | 'normal' | 'batch';
export interface PriorityRequest {
    id: string;
    priority: PriorityLevel;
    provider: string;
    model: string;
    payload: unknown;
    enqueuedAt: number;
    metadata?: Record<string, unknown>;
}
export interface PriorityConfig {
    /** Maximum concurrent fast-mode requests per provider */
    maxConcurrentFast?: number;
    /** Maximum concurrent normal requests per provider */
    maxConcurrentNormal?: number;
    /** Timeout for fast-mode requests before fallback (ms, default 30s) */
    fastTimeout?: number;
    /** Providers that support priority routing */
    supportedProviders?: string[];
}
export interface ProviderPriorityEndpoint {
    provider: string;
    priorityUrl?: string;
    priorityHeader?: {
        key: string;
        value: string;
    };
    priorityParam?: {
        key: string;
        value: string;
    };
}
export declare class PriorityQueue extends EventEmitter {
    private queues;
    private activeCounts;
    private config;
    private endpoints;
    constructor(config?: PriorityConfig);
    /** Register a custom priority endpoint for a provider */
    registerEndpoint(endpoint: ProviderPriorityEndpoint): void;
    /** Check if a provider supports priority routing */
    supportsPriority(provider: string): boolean;
    /** Get priority endpoint configuration for a provider */
    getEndpoint(provider: string): ProviderPriorityEndpoint | undefined;
    /** Enqueue a request */
    enqueue(request: PriorityRequest): void;
    /** Dequeue the next highest-priority request that can run */
    dequeue(): PriorityRequest | undefined;
    /** Mark a request as completed, freeing a concurrency slot */
    complete(provider: string, priority: PriorityLevel): void;
    /** Get queue lengths */
    getStats(): {
        fast: number;
        normal: number;
        batch: number;
        total: number;
        active: Record<string, {
            fast: number;
            normal: number;
            batch: number;
        }>;
    };
    /** Drain all requests (for shutdown) */
    drain(): PriorityRequest[];
    /** Determine effective priority for a request (auto-upgrade/downgrade) */
    static resolvePriority(requested: PriorityLevel, provider: string, supportedProviders: string[]): PriorityLevel;
    private canRun;
    private incrementActive;
}
/**
 * Tracks per-session fast mode toggle (like /fast command).
 */
export declare class FastModeManager {
    private sessions;
    /** Toggle fast mode for a session, returns new state */
    toggle(sessionId: string): boolean;
    /** Set fast mode explicitly */
    set(sessionId: string, enabled: boolean): void;
    /** Check if session has fast mode enabled */
    isEnabled(sessionId: string): boolean;
    /** Get priority level for a session */
    getPriority(sessionId: string): PriorityLevel;
    /** Clear all state */
    reset(): void;
}
//# sourceMappingURL=priority-queue.d.ts.map