neuro-cli 4.3.0 → 5.0.1

package/dist/core/engine.js

@@ -1,5 +1,5 @@
 // ============================================================
-// NeuroCLI - NeuroEngine v4.1.3
+// NeuroCLI - NeuroEngine v5.0 (Claude Code-style Agentic Loop)
 // The main engine that ties everything together
 // Now with: Sandbox, Plugin SDK, Enhanced MCP, Enhanced Approval,
 // Model Router, Prompt Cache, Undo/Redo, Output Styles,
@@ -15,7 +15,8 @@
 // Spec-Driven Development, LLM Evaluator Hooks, MCP Apps,
 // Multi-Model Orchestrator, Smart Monitor, Outcome Grading,
 // Observability (OTLP), Auto-Compact, Terminal UX,
-// Multi-Session, Git Worktree, Auto-Updater
+// Multi-Session, Git Worktree, Auto-Updater,
+// Rate Limit Manager
 // ============================================================
 import { join } from 'path';
 import { homedir } from 'os';
@@ -79,6 +80,7 @@ import { TerminalUX } from './terminal-ux.js';
 import { MultiSessionManager } from './multi-session.js';
 import { GitWorktreeManager } from './git-worktree.js';
 import { AutoUpdater } from './updater.js';
+import { RateLimitManager } from './rate-limiter.js';
 export class NeuroEngine {
     config;
     client;
@@ -143,11 +145,27 @@ export class NeuroEngine {
     multiSession;
     gitWorktree;
     updater;
+    rateLimiter;
     autoApproveSet;
     requireApprovalSet;
     constructor(config) {
         this.config = config;
+        // Rate Limit Manager - initialized FIRST so it's available for all systems
+        this.rateLimiter = new RateLimitManager({
+            globalRpm: 20,
+            perModelRpm: 10,
+            baseCooldownMs: 10000,
+            maxCooldownMs: 120000,
+            backoffMultiplier: 2.0,
+            rotationPoolSize: 5,
+            enableQueue: true,
+            maxQueueSize: 50,
+            maxQueueWaitMs: 60000,
+            adaptiveLearning: true,
+            verbose: true,
+        });
         this.client = new OpenRouterClient(config.apiKey, config.baseUrl);
+        this.client.setRateLimiter(this.rateLimiter);
         this.registry = registerAllTools(new ToolRegistry());
         this.contextManager = new ContextManager(config.defaultModel, config.context.maxTokens);
         this.sessionManager = new SessionManager();
@@ -166,6 +184,7 @@ export class NeuroEngine {
             return false;
         });
         this.fallback = new FallbackChain(this.client, config.fallbackChain);
+        this.fallback.setRateLimiter(this.rateLimiter);
         // Sandbox system
         this.sandbox = new Sandbox(config.sandbox);
         // Plugin system
@@ -196,6 +215,7 @@ export class NeuroEngine {
             categoryOverrides: {},
             maxTokenBudget: config.context.maxTokens,
         }, Object.fromEntries(Object.entries(MODELS).map(([id, m]) => [id, { name: m.name, contextWindow: m.contextWindow, maxOutput: m.maxOutput }])));
+        this.modelRouter.setRateLimiter(this.rateLimiter);
         // Output styles
         this.styleManager = new StyleManager(process.cwd());
         // Extended thinking
@@ -483,7 +503,7 @@ export class NeuroEngine {
         this.gitWorktree = new GitWorktreeManager(process.cwd());
         // Auto-Updater
         this.updater = new AutoUpdater({
-            currentVersion: '4.1.3',
+            currentVersion: '5.0.0',
             autoCheck: true,
             autoUpdate: false,
         });
@@ -523,6 +543,7 @@ Key responsibilities:
 - Manage dependencies between sub-tasks
 - Synthesize results from multiple agents
 - Handle errors and re-plan if needed
+- IMPORTANT: Keep working until the ENTIRE task is COMPLETE
 
 Always consider the strengths of each agent when delegating:
 - Planner: For task decomposition and architecture decisions
@@ -537,7 +558,7 @@ Always consider the strengths of each agent when delegating:
             temperature: 0.7,
             maxTokens: 4096,
             tools: [],
-            maxIterations: 20,
+            maxIterations: 0, // 0 = no limit, run until done
         };
         this.orchestrator = new Orchestrator(orchestratorConfig, this.client, this.registry, process.cwd(), this.sessionManager.getCurrent()?.id || 'default');
         // Register all agents with orchestrator
@@ -634,7 +655,9 @@ Always consider the strengths of each agent when delegating:
         }
     }
     /**
-     * Process a user message
+     * Process a user message — Claude Code style
+     * Every task is sent to the best agent which runs until completion.
+     * No arbitrary early termination — the agent keeps working until done.
      */
     async processMessage(message, mode = 'auto', targetAgent) {
         // Check spending limit via spending monitor
@@ -687,7 +710,7 @@ Always consider the strengths of each agent when delegating:
         const skillAdditions = this.skillSystem.getSystemPromptAdditions();
         const styleAddition = this.styleManager.getSystemPromptAddition();
         const thinkingAddition = this.extendedThinking.getSystemPromptAddition();
-        // Build UI callbacks
+        // Build UI callbacks — Claude Code style
         const callbacks = {
             onThinking: (thinking) => this.ui.thinking(thinking),
             onToken: (token) => this.ui.streamingToken(token),
@@ -702,28 +725,32 @@ Always consider the strengths of each agent when delegating:
                     return;
                 }
                 this.ui.toolCall(name, args);
-                // Record in undo/redo for file modification tools
-                if (['write_file', 'edit_file', 'apply_diff', 'delete_file'].includes(name)) {
-                    // The undo/redo push will happen in the tool execution result handler
-                }
             },
             onToolResult: (name, result, isError) => this.ui.toolResult(name, result, isError),
             onApprovalNeeded: async (name, args, risk) => {
                 return this.handleApproval(name, args, risk);
             },
