primocode 4.3.1 → 7.0.1

package/lib/act.js

@@ -1,500 +1,72 @@
-// Modo Primo Code — faz tudo sozinho: código, arquivos, terminal, navegador
-// REGRA FUNDAMENTAL: NUNCA entregue código no CMD/terminal.
-// SEMPRE use write_file para criar arquivos.
-// Se for executável (HTML, etc.), use open_in_browser para abrir.
-// Se for Python/JS, use run_in_new_terminal para executar.
-
+// Loop do agente autônomo — vai e volta entre server e execução local.
 
 'use strict';
 
-const path = require('path');
-const { c, actionHeader, toolLine, Spinner } = require('./ui');
+const { c, actionHeader, Spinner } = require('./ui');
 const tools = require('./tools');
 const api = require('./api');
 
 const MAX_ITERATIONS = 15;
 
-function fmtArgs(name, args) {
-    if (!args) return '';
-    switch (name) {
-        case 'read_file':          return args.path || '';
-        case 'write_file':         return `${args.path || ''} · ${(args.content || '').length} chars`;
-        case 'list_dir':           return args.path || '.';
-        case 'run_shell':          return args.command || '';
-        case 'run_in_new_terminal':return `${args.command || ''}${args.cwd ? ' @ ' + args.cwd : ''}`;
-        case 'open_in_browser':    return args.target || '';
-        case 'browser_open':       return args.url || '';
-        case 'browser_navigate':   return args.url || '';
-        case 'browser_click':      return args.selector || args.text || (args.x != null ? `${args.x},${args.y}` : '');
-        case 'browser_type':       return `${args.selector ? args.selector + ' · ' : ''}${(args.text || '').length} chars`;
-        case 'browser_key':        return args.key || '';
-        case 'browser_wait_for':   return args.selector || '';
-        case 'browser_wait':       return `${args.ms || 1000}ms`;
-        case 'browser_screenshot': return args.path || '(auto)';
-        case 'browser_eval':       return (args.js || '').slice(0, 60);
-        case 'browser_scroll':     return `dy=${args.dy || 400}`;
-        case 'browser_url':        return '';
-        case 'finish':             return args.summary || '';
-        default: return JSON.stringify(args).slice(0, 80);
-    }
-}
-
-// Nomes simples das ações
-const NICE = {
-    read_file: 'Read', write_file: 'Write', list_dir: 'List',
-    run_shell: 'Bash', run_in_new_terminal: 'Terminal', open_in_browser: 'Open',
-    browser_open: 'Browser', browser_navigate: 'Navigate', browser_click: 'Click',
-    browser_clickText: 'ClickText', browser_type: 'Type', browser_key: 'Key',
-    browser_wait_for: 'Wait', browser_wait: 'Wait', browser_screenshot: 'Screenshot',
-    browser_eval: 'Eval', browser_scroll: 'Scroll', browser_url: 'URL', finish: 'Finish',
-};
-
 function makeLogger() {
     return {
         event(kind, arg, result) {
             if (kind === 'run_shell') return;
             if (kind === 'run_shell_done') {
-                if (result) {
-                    const s = result.ok ? c.ok('  exit 0') : c.err(`  exit ${result.code}${result.killed ? ' timeout' : ''}`);
-                    process.stdout.write('\n' + s + '\n');
-                }
+                if (result) { const s = result.ok ? c.ok('  exit 0') : c.err(`  exit ${result.code}${result.killed?' timeout':''}`); process.stdout.write('\n'+s+'\n'); }
                 return;
             }
             const prefix = c.muted('  ⎿ ');
-            if (kind === 'write_file' && result && result.ok) {
-                console.log(prefix + c.muted(`${result.created ? 'created' : 'updated'} · ${tools.fmtBytes(result.bytes)}`));
-                return;
-            }
-            if (kind === 'read_file' && result && result.ok) {
-                console.log(prefix + c.muted(`${tools.fmtBytes(result.bytes || 0)}${result.truncated ? ' (truncated)' : ''}`));
-                return;
-            }
-            if (kind === 'list_dir' && result && result.ok) {
-                const lines = result.tree.split('\n').slice(0, 8);
-                for (const l of lines) console.log(prefix + c.muted(l));
-                const total = result.tree.split('\n').length;
-                if (total > 8) console.log(prefix + c.muted(`… +${total - 8}`));
-                return;
-            }
-            if (kind === 'open_in_browser' && result && result.ok) {
-                console.log(prefix + c.muted(`${result.opener || 'browser'}`));
-                return;
-            }
-            if (kind === 'run_in_new_terminal' && result && result.ok) {
-                console.log(prefix + c.muted(`${result.opener}`));
-                return;
-            }
-            if (kind === 'finish') {
-                console.log(prefix + c.muted(arg || 'ok'));
-                return;
-            }
-            if (result && result.ok === false) {
-                console.log(prefix + c.err(result.error || 'failed'));
-            }
+            if (kind === 'write_file' && result && result.ok) { console.log(prefix + c.muted(`${result.created?'created':'updated'} · ${tools.fmtBytes(result.bytes)}`)); return; }
+            if (kind === 'read_file' && result && result.ok) { console.log(prefix + c.muted(`${tools.fmtBytes(result.bytes||0)}${result.truncated?' (truncated)':''}`)); return; }
+            if (kind === 'list_dir' && result && result.ok) { const lines = result.tree.split('\n').slice(0,8); for (const l of lines) console.log(prefix + c.muted(l)); const total = result.tree.split('\n').length; if (total>8) console.log(prefix + c.muted(`… +${total-8}`)); return; }
+            if (kind === 'open_in_browser' && result && result.ok) { console.log(prefix + c.muted(`${result.opener||'browser'}`)); return; }
+            if (kind === 'run_in_new_terminal' && result && result.ok) { console.log(prefix + c.muted(`${result.opener}`)); return; }
+            if (kind === 'finish') { console.log(prefix + c.muted(arg || 'ok')); return; }
+            if (result && result.ok === false) console.log(prefix + c.err(result.error || 'failed'));
         },
     };
 }
 
