primocode 11.4.0 → 11.5.0

package/lib/provider/local/motor.js

@@ -19,6 +19,9 @@ const entrada = require('./entrada.js');
 const provedor = require('./provedor.js');
 const catalogo = require('../../skill/catalogo.js');
 const chamadaTorta = require('../../chamada-torta');
+const catalogoModelos = require('../catalogo');
+const orcamento = require('./orcamento.js');
+const revezamento = require('./revezamento.js');
 
 // A conversa pode ocupar isto, em tokens, além do prompt e das ferramentas.
 // Folgado: os modelos de hoje têm 128 mil ou mais de contexto.
@@ -45,8 +48,10 @@ function ferramentasDoCliente() {
         }
     }
     if (!lista.some((t) => t.function.name === 'finish') && doServidor.has('finish')) lista.push(doServidor.get('finish'));
-    return lista;
+    // mais_ferramentas só existe quando o recorte tira ferramentas (recorte.js monta o schema dela)
+    return lista.filter((t) => t.function.name !== 'mais_ferramentas');
 }
+let ULTIMO_PLANO = null;   // o que a última volta mandou (nível, tokens): o teste e a prova leem daqui
 let FERRAMENTAS = null;
 let FERRAMENTAS_SUB = null;
 function ferramentas(subagent) {
@@ -57,6 +62,28 @@ function ferramentas(subagent) {
     return subagent ? FERRAMENTAS_SUB : FERRAMENTAS;
 }
 
+/* ── O QUE O MODELO ESCOLHIDO SABE FAZER ─────────────────────────────────
+ * Vem do catálogo (models.dev): ferramentas, visão, contexto, saída máxima.
+ * Modelo que o catálogo não conhece (um gateway, um modelo novo) tem o
+ * benefício da dúvida: tudo ligado, como era antes. */
+function perfil(p = provedor.atual()) {
+    const cap = p && p.noCatalogo ? catalogoModelos.capacidades(p.noCatalogo, p.modelo) : null;
+    const saida = cap && cap.saida > 0 ? Math.min(SAIDA_MAXIMA, cap.saida) : SAIDA_MAXIMA;
+    // a conversa usa até metade do contexto; o resto fica para prompt, ferramentas e resposta
+    const teto = cap && cap.contexto > 0 ? Math.min(TETO_CONVERSA, Math.floor(cap.contexto * 0.5)) : TETO_CONVERSA;
+    return { conhecido: !!cap, ferramentas: cap ? cap.ferramentas : true, visao: cap ? cap.visao : true, saida, teto };
+}
+
+/** Modelo sem visão não recebe imagem: vira um aviso em texto (o pedido não quebra). */
+function semImagens(messages, pf) {
+    if (pf.visao) return messages;
+    return messages.map((m) => {
+        if (!m || !Array.isArray(m.content)) return m;
+        const partes = m.content.map((x) => (x && x.type === 'image_url' ? { type: 'text', text: '[imagem omitida: este modelo não vê imagens]' } : x));
+        return { ...m, content: partes };
+    });
+}
+
 /** O erro da API, no formato que o loop já sabe tratar (429 espera, 401 avisa). */
 async function erroHttp(r, p) {
     let msg = '';
@@ -72,8 +99,17 @@ async function erroHttp(r, p) {
     if (r.status === 401 || r.status === 403) {
         return new Error(`${r.status} ${quem} recusou a chave. Rode /api para colar outra, ou /api off para voltar ao servidor.`);
     }
-    const espera = r.headers && r.headers.get && r.headers.get('retry-after');
-    return new Error(`${r.status} ${quem}: ${String(msg).slice(0, 300)}${espera ? ` Please try again in ${espera}s.` : ''}`);
+    const h = (n) => (r.headers && r.headers.get && r.headers.get(n)) || null;
+    const espera = h('retry-after');
+    const e = new Error(`${r.status} ${quem}: ${String(msg).slice(0, 300)}${espera ? ` Please try again in ${espera}s.` : ''}`);
+    // o que o retry de TPM precisa, sem reler o texto: status, quanto esperar e o limite que o provedor contou
+    e.status = r.status;
+    e.esperaMs = orcamento.duracaoMs(espera) || orcamento.duracaoMs(h('x-ratelimit-reset-tokens')) || orcamento.duracaoMs((/try again in ([0-9hms.]+)/i.exec(msg) || [])[1]);
+    const lim = /Limit (\d+)/.exec(msg);
+    e.limiteTpm = lim ? Number(lim[1]) : null;
+    e.tpm = (r.status === 413 || r.status === 429) && /tokens per minute|\bTPM\b|request too large|reduce your message size/i.test(msg);
+    e.tpd = /tokens per day|\bTPD\b/i.test(msg);
+    return e;
 }
 
 function cabecalhos(p) {
@@ -100,8 +136,7 @@ async function completar(messages, { maxTokens = 600, temperatura = 0.2 } = {})
  * Lê o stream SSE do /chat/completions. Chama `aoPedaco(delta, fim)` a cada
  * pedaço. Resolve quando acaba ou quando `sinal` corta.
  */
-async function lerStream(corpo, { sinal, aoPedaco }) {
-    const p = provedor.atual();
+async function lerStream(corpo, { sinal, aoPedaco, p = provedor.atual() }) {
     let r;
     try {
         r = await fetch(`${p.base}/chat/completions`, {
@@ -158,45 +193,122 @@ function juntarChamadas(acumuladas, pedacos) {
     return acumuladas;
 }
 
+/* ── 413/429 POR TOKENS POR MINUTO ───────────────────────────────────────
+ * O provedor grátis diz quanto esperar (retry-after, x-ratelimit-reset-tokens). A pessoa lê uma
+ * frase simples, nunca o erro cru; a tentativa seguinte leva um pedido menor (um nível a mais de
+ * aperto em orcamento.planejar) e o nível fica lembrado para as próximas voltas. Só erro HTTP
+ * (antes de qualquer pedaço da resposta) é repetido: no meio do stream, nada de duplicar texto. */
+const MAX_TENTATIVAS_TPM = 3;
+const ESPERA_MAXIMA_MS = 70000;
+
+function dormir(ms, sinal) {
+    return new Promise((ok) => {
+        const t = setTimeout(ok, ms);
+        if (sinal) sinal.addEventListener('abort', () => { clearTimeout(t); ok(); }, { once: true });
+    });
+}
+
+async function comRetryDeTpm(montar, p, emit, sinal, enviar, dormirFn = dormir, revezar = null) {
+    let nivel = p ? orcamento.pisoDeNivel(p.id, p.modelo) : 0;
+    for (let tentativa = 0; ; tentativa++) {
+        const corpo = montar(nivel);
+        try { return await enviar(corpo); } catch (e) {
+            if (!e || !e.tpm || (sinal && sinal.aborted)) throw e;
+            // outro provedor grátis livre? Segue nele em vez de esperar (o erro veio antes de qualquer pedaço)
+            const outro = revezar && revezar(e);
+            if (outro) { p = outro; nivel = orcamento.pisoDeNivel(p.id, p.modelo); continue; }
+            if (e.tpd) throw new Error(`429 O limite de hoje do modelo grátis acabou. Tente amanhã, ou troque a chave ou o modelo com /api. (tokens per day)`);
+            if (e.limiteTpm && p) orcamento.aprender(p.id, p.modelo, e.limiteTpm);
+            if (tentativa >= MAX_TENTATIVAS_TPM) {
+                const s = Math.max(1, Math.ceil((e.esperaMs || 30000) / 1000));
+                throw new Error(`429 O modelo grátis pediu uma pausa de ${s}s e o pedido ainda não coube. Please try again in ${s}s.`);
+            }
+            // 413 sem tempo no header: o pedido era grande demais, não é fila — recorta já.
+            const espera = Math.min(ESPERA_MAXIMA_MS, e.esperaMs ? e.esperaMs + 500 : 0);
+            if (espera > 0) emit({ aviso: orcamento.fraseDePausa(espera) });
+            else emit({ aviso: 'O modelo grátis tem um limite por minuto: mando um pedido menor.' });
+            if (espera > 0) await dormirFn(espera, sinal);
+            const usado = Number.isInteger(montar.usado) ? montar.usado : nivel;
+            nivel = Math.min(orcamento.NIVEL_MAXIMO, Math.max(nivel, usado) + 1);
+            if (p) orcamento.subirPiso(p.id, p.modelo, nivel);
+        }
+    }
+}
+
 /* ── /api/act/stream ─────────────────────────────────────────────────── */
 async function requestAct(_servidor, body, emit) {
-    const { messages: convo = [], prompt, history, effort, projectDir, projectName, subagent, sinal } = body || {};
+    const { messages: convo = [], prompt, history, effort, projectDir, projectName, subagent, sinal, modo } = body || {};
     const pedido = [...convo].reverse().find((m) => m && m.role === 'user');
     const texto = String((pedido && pedido.content) || prompt || '');
     const forcar = effort && ESFORCO_PESQUISA.includes(String(effort)) ? ['pesquisa'] : [];
 
-    // Todas, sempre: o recorte por assunto do servidor existe para caber em
-    // 6.000 tokens por minuto, e ainda não conhece o Estúdio novo (estudio_*)
-    // — com ele, um pedido de vídeo chegaria sem a ferramenta de vídeo.
-    const tools = ferramentas(subagent);
-    const sistema = subagent
-        ? cerebro.SYSTEM_SUB
-        : entrada.montarPrompt(cerebro.SYSTEM_NUCLEO, cerebro.SECOES, texto, { forcar, jaAprendeu: entrada.jaAprendeu(convo) });
-    const messages = [{ role: 'system', content: sistema }];
-    if (projectDir) {
-        messages.push({ role: 'system', content: `[Projeto: ${projectName || 'sem nome'}]\n[Pasta: ${projectDir}]\n`
-            + 'Todo caminho que você passar para write_file/read_file/list_dir é relativo a esta pasta. '
-            + 'Use caminhos relativos simples (ex: "index.html", "src/app.js"). Nunca use caminho absoluto.' });
+    /* O que vai no pedido. Provedor sem limite de TPM: todas as ferramentas, como sempre.
+       Provedor com limite (Groq grátis ~8k/min): só os assuntos do pedido e do modo, descrições
+       e prompt mais curtos se ainda não couber (lib/provider/local/orcamento.js). */
+    const base = provedor.atual();            // o que a pessoa escolheu; o revezamento parte dele
+    const temImagem = convo.some((m) => m && Array.isArray(m.content) && m.content.some((x) => x && x.type === 'image_url'));
+    let p = base;
+    if (base && !base.cli) {
+        const e0 = revezamento.escolher(base, { visao: temImagem });
+        if (e0.trocou) {
+            p = e0.p;
+            emit({ aviso: p.id === base.id ? `Tem imagem; usei o ${p.modelo}, que enxerga.` : revezamento.frase(base, p, temImagem ? 'visao' : 'pausa') });
+        }
     }
-    const conversa = convo.length ? convo : [...(history || []), { role: 'user', content: String(prompt || '') }];
-    messages.push(...entrada.caberNoTeto(conversa.filter((m) => m && m.role), TETO_CONVERSA).messages);
+    let pf = perfil(p);
+    const revezar = (e) => {
+        if (!base || base.cli) return null;
+        revezamento.marcarOcupado(p.id, e.esperaMs, { dia: !!e.tpd });
+        const r = revezamento.escolher(base, { visao: temImagem });
+        if (!r.trocou || r.p.id === p.id) return null;
+        const de = p; p = r.p; pf = perfil(p);
+        emit({ aviso: revezamento.frase(de, p) });
+        return p;
+    };
+    const montar = (nivelMin = 0) => {
+        const limite = p ? orcamento.limiteTpm(p.id, p.modelo) : 0;
+        const conversa = convo.length ? convo : [...(history || []), { role: 'user', content: String(prompt || '') }];
+        const aparar = (m, sobra) => semImagens(entrada.caberNoTeto(m, sobra).messages, pf);
+        const mensagens = semImagens(entrada.caberNoTeto(conversa.filter((m) => m && m.role), pf.teto).messages, pf);
+        const extra = [];
+        if (projectDir) {
+            extra.push({ role: 'system', content: `[Projeto: ${projectName || 'sem nome'}]\n[Pasta: ${projectDir}]\n`
+                + 'Todo caminho que você passar para write_file/read_file/list_dir é relativo a esta pasta. '
+                + 'Use caminhos relativos simples (ex: "index.html", "src/app.js"). Nunca use caminho absoluto.' });
+        }
+        if (!pf.ferramentas) {
+            extra.push({ role: 'system', content: 'Este modelo não tem ferramentas neste momento: você não pode criar nem editar arquivos, nem rodar comandos. Responda só em texto e diga ao usuário o que ele mesmo pode fazer; se ele quiser que você aja, peça para trocar o modelo com /api modelos.' });
+        }
+        // modelo sem ferramentas só conversa: mandar `tools` a ele dá erro 400 em quase todo provedor
+        const todas = pf.ferramentas ? ferramentas(subagent) : [];
+        const plano = orcamento.planejar({ todas, texto, modo, mensagens, nucleo: cerebro.SYSTEM_NUCLEO, secoes: cerebro.SECOES,
+            limite: pf.ferramentas ? limite : 0, saidaMax: pf.saida, nivelMin, jaAprendeu: entrada.jaAprendeu(convo),
+            extraTokens: orcamento.tokensDe(extra), aparar, forcar, sistemaFixo: subagent ? cerebro.SYSTEM_SUB : null });
+        const msgs = [{ role: 'system', content: plano.sistema }, ...(projectDir ? [extra[0]] : []), ...plano.mensagens, ...extra.slice(projectDir ? 1 : 0)];
+        const corpo = { messages: msgs, ...(plano.tools.length ? { tools: plano.tools, tool_choice: 'auto' } : {}), temperature: 0.1, max_tokens: Math.min(pf.saida, plano.saida) };
+        montar.usado = plano.nivel;
+        ULTIMO_PLANO = { nivel: plano.nivel, recortou: plano.recortou, tokens: plano.tokens, limite };
+        if (process.env.PRIMOCODE_TRACO === '1') process.stderr.write(`  [orçamento] limite ${limite || 'sem'} · nível ${plano.nivel} · ${plano.tools.length} ferramentas · ${JSON.stringify(plano.tokens)}\n`);
+        return corpo;
+    };
 
     let texto_ = '';
     const chamadas = [];
-    await lerStream({ messages, tools, tool_choice: 'auto', temperature: 0.1, max_tokens: SAIDA_MAXIMA }, {
-        sinal,
+    await comRetryDeTpm(montar, p, emit, sinal, (corpo) => lerStream(corpo, {
+        sinal, p,
         aoPedaco: (delta) => {
             if (delta.tool_calls) juntarChamadas(chamadas, delta.tool_calls);
             if (delta.content && !chamadas.length) { texto_ += delta.content; emit({ delta: delta.content }); }
         },
-    });
+    }), undefined, revezar);
     chamadas.forEach((tc, i) => {
         if (!tc || !tc.name) return;
         /* JSON quebrado: tenta recuperar; se não der, o act.js devolve o erro
            (com os argumentos crus) ao modelo — ver lib/chamada-torta.js. */
         const rec = chamadaTorta.recuperar(tc.arguments);
         const args = rec.ok ? rec.args : chamadaTorta.marcar(tc.arguments);
-        emit({ tool_call: { id: tc.id || `local_${Date.now()}_${i}`, name: tc.name, arguments: args } });
+        // gpt-oss no Groq às vezes cola o canal do formato dele no nome ('estudio_motion<|channel|>commentary')
+        emit({ tool_call: { id: tc.id || `local_${Date.now()}_${i}`, name: tc.name.replace(/<\|.*$/, '').trim(), arguments: args } });
     });
     if (texto_) emit({ assistant_message: { content: texto_ } });
     emit({ done: true });
@@ -207,9 +319,10 @@ async function requestChat(_servidor, body, emit) {
     const { messages, prompt, history, sinal } = body || {};
     const turnos = Array.isArray(messages) ? messages
         : [...(Array.isArray(history) ? history : []), ...(prompt ? [{ role: 'user', content: prompt }] : [])];
+    const pf = perfil();
     await lerStream({
-        messages: [{ role: 'system', content: cerebro.SYSTEM_CHAT }, ...turnos.filter((m) => m && m.role)],
-        temperature: 0.4, max_tokens: 1200,
+        messages: semImagens([{ role: 'system', content: cerebro.SYSTEM_CHAT }, ...turnos.filter((m) => m && m.role)], pf),
+        temperature: 0.4, max_tokens: Math.min(1200, pf.saida),
     }, { sinal, aoPedaco: (delta) => { if (delta.content) emit({ delta: delta.content }); } });
     emit({ done: true });
 }
@@ -264,4 +377,4 @@ async function requestPlano(_servidor, { prompt } = {}) {
     }
 }
 
-module.exports = { requestAct, requestChat, requestResumo, requestPlano, juntarChamadas, lerPassos, ferramentas, ativo: () => !!provedor.atual() };
+module.exports = { comRetryDeTpm, ultimoPlano: () => ULTIMO_PLANO, perfil, semImagens, requestAct, requestChat, requestResumo, requestPlano, juntarChamadas, lerPassos, ferramentas, ativo: () => !!provedor.atual() };

package/lib/provider/local/orcamento.js

@@ -0,0 +1,193 @@
+/**
+ * orcamento.js — quanto cabe num pedido, para provedor com limite de tokens por minuto (TPM).
+ *
+ * O plano grátis do Groq aceita ~8.000 tokens por minuto. Só a definição das
+ * ~65 ferramentas do cliente já passa disso (HTTP 413), então o modo agente
+ * nem começava. Aqui mora a conta:
+ *
+ *   limite do provedor  →  quanto sobra para ferramentas + prompt + conversa
+ *   não coube?          →  descrições curtas, e só depois o prompt mais curto
+ *
+ * O limite NÃO fica espalhado no código. Ordem de quem manda:
+ *   1. PRIMOCODE_TPM (variável de ambiente, vale para tudo)
+ *   2. ~/.primocode/limites.json — { "groq": 8000, "groq/openai/gpt-oss-20b": 6000, "openai": 0 }
+ *      (0 = sem limite: comportamento antigo, todas as ferramentas)
+ *   3. o que o provedor contou num erro ("Limit 8000"), lembrado até fechar o programa
+ *   4. LIMITES_GRATIS, abaixo — só provedores cujo plano de entrada é conhecido por ser apertado
+ * Provedor fora dessas listas = sem limite.
+ *
+ * Puro de propósito (fora a leitura do limites.json): o teste mede o orçamento sem chave de API.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const entrada = require('./entrada.js');
+const recorte = require('./recorte.js');
+
+/** O único lugar com número de provedor. Quem paga e tem limite maior troca no limites.json. */
+const LIMITES_GRATIS = { groq: 8000 };
+
+/** Fração do limite que UM pedido pode usar (entrada + saída). Menos de 1 de propósito: o minuto é dividido
+ *  entre todas as voltas do agente, e um pedido que come o minuto inteiro faz a volta seguinte esperar. */
+const FRACAO_PEDIDO = 0.6;
+/** Fração do limite reservada para a resposta do modelo, e o mínimo dela. */
+const FRACAO_SAIDA = 0.2;
+const SAIDA_MINIMA = 768;
+/** A conversa nunca é espremida abaixo disto, mesmo no recorte mais fundo. */
+const CONVERSA_MINIMA = 1500;
+
+const PISOS = new Map();        // "provedor/modelo" → nível de aperto que já se mostrou necessário
+/** Caracteres por token da conta de orçamento. 4 é o de sempre (e erra para o lado seguro em JSON de schema);
+ *  trocável em PRIMOCODE_CHARS_POR_TOKEN sem mexer no código. */
+const CHARS_POR_TOKEN = Number(process.env.PRIMOCODE_CHARS_POR_TOKEN) > 0 ? Number(process.env.PRIMOCODE_CHARS_POR_TOKEN) : 4;
+function tokensDe(x) {
+    const texto = typeof x === 'string' ? x : JSON.stringify(x || '');
+    return Math.ceil(texto.length / CHARS_POR_TOKEN);
+}
+
+const APRENDIDOS = new Map();   // "provedor/modelo" → limite que o provedor disse num erro
+
+const ARQUIVO = () => path.join(os.homedir(), '.primocode', 'limites.json');
+
+function lerArquivo() {
+    try {
+        const j = JSON.parse(fs.readFileSync(ARQUIVO(), 'utf8'));
+        return j && typeof j === 'object' ? j : {};
+    } catch { return {}; }
+}
+
+function numeroOuNull(v) {
+    const n = Number(v);
+    return Number.isFinite(n) && n >= 0 ? n : null;
+}
+
+/** TPM do provedor/modelo, ou 0 se não há limite conhecido (= comportamento antigo). */
+function limiteTpm(provedorId, modelo) {
+    const env = numeroOuNull(process.env.PRIMOCODE_TPM);
+    if (env !== null && process.env.PRIMOCODE_TPM !== '') return env;
+    const arq = lerArquivo();
+    for (const chave of [`${provedorId}/${modelo}`, provedorId]) {
+        const n = numeroOuNull(arq[chave]);
+        if (n !== null) return n;
+    }
+    const visto = APRENDIDOS.get(`${provedorId}/${modelo}`);
+    if (visto) return visto;
+    return LIMITES_GRATIS[provedorId] || 0;
+}
+
+/** O provedor disse o limite dele no erro: passa a valer (só se for menor que o que se achava). */
+function aprender(provedorId, modelo, limite) {
+    const n = numeroOuNull(limite);
+    if (!n) return;
+    const chave = `${provedorId}/${modelo}`;
+    const atual = limiteTpm(provedorId, modelo);
+    if (!atual || n < atual) APRENDIDOS.set(chave, n);
+}
+
+function pisoDeNivel(provedorId, modelo) { return PISOS.get(`${provedorId}/${modelo}`) || 0; }
+function subirPiso(provedorId, modelo, nivel) {
+    const k = `${provedorId}/${modelo}`;
+    if (nivel > (PISOS.get(k) || 0)) PISOS.set(k, nivel);
+}
+function esquecerAprendidos() { APRENDIDOS.clear(); PISOS.clear(); }
+
+/* ── os níveis de aperto, do mais leve ao mais fundo ─────────────────────
+ *   0 tudo completo        1 descrições até 350 caracteres
+ *   2 descrições de 1 frase   3 prompt só com a seção do Estúdio
+ *   4 prompt só com o núcleo   5 assunto secundário sai (motion manda sobre estúdio)
+ *                                                                        */
+const NIVEL_MAXIMO = 5;
+const TAMANHO_DESCRICAO = [Infinity, 350, 160, 160, 160, 160];
+
+function encurtar(tools, max) {
+    if (!isFinite(max)) return tools;
+    return tools.map((t) => {
+        const d = t && t.function && t.function.description;
+        if (!d || d.length <= max) return t;
+        const corte = d.slice(0, max);
+        const ponto = Math.max(corte.lastIndexOf('. '), corte.lastIndexOf('; '));
+        const curta = ponto > max * 0.4 ? corte.slice(0, ponto + 1) : `${corte.replace(/\s+\S*$/, '')}…`;
+        return { ...t, function: { ...t.function, description: curta } };
+    });
+}
+
+function sistemaDoNivel(nucleo, secoes, texto, opts, nivel, grupos) {
+    if (opts.sistemaFixo) return opts.sistemaFixo;   // subagente: o prompt dele é curto e não tem seções
+    if (nivel <= 2) return entrada.montarPrompt(nucleo, secoes, texto, opts);
+    const partes = [nucleo];
+    if (nivel === 3 && secoes && secoes.estudio && (grupos.has('estudio') || grupos.has('after-effects'))) partes.push(secoes.estudio);
+    return partes.join('\n\n');
+}
+
+/**
+ * Decide o que vai no pedido.
+ *
+ * `todas`: as ferramentas completas. `mensagens`: a conversa já aparada.
+ * `limite`: TPM (0 = sem limite). `nivelMin`: de onde começar (o retry sobe).
+ * Devolve { tools, sistema, mensagens, nivel, grupos, recortou, saida, tokens }.
+ */
+function planejar({ todas, texto, modo, mensagens = [], nucleo, secoes, limite = 0, saidaMax = 8192, nivelMin = 0, jaAprendeu = new Set(), extraTokens = 0, aparar, sistemaFixo = null, forcar: forcarFora = [] }) {
+    const semLimite = !limite;
+    if (!semLimite) texto = recorte.pedidoReal(texto);   // o gatilho olha o que a pessoa escreveu, não o embrulho do CLI
+    const forcar = [...forcarFora, ...(semLimite ? [] : recorte.forcarDoModo(modo))];
+    const { grupos, usados } = recorte.gruposDoPedido(texto, mensagens, forcar);
+    // o manual do Estúdio (seção do prompt) acompanha o modo, mesmo que a ferramenta de vídeo seja só a de motion
+    const opts = { sistemaFixo, forcar: semLimite ? forcar : [...forcar, ...usados, ...(recorte.forcarDoModo(modo).length ? ['estudio'] : [])], jaAprendeu };
+    const escolhidas = semLimite ? todas : recorte.escolher(todas, grupos);
+    const recortou = escolhidas.length < todas.length;
+    const comMais = recortou ? [...escolhidas, recorte.maisFerramentas(todas, grupos)] : escolhidas;
+    const restritas = recortou ? (() => { const g = recorte.principais(grupos); const e = recorte.escolher(todas, g); return [...e, recorte.maisFerramentas(todas, g)]; })() : comMais;
+
+    if (semLimite) {
+        const sistema = sistemaFixo || entrada.montarPrompt(nucleo, secoes, texto, opts);
+        return { tools: comMais, sistema, mensagens, nivel: 0, grupos, recortou: false, saida: saidaMax,
+            tokens: { ferramentas: tokensDe(comMais), sistema: tokensDe(sistema), conversa: tokensDe(mensagens), total: 0 } };
+    }
+
+    const saida = Math.min(saidaMax, Math.max(SAIDA_MINIMA, Math.floor(limite * FRACAO_SAIDA)));
+    let ultimo = null;
+    for (let nivel = Math.min(nivelMin, NIVEL_MAXIMO); nivel <= NIVEL_MAXIMO; nivel++) {
+        const tools = encurtar(nivel >= 5 ? restritas : comMais, TAMANHO_DESCRICAO[nivel]);
+        const sistema = sistemaDoNivel(nucleo, secoes, texto, opts, nivel, grupos);
+        const msgs = recorte.enxugarContexto(mensagens, nivel);
+        const conv = tokensDe(msgs);
+        const fixo = tokensDe(tools) + tokensDe(sistema) + extraTokens;
+        const sobra = Math.floor(limite * FRACAO_PEDIDO) - fixo - saida;
+        ultimo = { tools, sistema, nivel, fixo, sobra, msgs, conv };
+        if (sobra >= conv) break;
+    }
+    // Mesmo no fundo não coube a conversa: ela é que encolhe (a mais velha primeiro).
+    let msgs = ultimo.msgs;
+    if (ultimo.sobra < ultimo.conv && aparar) msgs = aparar(ultimo.msgs, Math.max(CONVERSA_MINIMA, ultimo.sobra));
+    const tokens = { ferramentas: tokensDe(ultimo.tools), sistema: tokensDe(ultimo.sistema), conversa: tokensDe(msgs) };
+    tokens.total = tokens.ferramentas + tokens.sistema + tokens.conversa + extraTokens;
+    return { tools: ultimo.tools, sistema: ultimo.sistema, mensagens: msgs, nivel: ultimo.nivel, grupos, recortou, saida, tokens, limite };
+}
+
+/* ── o que o provedor pediu de espera ────────────────────────────────────
+ * "7.66s", "1m2.5s", "150ms", "2m" — o formato dos headers x-ratelimit-reset-*. */
+function duracaoMs(txt) {
+    const s = String(txt == null ? '' : txt).trim();
+    if (!s) return null;
+    if (/^\d+(\.\d+)?$/.test(s)) return Math.round(parseFloat(s) * 1000);       // retry-after em segundos
+    let total = 0; let achou = false;
+    const re = /(\d+(?:\.\d+)?)(ms|h|m|s)/g;
+    let m;
+    while ((m = re.exec(s))) {
+        achou = true;
+        const v = parseFloat(m[1]);
+        total += m[2] === 'ms' ? v : m[2] === 's' ? v * 1000 : m[2] === 'm' ? v * 60000 : v * 3600000;
+    }
+    return achou ? Math.round(total) : null;
+}
+
+/** A frase simples para a pessoa — nunca o erro cru. */
+function fraseDePausa(ms) {
+    const s = Math.max(1, Math.ceil(ms / 1000));
+    return `O modelo grátis pediu uma pausa de ${s}s. Já tento de novo com um pedido menor.`;
+}
+
+module.exports = { tokensDe, pisoDeNivel, subirPiso, LIMITES_GRATIS, NIVEL_MAXIMO, limiteTpm, aprender, esquecerAprendidos, planejar, encurtar, duracaoMs, fraseDePausa, ARQUIVO };

package/lib/provider/local/provedor.js

@@ -27,6 +27,7 @@
 const fs = require('fs');
 const os = require('os');
 const path = require('path');
+const catalogo = require('../catalogo');
 
 const ARQUIVO = () => path.join(os.homedir(), '.primocode', 'provedor.json');
 
@@ -51,6 +52,8 @@ const PROVEDORES = {
     },
     gemini: {
         nome: 'Gemini (Google)',
+        env: ['GEMINI_API_KEY'],
+        noCatalogo: 'google',
         base: 'https://generativelanguage.googleapis.com/v1beta/openai',
         modelos: ['gemini-2.5-flash', 'gemini-2.5-pro', 'gemini-2.0-flash'],
         onde: 'https://aistudio.google.com/apikey',
@@ -58,6 +61,8 @@ const PROVEDORES = {
     },
     chatgpt: {
         nome: 'ChatGPT (OpenAI)',
+        env: ['OPENAI_API_KEY'],
+        noCatalogo: 'openai',
         base: 'https://api.openai.com/v1',
         modelos: ['gpt-5-mini', 'gpt-5', 'gpt-4.1-mini', 'gpt-4o-mini'],
         onde: 'https://platform.openai.com/api-keys',
@@ -65,6 +70,8 @@ const PROVEDORES = {
     },
     claude: {
         nome: 'Claude (Anthropic)',
+        env: ['ANTHROPIC_API_KEY'],
+        noCatalogo: 'anthropic',
         base: 'https://api.anthropic.com/v1',
         modelos: ['claude-sonnet-5', 'claude-haiku-4-5-20251001', 'claude-opus-5-5'],
         onde: 'https://console.anthropic.com/settings/keys',
@@ -72,6 +79,7 @@ const PROVEDORES = {
     },
     groq: {
         nome: 'Groq',
+        env: ['GROQ_API_KEY'],
         base: 'https://api.groq.com/openai/v1',
         modelos: ['openai/gpt-oss-120b', 'llama-3.3-70b-versatile', 'openai/gpt-oss-20b'],
         onde: 'https://console.groq.com/keys',
@@ -79,6 +87,7 @@ const PROVEDORES = {
     },
     openrouter: {
         nome: 'OpenRouter',
+        env: ['OPENROUTER_API_KEY'],
         base: 'https://openrouter.ai/api/v1',
         modelos: ['openai/gpt-oss-120b', 'google/gemini-2.5-flash', 'anthropic/claude-sonnet-5'],
         onde: 'https://openrouter.ai/keys',
@@ -86,6 +95,7 @@ const PROVEDORES = {
     },
     deepseek: {
         nome: 'DeepSeek',
+        env: ['DEEPSEEK_API_KEY'],
         base: 'https://api.deepseek.com/v1',
         modelos: ['deepseek-chat'],
         onde: 'https://platform.deepseek.com/api_keys',
@@ -100,6 +110,66 @@ function mascarar(chave) {
     return `${k.slice(0, 4)}…${k.slice(-4)}`;
 }
 
+/* ── DE ONDE VEM CADA PROVEDOR ────────────────────────────────────────────
+ * 1. os do menu (PROVEDORES acima) — curados, com o modelo preferido
+ * 2. os da pessoa — ~/.primocode/provedores.json, qualquer endereço que fale
+ *    o formato da OpenAI (um gateway da empresa, um Ollama, um LiteLLM...):
+ *      { "meu-gateway": { "nome": "Meu gateway", "base": "https://…/v1",
+ *                         "env": ["MEU_GATEWAY_KEY"], "modelos": ["gpt-x"] } }
+ *    URL e chave moram NA MÁQUINA DA PESSOA, nunca no código.
+ * 3. os do catálogo models.dev (lib/provider/catalogo.js) — centenas
+ * A chave vem do arquivo do /api ou, se não houver, da variável de ambiente
+ * do provedor (GROQ_API_KEY etc.), como no OpenCode. */
+const ARQUIVO_PROVEDORES = () => path.join(os.homedir(), '.primocode', 'provedores.json');
+
+function provedoresDaPessoa() {
+    try {
+        const j = JSON.parse(fs.readFileSync(ARQUIVO_PROVEDORES(), 'utf8'));
+        const saida = {};
+        for (const [id, v] of Object.entries(j || {})) {
+            if (!v || typeof v.base !== 'string' || !/^https?:\/\//.test(v.base)) continue;
+            saida[id] = {
+                nome: String(v.nome || id), base: v.base.replace(/\/+$/, ''),
+                env: Array.isArray(v.env) ? v.env.map(String) : [],
+                modelos: Array.isArray(v.modelos) && v.modelos.length ? v.modelos.map(String) : [''],
+                dica: 'configurado por você', onde: '', propria: true,
+            };
+        }
+        return saida;
+    } catch { return {}; }
+}
+
+/** O provedor `id` de qualquer origem, ou null. */
+function resolver(id) {
+    if (PROVEDORES[id]) return PROVEDORES[id];
+    const meus = provedoresDaPessoa();
+    if (meus[id]) return meus[id];
+    const c = catalogo.carregarSync().provedores[id];
+    if (!c) return null;
+    return {
+        nome: c.nome, base: c.api, env: c.env,
+        // quem usa ferramenta vem primeiro: o agente precisa delas
+        modelos: Object.keys(c.modelos).sort((a, b) => Number(c.modelos[b].ferr) - Number(c.modelos[a].ferr)),
+        dica: `${Object.keys(c.modelos).length} modelos (catálogo)`, onde: '', catalogo: true,
+    };
+}
+
+/** Os que a pessoa pode escolher, na ordem do menu: curados, os dela, o resto do catálogo. */
+function todos() {
+    const lista = { ...PROVEDORES, ...provedoresDaPessoa() };
+    for (const id of Object.keys(catalogo.carregarSync().provedores)) if (!lista[id]) lista[id] = resolver(id);
+    return lista;
+}
+
+/** A chave de ambiente do provedor, se alguma das variáveis dele estiver preenchida. */
+function chaveDoAmbiente(p) {
+    for (const nome of (p && p.env) || []) {
+        const v = process.env[nome];
+        if (v && v.trim()) return v.trim();
+    }
+    return '';
+}
+
 let cache = null;
 let cacheMtime = 0;
 
@@ -108,20 +178,24 @@ function atual() {
     if (process.env.PRIMOCODE_SEM_PROVEDOR === '1') return null;
     let st;
     try { st = fs.statSync(ARQUIVO()); } catch { cache = null; return null; }
-    if (cache && st.mtimeMs === cacheMtime) return cache;
-    try {
-        const j = JSON.parse(fs.readFileSync(ARQUIVO(), 'utf8'));
-        const p = PROVEDORES[j.provedor];
-        cache = p && (j.chave || p.cli)
-            ? { id: j.provedor, nome: p.nome, cli: !!p.cli, base: j.base || p.base, modelo: j.modelo || p.modelos[0], chave: j.chave || '' }
-            : null;
-    } catch { cache = null; }
-    cacheMtime = st.mtimeMs;
-    return cache;
+    if (!(cache && st.mtimeMs === cacheMtime)) {
+        try { cache = JSON.parse(fs.readFileSync(ARQUIVO(), 'utf8')); } catch { cache = null; }
+        cacheMtime = st.mtimeMs;
+    }
+    if (!cache) return null;
+    const p = resolver(cache.provedor);
+    // a chave do ambiente é lida a cada chamada: trocar a variável vale na hora
+    const chave = cache.chave || chaveDoAmbiente(p);
+    if (!p || !(chave || p.cli)) return null;
+    return {
+        id: cache.provedor, nome: p.nome, cli: !!p.cli, base: cache.base || p.base,
+        modelo: cache.modelo || p.modelos[0], chave, daAmbiente: !cache.chave && !!chave,
+        noCatalogo: p.noCatalogo || (p.catalogo ? cache.provedor : (catalogo.carregarSync().provedores[cache.provedor] ? cache.provedor : '')),
+    };
 }
 
 function salvar({ provedor, chave, modelo }) {
-    if (!PROVEDORES[provedor]) throw new Error(`provedor desconhecido: ${provedor}`);
+    if (!resolver(provedor)) throw new Error(`provedor desconhecido: ${provedor}`);
     const arq = ARQUIVO();
     fs.mkdirSync(path.dirname(arq), { recursive: true });
     fs.writeFileSync(arq, JSON.stringify({ provedor, chave: String(chave || '').trim(), modelo }, null, 2), { mode: 0o600 });
@@ -133,7 +207,45 @@ function salvar({ provedor, chave, modelo }) {
 function trocarModelo(modelo) {
     const a = atual();
     if (!a) return null;
-    return salvar({ provedor: a.id, chave: a.chave, modelo });
+    return salvar({ provedor: a.id, chave: a.daAmbiente ? '' : a.chave, modelo });
+}
+
+/**
+ * Escolhe pelo nome: "modelo" (no provedor de agora) ou "provedor/modelo".
+ * OpenRouter tem ids com barra ("openai/gpt-oss-120b"): se o texto inteiro é
+ * um modelo do provedor de agora, é ele; só então a barra separa o provedor.
+ * Mudar de provedor exige a chave dele no ambiente (a do /api é de um só).
+ */
+function escolherModelo(ref) {
+    const txt = String(ref || '').trim();
+    if (!txt) return { ok: false, erro: 'diga o modelo: /api modelo <modelo> ou <provedor>/<modelo>' };
+    const a = atual();
+    const pAtual = a && resolver(a.id);
+    // catálogo manda no que ele conhece; nos curados, modelo fora dele passa COM aviso (o catálogo pode estar atrás)
+    const noCat = (id, p) => { const k = p.noCatalogo || id; return catalogo.carregarSync().provedores[k] || null; };
+    const checar = (id, p, m) => {
+        const c = noCat(id, p);
+        if (p.catalogo) return p.modelos.includes(m) ? null : { erro: `${p.nome} não tem o modelo ${m} no catálogo. Veja: primocode modelos --provedor ${id}` };
+        if (c && !c.modelos[m]) return { aviso: `O catálogo não lista ${m} para ${p.nome}; se der 404, veja: primocode modelos --provedor ${p.noCatalogo || id}` };
+        return null;
+    };
+    if (a && (!txt.includes('/') || pAtual.modelos.includes(txt) || (noCat(a.id, pAtual) || { modelos: {} }).modelos[txt])) {
+        const v = checar(a.id, pAtual, txt);
+        if (v && v.erro) return { ok: false, erro: v.erro };
+        return { ok: true, atual: trocarModelo(txt), aviso: v && v.aviso };
+    }
+    const i = txt.indexOf('/');
+    const pid = i > 0 ? txt.slice(0, i) : '';
+    const mid = txt.slice(i + 1);
+    const p = pid && resolver(pid);
+    if (!p || !mid) return { ok: false, erro: `não achei "${txt}". Use <provedor>/<modelo> (primocode modelos lista) ou rode /api antes.` };
+    const v = checar(pid, p, mid);
+    if (v && v.erro) return { ok: false, erro: v.erro };
+    const guardada = a && a.id === pid && !a.daAmbiente ? a.chave : '';
+    if (!guardada && !chaveDoAmbiente(p) && !p.cli) {
+        return { ok: false, erro: `${p.nome} precisa de chave: defina ${(p.env || [])[0] || 'a chave'} no ambiente ou rode /api ${pid}.` };
+    }
+    return { ok: true, atual: salvar({ provedor: pid, chave: guardada, modelo: mid }), aviso: v && v.aviso };
 }
 
 function desligar() {
@@ -143,7 +255,8 @@ function desligar() {
 
 /** A chave colada serve? Pergunta a lista de modelos à própria API. */
 async function conferir(provedor, chave, { buscar = fetch } = {}) {
-    const p = PROVEDORES[provedor];
+    const p = resolver(provedor);
+    if (!p) return { ok: false, error: `provedor desconhecido: ${provedor}` };
     let r;
     try {
         r = await buscar(`${p.base}/models`, {
@@ -166,4 +279,4 @@ async function conferir(provedor, chave, { buscar = fetch } = {}) {
     return { ok: true, modelo, disponiveis: lista };
 }
 
-module.exports = { PROVEDORES, ARQUIVO, mascarar, atual, salvar, trocarModelo, desligar, conferir };
+module.exports = { PROVEDORES, ARQUIVO, ARQUIVO_PROVEDORES, mascarar, atual, salvar, trocarModelo, escolherModelo, desligar, conferir, resolver, todos, provedoresDaPessoa, chaveDoAmbiente };