@neetru/cli 2.32.1 → 2.34.0

package/dist/lib/ai/orchestrator.js

@@ -1,4 +1,3 @@
-import Anthropic from '@anthropic-ai/sdk';
 import OpenAI from 'openai';
 import { config } from '../config.js';
 import { NEETRU_SYSTEM_CONTEXT, loadProjectContext } from './context.js';
@@ -7,6 +6,7 @@ import { getActiveTokenSync } from '../token-resolver.js';
 import { maybeWarnUntrustedHost } from '../api-client.js';
 import { readSseLines } from '../sse.js';
 import { log } from '../../utils/logger.js';
+import { CHAVE_DO_PROVEDOR, MODELOS_DO_AI_NA_TELA, NOMES_DOS_PROVEDORES, PROVEDORES_IA, ehModeloDoAi, } from './provedores.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
@@ -19,12 +19,7 @@ const NVIDIA_DEFAULT_MODEL = 'meta/llama-3.3-70b-instruct';
 // 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';
 // ── AI Gateway do Core (2026-07) ─────────────────────────────────────────────
 // `neetru ai --debug:model gateway` — usa o token de sessão `nrt_...` gravado
 // por `neetru login` (RFC 8628 device code) em vez de uma chave BYOK própria.
@@ -66,18 +61,7 @@ export function resetSessionBudget() {
 }
 /** 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';
-    }
+    return CHAVE_DO_PROVEDOR[provider];
 }
 /**
  * Parseia um valor de chave que PODE conter várias chaves separadas por
@@ -128,134 +112,65 @@ function nextPoolStart(provider, len) {
  *
  * Heurísticas (em ordem):
  *   1. Se user forçou um modelo (!= auto), respeita — desde que tenha cred.
- *   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).
+ *   2. Code generation pesado → NVIDIA NIM (llama-70b, gratuito).
+ *   3. Sumarização rápida / Q&A factual → Groq (mais rápido).
+ *   4. Fallback: primeiro provider com cred, gratuitos primeiro
+ *      (groq > nvidia > openai).
+ *
+ * bug_19d312f3: o default era Claude (API da Anthropic) e o Q&A rápido caía no
+ * Gemini quando faltava o Groq. Os dois saíram da lista única (vetados).
+ * Revisão do #104: o `auto` preferia a OpenAI (paga) na geração de código e no
+ * fallback, à frente do Groq e da NVIDIA. Agora ela só entra no `auto` quando
+ * nenhum provedor gratuito tem chave; quem a quer antes pede com `-m openai`.
  */
 export function routeModel(input, preferred) {
     const available = {
-        claude: !!resolveKey('anthropic'),
-        openai: !!resolveKey('openai'),
-        gemini: !!resolveKey('gemini'),
-        groq: !!resolveKey('groq'),
-        nvidia: !!resolveKey('nvidia'),
         // Gateway não é BYOK — "disponível" = tem sessão de `neetru login` válida
         // (mesmo resolver usado por todo o resto do CLI), não uma chave de pool.
         gateway: !!getActiveTokenSync(),
     };
+    for (const p of PROVEDORES_IA)
+        available[p] = !!resolveKey(p);
     if (preferred !== 'auto') {
         if (available[preferred])
             return preferred;
         // Pediu mas não tem cred — cai pra auto.
     }
     const lower = input.toLowerCase();
-    // Code generation pesado → OpenAI; fallback NVIDIA NIM (llama grande, free).
+    // Code generation pesado → NVIDIA NIM (llama grande, gratuito). Sem ela, segue
+    // a ordem do fallback (gratuitos primeiro).
     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) {
-        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.
+    // Sumarização rápida / Q&A factual → Groq (latência mais baixa).
     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) {
         if (available.groq)
             return 'groq';
-        if (available.gemini)
-            return 'gemini';
     }
-    // Default: Claude (arquitetura, análise, raciocínio).
-    if (available.claude)
-        return 'claude';
-    if (available.openai)
-        return 'openai';
-    if (available.gemini)
-        return 'gemini';
+    // Gratuitos primeiro; a OpenAI (paga) só sem nenhum deles.
     if (available.groq)
         return 'groq';
     if (available.nvidia)
         return 'nvidia';
