neuro-cli 4.3.0 → 5.0.1

package/dist/api/openrouter.js

@@ -1,6 +1,7 @@
 // ============================================================
 // NeuroCLI - OpenRouter API Client
 // Streaming + Tool Use + Multi-model support
+// Now with RateLimitManager integration
 // ============================================================
 // @ts-ignore
 import { createParser } from 'eventsource-parser';
@@ -9,6 +10,7 @@ export class OpenRouterClient {
     apiKey;
     baseUrl;
     totalUsage = { inputTokens: 0, outputTokens: 0, cost: 0 };
+    rateLimiter = null;
     constructor(apiKey, baseUrl = 'https://openrouter.ai/api/v1') {
         this.apiKey = apiKey;
         this.baseUrl = baseUrl;
@@ -20,15 +22,42 @@ export class OpenRouterClient {
         this.totalUsage = { inputTokens: 0, outputTokens: 0, cost: 0 };
     }
     /**
-     * Main chat completion with streaming
+     * Set the rate limiter instance for this client
+     */
+    setRateLimiter(rateLimiter) {
+        this.rateLimiter = rateLimiter;
+    }
+    /**
+     * Main chat completion with streaming + rate limit awareness
      */
     async chat(request, callbacks) {
         const model = MODELS[request.model];
         if (!model) {
             throw new Error(`Unknown model: ${request.model}`);
         }
+        // --- Rate limit pre-check ---
+        let activeModel = request.model;
+        if (this.rateLimiter) {
+            const check = await this.rateLimiter.acquire(request.model);
+            if (check.suggestedModel) {
+                // Switch to the suggested alternative model
+                activeModel = check.suggestedModel;
+                callbacks?.onThinking?.(`🔄 Rate limiter rotated to ${MODELS[activeModel]?.name || activeModel}`);
+            }
+            else if (!check.allowed) {
+                // Not allowed and no alternative - wait
+                if (check.waitMs > 0) {
+                    callbacks?.onThinking?.(`⏳ Rate limited, waiting ${Math.ceil(check.waitMs / 1000)}s...`);
+                    await new Promise(resolve => setTimeout(resolve, check.waitMs));
+                }
+            }
+        }
+        const activeModelConfig = MODELS[activeModel];
+        if (!activeModelConfig) {
+            throw new Error(`Unknown model after rate limit rotation: ${activeModel}`);
+        }
         const body = {
-            model: request.model,
+            model: activeModel,
             messages: request.messages.map(m => ({
                 role: m.role,
                 content: m.content,
@@ -38,9 +67,9 @@ export class OpenRouterClient {
             })),
             stream: request.stream ?? true,
             temperature: request.temperature ?? 0.7,
-            max_tokens: request.maxTokens ?? model.maxOutput,
+            max_tokens: request.maxTokens ?? activeModelConfig.maxOutput,
         };
-        if (request.tools && request.tools.length > 0 && model.supportsTools) {
+        if (request.tools && request.tools.length > 0 && activeModelConfig.supportsTools) {
             body.tools = request.tools.map(t => ({
                 type: 'function',
                 function: {
@@ -54,47 +83,133 @@ export class OpenRouterClient {
         let lastError = null;
         for (let attempt = 0; attempt <= maxRetries; attempt++) {
             if (attempt > 0) {
-                // Exponential backoff: 5s, 15s, 30s
-                const waitTime = Math.min(5000 * Math.pow(3, attempt - 1), 30000);
-                callbacks?.onThinking?.(`⏳ Rate limited, retrying in ${waitTime / 1000}s (attempt ${attempt + 1}/${maxRetries + 1})...`);
+                // Smart backoff: use rate limiter cooldown if available, otherwise exponential
+                let waitTime;
+                if (this.rateLimiter) {
+                    const state = this.rateLimiter.getStatus().find(s => s.model === activeModel);
+                    waitTime = state && state.cooldown > 0 ? state.cooldown * 1000 : Math.min(5000 * Math.pow(2, attempt - 1), 30000);
+                }
+                else {
+                    waitTime = Math.min(5000 * Math.pow(3, attempt - 1), 30000);
+                }
+                callbacks?.onThinking?.(`⏳ Retrying in ${Math.ceil(waitTime / 1000)}s (attempt ${attempt + 1}/${maxRetries + 1})...`);
                 await new Promise(resolve => setTimeout(resolve, waitTime));
             }
-            const response = await fetch(`${this.baseUrl}/chat/completions`, {
-                method: 'POST',
-                headers: {
-                    'Authorization': `Bearer ${this.apiKey}`,
-                    'Content-Type': 'application/json',
-                    'HTTP-Referer': 'https://neurocli.dev',
-                    'X-Title': 'NeuroCLI',
-                },
-                body: JSON.stringify(body),
-            });
-            if (!response.ok) {
-                const errorBody = await response.text();
-                // Parse retry_after from 429 errors
-                if (response.status === 429) {
-                    try {
-                        const errorData = JSON.parse(errorBody);
-                        const retryAfter = errorData?.error?.metadata?.retry_after_seconds;
-                        if (retryAfter && attempt < maxRetries) {
-                            lastError = new Error(`Rate limited, retry after ${retryAfter}s`);
+            const startTime = Date.now();
+            try {
+                const response = await fetch(`${this.baseUrl}/chat/completions`, {
+                    method: 'POST',
+                    headers: {
+                        'Authorization': `Bearer ${this.apiKey}`,
+                        'Content-Type': 'application/json',
+                        'HTTP-Referer': 'https://neurocli.dev',
+                        'X-Title': 'NeuroCLI',
+                    },
+                    body: JSON.stringify(body),
+                });
+                const responseTimeMs = Date.now() - startTime;
+                if (!response.ok) {
+                    const errorBody = await response.text();
+                    // Parse retry_after from 429 errors
+                    if (response.status === 429) {
+                        let retryAfterSeconds;
+                        try {
+                            const errorData = JSON.parse(errorBody);
+                            retryAfterSeconds = errorData?.error?.metadata?.retry_after_seconds;
+                        }
+                        catch { }
+                        // Record rate limit in manager
+                        if (this.rateLimiter) {
+                            this.rateLimiter.recordRateLimit(activeModel, retryAfterSeconds);
+                        }
+                        // Try model rotation before retrying
+                        if (this.rateLimiter && attempt < maxRetries) {
+                            const nextModel = this.rateLimiter.getNextRotationModel(activeModel);
+                            if (nextModel && nextModel !== activeModel) {
+                                const nextModelConfig = MODELS[nextModel];
+                                if (nextModelConfig) {
+                                    callbacks?.onThinking?.(`🔄 Rotating ${MODELS[activeModel]?.name || activeModel} → ${nextModelConfig.name} due to rate limit`);
+                                    activeModel = nextModel;
+                                    body.model = nextModel;
+                                    body.max_tokens = request.maxTokens ?? nextModelConfig.maxOutput;
+                                    if (request.tools && request.tools.length > 0 && nextModelConfig.supportsTools) {
+                                        // tools already set
+                                    }
+                                    else if (request.tools && !nextModelConfig.supportsTools) {
+                                        delete body.tools;
+                                    }
+                                    // Don't count this as a retry attempt for the new model
+                                    attempt--;
+                                    continue;
+                                }
+                            }
+                        }
+                        if (retryAfterSeconds && attempt < maxRetries) {
+                            lastError = new Error(`Rate limited, retry after ${retryAfterSeconds}s`);
                             continue; // Retry
                         }
+                        if (attempt < maxRetries) {
+                            lastError = new Error(`Rate limited (429): ${errorBody}`);
+                            continue;
+                        }
                     }
-                    catch { }
-                    // If we can't parse retry_after or max retries reached, throw
-                    if (attempt < maxRetries) {
-                        lastError = new Error(`Rate limited (429): ${errorBody}`);
-                        continue;
+                    // Server errors (5xx) - record and potentially rotate
+                    if (response.status >= 500) {
+                        if (this.rateLimiter) {
+                            this.rateLimiter.recordServerError(activeModel);
+                        }
+                        if (attempt < maxRetries) {
+                            lastError = new Error(`Server error (${response.status}): ${errorBody}`);
+                            // Try model rotation for server errors too
+                            if (this.rateLimiter) {
+                                const nextModel = this.rateLimiter.getNextRotationModel(activeModel);
+                                if (nextModel && nextModel !== activeModel) {
+                                    const nextModelConfig = MODELS[nextModel];
+                                    if (nextModelConfig) {
+                                        callbacks?.onThinking?.(`🔄 Rotating away from ${MODELS[activeModel]?.name || activeModel} due to server error`);
+                                        activeModel = nextModel;
+                                        body.model = nextModel;
+                                        body.max_tokens = request.maxTokens ?? nextModelConfig.maxOutput;
+                                        if (request.tools && request.tools.length > 0 && nextModelConfig.supportsTools) {
+                                            // tools already set
+                                        }
+                                        else if (request.tools && !nextModelConfig.supportsTools) {
+                                            delete body.tools;
+                                        }
+                                        attempt--;
+                                        continue;
+                                    }
+                                }
+                            }
+                            continue;
+                        }
                     }
+                    throw new Error(`OpenRouter API error (${response.status}): ${errorBody}`);
+                }
+                // Success!
+                if (this.rateLimiter) {
+                    this.rateLimiter.recordSuccess(activeModel, responseTimeMs);
+                }
+                if (request.stream && callbacks) {
+                    const result = await this.handleStreamingResponse(response, activeModel, callbacks);
+                    return result;
+                }
+                else {
+                    const result = await this.handleNonStreamingResponse(response, activeModel);
+                    return result;
                 }
-                throw new Error(`OpenRouter API error (${response.status}): ${errorBody}`);
-            }
-            if (request.stream && callbacks) {
-                return this.handleStreamingResponse(response, request.model, callbacks);
             }
-            else {
-                return this.handleNonStreamingResponse(response, request.model);
+            catch (error) {
+                // Network-level errors (fetch failed)
+                if (error instanceof TypeError && error.message.includes('fetch')) {
+                    if (this.rateLimiter) {
+                        this.rateLimiter.recordServerError(activeModel);
+                    }
+                    lastError = error;
+                    if (attempt < maxRetries)
+                        continue;
+                }
+                throw error;
             }
         }
         throw lastError || new Error('Max retries exceeded');

package/dist/commands/commands.js

@@ -297,6 +297,17 @@ export class CommandSystem {
                 description: 'Browser automation (navigate/screenshot/click)',
                 prompt: 'Use the browser to navigate, take screenshots, click elements, or extract content from web pages. {args}',
             },
+            // --- Rate Limit Commands ---
+            {
+                name: 'ratelimit',
+                description: 'Show rate limiter status for all models',
+                prompt: 'Show the current rate limiter status. Display health scores, cooldowns, 429 counts, and queue status for all tracked models. {args}',
+            },
+            {
+                name: 'ratelimit-reset',
+                description: 'Reset rate limiter state',
+                prompt: 'Reset all rate limiter cooldowns and health scores. Use this if models are stuck in cooldown. {args}',
+            },
         ];
         for (const cmd of bundled) {
             if (!this.commands.has(cmd.name)) {

package/dist/config/config.js

@@ -14,82 +14,82 @@ export const DEFAULT_CONFIG = {
         planner: {
             name: 'Planner',
             description: 'Task decomposition and planning specialist',
-            systemPrompt: `You are an expert software architect and planner. Your job is to break down complex tasks into clear, actionable steps. For each step, specify which agent should handle it and what tools they should use. Be thorough but concise.`,
+            systemPrompt: `You are an expert software architect and planner. Your job is to break down complex tasks into clear, actionable steps. For each step, specify which agent should handle it and what tools they should use. Be thorough but concise. Keep working until you have a COMPLETE plan covering every aspect of the task.`,
             model: 'qwen/qwen3-coder:free',
             temperature: 0.7,
             maxTokens: 4096,
             tools: ['read_file', 'search_files', 'list_directory'],
-            maxIterations: 10,
+            maxIterations: 0, // 0 = no limit, run until done
         },
         coder: {
             name: 'Coder',
             description: 'Code generation and modification specialist',
-            systemPrompt: `You are an expert software developer. You write clean, efficient, well-documented code. You understand design patterns, best practices, and can work with any programming language or framework. When modifying existing code, you make minimal, targeted changes. Always consider edge cases and error handling.`,
+            systemPrompt: `You are an expert software developer. You write clean, efficient, well-documented code. You understand design patterns, best practices, and can work with any programming language or framework. When modifying existing code, you make minimal, targeted changes. Always consider edge cases and error handling. IMPORTANT: You MUST keep working until the entire task is COMPLETE — do not stop after creating only some files. Create ALL necessary files, update ALL imports, and verify your work.`,
             model: 'qwen/qwen3-coder:free',
             temperature: 0.4,
             maxTokens: 16384,
             tools: ['read_file', 'write_file', 'edit_file', 'search_files', 'list_directory', 'run_command', 'apply_diff'],
-            maxIterations: 50,
+            maxIterations: 0, // 0 = no limit, run until done
         },
         reviewer: {
             name: 'Reviewer',
             description: 'Code review and quality assurance specialist',
-            systemPrompt: `You are an expert code reviewer. You analyze code for bugs, security vulnerabilities, performance issues, and adherence to best practices. You provide specific, actionable feedback with line references. You categorize issues by severity (critical, warning, suggestion). You also check for test coverage and documentation.`,
+            systemPrompt: `You are an expert code reviewer. You analyze code for bugs, security vulnerabilities, performance issues, and adherence to best practices. You provide specific, actionable feedback with line references. You categorize issues by severity (critical, warning, suggestion). You also check for test coverage and documentation. Keep reviewing until you have checked ALL relevant files.`,
             model: 'nvidia/nemotron-3-super-120b-a12b:free',
             temperature: 0.3,
             maxTokens: 8192,
             tools: ['read_file', 'search_files', 'list_directory'],
-            maxIterations: 15,
+            maxIterations: 0,
         },
         researcher: {
             name: 'Researcher',
             description: 'Information gathering and analysis specialist',
-            systemPrompt: `You are an expert researcher and analyst. You gather information from files, web resources, and codebases. You synthesize findings into clear, structured reports. You can explain complex technical concepts and find relevant examples or documentation.`,
+            systemPrompt: `You are an expert researcher and analyst. You gather information from files, web resources, and codebases. You synthesize findings into clear, structured reports. You can explain complex technical concepts and find relevant examples or documentation. Keep researching until you have a COMPLETE picture.`,
             model: 'google/gemma-4-31b-it:free',
             temperature: 0.5,
             maxTokens: 8192,
             tools: ['read_file', 'search_files', 'list_directory', 'web_search', 'web_fetch'],
-            maxIterations: 20,
+            maxIterations: 0,
         },
         tester: {
             name: 'Tester',
             description: 'Test generation and execution specialist',
-            systemPrompt: `You are an expert QA engineer. You write comprehensive test suites covering unit tests, integration tests, and edge cases. You run tests and analyze failures to identify root causes. You ensure code meets quality standards before it's considered complete.`,
+            systemPrompt: `You are an expert QA engineer. You write comprehensive test suites covering unit tests, integration tests, and edge cases. You run tests and analyze failures to identify root causes. You ensure code meets quality standards before it's considered complete. Keep testing until ALL tests pass.`,
             model: 'qwen/qwen3-coder:free',
             temperature: 0.3,
             maxTokens: 8192,
             tools: ['read_file', 'write_file', 'search_files', 'run_command', 'list_directory'],
-            maxIterations: 25,
+            maxIterations: 0,
         },
         debugger: {
             name: 'Debugger',
             description: 'Bug investigation and fixing specialist',
-            systemPrompt: `You are an expert debugger. You systematically investigate bugs by reading code, running diagnostic commands, analyzing error messages and stack traces. You identify root causes and implement targeted fixes. You verify fixes work before reporting completion.`,
+            systemPrompt: `You are an expert debugger. You systematically investigate bugs by reading code, running diagnostic commands, analyzing error messages and stack traces. You identify root causes and implement targeted fixes. You verify fixes work before reporting completion. Keep debugging until the bug is COMPLETELY fixed and verified.`,
             model: 'qwen/qwen3-coder:free',
             temperature: 0.2,
             maxTokens: 8192,
             tools: ['read_file', 'edit_file', 'search_files', 'run_command', 'list_directory', 'apply_diff'],
-            maxIterations: 20,
+            maxIterations: 0,
         },
         architect: {
             name: 'Architect',
             description: 'System design and architecture specialist',
-            systemPrompt: `You are an expert software architect. You design scalable, maintainable system architectures. You make technology stack decisions, define component boundaries, and establish coding standards. You create detailed technical specifications that other agents can implement.`,
+            systemPrompt: `You are an expert software architect. You design scalable, maintainable system architectures. You make technology stack decisions, define component boundaries, and establish coding standards. You create detailed technical specifications that other agents can implement. Keep designing until the architecture is COMPLETE and all components are specified.`,
             model: 'nvidia/nemotron-3-ultra-550b-a55b:free',
             temperature: 0.7,
             maxTokens: 8192,
             tools: ['read_file', 'search_files', 'list_directory'],
-            maxIterations: 15,
+            maxIterations: 0,
         },
         devops: {
             name: 'DevOps',
             description: 'Deployment and infrastructure specialist',
-            systemPrompt: `You are an expert DevOps engineer. You handle CI/CD pipelines, Docker configurations, cloud deployments, and infrastructure as code. You optimize build processes and ensure reliable deployments.`,
+            systemPrompt: `You are an expert DevOps engineer. You handle CI/CD pipelines, Docker configurations, cloud deployments, and infrastructure as code. You optimize build processes and ensure reliable deployments. Keep working until the deployment is FULLY configured and verified.`,
             model: 'cohere/north-mini-code:free',
             temperature: 0.3,
             maxTokens: 8192,
             tools: ['read_file', 'write_file', 'edit_file', 'run_command', 'search_files', 'list_directory'],
-            maxIterations: 25,
+            maxIterations: 0,
         },
     },
     tools: {
@@ -208,7 +208,7 @@ export const DEFAULT_CONFIG = {
     autoMode: {
         enabled: false,
         safetyLevel: 'conservative',
-        maxIterations: 50,
+        maxIterations: 0, // 0 = no limit, run until done (Claude Code style)
         maxCost: 0,
         maxTimeMs: 0,
         blockedCommands: ['rm -rf /', 'mkfs', 'dd if=/dev/zero'],

package/dist/core/engine.d.ts

@@ -57,6 +57,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 declare class NeuroEngine {
     config: NeuroConfig;
     client: OpenRouterClient;
@@ -117,6 +118,7 @@ export declare class NeuroEngine {
     multiSession: MultiSessionManager;
     gitWorktree: GitWorktreeManager;
     updater: AutoUpdater;
+    rateLimiter: RateLimitManager;
     private autoApproveSet;
     private requireApprovalSet;
     constructor(config: NeuroConfig);
@@ -137,7 +139,9 @@ export declare class NeuroEngine {
      */
     private initializeAgents;
     /**
-     * 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.
      */
     processMessage(message: string, mode?: 'auto' | 'agent' | 'direct', targetAgent?: string): Promise<{
         content: string;
@@ -153,8 +157,9 @@ export declare class NeuroEngine {
      */
     private handleApproval;
     /**
-     * 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
      */
     private assessComplexity;
     /**