-/**
- * Executa uma tarefa em modo Act (agente autônomo com tools).
- * @param {string} userPrompt - texto do usuário
- * @param {object} opts - { server, model, history: [{role,content}, ...] }
- * @returns {Promise<{userMessage, assistantMessage}>}  para o caller atualizar seu histórico
- */
 async function runAct(userPrompt, opts) {
-    const { server, model, history: chatHistory = [] } = opts;
-
-    // Injeta contexto do CWD e inclui histórico curto de conversa
-    const cwd = process.cwd();
-    const cwdBase = path.basename(cwd);
-    const enriched = `[contexto: diretório atual = ${cwd} (basename: '${cwdBase}')]\n\n${userPrompt}`;
-
-    // Estado do loop
-    // Começamos com as mensagens do chat (para memória) + o novo user prompt.
-    let messages = [];
-    if (Array.isArray(chatHistory) && chatHistory.length) {
-        // Só passamos user/assistant sem tool_calls (o histórico de tool calls foi episódico).
-        for (const m of chatHistory) {
-            if (m && (m.role === 'user' || m.role === 'assistant') && m.content) {
-                messages.push({ role: m.role, content: m.content });
-            }
+    const { server, model, history, projectDir, projectName } = opts || {};
+    const logger = makeLogger();
+    const messages = [
+        ...(Array.isArray(history) ? history.filter(m => m && m.role && m.content).slice(-20) : []),
+        { role: 'user', content: userPrompt },
+    ];
+    const toolResults = [];
+    let iteration = 0;
+
+    while (iteration < MAX_ITERATIONS) {
+        iteration++;
+        const sp = new Spinner('pensando').start();
+        let response;
+        try { response = await api.requestAct(server, messages, model); }
+        catch (e) { sp.stop(); console.log(c.err(`\nErro no servidor: ${e.message||e}`)); throw e; }
+        sp.stop();
+
+        if (!response.tool_calls || !response.tool_calls.length) {
+            const content = response.content || '';
+            console.log('\n' + c.white(content));
+            return { userMessage: { role: 'user', content: userPrompt }, assistantMessage: { role: 'assistant', content } };
         }
-    }
-
-    let promptForCall = enriched;
-    let toolResults = null;
-    let finished = false;
-    const log = makeLogger();
-    const recentCalls = [];
-    let finalAssistantText = '';
-    let sp = null;
-    let planCache = '';    // cache do plano do Planner entre turnos
-    let planShown = false; // evita mostrar plano múltiplas vezes
-    const filesWritten = new Set(); // arquivos criados/modificados pelo Construtor 1 (para refino)
-    const deferredOpens = [];       // open_in_browser adiados até depois do refino
-
-    for (let iter = 1; iter <= MAX_ITERATIONS && !finished; iter++) {
-        let assistantContent = '';
-        let assistantMessage = null;
-        let toolCalls = [];
-        let serverErr = null;
-        let hasToolCalls = false;
-        let streamingStarted = false;
-        let printedUpTo = 0;         // quantos chars de assistantContent já foram impressos
-        let suppressRest = false;    // uma vez detectado marker, para de imprimir
-        let retryNeeded = false;     // server pedidu retry (ex: finish rejeitado)
-        let rejectedNote = null;     // motivo da rejeição, injetado como tool_result no próximo turno
-        let subagentsPayload = null; // resultado de spawn_parallel (injetado como tool_result)
-        let subagentsToolCallId = null;
-        let subagentsTotal = 0;
-        let subagentsDone = 0;
-
-        // Spinner enquanto aguarda primeiro byte
-        sp = new Spinner('Pensando').start();
 
-        try {
-            await api.requestStream(server, '/api/act/stream', {
-                prompt: promptForCall,
-                history: messages,
-                tool_results: toolResults,
-                model,
-                plan_cache: planCache,
-            }, (evt) => {
-                if (evt.phase === 'inspiring') {
-                    if (sp) sp.stop();
-                    sp = new Spinner('Buscando referências').start();
-                }
-                if (evt.inspiration_urls && Array.isArray(evt.inspiration_urls) && evt.inspiration_urls.length > 0) {
-                    if (sp) { sp.stop(); sp = null; }
-                    console.log('\n' + c.muted('◆ Inspirando-se em:'));
-                    for (const u of evt.inspiration_urls) console.log(c.muted('  · ') + c.accent(u));
-                }
-                if (evt.phase === 'planning' && !planShown) {
-                    if (sp) sp.stop();
-                    sp = new Spinner('Pensando').start();
-                }
-                if (evt.plan) {
-                    planCache = evt.plan;
-                    if (sp) { sp.stop(); sp = null; }
-                    planShown = true;
-                    sp = new Spinner('Executando').start();
-                }
-                if (evt.subagents_spawning) {
-                    subagentsTotal = evt.subagents_spawning;
-                    if (sp) sp.stop();
-                    console.log('\n' + c.muted(`◆ Spawn de ${subagentsTotal} subagentes em paralelo`));
-                    sp = new Spinner(`Subagentes 0/${subagentsTotal}`).start();
-                }
-                if (evt.subagent_done) {
-                    subagentsDone++;
-                    const d = evt.subagent_done;
-                    if (sp) { sp.stop(); sp = null; }
-                    const status = d.ok ? c.ok('✓') : c.err('✗');
-                    console.log(`  ${status} ${c.muted(d.title)} ${c.muted('· ' + (d.bytes || 0) + ' bytes')}`);
-                    if (subagentsDone < subagentsTotal) sp = new Spinner(`Subagentes ${subagentsDone}/${subagentsTotal}`).start();
-                }
-                if (evt.subagents_result) {
-                    subagentsPayload = evt.subagents_result;
-                    subagentsToolCallId = evt.tool_call_id;
-                    if (sp) { sp.stop(); sp = null; }
-                }
-                if (evt.erro) { serverErr = evt.erro; return; }
-                if (evt.delta) {
-                    if (!streamingStarted) {
-                        sp.stop();
-                        process.stdout.write('\n');
-                        streamingStarted = true;
-                    }
-                    assistantContent += evt.delta;
-
-                    if (suppressRest) return;
-
-                    // Se aparece começo de marker suspeito, marca e para de imprimir daqui em diante.
-                    // Também "rebobina" cortando o que já foi acumulado até antes do marker
-                    // (não conseguimos apagar do terminal, mas o texto final ficará limpo).
-                    const leakRe = /<\||【|\n\s*\{\s*"(name|type|summary|arguments|command|path)"|\bfinish\s*\(|\bwrite_file\s*\(|\brun_shell\s*\(|\bopen_in_browser\s*\(|\bbrowser_\w+\s*\(/;
-                    const m = assistantContent.match(leakRe);
-                    if (m && m.index !== undefined) {
-                        const safeEnd = m.index;
-                        if (safeEnd > printedUpTo) {
-                            process.stdout.write(c.white(assistantContent.slice(printedUpTo, safeEnd)));
-                            printedUpTo = safeEnd;
-                        }
-                        suppressRest = true;
-                        return;
-                    }
-
-                    // Imprime até len-2 para dar margem se um marker começar a formar
-                    const target = Math.max(printedUpTo, assistantContent.length - 2);
-                    if (target > printedUpTo) {
-                        process.stdout.write(c.white(assistantContent.slice(printedUpTo, target)));
-                        printedUpTo = target;
-                    }
-                }
-                if (evt.tool_call) toolCalls.push(evt.tool_call);
-                if (evt.assistant_message) assistantMessage = evt.assistant_message;
-                if (evt.tool_rejected) rejectedNote = evt.tool_rejected;
-                if (evt.retry_needed) retryNeeded = true;
-                if (evt.done) hasToolCalls = !!evt.has_tool_calls;
-                if (evt.instability) { serverErr = 'servidor com rate-limit; tente novamente em alguns minutos'; return; }
-            });
-        } catch (e) {
-            if (sp) sp.stop();
-            console.log(c.err(`\nerro: ${e.message}`));
-            return { userMessage: { role: 'user', content: userPrompt }, assistantMessage: { role: 'assistant', content: `[erro: ${e.message}]` } };
+        for (const tc of response.tool_calls) {
+            const name = tc.function?.name || tc.name;
+            let args = {}; try { args = JSON.parse(tc.function?.arguments || tc.arguments || '{}'); } catch {}
+            console.log(actionHeader(name, args));
+            logger.event(name, null, null);
+            let result; try { result = await tools.execute(name, args); } catch (e) { result = { ok: false, error: e.message || String(e) }; }
+            logger.event(name + '_done', null, result);
+            toolResults.push({ tool_call_id: tc.id, role: 'tool', name, content: JSON.stringify(result) });
         }
 
-        if (sp && !streamingStarted) sp.stop();
-
-        // Flush do buffer de 2 chars retido para evitar corte de markers
-        if (streamingStarted && !suppressRest && printedUpTo < assistantContent.length) {
-            process.stdout.write(c.white(assistantContent.slice(printedUpTo)));
-            printedUpTo = assistantContent.length;
-        }
-
-        if (serverErr) {
-            console.log(c.err(`\nerro: ${serverErr}`));
-            return { userMessage: { role: 'user', content: userPrompt }, assistantMessage: { role: 'assistant', content: `[erro: ${serverErr}]` } };
-        }
-
-        if (streamingStarted) process.stdout.write('\n');
-
-        // Atualiza messages internas do loop (com tool_calls, para o modelo saber o que pediu)
-        if (assistantMessage) messages.push(assistantMessage);
-        else messages.push({ role: 'assistant', content: assistantContent });
-
-        // No primeiro turno, inserimos o user antes do assistant (foi só passado como prompt)
-        if (iter === 1) {
-            const last = messages.pop();
-            messages.push({ role: 'user', content: enriched });
-            messages.push(last);
-        }
-
-        promptForCall = null;
-
-        if (assistantContent) {
-            let cleaned = assistantContent
-                .replace(/<\|[\s\S]*$/g, '')
-                .replace(/【[\s\S]*$/g, '')
-                .replace(/\n\s*\{\s*"(name|type|summary|arguments|command|path)"[\s\S]*$/, '')
-                .replace(/^\s*\{\s*"(name|type|summary|arguments)"[\s\S]*$/, '')
-                // Corta chamadas de função vazadas em texto
-                .replace(/\b(finish|write_file|read_file|list_dir|run_shell|run_in_new_terminal|open_in_browser|browser_\w+)\s*\([\s\S]*$/g, '')
-                .trim();
-            if (cleaned) finalAssistantText = cleaned;
-        }
-
-        // Subagentes rodaram — injeta resultado como tool_result e segue loop
-        if (subagentsPayload && subagentsToolCallId) {
-            toolResults = [{ tool_call_id: subagentsToolCallId, result: JSON.stringify(subagentsPayload) }];
-            promptForCall = null;
-            continue;
-        }
-
-        // Server pediu retry (ex: finish sem trabalho no primeiro turno)
-        if (retryNeeded && rejectedNote) {
-            // Injeta pseudo tool_result educativo pro próximo turno
-            const rejectedId = assistantMessage?.tool_calls?.[0]?.id;
-            if (rejectedId) {
-                toolResults = [{ tool_call_id: rejectedId, result: JSON.stringify({ ok: false, error: rejectedNote.reason }) }];
-            }
-            // Novo prompt reforçando a ordem
-            promptForCall = `[sistema] Seu último ${rejectedNote.name}() foi rejeitado: ${rejectedNote.reason}\n\nExecute o pedido original agora, usando as ferramentas corretas antes de qualquer finish.`;
-            continue;
-        }
-
-        if (!hasToolCalls || toolCalls.length === 0) {
-            finished = true;
-            break;
-        }
-
-        // Executa cada tool
-        const results = [];
-        for (const tc of toolCalls) {
-            const name = tc.name;
-            const args = tc.arguments || {};
-            const nice = NICE[name] || name;
-            const detail = fmtArgs(name, args);
-            console.log('\n' + toolLine(nice, detail));
-
-            let res;
-            // Interceptação: se o Construtor 1 quer abrir arquivo E há refino planejado,
-            // adia a abertura pra DEPOIS do refino (não mostra ao usuário versão bugada).
-            // Só adiamos se já houver pelo menos 1 arquivo escrito (senão não faz sentido refinar).
-            const shouldDeferOpen = (name === 'open_in_browser' && args.target && filesWritten.size > 0);
-            if (shouldDeferOpen) {
-                deferredOpens.push(args.target);
-                res = { ok: true, text_for_model: JSON.stringify({ ok: true, deferred: true, note: 'abertura adiada para depois do refino' }) };
-                console.log(c.muted('  ⎿ adiado até depois do refino'));
-            } else {
-                try {
-                    res = await tools.executeTool(name, args, log);
-                } catch (e) {
-                    res = { ok: false, text_for_model: JSON.stringify({ ok: false, error: e.message }) };
-                    console.log(c.err(`  exception: ${e.message}`));
-                }
-            }
-            results.push({ tool_call_id: tc.id, result: res.text_for_model });
-
-            // Rastreia arquivos escritos para depois passar ao Construtor 2 (refino)
-            if (name === 'write_file' && args.path) {
-                try { filesWritten.add(String(args.path)); } catch { /* noop */ }
-            }
-
-            if (res.finish) finished = true;
-
-            const sig = name + '|' + JSON.stringify(args);
-            recentCalls.push(sig);
-            if (recentCalls.length > 4) recentCalls.shift();
-            if (recentCalls.filter(s => s === sig).length >= 3) {
-                console.log('\n' + c.warn('loop detectado — encerrando.'));
-                finished = true;
-                break;
-            }
-        }
-
-        toolResults = results;
-        if (finished) break;
-    }
-
-    if (!finished) console.log('\n' + c.warn(`limite de ${MAX_ITERATIONS} iterações atingido.`));
-
-    // ═══ FASE C — Refino (Construtor 2) ═══
-    // Só refina se o Construtor 1 realmente criou/modificou arquivos.
-    // Não refina para saudações/perguntas conceituais.
-    if (filesWritten.size > 0) {
-        const refineFiles = Array.from(filesWritten).slice(0, 8); // cap defensivo
-        console.log('\n' + c.muted('◆ Refinando (Construtor 2)'));
-        let refineSp = new Spinner('Melhorando').start();
-        let refineIter = 0;
-        let refineDone = false;
-        let refineToolResults = null;
-        const REFINE_MAX = 6;
-        // Histórico ISOLADO do refino — nunca inclui o histórico do executor
-        // (isso quebra o Groq porque as tool_calls antigas não têm tool_results correspondentes).
-        const refineMessages = [];
-
-        while (!refineDone && refineIter < REFINE_MAX) {
-            refineIter++;
-            let assistantMessage = null;
-            let toolCalls = [];
-            let serverErr = null;
-            let hasToolCalls = false;
-            let streamingStarted = false;
-            let printedUpTo = 0;
-            let suppressRest = false;
-            let assistantContent = '';
-
-            try {
-                await api.requestStream(server, '/api/act/stream', {
-                    refine: true,
-                    refine_files: refineFiles,
-                    refine_original_prompt: userPrompt,
-                    refine_history: refineMessages,
-                    tool_results: refineToolResults,
-                    model,
-                }, (evt) => {
-                    if (evt.erro) { serverErr = evt.erro; return; }
-                    if (evt.delta) {
-                        if (!streamingStarted) {
-                            if (refineSp) { refineSp.stop(); refineSp = null; }
-                            process.stdout.write('\n');
-                            streamingStarted = true;
-                        }
-                        assistantContent += evt.delta;
-                        if (suppressRest) return;
-                        const leakRe = /<\||【|\n\s*\{\s*"(name|type|summary|arguments|command|path)"|\bfinish\s*\(|\bwrite_file\s*\(|\brun_shell\s*\(|\bopen_in_browser\s*\(|\bbrowser_\w+\s*\(/;
-                        const mm = assistantContent.match(leakRe);
-                        if (mm && mm.index !== undefined) {
-                            const safeEnd = mm.index;
-                            if (safeEnd > printedUpTo) {
-                                process.stdout.write(c.white(assistantContent.slice(printedUpTo, safeEnd)));
-                                printedUpTo = safeEnd;
-                            }
-                            suppressRest = true;
-                            return;
-                        }
-                        const target = Math.max(printedUpTo, assistantContent.length - 2);
-                        if (target > printedUpTo) {
-                            process.stdout.write(c.white(assistantContent.slice(printedUpTo, target)));
-                            printedUpTo = target;
-                        }
-                    }
-                    if (evt.tool_call) toolCalls.push(evt.tool_call);
-                    if (evt.assistant_message) assistantMessage = evt.assistant_message;
-                    if (evt.done) hasToolCalls = !!evt.has_tool_calls;
-                    if (evt.instability) { serverErr = 'refino indisponível (rate-limit)'; return; }
-                    if (evt.refine_skipped) { refineDone = true; return; }
-                });
-            } catch (e) {
-                if (refineSp) refineSp.stop();
-                console.log(c.warn(`\n(refino pulado: ${e.message})`));
-                break;
-            }
-
-            if (refineSp && !streamingStarted) refineSp.stop();
-            if (streamingStarted && !suppressRest && printedUpTo < assistantContent.length) {
-                process.stdout.write(c.white(assistantContent.slice(printedUpTo)));
-            }
-            if (streamingStarted) process.stdout.write('\n');
-
-            if (serverErr) { console.log(c.warn(`\n(refino falhou: ${serverErr})`)); break; }
-
-            // Guarda o assistant_message NO HISTÓRICO ISOLADO do refino (não no messages global)
-            if (assistantMessage) refineMessages.push(assistantMessage);
-            if (!hasToolCalls || toolCalls.length === 0) { refineDone = true; break; }
-
-            const results = [];
-            for (const tc of toolCalls) {
-                const name = tc.name;
-                const args = tc.arguments || {};
-                const nice = NICE[name] || name;
-                const detail = fmtArgs(name, args);
-                console.log('\n' + toolLine(nice, detail));
-                let res;
-                try { res = await tools.executeTool(name, args, log); }
-                catch (e) { res = { ok: false, text_for_model: JSON.stringify({ ok: false, error: e.message }) }; console.log(c.err(`  exception: ${e.message}`)); }
-                results.push({ tool_call_id: tc.id, result: res.text_for_model });
-                // O refino também precisa adicionar tool result no histórico isolado
-                refineMessages.push({ role: 'tool', tool_call_id: tc.id, content: res.text_for_model });
-                if (res.finish) refineDone = true;
-            }
-            refineToolResults = null; // já injetamos no refineMessages, não duplicar
-
-            // Prepara spinner do próximo turno de refino se ainda não terminou
-            if (!refineDone) refineSp = new Spinner('Melhorando').start();
-        }
-        if (refineSp) refineSp.stop();
-
-        // Executa aberturas adiadas agora que o refino terminou
-        if (deferredOpens.length > 0) {
-            for (const target of deferredOpens) {
-                console.log('\n' + toolLine('Open', target));
-                try {
-                    const res = await tools.executeTool('open_in_browser', { target }, log);
-                    if (!res.ok && res.text_for_model) {
-                        console.log(c.muted('  ⎿ ' + (res.error || 'ok')));
-                    }
-                } catch (e) {
-                    console.log(c.err(`  ⎿ falha: ${e.message}`));
-                }
-            }
-        }
-    } else if (deferredOpens.length > 0) {
-        // Não houve refino mas há aberturas adiadas — executa direto (fallback)
-        for (const target of deferredOpens) {
-            console.log('\n' + toolLine('Open', target));
-            try { await tools.executeTool('open_in_browser', { target }, log); }
-            catch (e) { console.log(c.err(`  ⎿ falha: ${e.message}`)); }
-        }
+        messages.push({ role: 'assistant', content: response.content || '', tool_calls: response.tool_calls });
+        for (const tr of toolResults) messages.push({ role: 'tool', tool_call_id: tr.tool_call_id, name: tr.name, content: tr.content });
     }
-
-    // Retorna a mensagem final para o caller anexar ao histórico do chat
-    // Consolidamos toda a atividade + texto final para o usuário poder referenciar depois
-    return {
-        userMessage: { role: 'user', content: userPrompt },
-        assistantMessage: { role: 'assistant', content: finalAssistantText || '[ação concluída]' },
-    };
+    console.log(c.err('\nLimite de iterações atingido.'));
+    return { userMessage: { role: 'user', content: userPrompt }, assistantMessage: { role: 'assistant', content: 'Limite de iterações atingido.' } };
 }
 
 module.exports = { runAct };

package/lib/api.js

@@ -12,7 +12,7 @@ function request(serverUrl, endpoint, payload) {
     return new Promise((resolve, reject) => {
         const url = new URL(endpoint, serverUrl);
         const data = JSON.stringify(payload);
-        const options = { hostname: url.hostname, port: url.port || (url.protocol==='https:'?443:80), path: url.pathname+url.search, method: 'POST', headers: { 'Content-Type':'application/json', 'Content-Length':Buffer.byteLength(data) }, timeout: 60000 };
+        const options = { hostname: url.hostname, port: url.port || (url.protocol==='https:'?443:80), path: url.pathname+url.search, method: 'POST', headers: { 'Content-Type':'application/json', 'Content-Length':Buffer.byteLength(data) } };
         const client = url.protocol==='https:' ? https : http;
         const req = client.request(options, (res) => { let body=''; res.on('data', c=>body+=c); res.on('end', () => { try { const json=JSON.parse(body); if (res.statusCode>=400) reject(new Error(json.erro||json.error||`HTTP ${res.statusCode}`)); else resolve(json); } catch { reject(new Error(`Resposta inválida: ${body.slice(0,200)}`)); } }); });
         req.on('error', reject); req.write(data); req.end();
@@ -23,14 +23,16 @@ function requestStream(serverUrl, endpoint, payload, onEvent) {
     return new Promise((resolve, reject) => {
         const url = new URL(endpoint, serverUrl);
         const data = JSON.stringify(payload);
-        const options = { hostname: url.hostname, port: url.port || (url.protocol==='https:'?443:80), path: url.pathname+url.search, method: 'POST', headers: { 'Content-Type':'application/json', 'Content-Length':Buffer.byteLength(data), 'Accept':'text/event-stream' }, timeout: 60000 };
+        const options = { hostname: url.hostname, port: url.port || (url.protocol==='https:'?443:80), path: url.pathname+url.search, method: 'POST', headers: { 'Content-Type':'application/json', 'Content-Length':Buffer.byteLength(data), 'Accept':'text/event-stream' } };
         const client = url.protocol==='https:' ? https : http;
         const req = client.request(options, (res) => { let buffer=''; res.on('data', chunk => { buffer+=chunk; const lines=buffer.split('\n'); buffer=lines.pop(); for (const line of lines) if (line.startsWith('data: ')) { try { const evt=JSON.parse(line.slice(6)); onEvent(evt); if (evt.done) resolve(); } catch {} } }); res.on('end', () => resolve()); });
         req.on('error', reject); req.write(data); req.end();
     });
 }
 
-function requestAct(serverUrl, messages, model) { return request(serverUrl, '/api/act', { messages, model }); }
+function requestAct(serverUrl, messages, model, extras) { 
+    return request(serverUrl, '/api/act', { messages, model, ...(extras || {}) }); 
+}
 
 function getHealth(serverUrl) {
     return new Promise((resolve, reject) => { const url=new URL('/health',serverUrl); const client=url.protocol==='https:'?https:http; const req=client.get(url, (res)=>{ let body=''; res.on('data',c=>body+=c); res.on('end',()=>{ try { resolve(JSON.parse(body)); } catch { reject(new Error('Resposta inválida do health check')); } }); }); req.on('error',reject); });