+    if (available.openai)
+        return 'openai';
+    // Sem chave de provedor nenhum. O `auto` não cai no AI Gateway por conta
+    // própria (gasta a cota do gateway), mas quem tem sessão do `neetru login`
+    // fica sabendo como pedi-lo — sem isto, cada pergunta só dizia "rode neetru
+    // auth setup" (revisão do #104).
+    if (available.gateway) {
+        throw new Error(`Nenhum provedor de IA configurado com chave (${NOMES_DOS_PROVEDORES}). ` +
+            'Para usar o AI Gateway da Neetru com a sua sessão do `neetru login`, abra com `neetru ai -m gateway` ' +
+            '(nesta sessão: /debug:model gateway) ou grave `neetru config set defaultModel gateway`. ' +
+            'Para usar uma chave sua: neetru auth setup');
+    }
     // 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 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 system = [NEETRU_SYSTEM_CONTEXT, systemExtra].filter(Boolean).join('\n\n');
-    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);
-        }
-    }
-    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}`);
-}
 /**
  * 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
@@ -369,117 +284,6 @@ function streamNvidia(messages, systemExtra, onChunk) {
         onChunk,
     });
 }
-/**
- * Stream via Gemini REST API `streamGenerateContent`.
- *
- * 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 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 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;
-                }
-                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');
-            let full = '';
-            let usage;
-            try {
-                await readSseLines(resp.body, (payload) => {
-                    try {
-                        const obj = JSON.parse(payload);
-                        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 {
-                clearTimeout(timer);
-            }
-            recordUsage(usage);
-            return full;
-        }
-        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;
-        }
-    }
-    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}`);
-}
 /**
  * Streamer do AI Gateway do Core (`POST /api/cli/v1/ai/chat`).
  *
@@ -494,8 +298,8 @@ async function streamGemini(messages, systemExtra, onChunk, signal) {
  * Resposta SSE OpenAI-compatible: `data: {"choices":[{"delta":{"content":"…"}}]}`
  * terminando em `data: [DONE]`. Usage (quando presente) vem em `chunk.usage`
  * (só quando o provider por trás do gateway suporta `stream_options.include_usage`
- * — ex: OpenAI/Groq/NVIDIA; modelos roteados pro provider Anthropic não expõem
- * usage por chunk). Se o stream nunca trouxer usage, `recordUsage` simplesmente
+ * — ex: OpenAI/Groq/NVIDIA; provider que não expõe usage por chunk não manda
+ * nada). Se o stream nunca trouxer usage, `recordUsage` simplesmente
  * não é chamado — não inventamos número.
  */
 async function streamGateway(messages, systemExtra, onChunk, signal) {
@@ -521,7 +325,7 @@ async function streamGateway(messages, systemExtra, onChunk, signal) {
     ];
     const ctrl = new AbortController();
     const timer = setTimeout(() => ctrl.abort(new Error(`Neetru AI Gateway stream timeout (${STREAM_TIMEOUT_MS}ms)`)), STREAM_TIMEOUT_MS);
-    // Encadeia signal externo com o local (mesmo padrão de streamGemini).
+    // Encadeia signal externo com o local.
     if (signal) {
         if (signal.aborted)
             ctrl.abort();
@@ -613,17 +417,12 @@ 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 'gateway':
             return streamGateway(messages, systemExtra, onChunk);
-        case 'claude':
-        default:
-            return streamClaude(messages, systemExtra, onChunk);
     }
 }
 /**
@@ -632,7 +431,16 @@ function streamFor(model, messages, systemExtra, onChunk) {
  */
 export async function chat(messages, onChunk, preferred) {
     const lastUserMsg = [...messages].reverse().find((m) => m.role === 'user')?.content ?? '';
-    const model = routeModel(lastUserMsg, preferred ?? config.get('defaultModel') ?? 'auto');
+    // bug_19d312f3: `defaultModel` pode trazer `claude` ou `gemini` gravado por
+    // uma versão antiga — o schema da config não os recusa na leitura para não
+    // derrubar todo comando. Aqui o valor desconhecido é recusado com o caminho
+    // de volta, em vez de cair calado no `auto`.
+    const pedido = preferred ?? config.get('defaultModel') ?? 'auto';
+    if (!ehModeloDoAi(pedido)) {
+        throw new Error(`O modelo "${String(pedido)}" não existe no neetru ai. Use: ${MODELOS_DO_AI_NA_TELA}. ` +
+            'Se ele veio da config, rode `neetru config set defaultModel auto`.');
+    }
+    const model = routeModel(lastUserMsg, pedido);
     const projectCtx = await loadProjectContext();
     log.dim(`modelo: ${model}`);
     return streamFor(model, messages, projectCtx, onChunk);
@@ -650,17 +458,9 @@ export async function chat(messages, onChunk, preferred) {
  * N tokens quando só 2-3 providers são necessários.
  */
 export async function chatParallel(prompt, systemExtra, opts) {
-    // `gateway` fica de fora do team mode: não é BYOK (sem `Provider`/pool de
-    // chaves equivalente) — por isso `Partial` em vez de `Record<ResolvedModel,…>`.
-    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]));
+    // `gateway` fica de fora do team mode: não é BYOK (sem pool de chaves). A
+    // ordem é a da lista única (`PROVEDORES_IA`).
+    let targets = PROVEDORES_IA.filter((p) => !!resolveKey(p));
     if (targets.length === 0) {
         throw new Error('Nenhum provedor configurado. Rode: neetru auth setup');
     }

