@neetru/cli 2.11.4 → 2.12.1

package/dist/lib/ai/orchestrator.js

@@ -4,62 +4,153 @@ import { config } from '../config.js';
 import { NEETRU_SYSTEM_CONTEXT, loadProjectContext } from './context.js';
 import { discoveredKeys } from './auth-discovery.js';
 import { log } from '../../utils/logger.js';
+// ── Endpoints + modelos default dos providers OpenAI-compatible ──────────────
+// Groq e NVIDIA NIM expõem APIs OpenAI-compatible → reusamos o SDK `openai`
+// só trocando `baseURL`. Modelos são overridáveis via `neetru config set
+// groqModel|nvidiaModel <id>` (defaults aqui).
+const GROQ_BASE_URL = 'https://api.groq.com/openai/v1';
+const NVIDIA_BASE_URL = 'https://integrate.api.nvidia.com/v1';
+const GROQ_DEFAULT_MODEL = 'llama-3.3-70b-versatile';
+const NVIDIA_DEFAULT_MODEL = 'meta/llama-3.3-70b-instruct';
+// ── Modelos default (2026-06-08) ─────────────────────────────────────────────
+// OpenAI: gpt-4.1 (lançado 2025-04; mantém razão custo/capacidade melhor que
+//   gpt-4o para tasks de código e análise; overridável via `neetru config set
+//   openaiModel <id>`).
+// Gemini: gemini-2.5-flash (lançado 2025-05; substitui 1.5-flash com thinking
+//   mode e contexto 1M; overridável via `neetru config set geminiModel <id>`).
+// Claude: claude-sonnet-4-6 (já era; mantido).
+const OPENAI_DEFAULT_MODEL = 'gpt-4.1';
+const GEMINI_DEFAULT_MODEL = 'gemini-2.5-flash';
+const CLAUDE_DEFAULT_MODEL = 'claude-sonnet-4-6';
+// ── Timeout de stream (ms) ───────────────────────────────────────────────────
+// Tempo máximo pra receber o 1º byte (ou completar) um stream de qualquer
+// provider. Configurável via env NEETRU_STREAM_TIMEOUT_MS (ex: 120000 pra 2min).
+// Default: 60 000ms (1 min) — saudável pra modelos com CoT que demoram mais.
+const STREAM_TIMEOUT_MS = Number(process.env['NEETRU_STREAM_TIMEOUT_MS'] ?? 60_000);
+/** Acumulador de budget em memória (por processo). */
+const _budget = {
+    totalInputTokens: 0,
+    totalOutputTokens: 0,
+    calls: 0,
+};
+function recordUsage(usage) {
+    if (!usage)
+        return;
+    _budget.totalInputTokens += usage.inputTokens;
+    _budget.totalOutputTokens += usage.outputTokens;
+    _budget.calls += 1;
+    log.dim(`tokens: +${usage.inputTokens}in +${usage.outputTokens}out` +
+        ` (sessão: ${_budget.totalInputTokens}in ${_budget.totalOutputTokens}out, ${_budget.calls} chamadas)`);
+}
+/** Retorna snapshot do budget acumulado na sessão. Útil pra testes e relatórios. */
+export function getSessionBudget() {
+    return { ..._budget };
+}
+/** Reseta o budget (útil em testes). */
+export function resetSessionBudget() {
+    _budget.totalInputTokens = 0;
+    _budget.totalOutputTokens = 0;
+    _budget.calls = 0;
+}
+/** Mapeia provider → chave no config local do Neetru. */
+function configKeyFor(provider) {
+    switch (provider) {
+        case 'anthropic':
+            return 'anthropicApiKey';
+        case 'openai':
+            return 'openaiApiKey';
+        case 'gemini':
+            return 'geminiApiKey';
+        case 'groq':
+            return 'groqApiKey';
+        case 'nvidia':
+            return 'nvidiaApiKey';
+    }
+}
 /**
- * Resolve a apiKey efetiva pra um provider. Prioridade:
- *   1. Config local do Neetru (set via `neetru config set`).
- *   2. Cred descoberta de Claude Code / Codex / Gemini CLIs concorrentes
- *      (auth-discovery).
- *
- * Não faz lookup repetido — caller pode chamar várias vezes sem custo
- * (discovery é cacheada via module-level evaluation no detect call mas
- * aqui rechamamos pra refletir mudanças em runtime).
+ * Parseia um valor de chave que PODE conter várias chaves separadas por
+ * vírgula (pool de rate-limit). Ex: "key1, key2,key3" → ['key1','key2','key3'].
+ * Trim + filtra vazios. String única vira pool de 1.
  */