-            onIteration: (i, max) => {
-                this.ui.info(`Iteration ${i}/${max}`);
+            onIteration: (i, _max) => {
+                // Claude Code style: show iteration count without a ceiling
+                this.ui.agentActivity(this.config.defaultModel, 'working', `step ${i}`);
+            },
+            onCycleStart: (cycle, summary) => {
+                this.ui.agentActivity(this.config.defaultModel, 'working', `cycle ${cycle}: ${summary}`);
+            },
+            onTaskComplete: (reason) => {
+                this.ui.agentActivity(this.config.defaultModel, 'done', reason);
             },
         };
         let result;
         const activeModel = routeDecision?.model || this.config.defaultModel;
+        // === Claude Code-style routing: always send to the best agent and let it run until done ===
         if (mode === 'direct' && targetAgent) {
+            // Direct mode: use specified agent
             const agent = this.agents.get(targetAgent);
             if (!agent) {
                 this.ui.error(`Agent not found: ${targetAgent}`);
                 return { content: '', usage: { inputTokens: 0, outputTokens: 0, cost: 0 } };
             }
-            // Override agent model if defaultModel differs from agent's model
             const originalModel = agent.configModel;
             if (this.config.defaultModel !== originalModel) {
                 agent.configModel = this.config.defaultModel;
@@ -735,10 +762,10 @@ Always consider the strengths of each agent when delegating:
             finally {
                 this.ui.endStreaming();
             }
-            // Restore original model
             agent.configModel = originalModel;
         }
         else if (mode === 'agent') {
+            // Orchestration mode: multi-agent with re-planning
             const orchestrateResult = await this.orchestrator.orchestrate(message, callbacks);
             result = {
                 content: orchestrateResult.content,
@@ -749,58 +776,52 @@ Always consider the strengths of each agent when delegating:
             };
         }
         else {
-            const complexity = routeDecision?.complexity || this.assessComplexity(message);
+            // Auto mode — Claude Code style: route to best agent, let it run until done
             const category = routeDecision?.category || this.modelRouter.getCategory(message);
-            if (complexity === 'simple') {
-                // Route to the best agent based on task category
-                const targetAgentName = this.selectAgentForCategory(category);
-                const agent = this.agents.get(targetAgentName);
-                if (agent) {
-                    this.ui.info(`Using ${targetAgentName} agent (${category} task)`);
+            const targetAgentName = this.selectAgentForCategory(category);
+            const agent = this.agents.get(targetAgentName);
+            if (agent) {
+                // Override agent model with routed model if different
+                const originalModel = agent.configModel;
+                if (activeModel !== originalModel) {
+                    agent.configModel = activeModel;
+                }
+                this.ui.info(`Using ${targetAgentName} agent (${category} task) — will run until complete`);
+                this.ui.startStreaming();
+                try {
+                    result = await agent.run(message, callbacks);
+                }
+                finally {
+                    this.ui.endStreaming();
+                }
+                // Restore original model
+                agent.configModel = originalModel;
+            }
+            else {
+                // Fallback: try Coder, then orchestrator
+                const coderAgent = this.agents.get('Coder');
+                if (coderAgent) {
+                    this.ui.info(`Using Coder agent — will run until complete`);
                     this.ui.startStreaming();
                     try {
-                        result = await agent.run(message, callbacks);
+                        result = await coderAgent.run(message, callbacks);
                     }
                     finally {
                         this.ui.endStreaming();
                     }
                 }
                 else {
-                    // Fallback to Coder
-                    const coderAgent = this.agents.get('Coder');
-                    if (coderAgent) {
-                        this.ui.startStreaming();
-                        try {
-                            result = await coderAgent.run(message, callbacks);
-                        }
-                        finally {
-                            this.ui.endStreaming();
-                        }
-                    }
-                    else {
-                        this.ui.warning('No agents initialized, using orchestration mode');
-                        const orchestrateResult = await this.orchestrator.orchestrate(message, callbacks);
-                        result = {
-                            content: orchestrateResult.content,
-                            toolCallsMade: 0,
-                            iterations: orchestrateResult.execution.iterations,
-                            usage: orchestrateResult.totalUsage,
-                            execution: orchestrateResult.execution,
-                        };
-                    }
+                    this.ui.warning('No agents initialized, using orchestration mode');
+                    const orchestrateResult = await this.orchestrator.orchestrate(message, callbacks);
+                    result = {
+                        content: orchestrateResult.content,
+                        toolCallsMade: 0,
+                        iterations: orchestrateResult.execution.iterations,
+                        usage: orchestrateResult.totalUsage,
+                        execution: orchestrateResult.execution,
+                    };
                 }
             }
-            else {
-                this.ui.thinking('Analyzing task complexity... Using multi-agent orchestration');
-                const orchestrateResult = await this.orchestrator.orchestrate(message, callbacks);
-                result = {
-                    content: orchestrateResult.content,
-                    toolCallsMade: 0,
-                    iterations: orchestrateResult.execution.iterations,
-                    usage: orchestrateResult.totalUsage,
-                    execution: orchestrateResult.execution,
-                };
-            }
         }
         // Parse extended thinking blocks from response
         const thinkingResult = this.extendedThinking.parseResponse(result.content);
@@ -914,8 +935,9 @@ Always consider the strengths of each agent when delegating:
         return result.approved;
     }
     /**
-     * Assess task complexity to decide execution mode
-     * Now delegates to ModelRouter for more sophisticated analysis
+     * Assess task complexity — delegates to ModelRouter
+     * Note: complexity no longer determines execution mode (all tasks run until complete)
+     * but is still used for model selection
      */
     assessComplexity(message) {
         const decision = this.modelRouter.route(message);

package/dist/core/fallback.d.ts

@@ -1,5 +1,6 @@
 import { OpenRouterClient, TokenUsage } from '../api/openrouter.js';
 import { Message } from './types.js';
+import { RateLimitManager } from './rate-limiter.js';
 export interface FallbackConfig {
     models: string[];
     maxRetries: number;
@@ -27,9 +28,14 @@ export interface FallbackResult {
 export declare class FallbackChain {
     private config;
     private client;
+    private rateLimiter;
     constructor(client: OpenRouterClient, config?: Partial<FallbackConfig>);
     /**
-     * Execute a chat request with fallback chain
+     * Set the rate limiter for intelligent model rotation
+     */
+    setRateLimiter(rateLimiter: RateLimitManager): void;
+    /**
+     * Execute a chat request with fallback chain + rate limit awareness
      */
     chatWithFallback(primaryModel: string, messages: Message[], options: {
         tools?: unknown[];

package/dist/core/fallback.js

@@ -1,12 +1,14 @@
 // ============================================================
 // NeuroCLI - Fallback Model Chain
 // Automatic model fallback on failure
+// Now with RateLimitManager integration
 // ============================================================
 import { MODELS } from '../api/models.js';
 import chalk from 'chalk';
 export class FallbackChain {
     config;
     client;
+    rateLimiter = null;
     constructor(client, config) {
         this.client = client;
         this.config = {
@@ -18,13 +20,67 @@ export class FallbackChain {
         };
     }
     /**
-     * Execute a chat request with fallback chain
+     * Set the rate limiter for intelligent model rotation
+     */
+    setRateLimiter(rateLimiter) {
+        this.rateLimiter = rateLimiter;
+    }
+    /**
+     * Execute a chat request with fallback chain + rate limit awareness
      */
     async chatWithFallback(primaryModel, messages, options, onModelSwitch) {
-        const chain = [primaryModel, ...this.config.models.filter(m => m !== primaryModel)];
+        // Build the model chain: primary + configured fallbacks
+        let chain = [primaryModel, ...this.config.models.filter(m => m !== primaryModel)];
+        // If rate limiter is available, prioritize models with good health
+        if (this.rateLimiter) {
+            const availableModels = this.rateLimiter.getNextRotationModel(primaryModel);
+            // Insert rate-limiter-suggested models at the front of the chain
+            const healthyAlternatives = [];
+            const allStates = this.rateLimiter.getStatus();
+            for (const state of allStates) {
+                if (state.model !== primaryModel && state.health >= 50 && state.cooldown === 0) {
+                    healthyAlternatives.push(state.model);
+                }
+            }
+            // Remove duplicates and merge chains
+            const seen = new Set([primaryModel]);
+            const mergedChain = [primaryModel];
+            // Add healthy alternatives first (from rate limiter)
+            for (const m of healthyAlternatives) {
+                if (!seen.has(m)) {
+                    seen.add(m);
+                    mergedChain.push(m);
+                }
+            }
+            // Then add original fallback chain
+            for (const m of chain) {
+                if (!seen.has(m)) {
+                    seen.add(m);
+                    mergedChain.push(m);
+                }
+            }
+            chain = mergedChain;
+        }
         const attempts = [];
         let totalUsage = { inputTokens: 0, outputTokens: 0, cost: 0 };
         for (const model of chain) {
+            // Skip models that are in cooldown (if rate limiter is available)
+            if (this.rateLimiter) {
+                const check = this.rateLimiter.checkRateLimit(model);
+                if (!check.allowed && check.waitMs > 30000) {
+                    // If wait is more than 30s, skip this model entirely
+                    console.log(chalk.gray(`  ⏭️ Skipping ${MODELS[model]?.name || model} (cooldown: ${Math.ceil(check.waitMs / 1000)}s)`));
+                    attempts.push({ model, success: false, error: `In cooldown (${Math.ceil(check.waitMs / 1000)}s)` });
+                    continue;
+                }
+                if (!check.allowed && check.suggestedModel) {
+                    // Use the suggested alternative instead
+                    if (!chain.includes(check.suggestedModel)) {
+                        chain.push(check.suggestedModel);
+                    }
+                    continue;
+                }
+            }
             for (let retry = 0; retry <= this.config.maxRetries; retry++) {
                 try {
                     const modelInfo = MODELS[model];
@@ -62,7 +118,16 @@ export class FallbackChain {
                         errMsg.includes('503') ||
                         errMsg.includes('500'));
                     if (shouldFallback) {
-                        console.log(chalk.yellow(`  ⚠ ${model} failed: ${errMsg.slice(0, 80)}`));
+                        // Record the rate limit or server error
+                        if (this.rateLimiter) {
+                            if (errMsg.includes('429') || errMsg.toLowerCase().includes('rate_limit')) {
+                                this.rateLimiter.recordRateLimit(model);
+                            }
+                            else if (errMsg.includes('500') || errMsg.includes('503')) {
+                                this.rateLimiter.recordServerError(model);
+                            }
+                        }
+                        console.log(chalk.yellow(`  ⚠ ${MODELS[model]?.name || model} failed: ${errMsg.slice(0, 80)}`));
                         break; // Try next model in chain
                     }
                     // For other errors, retry on same model

package/dist/core/model-router.d.ts

@@ -29,9 +29,15 @@ export declare class ModelRouter {
     private availableModels;
     private currentEffort;
     private forcedModel;
+    private rateLimiter;
     constructor(config: RouterConfig, availableModels: Record<string, ModelInfo>);
+    /**
+     * Set the rate limiter for rate-aware routing decisions
+     */
+    setRateLimiter(rateLimiter: import('./rate-limiter.js').RateLimitManager): void;
     /**
      * Route a prompt to the best available model.
+     * Now rate-limit-aware: avoids models in cooldown and rotates to healthy alternatives.
      */
     route(prompt: string, effort?: EffortLevel): RoutingDecision;
     /**

package/dist/core/model-router.js

@@ -72,7 +72,7 @@ const COMPLEXITY_SIGNALS = {
             /\b(hello|hi|thanks|yes|no|ok|sure|done|correct|right|please)\b/i,
         ],
         lengthThreshold: 80,
-        maxSteps: 5,
+        maxSteps: 0, // 0 = no limit (Claude Code style)
     },
     moderate: {
         patterns: [
@@ -83,7 +83,7 @@ const COMPLEXITY_SIGNALS = {
             /\b(refactor|clean|simplify|optimize|restructure)\b/i,
         ],
         lengthThreshold: 300,
-        maxSteps: 15,
+        maxSteps: 0, // 0 = no limit (Claude Code style)
     },
     complex: {
         patterns: [
@@ -97,7 +97,7 @@ const COMPLEXITY_SIGNALS = {
             /\b(security\s+(audit|review|hardening)|performance\s+(optim|tuning|profiling)|scalab(ility|le))\b/i,
         ],
         lengthThreshold: 500,
-        maxSteps: 30,
+        maxSteps: 0, // 0 = no limit (Claude Code style)
     },
 };
 // ---------------------------------------------------------------------------
@@ -124,6 +124,7 @@ export class ModelRouter {
     availableModels;
     currentEffort = 'medium';
     forcedModel = null;
+    rateLimiter = null;
     // -----------------------------------------------------------------------
     // Construction
     // -----------------------------------------------------------------------
@@ -135,15 +136,53 @@ export class ModelRouter {
     // -----------------------------------------------------------------------
     // Public API
     // -----------------------------------------------------------------------
+    /**
+     * Set the rate limiter for rate-aware routing decisions
+     */
+    setRateLimiter(rateLimiter) {
+        this.rateLimiter = rateLimiter;
+    }
     /**
      * Route a prompt to the best available model.
+     * Now rate-limit-aware: avoids models in cooldown and rotates to healthy alternatives.
      */
     route(prompt, effort) {
         const effectiveEffort = effort ?? this.currentEffort;
         const analysis = this.analyzePrompt(prompt);
         const estimatedTokens = this.estimateTokens(prompt);
-        const model = this.selectModel(analysis.complexity, analysis.category, effectiveEffort);
+        let model = this.selectModel(analysis.complexity, analysis.category, effectiveEffort);
         const alternatives = this.getAlternatives(analysis.complexity, analysis.category);
+        // --- Rate-limit-aware routing ---
+        if (this.rateLimiter) {
+            const check = this.rateLimiter.checkRateLimit(model);
+            if (!check.allowed && check.suggestedModel) {
+                // Use the rate limiter's suggested alternative
+                const suggested = check.suggestedModel;
+                if (this.availableModels[suggested]) {
+                    model = suggested;
+                }
+                else {
+                    // The suggested model isn't in our available models, try alternatives
+                    for (const alt of alternatives) {
+                        const altCheck = this.rateLimiter.checkRateLimit(alt);
+                        if (altCheck.allowed) {
+                            model = alt;
+                            break;
+                        }
+                    }
+                }
+            }
+            else if (!check.allowed) {
+                // Model is rate limited and no suggested alternative, try alternatives
+                for (const alt of alternatives) {
+                    const altCheck = this.rateLimiter.checkRateLimit(alt);
+                    if (altCheck.allowed) {
+                        model = alt;
+                        break;
+                    }
+                }
+            }
+        }
         const reasoning = this.buildReasoning(analysis, effectiveEffort, model);
         return {
             model,

package/dist/core/rate-limiter.d.ts

@@ -0,0 +1,162 @@
+export interface RateLimiterConfig {
+    /** Maximum requests per minute across all models (default: 20) */
+    globalRpm: number;
+    /** Maximum requests per minute per model (default: 10) */
+    perModelRpm: number;
+    /** Base cooldown after a 429 in ms (default: 10000) */
+    baseCooldownMs: number;
+    /** Maximum cooldown in ms (default: 120000) */
+    maxCooldownMs: number;
+    /** Multiplier for consecutive 429s (default: 2.0) */
+    backoffMultiplier: number;
+    /** Number of free model rotation slots (default: 5) */
+    rotationPoolSize: number;
+    /** Enable request queuing during rate limits (default: true) */
+    enableQueue: boolean;
+    /** Maximum queue size (default: 50) */
+    maxQueueSize: number;
+    /** Maximum time a request can wait in queue in ms (default: 60000) */
+    maxQueueWaitMs: number;
+    /** Enable adaptive learning from rate limit patterns (default: true) */
+    adaptiveLearning: boolean;
+    /** Log rate limit events to console (default: true) */
+    verbose: boolean;
+}
+export interface ModelRateState {
+    /** Model ID */
+    modelId: string;
+    /** Current cooldown end time (0 = not cooling down) */
+    cooldownUntil: number;
+    /** Number of consecutive 429s */
+    consecutive429s: number;
+    /** Total 429s received */
+    total429s: number;
+    /** Total successful requests */
+    totalSuccesses: number;
+    /** Requests in current minute window */
+    requestsThisMinute: number;
+    /** Minute window start time */
+    minuteWindowStart: number;
+    /** Last request timestamp */
+    lastRequestAt: number;
+    /** Average response time in ms */
+    avgResponseMs: number;
+    /** Whether model is currently in rotation pool */
+    inRotationPool: boolean;
+    /** Health score 0-100 (100 = healthy) */
+    healthScore: number;
+}
+export interface RateLimitCheck {
+    /** Whether the request can proceed */
+    allowed: boolean;
+    /** Wait time in ms if not allowed (0 if allowed) */
+    waitMs: number;
+    /** Suggested alternative model (null if current is fine) */
+    suggestedModel: string | null;
+    /** Reason for the decision */
+    reason: string;
+}
+export interface QueuedRequest {
+    id: string;
+    model: string;
+    enqueuedAt: number;
+    resolve: (check: RateLimitCheck) => void;
+    reject: (error: Error) => void;
+}
+export declare class RateLimitManager {
+    private config;
+    private modelStates;
+    private globalRequestTimestamps;
+    private requestQueue;
+    private queueProcessTimer;
+    private rotationPool;
+    private currentRotationIndex;
+    private requestIdCounter;
+    private rateLimitPatterns;
+    constructor(config?: Partial<RateLimiterConfig>);
+    /**
+     * Check if a request can be made to a specific model.
+     * Returns a RateLimitCheck with the decision and optional alternative model.
+     */
+    checkRateLimit(modelId: string): RateLimitCheck;
+    /**
+     * Acquire permission to make a request. Resolves when the request can proceed.
+     * If queuing is enabled, waits in queue. Otherwise, rejects if rate limited.
+     */
+    acquire(modelId: string): Promise<RateLimitCheck>;
+    /**
+     * Record a successful request completion
+     */
+    recordSuccess(modelId: string, responseTimeMs: number): void;
+    /**
+     * Record a rate limit (429) response
+     */
+    recordRateLimit(modelId: string, retryAfterSeconds?: number): void;
+    /**
+     * Record a server error (5xx) - treat as potential overload
+     */
+    recordServerError(modelId: string): void;
+    /**
+     * Get the next available model from the rotation pool.
+     * Skips models that are in cooldown or have low health.
+     */
+    getNextRotationModel(excludeModel?: string): string | null;
+    /**
+     * Get the best available model for a given requested model.
+     * Tries the requested model first, then falls back through the rotation pool.
+     */
+    getBestAvailableModel(requestedModel: string): string;
+    /**
+     * Get rate limit status for all tracked models
+     */
+    getStatus(): Array<{
+        model: string;
+        name: string;
+        health: number;
+        cooldown: number;
+        consecutive429s: number;
+        total429s: number;
+        totalSuccesses: number;
+        rpm: number;
+        avgResponseMs: number;
+    }>;
+    /**
+     * Get queue status
+     */
+    getQueueStatus(): {
+        size: number;
+        oldestWaitMs: number;
+    };
+    /**
+     * Reset all rate limit state (useful for testing)
+     */
+    reset(): void;
+    /**
+     * Reset a specific model's rate limit state
+     */
+    resetModel(modelId: string): void;
+    /**
+     * Update configuration at runtime
+     */
+    updateConfig(updates: Partial<RateLimiterConfig>): void;
+    /**
+     * Print a formatted status table
+     */
+    printStatus(): void;
+    private getOrCreateState;
+    private recordRequestStart;
+    private cleanupGlobalTimestamps;
+    private cleanupModelTimestamps;
+    private findAvailableModel;
+    private initializeRotationPool;
+    private enqueueRequest;
+    private startQueueProcessor;
+    private processQueue;
+    private recordRateLimitPattern;
+    private getHealthBar;
+    /**
+     * Cleanup - call when shutting down
+     */
+    dispose(): void;
+}
+//# sourceMappingURL=rate-limiter.d.ts.map