package/dist/lib/ai/provedores.d.ts

@@ -0,0 +1,57 @@
+/**
+ * A lista ÚNICA de provedores de IA da CLI (bug_19d312f3).
+ *
+ * Antes havia duas listas que discordavam. O `neetru ai` e o `neetru auth`
+ * trabalhavam com anthropic, openai, gemini, groq e nvidia; o `neetru code`,
+ * o `neetru ai models` e a config do AI Gateway, com groq, nvidia e openai. A
+ * primeira oferecia Anthropic e Gemini, que a casa não usa: IA só de provedor
+ * gratuito, e a API da Anthropic e o Gemini custam e estão vetados.
+ *
+ * Agora todo lugar que enumera provedor lê daqui: o assistente do
+ * `neetru auth setup`, a descoberta de chaves, o roteamento e o `/debug:model`
+ * do `neetru ai`, o `--provider` do `neetru code`, o catálogo do
+ * `neetru ai models`, as chaves aceitas pelo `neetru config set` e o schema da
+ * config. O teste `provedores-ia-lista-unica.test.ts` trava a lista e falha se
+ * outro arquivo de `src/` declarar uma lista própria.
+ *
+ * Este módulo não importa nada de propósito: o `index.ts` e o `neetru code` o
+ * leem sem carregar o SDK de nenhum provedor.
+ */
+/**
+ * Provedores com os quais a CLI fala. Groq e NVIDIA NIM primeiro (gratuitos).
+ * A OpenAI é paga: o `auto` do `neetru ai` só a escolhe quando nenhum gratuito
+ * tem chave (`routeModel` no orchestrator); fora isso, só com `-m openai`.
+ */
+export declare const PROVEDORES_IA: readonly ["groq", "nvidia", "openai"];
+export type ProvedorIa = (typeof PROVEDORES_IA)[number];
+/** Chave da config local que guarda a chave de API de cada provedor. */
+export declare const CHAVE_DO_PROVEDOR: {
+    readonly groq: "groqApiKey";
+    readonly nvidia: "nvidiaApiKey";
+    readonly openai: "openaiApiKey";
+};
+export type ChaveDeProvedor = (typeof CHAVE_DO_PROVEDOR)[ProvedorIa];
+/** Chave da config local que troca o modelo padrão de cada provedor. */
+export declare const CHAVE_DE_MODELO_DO_PROVEDOR: {
+    readonly groq: "groqModel";
+    readonly nvidia: "nvidiaModel";
+    readonly openai: "openaiModel";
+};
+export type ChaveDeModeloDoProvedor = (typeof CHAVE_DE_MODELO_DO_PROVEDOR)[ProvedorIa];
+/** Variável de ambiente de onde a descoberta lê a chave de cada provedor. */
+export declare const VARIAVEL_DO_PROVEDOR: Readonly<Record<ProvedorIa, string>>;
+/** Nome que aparece na tela. */
+export declare const NOME_DO_PROVEDOR: Readonly<Record<ProvedorIa, string>>;
+/** Ordem de `PROVEDORES_IA`, já com o nome da tela: "Groq, NVIDIA NIM, OpenAI". */
+export declare const NOMES_DOS_PROVEDORES: string;
+/**
+ * O que `neetru ai -m`, o `/debug:model` e a chave `defaultModel` aceitam: um
+ * provedor da lista, o AI Gateway da Neetru (sessão do `neetru login`) ou
+ * `auto` (a CLI escolhe entre os provedores com chave).
+ */
+export declare const MODELOS_DO_AI: readonly ["groq", "nvidia", "openai", "gateway", "auto"];
+export type ModeloDoAi = (typeof MODELOS_DO_AI)[number];
+/** Os modelos aceitos, prontos para a tela: "groq | nvidia | openai | gateway | auto". */
+export declare const MODELOS_DO_AI_NA_TELA: string;
+export declare function ehProvedorIa(valor: unknown): valor is ProvedorIa;
+export declare function ehModeloDoAi(valor: unknown): valor is ModeloDoAi;