-function resolveKey(provider) {
-    const configKey = provider === 'anthropic'
-        ? 'anthropicApiKey'
-        : provider === 'openai'
-            ? 'openaiApiKey'
-            : 'geminiApiKey';
-    const localKey = config.get(configKey);
+export function parseKeyPool(raw) {
+    if (!raw)
+        return [];
+    return raw
+        .split(',')
+        .map((s) => s.trim())
+        .filter(Boolean);
+}
+/**
+ * Resolve o POOL de chaves efetivo pra um provider. Prioridade:
+ *   1. Config local do Neetru (`neetru config set <provider>ApiKey`).
+ *   2. Cred descoberta (auth-discovery: CLIs concorrentes OU env var).
+ * O valor pode ser comma-separated → vira pool de N chaves.
+ */
+function resolveKeyPool(provider) {
+    const localKey = config.get(configKeyFor(provider));
     if (localKey)
-        return localKey;
-    return discoveredKeys()[provider];
+        return parseKeyPool(localKey);
+    return parseKeyPool(discoveredKeys()[provider]);
+}
+/**
+ * Resolve a apiKey efetiva (a 1ª do pool) pra um provider — usado pelos
+ * checks de disponibilidade. Stream functions usam o pool inteiro.
+ */
+function resolveKey(provider) {
+    return resolveKeyPool(provider)[0];
+}
+// ── Rotação de pool (round-robin entre chamadas) ─────────────────────────────
+// Cursor por-provider em memória: cada chamada começa numa chave diferente,
+// espalhando carga entre as chaves do pool. Em 401/403/429 numa chave, o
+// streamer cai pra próxima do pool dentro da MESMA chamada (fallthrough).
+const _poolCursor = {};
+function nextPoolStart(provider, len) {
+    if (len <= 1)
+        return 0;
+    const cur = _poolCursor[provider] ?? 0;
+    _poolCursor[provider] = (cur + 1) % len;
+    return cur;
 }
 /**
  * Escolhe o modelo mais adequado para um dado tipo de tarefa.
  *
  * Heurísticas (em ordem):
  *   1. Se user forçou um modelo (!= auto), respeita — desde que tenha cred.
- *   2. Code generation pesado → OpenAI (gpt-4o codex-trained) se tiver.
- *   3. Análise/arquitetura/raciocínio longo → Claude (sonnet 4.6).
- *   4. Sumarização rápida / Q&A factual → Gemini (mais barato) se tiver.
- *   5. Fallback: o primeiro provider com cred (claude > openai > gemini).
+ *   2. Code generation pesado → OpenAI (gpt-4.1); senão NVIDIA NIM (llama-70b).
+ *   3. Sumarização rápida / Q&A factual → Groq (mais rápido); senão Gemini.
+ *   4. Default: Claude (arquitetura, análise, raciocínio longo).
+ *   5. Fallback: primeiro provider com cred (claude > openai > gemini > groq > nvidia).
  */
 export function routeModel(input, preferred) {
-    // Provedores efetivamente disponíveis (config OU discovery).
     const available = {
         claude: !!resolveKey('anthropic'),
         openai: !!resolveKey('openai'),
         gemini: !!resolveKey('gemini'),
+        groq: !!resolveKey('groq'),
+        nvidia: !!resolveKey('nvidia'),
     };
     if (preferred !== 'auto') {
-        if (preferred === 'claude' && available.claude)
-            return 'claude';
-        if (preferred === 'openai' && available.openai)
-            return 'openai';
-        if (preferred === 'gemini' && available.gemini)
-            return 'gemini';
+        if (available[preferred])
+            return preferred;
         // Pediu mas não tem cred — cai pra auto.
     }
     const lower = input.toLowerCase();
-    // Code generation pesado → OpenAI
+    // Code generation pesado → OpenAI; fallback NVIDIA NIM (llama grande, free).
     const isCodeGen = /\b(crie|gere|escreva|implemente|escreve|gera|cria)\s+(um|uma|o|a|essa|esse|esta|este)?\s*(componente|função|funcao|classe|módulo|modulo|arquivo|test|teste|endpoint|rota|hook|serviço|servico|api)\b/i.test(lower) || /^```|^class\s|^function\s|^const\s+\w+\s*=\s*\(/m.test(input);
-    if (isCodeGen && available.openai)
-        return 'openai';
-    // Sumarização rápida / Q&A factual → Gemini
+    if (isCodeGen) {
+        if (available.openai)
+            return 'openai';
+        if (available.nvidia)
+            return 'nvidia';
+    }
+    // Sumarização rápida / Q&A factual → Groq (latência mais baixa); senão Gemini.
     const isQuickQa = /\b(o que é|o que e|defina|defina o|defina a|resuma|resume|sumariza|sumarize|que faz|para que serve)\b/i.test(lower) && input.length < 240;
-    if (isQuickQa && available.gemini)
-        return 'gemini';
+    if (isQuickQa) {
+        if (available.groq)
+            return 'groq';
+        if (available.gemini)
+            return 'gemini';
+    }
     // Default: Claude (arquitetura, análise, raciocínio).
     if (available.claude)
         return 'claude';
@@ -67,139 +158,350 @@ export function routeModel(input, preferred) {
         return 'openai';
     if (available.gemini)
         return 'gemini';
+    if (available.groq)
+        return 'groq';
+    if (available.nvidia)
+        return 'nvidia';
     // Sem creds em lugar nenhum — joga erro descritivo. Caller pode oferecer
     // `neetru auth setup` antes de tentar.
     throw new Error('Nenhum provedor de IA configurado. Rode: neetru auth setup');
 }
+/**
+ * Streamer Claude/Anthropic com pool de chaves, timeout e usage tracking.
+ * Faz rotação round-robin igual ao streamOpenAICompatible: começa numa chave
+ * do pool e, em 401/403/429, cai pra próxima (fallthrough). Timeout via
+ * AbortController (STREAM_TIMEOUT_MS). Usage capturado do evento final_message.
+ */
 async function streamClaude(messages, systemExtra, onChunk) {
-    const apiKey = resolveKey('anthropic');
-    if (!apiKey) {
+    const keys = resolveKeyPool('anthropic');
+    if (keys.length === 0) {
         throw new Error('Cred Claude/Anthropic ausente. Rode `neetru auth setup` ou `neetru config set anthropicApiKey <sk-ant-...>`');
     }
-    const client = new Anthropic({ apiKey });
     const system = [NEETRU_SYSTEM_CONTEXT, systemExtra].filter(Boolean).join('\n\n');
-    let full = '';
-    const stream = await client.messages.stream({
-        model: 'claude-sonnet-4-6',
-        max_tokens: 8096,
-        system,
-        messages: messages.map((m) => ({ role: m.role, content: m.content })),
-    });
-    for await (const chunk of stream) {
-        if (chunk.type === 'content_block_delta' &&
-            chunk.delta.type === 'text_delta') {
-            onChunk(chunk.delta.text);
-            full += chunk.delta.text;
+    const model = config.get('claudeModel') ?? CLAUDE_DEFAULT_MODEL;
+    const start = nextPoolStart('anthropic', keys.length);
+    let lastErr;
+    for (let i = 0; i < keys.length; i++) {
+        const apiKey = keys[(start + i) % keys.length];
+        const ctrl = new AbortController();
+        const timer = setTimeout(() => ctrl.abort(new Error(`Claude stream timeout (${STREAM_TIMEOUT_MS}ms)`)), STREAM_TIMEOUT_MS);
+        try {
+            const client = new Anthropic({ apiKey });
+            let full = '';
+            let usage;
+            const stream = await client.messages.stream({
+                model,
+                max_tokens: 8096,
+                system,
+                messages: messages.map((m) => ({ role: m.role, content: m.content })),
+            }, { signal: ctrl.signal });
+            for await (const chunk of stream) {
+                if (chunk.type === 'content_block_delta' && chunk.delta.type === 'text_delta') {
+                    onChunk(chunk.delta.text);
+                    full += chunk.delta.text;
+                }
+                if (chunk.type === 'message_delta' && chunk.usage) {
+                    // usage aparece no evento message_delta do streaming
+                    const u = chunk.usage;
+                    usage = {
+                        inputTokens: u.input_tokens ?? 0,
+                        outputTokens: u.output_tokens ?? 0,
+                        totalTokens: (u.input_tokens ?? 0) + (u.output_tokens ?? 0),
+                    };
+                }
+            }
+            // Captura usage do objeto final da stream se não veio via eventos.
+            if (!usage) {
+                const finalMsg = await stream.finalMessage().catch(() => null);
+                if (finalMsg?.usage) {
+                    usage = {
+                        inputTokens: finalMsg.usage.input_tokens ?? 0,
+                        outputTokens: finalMsg.usage.output_tokens ?? 0,
+                        totalTokens: (finalMsg.usage.input_tokens ?? 0) + (finalMsg.usage.output_tokens ?? 0),
+                    };
+                }
+            }
+            recordUsage(usage);
+            return full;
+        }
+        catch (err) {
+            lastErr = err;
+            // Timeout → propaga direto (não adianta tentar outra chave).
+            if (ctrl.signal.aborted)
+                throw err;
+            const status = err?.status ?? err?.response?.status;
+            if (status === 401 || status === 403 || status === 429)
+                continue;
+            throw err;
+        }
+        finally {
+            clearTimeout(timer);
         }
     }
-    return full;
+    const detail = lastErr?.message ?? String(lastErr);
+    throw new Error(`Claude: todas as ${keys.length} chave(s) do pool falharam (auth/rate-limit). Último erro: ${detail}`);
 }
-async function streamOpenAI(messages, systemExtra, onChunk) {
-    const apiKey = resolveKey('openai');
-    if (!apiKey) {
-        throw new Error('Cred OpenAI ausente. Rode `neetru auth setup` ou `neetru config set openaiApiKey <sk-...>`');
+/**
+ * Streamer genérico pra qualquer endpoint OpenAI-compatible (OpenAI, Groq,
+ * NVIDIA NIM). Faz rotação de pool: começa numa chave round-robin e, em
+ * 401/403/429 ANTES do 1º chunk, cai pra próxima chave do pool (fallthrough).
+ * Erros não-auth/rate-limit propagam direto.
+ *
+ * Melhorias 2026-06-08:
+ *  - AbortController com STREAM_TIMEOUT_MS (default 60s).
+ *  - max_tokens passado em todas as chamadas (default 8096).
+ *  - Usage capturado de stream final chunk (stream: true + usage field).
+ */
+async function streamOpenAICompatible(opts) {
+    const { provider, label, baseURL, model, keys, messages, systemExtra, onChunk, maxTokens = 8096 } = opts;
+    if (keys.length === 0) {
+        throw new Error(`Cred ${label} ausente. Rode \`neetru config set ${configKeyFor(provider)} <chave>\``);
     }
