primocode 9.7.0 → 9.8.0-beta.1

package/lib/local/entrada.js

@@ -0,0 +1,332 @@
+/**
+ * orcamento-entrada.js — o que ENTRA no pedido, e quanto isso custa.
+ *
+ * ── O NÚMERO QUE MOTIVOU ESTE ARQUIVO ────────────────────────────────────
+ * Medido no servidor, com o pedido VAZIO — antes de o usuário digitar
+ * qualquer coisa:
+ *
+ *     schema das 45 ferramentas ....... 4.326 tokens
+ *     prompt do sistema ............... 2.365 tokens
+ *     ────────────────────────────────────────────
+ *     piso de qualquer pedido ......... 6.691 tokens
+ *     teto do plano grátis ............ 6.000 tokens por minuto
+ *
+ * Ou seja: TODO pedido do modo primocode já nascia estourado. Não era a
+ * conversa que crescia demais — era o custo fixo que não cabia. O usuário via
+ * "a conversa passou do teto" no meio de uma tarefa e não tinha o que encurtar.
+ *
+ * ── A IDEIA ──────────────────────────────────────────────────────────────
+ * Ninguém precisa das 45 ferramentas para fazer um slide. Quem pede um vídeo
+ * não usa `desktop_click`; quem conserta um bug não usa `studio_criar`. Então
+ * cada pedido leva só o que aquele pedido pode usar — ferramentas E seções do
+ * prompt — e o que sobra do orçamento vira espaço para a conversa.
+ *
+ * O núcleo (ler, escrever, procurar, rodar, terminar) vai SEMPRE: é o que
+ * qualquer tarefa usa, e adivinhar errado aqui custaria a tarefa inteira.
+ *
+ * Puro de propósito: sem I/O e sem rede, para o teste medir o orçamento sem
+ * chave de API nenhuma.
+ */
+
+'use strict';
+
+/**
+ * A MESMA conta do orcamento.js — e isso não era verdade antes.
+ *
+ * Aqui era 4 caracteres por token e lá 2,6. Para o mesmo prompt e as mesmas
+ * ferramentas as duas discordavam em 2.070 tokens, e quem decidia o orçamento
+ * de entrada era a conta OTIMISTA: achava que 3.844 cabiam em 5.200 quando o
+ * custo real era ~5.900. JSON de schema é o pior caso — pontuação, aspas e
+ * identificador curto tokenizam muito pior que texto corrido.
+ */
+const CHARS_POR_TOKEN = 2.6;
+function tokensDe(x) {
+    const texto = typeof x === 'string' ? x : JSON.stringify(x || '');
+    return Math.ceil(texto.length / CHARS_POR_TOKEN);
+}
+
+/**
+ * O mesmo schema, com a descrição cortada na primeira frase.
+ *
+ * A primeira frase é a que diz o que a tool FAZ; o resto é conselho de uso,
+ * que também está no prompt. Num teto apertado isso vale 768 tokens (3.130 ->
+ * 2.362) sem tirar nenhuma ferramenta da mão do agente — e ferramenta a menos
+ * é tarefa que não sai.
+ */
+function enxugarSchema(tools) {
+    return (tools || []).map((t) => {
+        const d = t && t.function && t.function.description;
+        if (!d) return t;
+        const primeira = String(d).split(/(?<=\.)\s/)[0].slice(0, 160);
+        if (primeira.length >= String(d).length) return t;
+        return { ...t, function: { ...t.function, description: primeira } };
+    });
+}
+
+// ── Os grupos ────────────────────────────────────────────────────────────
+// `sempre: true` é o núcleo — vai em todo pedido, sem discussão.
+const GRUPOS = [
+    {
+        nome: 'nucleo',
+        sempre: true,
+        tools: ['write_file', 'edit_file', 'multi_edit', 'read_file', 'list_dir',
+            'glob', 'grep', 'run_shell', 'write_todos', 'finish'],
+    },
+    {
+        nome: 'estudio',
+        tools: ['studio_manual', 'studio_spec', 'studio_criar', 'studio_ler',
+            'studio_atualizar', 'studio_versoes', 'studio_listar', 'studio_midia'],
+        // O que o estúdio produz, e os apps que ele substitui.
+        gatilho: /\b(slides?|apresenta[çc][ãa]o|deck|v[íi]deo|reels?|anima[çc][ãa]o|post|banner|capa|thumbnail|arte|cartaz|logo|planilha|tabela|or[çc]amento|documento|relat[óo]rio|artigo|proposta|contrato|diagrama|fluxograma|organograma|mapa mental|narra[çc][ãa]o|trilha|est[úu]dio|canva|powerpoint|keynote|word|docs|excel|sheets|photoshop|figma|capcut|premiere|miro)\b/i,
+    },
+    {
+        nome: 'navegador',
+        tools: ['browser_open', 'browser_click', 'browser_type', 'browser_key',
+            'browser_read', 'browser_screenshot', 'browser_scroll', 'browser_wait',
+            'browser_eval', 'open_in_browser'],
+        gatilho: /\b(site|p[áa]gina|navegador|browser|chrome|url|https?:|www\.|link|formul[áa]rio|login|clicar no bot[ãa]o|testar? (a p[áa]gina|no navegador)|pesquis|busca|internet|not[íi]cia|empresa|mercado)\b/i,
+    },
+    {
+        nome: 'computador',
+        tools: ['desktop_open_app', 'desktop_windows', 'desktop_focus', 'desktop_elements',
+            'desktop_click_element', 'desktop_click', 'desktop_double_click', 'desktop_move',
+            'desktop_drag', 'desktop_type', 'desktop_key', 'desktop_scroll', 'desktop_size',
+            'desktop_screenshot'],
+        // Só quando a tarefa é MESMO no computador. É o grupo mais caro
+        // (1.141 tokens) e o menos usado no dia a dia.
+        gatilho: /\b(janela|[áa]rea de trabalho|desktop|abrir? o (app|programa|aplicativo)|clica(r)? (na tela|no [íi]cone)|[íi]cone|mouse|teclado|atalho|print da tela|screenshot|alt\+tab|ctrl\+|bloco de notas|calculadora|explorer|finder)\b/i,
+    },
+    {
+        nome: 'pesquisa',
+        tools: ['pesquisar_referencia'],
+        gatilho: /\b(pesquis|busca|procur|internet|documenta[çc][ãa]o|refer[êe]ncia|empresa|mercado|not[íi]cia|quem [ée]|sobre a |sobre o |dados de|hist[óo]ria d)\b/i,
+    },
+    {
+        /* O PIPELINE DE QUATRO PAPÉIS, e ele é caro de duas formas: o schema
+           dele é longo, e chamá-lo custa seis a oito agentes. Por isso o
+           gatilho pede o PAR — um verbo de construir colado num substantivo de
+           coisa inteira. "Melhore o site" e "conserte o app" não passam de
+           propósito: o pipeline constrói do zero, e mandá-lo mexer no que já
+           existe é pagar oito agentes para refazer o que estava pronto. */
+        nome: 'pipeline',
+        tools: ['construir_app'],
+        gatilho: /\b(fa[çc]a|fa[çc]er|faz|cria|crie|criar|monta|monte|montar|constr[óo]i|construa|construir|desenvolv[ae]|quero|preciso de)\b[^.!?]{0,24}\b(app|aplicativo|site|p[áa]gina|landing|jogo|game|ferramenta|dashboard|painel|calculadora|sistema|portf[óo]lio|loja|formul[áa]rio|cron[ôo]metro|agenda|lista de tarefas|to-?do)\b/i,
+    },
+    {
+        /* O ARQUIVO do vídeo. Quem pede "faz um vídeo" recebe o link e o
+           botão de baixar; a ferramenta que gera o mp4 sem clique só entra
+           quando o pedido fala do arquivo — é o que mantém o pedido de vídeo
+           dentro do teto do minuto (medido: ela custa ~180 tokens). */
+        nome: 'exportar',
+        tools: ['studio_exportar'],
+        gatilho: /\b(mp4|webm|baix[ae]r?|download|exporta\w*|salv[ae]r? (o )?v[íi]deo|arquivo (do|de) v[íi]deo|me manda o v[íi]deo|manda o arquivo|renderiza\w*)\b/i,
+    },
+    {
+        nome: 'delegar',
+        tools: ['spawn_agent'],
+        // Delegar só compensa em tarefa grande; em pedido curto é peso morto.
+        gatilho: /\b(v[áa]rios|v[áa]rias|todos os|todas as|em paralelo|projeto inteiro|refator|migra[çc][ãa]o|auditor)\b/i,
+    },
+    {
+        nome: 'terminal',
+        tools: ['run_in_new_terminal'],
+        gatilho: /\b(servidor|dev|watch|npm run|yarn|vite|next|rodar? em segundo plano|localhost|porta \d+)\b/i,
+    },
+    {
+        // Sem tool nova — só a seção de prompt com as regras de qualidade de
+        // código. Nasceu de reclamação real do dono: "ele faz coisas
+        // horríveis em relação a código". As regras custam ~200 tokens e só
+        // entram quando a tarefa É de código.
+        nome: 'codigo',
+        tools: [],
+        gatilho: /\b(c[óo]digo|app|site|jogo|fun[çc][ãa]o|bug|erro|script|html|css|javascript|typescript|python|node|api|backend|frontend|componente|refator|classe|m[óo]dulo|landing)\b/i,
+    },
+];
+
+/**
+ * Quais grupos esta tarefa pode usar.
+ *
+ * Olha o pedido do usuário — não a conversa inteira: o que o modelo escreveu
+ * no meio do caminho não deve mudar o que ele pode usar depois. `forcar`
+ * existe para o que já foi decidido fora daqui (o esforço alto sempre pesquisa).
+ */
+function gruposDe(texto, forcar = []) {
+    const t = String(texto || '');
+    const escolhidos = new Set(['nucleo', ...forcar]);
+    for (const g of GRUPOS) {
+        if (g.sempre) { escolhidos.add(g.nome); continue; }
+        if (g.gatilho && g.gatilho.test(t)) escolhidos.add(g.nome);
+    }
+    return escolhidos;
+}
+
+/** As ferramentas dos grupos escolhidos, na ordem original da lista. */
+function escolherFerramentas(todas, texto, opts = {}) {
+    const grupos = gruposDe(texto, opts.forcar);
+    const permitidas = new Set();
+    for (const g of GRUPOS) {
+        if (grupos.has(g.nome)) for (const t of g.tools) permitidas.add(t);
+    }
+    const escolhidas = (todas || []).filter((t) => permitidas.has(t.function && t.function.name));
+    // Rede de segurança: se a seleção falhar (nome novo que ninguém mapeou),
+    // é melhor mandar tudo do que mandar um agente sem ferramenta.
+    return escolhidas.length >= 5 ? escolhidas : todas;
+}
+
+/**
+ * O que a conversa mostra que o agente JÁ APRENDEU.
+ *
+ * A seção "O ESTÚDIO" do prompt ensina o que a spec entrega — e a spec, quando
+ * já foi lida, está inteira na conversa. Manter as duas é pagar duas vezes
+ * pelo mesmo ensinamento, e são 1.113 tokens que fazem falta justamente na
+ * hora de escrever o documento.
+ *
+ * O mesmo vale para pesquisa: com as fontes já lidas, o texto sobre COMO
+ * pesquisar não muda mais nada.
+ */
+function jaAprendeu(messages) {
+    const nomePorId = new Map();
+    for (const m of messages || []) {
+        for (const tc of (m && m.tool_calls) || []) {
+            nomePorId.set(tc.id, (tc.function && tc.function.name) || tc.name);
+        }
+    }
+    const feitas = new Set();
+    for (const m of messages || []) {
+        if (m && m.role === 'tool' && nomePorId.has(m.tool_call_id)) feitas.add(nomePorId.get(m.tool_call_id));
+    }
+    const dispensaveis = new Set();
+    if (feitas.has('studio_spec') || feitas.has('studio_manual')) dispensaveis.add('estudio');
+    if (feitas.has('pesquisar_referencia')) dispensaveis.add('pesquisa');
+    return dispensaveis;
+}
+
+/**
+ * O prompt, montado só com as seções que a tarefa usa.
+ *
+ * `secoes` é { nome: texto }. O núcleo entra sempre; as outras entram quando o
+ * grupo correspondente entrou.
+ */
+function montarPrompt(nucleo, secoes, texto, opts = {}) {
+    const grupos = gruposDe(texto, opts.forcar);
+    const dispensaveis = opts.jaAprendeu || new Set();
+    const partes = [nucleo];
+    for (const [nome, corpo] of Object.entries(secoes || {})) {
+        if (grupos.has(nome) && corpo && !dispensaveis.has(nome)) partes.push(corpo);
+    }
+    return partes.join('\n\n');
+}
+
+/**
+ * O relatório do que este pedido vai custar, para o servidor registrar e para
+ * o teste provar que a economia existe.
+ */
+function relatorio({ prompt, ferramentas, messages }) {
+    const p = tokensDe(prompt);
+    const f = tokensDe(ferramentas);
+    const m = tokensDe(messages);
+    return { prompt: p, ferramentas: f, conversa: m, total: p + f + m, tools: (ferramentas || []).length };
+}
+
+/**
+ * Faz a CONVERSA caber no que sobrou do orçamento.
+ *
+ * A seleção de ferramentas resolve o custo fixo; isto resolve o variável. Numa
+ * tarefa de pesquisa o histórico cresce rápido (cada página lida são milhares
+ * de caracteres), e sem um teto ela volta a estourar no meio do trabalho —
+ * justamente depois de todo o esforço já gasto.
+ *
+ * Ordem das concessões, da menos dolorosa para a mais:
+ *   1. encurta os resultados de tool ANTIGOS (os novos são os que importam);
+ *   2. encurta mais ainda, se preciso;
+ *   3. em último caso, descarta as rodadas mais VELHAS — sempre o par
+ *      inteiro (o turno do assistente com tool_calls + as respostas dele),
+ *      porque a API recusa um role:'tool' órfão.
+ *
+ * O pedido do usuário e a última rodada nunca são descartados: sem eles o
+ * modelo não sabe mais o que estava fazendo.
+ */
+// Tools cuja resposta é DOCUMENTO FIXO e que o agente precisa ter em mãos na
+// hora de escrever. Encolher isto é o que criou o loop original: sem o formato,
+// o modelo pede a spec de novo, e de novo.
+//
+// O CLI já protege as mesmas mensagens antes de mandar (lib/repeticao.js), mas
+// quem falava por último aqui era `caberNoTeto`, que não sabia disso e cortava
+// assim mesmo. Dois compactadores brigando, e o do servidor ganhava.
+const REFERENCIAS = new Set(['studio_manual', 'studio_spec']);
+
+// Referência tem teto GENEROSO, não infinito.
+//
+// Proteger a spec inteira parecia certo — sem o formato o agente não escreve o
+// documento — mas a spec do `corte` são 3.270 tokens, e com o prompt e as 17
+// tools isso dá 7.126: estoura o minuto SOZINHO, e nenhum corte na conversa
+// resolve. Protegida demais, ela deixava de caber. O começo do documento é o
+// formato (que o agente precisa); o fim são exemplos e opções avançadas.
+const LIMITE_REFERENCIA = 3500;
+
+/** Os índices de role:'tool' que não podem encolher: a cópia mais nova de cada referência. */
+function referenciasProtegidas(messages) {
+    const nomePorId = new Map();
+    for (const m of messages || []) {
+        for (const tc of (m && m.tool_calls) || []) {
+            nomePorId.set(tc.id, (tc.function && tc.function.name) || tc.name);
+        }
+    }
+    const ultima = new Map();
+    (messages || []).forEach((m, i) => {
+        if (!m || m.role !== 'tool') return;
+        const nome = nomePorId.get(m.tool_call_id);
+        if (REFERENCIAS.has(nome)) ultima.set(nome, i);
+    });
+    return new Set(ultima.values());
+}
+
+function caberNoTeto(messages, sobra) {
+    const conta = (m) => tokensDe(m);
+    if (conta(messages) <= sobra) return { messages, cortou: false };
+
+    let atual = messages.map((m) => ({ ...m }));
+
+    // 1 e 2: encurtar resultados antigos, em dois apertos.
+    const protegidas = referenciasProtegidas(atual);
+    for (const limite of [400, 120]) {
+        const indices = atual.map((m, i) => (m.role === 'tool' ? i : -1)).filter((i) => i >= 0);
+        const manterInteiros = new Set(indices.slice(-2));
+        atual = atual.map((m, i) => {
+            const texto = String(m.content || '');
+            // Referência: teto próprio, muito maior que o dos outros — o
+            // formato vem no começo do documento.
+            if (protegidas.has(i)) {
+                if (texto.length <= LIMITE_REFERENCIA) return m;
+                return { ...m, content: texto.slice(0, LIMITE_REFERENCIA) + '…(spec cortada no limite do plano; o formato essencial está acima)' };
+            }
+            if (m.role !== 'tool' || manterInteiros.has(i)) return m;
+            if (texto.length <= limite) return m;
+            return { ...m, content: texto.slice(0, limite) + '…(encurtado para caber no limite do plano)' };
+        });
+        if (conta(atual) <= sobra) return { messages: atual, cortou: true, como: 'encurtou resultados antigos' };
+    }
+
+    // 3: descartar as rodadas mais velhas, em pares completos.
+    while (conta(atual) > sobra) {
+        const aindaProtegidas = referenciasProtegidas(atual);
+        const primeiroAssistente = atual.findIndex((m, i) => {
+            if (!(m.role === 'assistant' && m.tool_calls)) return false;
+            // Descartar a rodada que trouxe a spec é recriar o loop original:
+            // sem o formato o agente pede a spec de novo, e de novo.
+            let f = i + 1;
+            while (f < atual.length && atual[f].role === 'tool') { if (aindaProtegidas.has(f)) return false; f++; }
+            return true;
+        });
+        if (primeiroAssistente === -1) break;
+        let fim = primeiroAssistente + 1;
+        while (fim < atual.length && atual[fim].role === 'tool') fim++;
+        // Nunca engolir tudo: para se sobrar só o pedido do usuário.
+        if (fim >= atual.length - 1) break;
+        atual = [...atual.slice(0, primeiroAssistente), ...atual.slice(fim)];
+    }
+
+    return { messages: atual, cortou: true, como: 'descartou as rodadas mais antigas' };
+}
+
+module.exports = { GRUPOS, CHARS_POR_TOKEN, REFERENCIAS, LIMITE_REFERENCIA, tokensDe, enxugarSchema, referenciasProtegidas, jaAprendeu, gruposDe, escolherFerramentas, montarPrompt, relatorio, caberNoTeto };