package/dist/lib/ai/provedores.js

@@ -0,0 +1,66 @@
+/**
+ * A lista ÚNICA de provedores de IA da CLI (bug_19d312f3).
+ *
+ * Antes havia duas listas que discordavam. O `neetru ai` e o `neetru auth`
+ * trabalhavam com anthropic, openai, gemini, groq e nvidia; o `neetru code`,
+ * o `neetru ai models` e a config do AI Gateway, com groq, nvidia e openai. A
+ * primeira oferecia Anthropic e Gemini, que a casa não usa: IA só de provedor
+ * gratuito, e a API da Anthropic e o Gemini custam e estão vetados.
+ *
+ * Agora todo lugar que enumera provedor lê daqui: o assistente do
+ * `neetru auth setup`, a descoberta de chaves, o roteamento e o `/debug:model`
+ * do `neetru ai`, o `--provider` do `neetru code`, o catálogo do
+ * `neetru ai models`, as chaves aceitas pelo `neetru config set` e o schema da
+ * config. O teste `provedores-ia-lista-unica.test.ts` trava a lista e falha se
+ * outro arquivo de `src/` declarar uma lista própria.
+ *
+ * Este módulo não importa nada de propósito: o `index.ts` e o `neetru code` o
+ * leem sem carregar o SDK de nenhum provedor.
+ */
+/**
+ * Provedores com os quais a CLI fala. Groq e NVIDIA NIM primeiro (gratuitos).
+ * A OpenAI é paga: o `auto` do `neetru ai` só a escolhe quando nenhum gratuito
+ * tem chave (`routeModel` no orchestrator); fora isso, só com `-m openai`.
+ */
+export const PROVEDORES_IA = ['groq', 'nvidia', 'openai'];
+/** Chave da config local que guarda a chave de API de cada provedor. */
+export const CHAVE_DO_PROVEDOR = {
+    groq: 'groqApiKey',
+    nvidia: 'nvidiaApiKey',
+    openai: 'openaiApiKey',
+};
+/** Chave da config local que troca o modelo padrão de cada provedor. */
+export const CHAVE_DE_MODELO_DO_PROVEDOR = {
+    groq: 'groqModel',
+    nvidia: 'nvidiaModel',
+    openai: 'openaiModel',
+};
+/** Variável de ambiente de onde a descoberta lê a chave de cada provedor. */
+export const VARIAVEL_DO_PROVEDOR = {
+    groq: 'GROQ_API_KEY',
+    nvidia: 'NVIDIA_API_KEY',
+    openai: 'OPENAI_API_KEY',
+};
+/** Nome que aparece na tela. */
+export const NOME_DO_PROVEDOR = {
+    groq: 'Groq',
+    nvidia: 'NVIDIA NIM',
+    openai: 'OpenAI',
+};
+/** Ordem de `PROVEDORES_IA`, já com o nome da tela: "Groq, NVIDIA NIM, OpenAI". */
+export const NOMES_DOS_PROVEDORES = PROVEDORES_IA.map((p) => NOME_DO_PROVEDOR[p]).join(', ');
+/**
+ * O que `neetru ai -m`, o `/debug:model` e a chave `defaultModel` aceitam: um
+ * provedor da lista, o AI Gateway da Neetru (sessão do `neetru login`) ou
+ * `auto` (a CLI escolhe entre os provedores com chave).
+ */
+export const MODELOS_DO_AI = [...PROVEDORES_IA, 'gateway', 'auto'];
+/** Os modelos aceitos, prontos para a tela: "groq | nvidia | openai | gateway | auto". */
+export const MODELOS_DO_AI_NA_TELA = MODELOS_DO_AI.join(' | ');
+export function ehProvedorIa(valor) {
+    return typeof valor === 'string' && PROVEDORES_IA.includes(valor);
+}
+export function ehModeloDoAi(valor) {
+    return typeof valor === 'string' && MODELOS_DO_AI.includes(valor);
+}
+//# sourceMappingURL=provedores.js.map