-    const client = new OpenAI({ apiKey });
     const systemContent = [NEETRU_SYSTEM_CONTEXT, systemExtra].filter(Boolean).join('\n\n');
-    let full = '';
-    const stream = await client.chat.completions.create({
-        model: 'gpt-4o',
-        stream: true,
-        messages: [
-            { role: 'system', content: systemContent },
-            ...messages.map((m) => ({ role: m.role, content: m.content })),
-        ],
-    });
-    for await (const chunk of stream) {
-        const text = chunk.choices[0]?.delta?.content ?? '';
-        if (text) {
-            onChunk(text);
-            full += text;
+    const start = nextPoolStart(provider, keys.length);
+    let lastErr;
+    for (let i = 0; i < keys.length; i++) {
+        const apiKey = keys[(start + i) % keys.length];
+        const ctrl = new AbortController();
+        const timer = setTimeout(() => ctrl.abort(new Error(`${label} stream timeout (${STREAM_TIMEOUT_MS}ms)`)), STREAM_TIMEOUT_MS);
+        const client = new OpenAI({ apiKey, ...(baseURL ? { baseURL } : {}) });
+        try {
+            let full = '';
+            let usage;
+            // stream_options.include_usage retorna usage no último chunk (OpenAI compat).
+            const stream = await client.chat.completions.create({
+                model,
+                stream: true,
+                stream_options: { include_usage: true },
+                max_tokens: maxTokens,
+                messages: [
+                    { role: 'system', content: systemContent },
+                    ...messages.map((m) => ({ role: m.role, content: m.content })),
+                ],
+            }, { signal: ctrl.signal });
+            for await (const chunk of stream) {
+                const text = chunk.choices[0]?.delta?.content ?? '';
+                if (text) {
+                    onChunk(text);
+                    full += text;
+                }
+                // O último chunk de stream (com choices[0].finish_reason) traz usage
+                // quando stream_options.include_usage=true.
+                if (chunk.usage) {
+                    usage = {
+                        inputTokens: chunk.usage.prompt_tokens ?? 0,
+                        outputTokens: chunk.usage.completion_tokens ?? 0,
+                        totalTokens: chunk.usage.total_tokens ?? 0,
+                    };
+                }
+            }
+            recordUsage(usage);
+            return full;
+        }
+        catch (err) {
+            lastErr = err;
+            // Timeout → propaga direto (não adianta tentar outra chave).
+            if (ctrl.signal.aborted)
+                throw err;
+            const status = err?.status ?? err?.response?.status;
+            // Só rotaciona em auth/rate-limit. Outros erros (modelo inválido, rede,
+            // payload) propagam direto — rotacionar não ajudaria.
+            if (status === 401 || status === 403 || status === 429)
+                continue;
+            throw err;
+        }
+        finally {
+            clearTimeout(timer);
         }
     }
-    return full;
+    const detail = lastErr?.message ?? String(lastErr);
+    throw new Error(`${label}: todas as ${keys.length} chave(s) do pool falharam (auth/rate-limit). Último erro: ${detail}`);
+}
+function streamOpenAI(messages, systemExtra, onChunk) {
+    // Modelo default: gpt-4.1 (lançado 2025-04; melhor custo/capacidade que gpt-4o).
+    // Override: neetru config set openaiModel <id>
+    return streamOpenAICompatible({
+        provider: 'openai',
+        label: 'OpenAI',
+        model: config.get('openaiModel') ?? OPENAI_DEFAULT_MODEL,
+        keys: resolveKeyPool('openai'),
+        messages,
+        systemExtra,
+        onChunk,
+    });
+}
+function streamGroq(messages, systemExtra, onChunk) {
+    return streamOpenAICompatible({
+        provider: 'groq',
+        label: 'Groq',
+        baseURL: GROQ_BASE_URL,
+        model: config.get('groqModel') ?? GROQ_DEFAULT_MODEL,
+        keys: resolveKeyPool('groq'),
+        messages,
+        systemExtra,
+        onChunk,
+    });
+}
+function streamNvidia(messages, systemExtra, onChunk) {
+    return streamOpenAICompatible({
+        provider: 'nvidia',
+        label: 'NVIDIA NIM',
+        baseURL: NVIDIA_BASE_URL,
+        model: config.get('nvidiaModel') ?? NVIDIA_DEFAULT_MODEL,
+        keys: resolveKeyPool('nvidia'),
+        messages,
+        systemExtra,
+        onChunk,
+    });
 }
 /**
- * Stream via Gemini. Usa a REST API REST `streamGenerateContent` direto
- * (sem dependência extra). Modelo: gemini-1.5-flash (rápido + barato).
+ * Stream via Gemini REST API `streamGenerateContent`.
  *
- * Cleanup: reader.cancel() + AbortController em finally — sem isso o body
- * fica dangling em erros/cancellation (Codex MEDIUM 2026-05-16).
+ * Melhorias 2026-06-08:
+ *  - Pool de chaves (comma-separated em geminiApiKey): rotação round-robin +
+ *    fallthrough em 401/403/429 (igual ao OpenAI-compatible).
+ *  - Modelo default atualizado: gemini-2.5-flash (substitui gemini-1.5-flash).
+ *    Override: neetru config set geminiModel <id>
+ *  - Timeout via AbortController (STREAM_TIMEOUT_MS).
+ *  - Usage tracking: captura usageMetadata do último objeto SSE.
+ *  - Linka signal externo (parâmetro) com o AbortController interno.
+ *  - Cleanup: reader.cancel() em finally.
  */
 async function streamGemini(messages, systemExtra, onChunk, signal) {
-    const apiKey = resolveKey('gemini');
-    if (!apiKey) {
+    const keys = resolveKeyPool('gemini');
+    if (keys.length === 0) {
         throw new Error('Cred Gemini ausente. Rode `neetru auth setup` ou `neetru config set geminiApiKey <key>`');
     }
     const systemContent = [NEETRU_SYSTEM_CONTEXT, systemExtra].filter(Boolean).join('\n\n');
+    const model = config.get('geminiModel') ?? GEMINI_DEFAULT_MODEL;
     // Gemini API expects user/model roles (não assistant). Converte.
     const contents = messages.map((m) => ({
         role: m.role === 'assistant' ? 'model' : 'user',
         parts: [{ text: m.content }],
     }));
-    const url = `https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-flash:streamGenerateContent?alt=sse&key=${encodeURIComponent(apiKey)}`;
-    const ctrl = new AbortController();
-    // Encadeia signal externo (se fornecido) com o local.
-    if (signal) {
-        if (signal.aborted)
-            ctrl.abort();
-        else
-            signal.addEventListener('abort', () => ctrl.abort(), { once: true });
-    }
-    const resp = await fetch(url, {
-        method: 'POST',
-        headers: { 'content-type': 'application/json' },
-        body: JSON.stringify({
-            systemInstruction: { parts: [{ text: systemContent }] },
-            contents,
-        }),
-        signal: ctrl.signal,
-    });
-    if (!resp.ok || !resp.body) {
-        const txt = await resp.text().catch(() => '');
-        throw new Error(`Gemini API erro ${resp.status}: ${txt.slice(0, 200)}`);
-    }
-    const reader = resp.body.getReader();
-    const dec = new TextDecoder();
-    let buf = '';
-    let full = '';
-    try {
-        while (true) {
-            const { value, done } = await reader.read();
-            if (done)
-                break;
-            buf += dec.decode(value, { stream: true });
-            // SSE: linhas começando com "data: "
-            const lines = buf.split('\n');
-            buf = lines.pop() ?? '';
-            for (const line of lines) {
-                const m = line.match(/^data:\s*(.*)$/);
-                if (!m)
+    const start = nextPoolStart('gemini', keys.length);
+    let lastErr;
+    for (let i = 0; i < keys.length; i++) {
+        const apiKey = keys[(start + i) % keys.length];
+        const ctrl = new AbortController();
+        const timer = setTimeout(() => ctrl.abort(new Error(`Gemini stream timeout (${STREAM_TIMEOUT_MS}ms)`)), STREAM_TIMEOUT_MS);
+        // Encadeia signal externo com o local.
+        if (signal) {
+            if (signal.aborted)
+                ctrl.abort();
+            else
+                signal.addEventListener('abort', () => ctrl.abort(), { once: true });
+        }
+        const url = `https://generativelanguage.googleapis.com/v1beta/models/${encodeURIComponent(model)}:streamGenerateContent?alt=sse&key=${encodeURIComponent(apiKey)}`;
+        try {
+            const resp = await fetch(url, {
+                method: 'POST',
+                headers: { 'content-type': 'application/json' },
+                body: JSON.stringify({
+                    systemInstruction: { parts: [{ text: systemContent }] },
+                    contents,
+                    generationConfig: { maxOutputTokens: 8192 },
+                }),
+                signal: ctrl.signal,
+            });
+            // Erros de auth/rate-limit → rotaciona chave.
+            if (!resp.ok) {
+                if (resp.status === 401 || resp.status === 403 || resp.status === 429) {
+                    lastErr = new Error(`Gemini API erro ${resp.status}`);
                     continue;
-                try {
-                    const obj = JSON.parse(m[1]);
-                    const txt = obj?.candidates?.[0]?.content?.parts?.[0]?.text;
-                    if (typeof txt === 'string' && txt) {
-                        onChunk(txt);
-                        full += txt;
+                }
+                const txt = await resp.text().catch(() => '');
+                throw new Error(`Gemini API erro ${resp.status}: ${txt.slice(0, 200)}`);
+            }
+            if (!resp.body)
+                throw new Error('Gemini: resposta sem body');
+            const reader = resp.body.getReader();
+            const dec = new TextDecoder();
+            let buf = '';
+            let full = '';
+            let usage;
+            try {
+                while (true) {
+                    const { value, done } = await reader.read();
+                    if (done)
+                        break;
+                    buf += dec.decode(value, { stream: true });
+                    // SSE: linhas começando com "data: "
+                    const lines = buf.split('\n');
+                    buf = lines.pop() ?? '';
+                    for (const line of lines) {
+                        const matchData = line.match(/^data:\s*(.*)$/);
+                        if (!matchData)
+                            continue;
+                        try {
+                            const obj = JSON.parse(matchData[1]);
+                            const txt = obj?.candidates?.[0]?.content?.parts?.[0]?.text;
+                            if (typeof txt === 'string' && txt) {
+                                onChunk(txt);
+                                full += txt;
+                            }
+                            // usageMetadata aparece no último objeto da stream.
+                            if (obj?.usageMetadata) {
+                                const u = obj.usageMetadata;
+                                usage = {
+                                    inputTokens: u.promptTokenCount ?? 0,
+                                    outputTokens: u.candidatesTokenCount ?? 0,
+                                    totalTokens: u.totalTokenCount ?? 0,
+                                };
+                            }
+                        }
+                        catch {
+                            // ignora linha de keep-alive
+                        }
                     }
                 }
+            }
+            finally {
+                // Libera o reader; idempotente — safe em erro, completion ou abort.
+                try {
+                    await reader.cancel();
+                }
                 catch {
-                    // ignora linha de keep-alive
+                    // reader já fechado, ignora.
                 }
+                clearTimeout(timer);
             }
+            recordUsage(usage);
+            return full;
         }
-    }
-    finally {
-        // Libera o reader; idempotente — safe em erro, completion ou abort.
-        try {
-            await reader.cancel();
-        }
-        catch {
-            // reader já fechado, ignora.
+        catch (err) {
+            clearTimeout(timer);
+            lastErr = err;
+            // Timeout → propaga direto (não adianta tentar outra chave).
+            if (ctrl.signal.aborted)
+                throw err;
+            // Auth/rate-limit → rotaciona pra próxima chave do pool
+            // (espelhando o comportamento de streamOpenAICompatible).
+            const status = err?.status ?? err?.response?.status;
+            if (status === 401 || status === 403 || status === 429)
+                continue;
+            // Outros erros (rede, modelo inválido, payload) propagam direto.
+            throw err;
         }
     }
-    return full;
+    const detail = lastErr?.message ?? String(lastErr);
+    throw new Error(`Gemini: todas as ${keys.length} chave(s) do pool falharam (auth/rate-limit). Último erro: ${detail}`);
+}
+/** Dispatcher de stream por modelo resolvido. */
+function streamFor(model, messages, systemExtra, onChunk) {
+    switch (model) {
+        case 'openai':
+            return streamOpenAI(messages, systemExtra, onChunk);
+        case 'gemini':
+            return streamGemini(messages, systemExtra, onChunk);
+        case 'groq':
+            return streamGroq(messages, systemExtra, onChunk);
+        case 'nvidia':
+            return streamNvidia(messages, systemExtra, onChunk);
+        case 'claude':
+        default:
+            return streamClaude(messages, systemExtra, onChunk);
+    }
 }
 /**
  * Orquestrador principal: decide o modelo, injeta contexto Neetru,
@@ -210,11 +512,7 @@ export async function chat(messages, onChunk, preferred) {
     const model = routeModel(lastUserMsg, preferred ?? config.get('defaultModel') ?? 'auto');
     const projectCtx = await loadProjectContext();
     log.dim(`modelo: ${model}`);
-    if (model === 'openai')
-        return streamOpenAI(messages, projectCtx, onChunk);
-    if (model === 'gemini')
-        return streamGemini(messages, projectCtx, onChunk);
-    return streamClaude(messages, projectCtx, onChunk);
+    return streamFor(model, messages, projectCtx, onChunk);
 }
 /**
  * Spawn N agents concorrentes pra mesma pergunta. Útil pra "team mode":
@@ -223,28 +521,32 @@ export async function chat(messages, onChunk, preferred) {
  *
  * Limite: spawn só até a quantidade de providers com cred. Se pedir 5 mas
  * só tem 2 providers configurados, roda 2.
+ *
+ * Budget cap (2026-06-08): `maxProviders` limita o número de providers
+ * usados em paralelo (default: todos os disponíveis). Útil pra não queimar
+ * N tokens quando só 2-3 providers são necessários.
  */
-export async function chatParallel(prompt, systemExtra) {
-    const targets = [];
-    if (resolveKey('anthropic'))
-        targets.push('claude');
-    if (resolveKey('openai'))
-        targets.push('openai');
-    if (resolveKey('gemini'))
-        targets.push('gemini');
+export async function chatParallel(prompt, systemExtra, opts) {
+    const providerOf = {
+        claude: 'anthropic',
+        openai: 'openai',
+        gemini: 'gemini',
+        groq: 'groq',
+        nvidia: 'nvidia',
+    };
+    const order = ['claude', 'openai', 'gemini', 'groq', 'nvidia'];
+    let targets = order.filter((m) => !!resolveKey(providerOf[m]));
     if (targets.length === 0) {
         throw new Error('Nenhum provedor configurado. Rode: neetru auth setup');
     }
+    // Aplica cap de providers (budget).
+    if (opts?.maxProviders != null && opts.maxProviders > 0) {
+        targets = targets.slice(0, opts.maxProviders);
+    }
     const messages = [{ role: 'user', content: prompt }];
     const noop = () => { };
     const results = await Promise.allSettled(targets.map(async (m) => {
-        let response = '';
-        if (m === 'claude')
-            response = await streamClaude(messages, systemExtra, noop);
-        else if (m === 'openai')
-            response = await streamOpenAI(messages, systemExtra, noop);
-        else
-            response = await streamGemini(messages, systemExtra, noop);
+        const response = await streamFor(m, messages, systemExtra, noop);
         return { model: m, response };
     }));
     return results.map((r, i) => r.status === 'fulfilled'