package/lib/local/motor.js

@@ -0,0 +1,264 @@
+/**
+ * motor.js — o agente falando DIRETO com a IA da pessoa, daqui da máquina.
+ *
+ * Faz o que o primocode-server faz nas rotas /api/act/stream, /api/chat/stream,
+ * /api/resumir e /api/plano, com o mesmo prompt e as mesmas ferramentas
+ * (lib/local/cerebro.json, copiado do servidor por scripts/cerebro-do-servidor.js),
+ * e devolve os MESMOS eventos. Para o loop do agente (lib/act.js), nada muda:
+ * ele não sabe se quem respondeu foi o servidor ou a API da pessoa.
+ *
+ * O que fica de fora de propósito: a fila de provedores e o orçamento de 6.000
+ * tokens por minuto. Os dois existem para caber na cota compartilhada — aqui
+ * a conta é da pessoa, e o teto é o dela.
+ */
+
+'use strict';
+
+const cerebro = require('./cerebro.json');
+const entrada = require('./entrada.js');
+const provedor = require('./provedor.js');
+const catalogo = require('../catalogo.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.
+const TETO_CONVERSA = Number(process.env.PRIMOCODE_TETO_LOCAL || 60000);
+const SAIDA_MAXIMA = 8192;
+const ESFORCO_PESQUISA = ['high', 'xhigh', 'max', 'ultracode'];
+
+/* ── AS FERRAMENTAS QUE ESTE CLIENTE EXECUTA ─────────────────────────────
+ * O servidor ainda oferece o Estúdio antigo (studio_*), que este cliente não
+ * executa mais; e o cliente tem o Estúdio novo (estudio_*, planejar_producao),
+ * que o servidor não conhece. Local, a lista certa é a do CLIENTE: o schema
+ * vem do servidor quando existe lá, e do catálogo quando só existe aqui. */
+function ferramentasDoCliente() {
+    const doServidor = new Map(cerebro.TOOLS.map((t) => [t.function.name, t]));
+    const lista = [];
+    for (const grupo of catalogo.GRUPOS) {
+        for (const item of grupo.itens) {
+            if (doServidor.has(item.tool)) { lista.push(doServidor.get(item.tool)); continue; }
+            lista.push({ type: 'function', function: {
+                name: item.tool,
+                description: `${item.faz}. Argumentos: ${item.args || 'nenhum'}`.slice(0, 1800),
+                parameters: { type: 'object', properties: {}, additionalProperties: true },
+            } });
+        }
+    }
+    if (!lista.some((t) => t.function.name === 'finish') && doServidor.has('finish')) lista.push(doServidor.get('finish'));
+    return lista;
+}
+let FERRAMENTAS = null;
+let FERRAMENTAS_SUB = null;
+function ferramentas(subagent) {
+    if (!FERRAMENTAS) {
+        FERRAMENTAS = ferramentasDoCliente();
+        FERRAMENTAS_SUB = FERRAMENTAS.filter((t) => !['spawn_agent', 'construir_app'].includes(t.function.name));
+    }
+    return subagent ? FERRAMENTAS_SUB : FERRAMENTAS;
+}
+
+/** O erro da API, no formato que o loop já sabe tratar (429 espera, 401 avisa). */
+async function erroHttp(r, p) {
+    let msg = '';
+    try {
+        const corpo = await r.text();
+        try {
+            const j = JSON.parse(corpo);
+            const e = Array.isArray(j) ? j[0] && j[0].error : j.error;
+            msg = (e && (e.message || e.status)) || j.message || corpo;
+        } catch { msg = corpo; }
+    } catch { /* sem corpo */ }
+    const quem = p ? p.nome : 'o provedor';
+    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.` : ''}`);
+}
+
+function cabecalhos(p) {
+    const h = { 'Content-Type': 'application/json', Authorization: `Bearer ${p.chave}` };
+    if (p.id === 'openrouter') { h['HTTP-Referer'] = 'https://github.com/parisgroup-ai/primocode'; h['X-Title'] = 'PrimoCode'; }
+    return h;
+}
+
+/** Uma chamada inteira, sem stream (resumo, plano). */
+async function completar(messages, { maxTokens = 600, temperatura = 0.2 } = {}) {
+    const p = provedor.atual();
+    const r = await fetch(`${p.base}/chat/completions`, {
+        method: 'POST',
+        headers: cabecalhos(p),
+        body: JSON.stringify({ model: p.modelo, messages, temperature: temperatura, max_tokens: maxTokens }),
+        signal: AbortSignal.timeout(90000),
+    });
+    if (!r.ok) throw await erroHttp(r, p);
+    const j = await r.json();
+    return String((j.choices && j.choices[0] && j.choices[0].message && j.choices[0].message.content) || '').trim();
+}
+
+/**
+ * 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();
+    let r;
+    try {
+        r = await fetch(`${p.base}/chat/completions`, {
+            method: 'POST', headers: cabecalhos(p), body: JSON.stringify({ ...corpo, model: p.modelo, stream: true }), signal: sinal,
+        });
+    } catch (e) {
+        if (sinal && sinal.aborted) return;
+        throw new Error(`ECONNRESET não consegui falar com ${p.nome}: ${e.message}`);
+    }
+    if (!r.ok) throw await erroHttp(r, p);
+    const decod = new TextDecoder();
+    let buffer = '';
+    try {
+        for await (const pedaco of r.body) {
+            buffer += decod.decode(pedaco, { stream: true });
+            const linhas = buffer.split('\n');
+            buffer = linhas.pop();
+            for (const linha of linhas) {
+                const l = linha.trim();
+                if (!l.startsWith('data:')) continue;
+                const dado = l.slice(5).trim();
+                if (dado === '[DONE]') return;
+                let j;
+                try { j = JSON.parse(dado); } catch { continue; }
+                if (j.error) throw new Error(`${j.error.code || 400} ${j.error.message || JSON.stringify(j.error)}`);
+                const escolha = j.choices && j.choices[0];
+                if (escolha) aoPedaco(escolha.delta || {}, escolha.finish_reason);
+            }
+        }
+    } catch (e) {
+        if (sinal && sinal.aborted) return;
+        throw e;
+    }
+}
+
+/** Junta os pedaços de tool_call. Gemini às vezes manda sem `index` e sem `id`. */
+function juntarChamadas(acumuladas, pedacos) {
+    for (const tc of pedacos || []) {
+        let idx;
+        if (Number.isInteger(tc.index)) idx = tc.index;
+        else if (tc.id) {
+            idx = acumuladas.findIndex((a) => a && a.id === tc.id);
+            if (idx < 0) idx = acumuladas.length;             // id novo: chamada nova
+        } else idx = Math.max(0, acumuladas.length - 1);     // sem nada: continua a última
+        if (!acumuladas[idx]) acumuladas[idx] = { id: tc.id || '', name: '', arguments: '' };
+        const alvo = acumuladas[idx];
+        if (tc.id) alvo.id = tc.id;
+        if (tc.function && tc.function.name) alvo.name = tc.function.name;
+        if (tc.function && tc.function.arguments) {
+            const a = tc.function.arguments;
+            alvo.arguments += typeof a === 'string' ? a : JSON.stringify(a);
+        }
+    }
+    return acumuladas;
+}
+
+/* ── /api/act/stream ─────────────────────────────────────────────────── */
+async function requestAct(_servidor, body, emit) {
+    const { messages: convo = [], prompt, history, effort, projectDir, projectName, subagent, sinal } = 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.' });
+    }
+    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 texto_ = '';
+    const chamadas = [];
+    await lerStream({ messages, tools, tool_choice: 'auto', temperature: 0.1, max_tokens: SAIDA_MAXIMA }, {
+        sinal,
+        aoPedaco: (delta) => {
+            if (delta.tool_calls) juntarChamadas(chamadas, delta.tool_calls);
+            if (delta.content && !chamadas.length) { texto_ += delta.content; emit({ delta: delta.content }); }
+        },
+    });
+    chamadas.forEach((tc, i) => {
+        if (!tc || !tc.name) return;
+        let args = {};
+        try { args = JSON.parse(tc.arguments || '{}'); } catch { /* o loop pede de novo */ }
+        emit({ tool_call: { id: tc.id || `local_${Date.now()}_${i}`, name: tc.name, arguments: args } });
+    });
+    if (texto_) emit({ assistant_message: { content: texto_ } });
+    emit({ done: true });
+}
+
+/* ── /api/chat/stream ────────────────────────────────────────────────── */
+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 }] : [])];
+    await lerStream({
+        messages: [{ role: 'system', content: cerebro.SYSTEM_CHAT }, ...turnos.filter((m) => m && m.role)],
+        temperature: 0.4, max_tokens: 1200,
+    }, { sinal, aoPedaco: (delta) => { if (delta.content) emit({ delta: delta.content }); } });
+    emit({ done: true });
+}
+
+/* ── /api/resumir ────────────────────────────────────────────────────── */
+async function requestResumo(_servidor, { resumo, mensagens } = {}) {
+    const novas = Array.isArray(mensagens) ? mensagens.filter((m) => m && m.role) : [];
+    if (!novas.length) return { resumo: String(resumo || '') };
+    const virarTexto = (m) => {
+        const quem = m.role === 'user' ? 'USUÁRIO' : m.role === 'assistant' ? 'AGENTE' : 'FERRAMENTA';
+        const conteudo = typeof m.content === 'string' ? m.content : JSON.stringify(m.content || '');
+        return `${quem}: ${conteudo.slice(0, 1200)}`;
+    };
+    const corpo = (resumo ? `RESUMO ANTERIOR:\n${resumo}\n\n` : '') + `MENSAGENS NOVAS:\n${novas.map(virarTexto).join('\n')}`;
+    try {
+        const limpo = await completar([{ role: 'system', content: cerebro.SYSTEM_RESUMO }, { role: 'user', content: corpo }], { maxTokens: 600 });
+        return { resumo: limpo || String(resumo || '') };
+    } catch (e) {
+        return { resumo: String(resumo || ''), erro: e.message };
+    }
+}
+
+/** Os passos do plano, tolerando cerca de markdown. Mesma regra do servidor. */
+function lerPassos(texto) {
+    const bruto = String(texto || '').trim().replace(/^```(?:json)?\s*/i, '').replace(/```\s*$/i, '');
+    const abre = bruto.indexOf('{');
+    const fecha = bruto.lastIndexOf('}');
+    if (abre === -1 || fecha <= abre) return null;
+    let j;
+    try { j = JSON.parse(bruto.slice(abre, fecha + 1)); } catch { return null; }
+    const lista = Array.isArray(j && j.passos) ? j.passos : null;
+    if (!lista || !lista.length) return null;
+    const limpos = lista
+        .map((p) => ({ titulo: String((p && p.titulo) || 'passo').slice(0, 60), pedido: String((p && p.pedido) || '').trim() }))
+        .filter((p) => p.pedido.length > 10)
+        .slice(0, 3);
+    return limpos.length ? limpos : null;
+}
+
+/* ── /api/plano ──────────────────────────────────────────────────────── */
+async function requestPlano(_servidor, { prompt } = {}) {
+    const cru = String(prompt || '').trim();
+    const passoUnico = [{ titulo: 'tarefa', pedido: cru }];
+    if (cru.length < 25) return { passos: passoUnico, dividiu: false };
+    try {
+        const passos = lerPassos(await completar(
+            [{ role: 'system', content: cerebro.SYSTEM_PLANO }, { role: 'user', content: cru }],
+            { maxTokens: 800, temperatura: 0.1 })) || passoUnico;
+        return { passos, dividiu: passos.length > 1 };
+    } catch {
+        return { passos: passoUnico, dividiu: false };
+    }
+}
+
+module.exports = { requestAct, requestChat, requestResumo, requestPlano, juntarChamadas, lerPassos, ferramentas, ativo: () => !!provedor.atual() };