package/dist/lib/api-client.d.ts

@@ -16,7 +16,14 @@ export declare class CliApiError extends Error {
      * por quem faz vários envios em sequência (ex.: `neetru docs sync`).
      */
     readonly retryAfterSeconds?: number;
-    constructor(status: number, code: string, message: string, correlationId?: string, retryAfterSeconds?: number);
+    /**
+     * Campos EXTRAS do erro canônico `{ error: { code, message, ...detalhes } }`
+     * (ex.: core#732 — `instanceId`, `instanceCreatedAt`, `docCreatedAt`,
+     * `outrosServidores`, `comandoConferencia` no force-cleanup). Ausente quando
+     * o corpo só traz `code`/`message`. Quem usa valida o tipo de cada campo.
+     */
+    readonly details?: Readonly<Record<string, unknown>>;
+    constructor(status: number, code: string, message: string, correlationId?: string, retryAfterSeconds?: number, details?: Readonly<Record<string, unknown>>);
 }
 /** `Retry-After` em segundos (aceita número ou data HTTP). undefined se ausente/ilegível. */
 export declare function parseRetryAfter(value: string | null | undefined, now?: number): number | undefined;

package/dist/lib/api-client.js

@@ -17,13 +17,22 @@ export class CliApiError extends Error {
      * por quem faz vários envios em sequência (ex.: `neetru docs sync`).
      */
     retryAfterSeconds;
-    constructor(status, code, message, correlationId, retryAfterSeconds) {
+    /**
+     * Campos EXTRAS do erro canônico `{ error: { code, message, ...detalhes } }`
+     * (ex.: core#732 — `instanceId`, `instanceCreatedAt`, `docCreatedAt`,
+     * `outrosServidores`, `comandoConferencia` no force-cleanup). Ausente quando
+     * o corpo só traz `code`/`message`. Quem usa valida o tipo de cada campo.
+     */
+    details;
+    constructor(status, code, message, correlationId, retryAfterSeconds, details) {
         super(message);
         this.name = 'CliApiError';
         this.status = status;
         this.code = code;
         this.correlationId = correlationId;
         this.retryAfterSeconds = retryAfterSeconds;
+        if (details && Object.keys(details).length > 0)
+            this.details = details;
     }
 }
 /** `Retry-After` em segundos (aceita número ou data HTTP). undefined se ausente/ilegível. */
@@ -182,6 +191,7 @@ export async function apiRequest(path, opts = {}) {
         const errBody = parsed;
         let code = `http_${response.status}`;
         let message = `Erro HTTP ${response.status}`;
+        let details;
         if (errBody?.error) {
             if (typeof errBody.error === 'string') {
                 // Formato RFC. Auditoria cli/v1 2026-09-29: o 401 do `requireCliAuth`
@@ -196,6 +206,12 @@ export async function apiRequest(path, opts = {}) {
                 // Formato interno Neetru
                 code = errBody.error.code ?? code;
                 message = errBody.error.message ?? message;
+                // Campos além de `code`/`message` (core#732): vão em `details`, crus.
+                const { code: _c, message: _m, ...extras } = errBody.error;
+                void _c;
+                void _m;
+                if (Object.keys(extras).length > 0)
+                    details = extras;
             }
         }
         else if (typeof parsed === 'string' && parsed.trim() !== '') {
@@ -242,7 +258,7 @@ export async function apiRequest(path, opts = {}) {
         }
         // LABS #6 (2026-09-28): captura o x-correlation-id do Core p/ o rodapé do erro.
         const correlationId = response.headers.get('x-correlation-id') ?? undefined;
-        throw new CliApiError(response.status, code, message, correlationId, parseRetryAfter(response.headers.get('retry-after')));
+        throw new CliApiError(response.status, code, message, correlationId, parseRetryAfter(response.headers.get('retry-after')), details);
     }
     return parsed;
 }