kafox-cli 0.10.1 → 0.10.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kafox-cli",
-  "version": "0.10.1",
+  "version": "0.10.2",
   "description": "Kafox CLI: TUI com streaming, thinking, edit com diff, agent tools (files/shell), MCP e temas",
   "repository": {
     "type": "git",

package/src/auth.js

@@ -14,8 +14,10 @@ async function fetchApi(pathname, options = {}) {
       return await fetch(url, {
         ...options,
         headers: { ...storage.getAuthHeaders(options.headers), ...options.headers },
-        // timeout por tentativa: nao deixa um host travado segurar o login.
-        signal: AbortSignal.timeout ? AbortSignal.timeout(12000) : undefined,
+        // Timeout por tentativa: nao deixa um host travado segurar o login.
+        // Mas se o caller passou o proprio signal (ex.: o stream do chat, que
+        // pode durar minutos), respeita ele em vez de matar em 12s.
+        signal: options.signal || (AbortSignal.timeout ? AbortSignal.timeout(12000) : undefined),
       });
     } catch (error) {
       lastError = error;

package/src/gateway.js

@@ -117,7 +117,9 @@ function wait(ms, signal) {
       resolve(value);
     };
     const timer = setTimeout(() => done(true), ms);
-    timer.unref?.();
+    // Sem unref(): o backoff precisa manter o event loop vivo. Se este for o
+    // unico timer pendente e estiver unref'd, o Node dorme e a CLI so acorda
+    // quando o usuario digita algo — o retry ficaria "travado" ate um input.
     function onAbort() {
       done(false);
     }
@@ -139,7 +141,7 @@ function errorFrom(data, status) {
  * Le um stream SSE de chat completions (OpenAI-compatible) e chama os
  * callbacks a cada delta. Devolve o resultado final.
  */
-async function readStream({ response, started, onDelta, onReasoning }) {
+async function readStream({ response, started, onDelta, onReasoning, skipPrefix = "", signal } = {}) {
   const decoder = new TextDecoder();
   let buffer = "";
   let text = "";
@@ -147,6 +149,73 @@ async function readStream({ response, started, onDelta, onReasoning }) {
   let usage = null;
   const toolCalls = [];
 
+  // Watchdog de inatividade: o provedor as vezes morre sem FIN e o `for await`
+  // do body fica pendurado pra sempre (o event loop dorme e a CLI so acorda no
+  // proximo input). Se nenhum byte chega por IDLE_MS, aborta localmente e marca
+  // como retryable — o chat() reconecta por continuacao.
+  const IDLE_MS = Number(process.env.KAFOX_STREAM_IDLE_MS) || 90_000;
+  const idle = new AbortController();
+  let idleTimer = null;
+  let idleFired = false;
+  const clearIdle = () => {
+    if (idleTimer) clearTimeout(idleTimer);
+    idleTimer = null;
+  };
+  // Quando o watchdog dispara, cancelamos o reader do body: isso desbloqueia o
+  // `read()` pendurado (o signal do fetch sozinho nao interrompe um body ja
+  // iniciado se a conexao morreu sem FIN).
+  let reader = null;
+  const onIdleAbort = () => {
+    idleFired = true;
+    reader?.cancel?.().catch(() => {});
+  };
+  idle.signal.addEventListener("abort", onIdleAbort, { once: true });
+  const bumpIdle = () => {
+    if (idleTimer) clearTimeout(idleTimer);
+    idleTimer = setTimeout(() => idle.abort(new Error("stream idle timeout")), IDLE_MS);
+  };
+  bumpIdle();
+  // Continuacao: o provedor costuma repetir o inicio ja recebido antes de
+  // seguir. Segura a emissao ate passar do prefixo para nao duplicar na tela.
+  let toSkip = skipPrefix;
+  // Texto efetivamente entregue ao onDelta nesta tentativa (sem o prefixo).
+  let emitted = "";
+
+  const emitContent = (chunk) => {
+    if (toSkip) {
+      if (chunk.length <= toSkip.length) {
+        // O trecho novo ainda esta dentro do prefixo repetido: confere se bate.
+        if (toSkip.startsWith(chunk)) {
+          toSkip = toSkip.slice(chunk.length);
+          return;
+        }
+        // Divergiu do prefixo: o modelo recomecou; emite tudo o que veio.
+        toSkip = "";
+        emitted += chunk;
+        onDelta?.(chunk);
+        return;
+      }
+      // Passou do prefixo: descarta a parte repetida e emite o resto.
+      const overlap = chunk.slice(0, toSkip.length);
+      if (overlap === toSkip || chunk.startsWith(toSkip)) {
+        const rest = chunk.slice(toSkip.length);
+        toSkip = "";
+        if (rest) {
+          emitted += rest;
+          onDelta?.(rest);
+        }
+        return;
+      }
+      // Nao bateu: recomecou, emite tudo.
+      toSkip = "";
+      emitted += chunk;
+      onDelta?.(chunk);
+      return;
+    }
+    emitted += chunk;
+    onDelta?.(chunk);
+  };
+
   const handleLine = (line) => {
     if (!line.startsWith("data:")) return null;
     const data = line.slice(5).trim();
@@ -172,48 +241,81 @@ async function readStream({ response, started, onDelta, onReasoning }) {
     }
     if (delta.content) {
       text += delta.content;
-      onDelta?.(delta.content);
+      emitContent(delta.content);
     }
     if (Array.isArray(delta.tool_calls)) mergeToolCalls(toolCalls, delta.tool_calls);
     return null;
   };
 
   try {
-    for await (const chunk of response.body) {
-      buffer += decoder.decode(chunk, { stream: true });
+    reader = response.body.getReader();
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      bumpIdle();
+      buffer += decoder.decode(value, { stream: true });
       let index = buffer.indexOf("\n");
       while (index >= 0) {
         const line = buffer.slice(0, index).replace(/\r$/, "");
         buffer = buffer.slice(index + 1);
         const failure = handleLine(line);
-        if (failure) return { ok: false, error: failure.error, retryable: failure.retryable };
+        if (failure) { clearIdle(); return { ok: false, error: failure.error, retryable: failure.retryable }; }
         index = buffer.indexOf("\n");
       }
     }
     if (buffer.trim()) handleLine(buffer.trim());
+    // O cancel() do watchdog pode encerrar o reader como "done": se foi o
+    // watchdog que disparou, isso e falha e deve reconectar.
+    if (idleFired) {
+      clearIdle();
+      return {
+        ok: false,
+        error: `Stream interrompido: sem resposta do provedor por ${Math.round(IDLE_MS / 1000)}s`,
+        text,
+        emitted,
+        retryable: true,
+      };
+    }
   } catch (error) {
-    if (error?.name === "AbortError") {
-      return { ok: true, text, reasoning, toolCalls, ms: Date.now() - started, aborted: true };
+    clearIdle();
+    if (error?.name === "AbortError" || idleFired) {
+      // Abort com o signal do usuario ativo = ele apertou Esc: encerra.
+      if (signal?.aborted && !idleFired) {
+        return { ok: true, text, emitted, reasoning, toolCalls, ms: Date.now() - started, aborted: true };
+      }
+      // Sem abort do usuario, falha de conexao ou watchdog de inatividade:
+      // marca como retryable para o chat() reconectar de onde parou.
+      return {
+        ok: false,
+        error: idleFired
+          ? `Stream interrompido: sem resposta do provedor por ${Math.round(IDLE_MS / 1000)}s`
+          : `Stream interrompido: ${error.message || "conexao caiu"}`,
+        text,
+        emitted,
+        retryable: true,
+      };
     }
     return {
       ok: false,
       error: `Stream interrompido: ${error.message}`,
       text,
+      emitted,
       retryable: retryableMessage(error.message),
     };
   }
+  clearIdle();
 
-  return { ok: true, text, reasoning, toolCalls: toolCalls.filter(Boolean), usage, ms: Date.now() - started };
+  return { ok: true, text, emitted, reasoning, toolCalls: toolCalls.filter(Boolean), usage, ms: Date.now() - started };
 }
 
 /**
  * Uma tentativa no provedor kafox (gateway proprio): login/saldo/chave da conta
  * e POST em `/api/chat`.
  */
-async function attemptChat({ messages, model, tools, onDelta, onReasoning, signal } = {}) {
+async function attemptChat({ messages, model, tools, onDelta, onReasoning, signal, skipPrefix } = {}) {
   const socket = providerForModel(model);
   if (socket.provider.kind === "openai") {
-    return attemptOpenAI({ messages, model: socket.model, provider: socket.provider, tools, onDelta, onReasoning, signal });
+    return attemptOpenAI({ messages, model: socket.model, provider: socket.provider, tools, onDelta, onReasoning, signal, skipPrefix });
   }
 
   const ready = await ensureReady({ model });
@@ -235,11 +337,11 @@ async function attemptChat({ messages, model, tools, onDelta, onReasoning, signa
       signal,
     });
   } catch (error) {
-    if (error?.name === "AbortError") return { ok: false, code: "aborted", error: "Cancelado." };
+    if (error?.name === "AbortError" && signal?.aborted) return { ok: false, code: "aborted", error: "Cancelado." };
     return {
       ok: false,
-      error: `Falha de rede: ${error.message}`,
-      retryable: retryableMessage(error.message),
+      error: error?.name === "AbortError" ? `Falha de rede: ${error.message || "conexao caiu"}` : `Falha de rede: ${error.message}`,
+      retryable: error?.name === "AbortError" ? true : retryableMessage(error.message),
       keyCreated: ready.keyCreated,
     };
   }
@@ -254,7 +356,7 @@ async function attemptChat({ messages, model, tools, onDelta, onReasoning, signa
     };
   }
 
-  const result = await readStream({ response, started, onDelta, onReasoning });
+  const result = await readStream({ response, started, onDelta, onReasoning, skipPrefix, signal });
   return { ...result, model: ready.model, keyCreated: ready.keyCreated };
 }
 
@@ -263,7 +365,7 @@ async function attemptChat({ messages, model, tools, onDelta, onReasoning, signa
  * `{baseUrl}/chat/completions` com a chave do usuario. Sem login/saldo da conta
  * kafox; o custo e cobrado pelo proprio provedor.
  */
-async function attemptOpenAI({ messages, model, provider, tools, onDelta, onReasoning, signal } = {}) {
+async function attemptOpenAI({ messages, model, provider, tools, onDelta, onReasoning, signal, skipPrefix } = {}) {
   const apiKey = storage.getProviderKey(provider.id);
   if (!apiKey) {
     return {
@@ -292,11 +394,11 @@ async function attemptOpenAI({ messages, model, provider, tools, onDelta, onReas
       signal,
     });
   } catch (error) {
-    if (error?.name === "AbortError") return { ok: false, code: "aborted", error: "Cancelado." };
+    if (error?.name === "AbortError" && signal?.aborted) return { ok: false, code: "aborted", error: "Cancelado." };
     return {
       ok: false,
-      error: `Falha de rede: ${error.message}`,
-      retryable: retryableMessage(error.message),
+      error: error?.name === "AbortError" ? `Falha de rede: ${error.message || "conexao caiu"}` : `Falha de rede: ${error.message}`,
+      retryable: error?.name === "AbortError" ? true : retryableMessage(error.message),
     };
   }
 
@@ -309,42 +411,93 @@ async function attemptOpenAI({ messages, model, provider, tools, onDelta, onReas
     };
   }
 
-  const result = await readStream({ response, started, onDelta, onReasoning });
+  const result = await readStream({ response, started, onDelta, onReasoning, skipPrefix, signal });
   return { ...result, model, provider: provider.id };
 }
 
 /**
  * Chat completions com stream (SSE) via /api/chat, com retry em falha de rede.
  * onRetry avisa a TUI (tentativa, espera) para ela mostrar a contagem.
+ *
+ * Queda no meio da resposta (o pior caso: ja saiu texto e o stream morre) e
+ * reconectada por continuacao: reenvia a conversa com o trecho parcial como
+ * assistant e pede para seguir de onde parou. O `skipPrefix` faz o provedor
+ * repetir o inicio; o gateway descarta a repeticao, entao a TUI so ve o que
+ * e novo. Se a continuacao falhar, devolve o parcial para nao perder nada.
  */
 async function chat({ messages, model, tools, onDelta, onReasoning, onRetry, signal, retries = RETRY_MAX } = {}) {
   const maxAttempts = Math.max(1, Number(retries) || RETRY_MAX);
   let attempt = 0;
   let last = null;
   let clearedKey = false;
+  // Acumulado entre tentativas (modo continuacao).
+  let carried = "";
+  let working = messages;
+  let skipPrefix = "";
 
   while (attempt < maxAttempts) {
     attempt += 1;
-    const result = await attemptChat({ messages, model, tools, onDelta, onReasoning, signal });
+    const result = await attemptChat({
+      messages: working,
+      model,
+      tools,
+      onDelta,
+      onReasoning,
+      signal,
+      skipPrefix,
+    });
 
-    if (result.ok || result.code === "aborted") return result;
+    if (result.ok || result.code === "aborted") {
+      if (carried && result.ok) {
+        // Junta o trecho das tentativas anteriores ao texto final.
+        const emitted = result.emitted ?? "";
+        const fullText = carried + emitted;
+        // Se o provedor mandou texto novo menor que o esperado, ainda vale o
+        // que ja foi mostrado; devolve o maior dos dois para o consumidor.
+        return { ...result, text: fullText.length >= (result.text || "").length ? fullText : result.text };
+      }
+      return result;
+    }
     if (result.code === "invalid_api_key" && !clearedKey) {
       clearedKey = true;
       storage.clearApiKey();
       continue;
     }
-    // Ja saiu texto: repetir duplicaria a resposta na tela.
-    if (!result.retryable || result.text) return result;
+    // Erro nao recuperavel (saldo, chave, modelo): devolve como veio.
+    if (!result.retryable) return carried ? { ...result, text: result.text || carried } : result;
     last = result;
 
+    // Caiu ja com texto na tela: reconecta continuando de onde parou.
+    const partial = String(result.text || "");
+    if (partial.trim()) {
+      carried += partial;
+      skipPrefix = carried;
+      working = [
+        ...messages,
+        { role: "assistant", content: carried },
+        {
+          role: "user",
+          content:
+            "Sua resposta anterior foi interrompida por uma falha de conexao. " +
+            "Continue exatamente de onde parou, sem repetir nada do que ja foi escrito.",
+        },
+      ];
+    }
+
     if (attempt >= maxAttempts) break;
 
     const delay = backoffMs(attempt);
     onRetry?.({ attempt, maxAttempts, delay, error: result.error });
     const slept = await wait(delay, signal);
-    if (!slept) return { ok: false, code: "aborted", error: "Cancelado.", keyCreated: result.keyCreated };
+    if (!slept) {
+      return { ok: false, code: "aborted", error: "Cancelado.", text: carried, keyCreated: result.keyCreated };
+    }
   }
 
+  // Esgotou as tentativas: se ja tinha texto, entrega o parcial (melhor que erro).
+  if (carried.trim()) {
+    return { ...last, ok: true, text: carried, attempts: attempt, partial: true };
+  }
   return { ...last, attempts: attempt };
 }
 

package/src/tui.js

@@ -316,8 +316,26 @@ function tableLines(header, aligns = [], body = [], width = 80, theme = "default
   return lines;
 }
 
-/** Converte Markdown simples em linhas prontas para o terminal. */
+// Cache do markdown renderizado por {texto, largura, tema}. Sem isso, cada
+// frame (inclusive a cada tecla) reparseava o markdown de TODAS as mensagens
+// da conversa, o que domina o tempo de render em chats longos.
+const MARKDOWN_CACHE = new Map();
+const MARKDOWN_CACHE_MAX = 400;
+/** Converte Markdown simples em linhas prontas para o terminal (com cache). */
 function markdownLines(text, width, theme = "default") {
+  const key = `${width}\u0000${theme}\u0000${text}`;
+  const hit = MARKDOWN_CACHE.get(key);
+  if (hit) return hit;
+  const out = markdownLinesUncached(text, width, theme);
+  if (MARKDOWN_CACHE.size >= MARKDOWN_CACHE_MAX) {
+    // Despeja o mais antigo (ordem de insercao do Map).
+    MARKDOWN_CACHE.delete(MARKDOWN_CACHE.keys().next().value);
+  }
+  MARKDOWN_CACHE.set(key, out);
+  return out;
+}
+
+function markdownLinesUncached(text, width, theme = "default") {
   const accent = accentFor(theme);
   const out = [];
   const rows = String(text).replace(/\r/g, "").split("\n");
@@ -481,6 +499,8 @@ const CONTROL_KEYS = {
   12: { name: "l", ctrl: true },
   13: { name: "return" },
   21: { name: "u", ctrl: true },
+  // Ctrl+R: atualiza saldo da conta e dos provedores externos agora.
+  18: { name: "r", ctrl: true },
   // Ctrl+Q: desiste das mensagens que estao na fila (nao cancela a atual).
   17: { name: "q", ctrl: true },
   23: { name: "w", ctrl: true },
@@ -684,6 +704,7 @@ function initialState() {
     modal: null,
     models: [],
     balance: null,
+    providerBalances: [],
     tokens: 0,
     files: [],
     mcp: { loading: false, statuses: [], tools: 0 },
@@ -754,6 +775,8 @@ function heroLines(state, width, available) {
           " envia   " +
           chalk.dim("/") +
           " menu   " +
+          chalk.dim("ctrl+r") +
+          " saldo   " +
           chalk.dim("ctrl+c") +
           " sai",
         width
@@ -1082,40 +1105,81 @@ function compactionLines(message, width, state) {
   return lines;
 }
 
-function messageLines(state, width) {
+/**
+ * Virtualizacao de mensagens.
+ *
+ * Sem isso, cada frame (inclusive a cada tecla) reconstruia linha a linha TODO
+ * o historico da conversa; em chats longos isso domina o tempo de render e
+ * trava a digitacao. Aqui cada mensagem tem suas linhas memorizadas (chaveadas
+ * por texto/largura/tema + o estado que muda o desenho) e so as mensagens que
+ * caem no viewport sao realmente remontadas.
+ */
+const MESSAGE_CACHE = new Map();
+const MESSAGE_CACHE_MAX = 600;
+
+/** Chave de cache de uma mensagem: tudo que muda o desenho dela. */
+function messageCacheKey(message, width, state) {
+  const streaming = state.streaming;
+  const extra =
+    message.role === "tool"
+      ? `${message.status || ""}\u0001${message.duration || ""}\u0001${state.toolCompact ? 1 : 0}`
+      : message.role === "thinking"
+        ? `${message.done ? 1 : 0}`
+        : "";
+  return `${width}\u0000${state.theme}\u0000${message.role}\u0000${extra}\u0000${message.text}`;
+}
+
+/** Linhas de UMA mensagem (com cache). */
+function messageBlock(message, width, state) {
+  const key = messageCacheKey(message, width, state);
+  const hit = MESSAGE_CACHE.get(key);
+  if (hit) return hit;
+  const out = messageBlockUncached(message, width, state);
+  if (MESSAGE_CACHE.size >= MESSAGE_CACHE_MAX) {
+    MESSAGE_CACHE.delete(MESSAGE_CACHE.keys().next().value);
+  }
+  MESSAGE_CACHE.set(key, out);
+  return out;
+}
+
+function messageBlockUncached(message, width, state) {
   const lines = [];
-  for (const message of state.messages) {
-    if (message.role === "user") {
-      lines.push("");
-      const body = wrap(message.text, width - 2);
-      lines.push(indent(2) + chalk.cyan("▌ ") + chalk.bold(body[0] || ""));
-      for (let index = 1; index < body.length; index += 1) {
-        lines.push(indent(4) + chalk.bold(body[index]));
-      }
-    } else if (message.role === "compaction") {
-      lines.push(...compactionLines(message, width, state));
-    } else if (message.role === "assistant") {
-      lines.push("");
-      lines.push(...markdownLines(message.text, width - 2, state.theme));
-      // Só latência: a rota usada por trás é da Kafox, não do cliente.
-      const meta = [];
-      if (message.interrupted) meta.push("interrompido");
-      if (message.ms) meta.push(`${(message.ms / 1000).toFixed(1)}s`);
-      if (meta.length) lines.push("");
-      if (meta.length) lines.push(indent(2) + chalk.dim(meta.join(" · ")));
-    } else if (message.role === "thinking") {
-      lines.push(...thinkingLines(message, width));
-    } else if (message.role === "tool") {
-      lines.push(...toolCardLines(message, width, state));
-    } else {
-      lines.push("");
-      const color = message.error ? chalk.red : message.interrupted ? chalk.yellow : chalk.dim;
-      const mark = message.interrupted ? "⏹" : "!";
-      for (const line of wrap(message.text, width - 4)) lines.push(color(indent(2) + mark + " " + line));
-    }
+  if (message.role === "user") {
+    lines.push("");
+    const body = wrap(message.text, width - 2);
+    lines.push(indent(2) + chalk.cyan("▌ ") + chalk.bold(body[0] || ""));
+    for (let index = 1; index < body.length; index += 1) {
+      lines.push(indent(4) + chalk.bold(body[index]));
+    }
+  } else if (message.role === "compaction") {
+    lines.push(...compactionLines(message, width, state));
+  } else if (message.role === "assistant") {
+    lines.push("");
+    lines.push(...markdownLines(message.text, width - 2, state.theme));
+    const meta = [];
+    if (message.interrupted) meta.push("interrompido");
+    if (message.ms) meta.push(`${(message.ms / 1000).toFixed(1)}s`);
+    if (meta.length) lines.push("");
+    if (meta.length) lines.push(indent(2) + chalk.dim(meta.join(" · ")));
+  } else if (message.role === "thinking") {
+    lines.push(...thinkingLines(message, width));
+  } else if (message.role === "tool") {
+    lines.push(...toolCardLines(message, width, state));
+  } else {
+    lines.push("");
+    const color = message.error ? chalk.red : message.interrupted ? chalk.yellow : chalk.dim;
+    const mark = message.interrupted ? "⏹" : "!";
+    for (const line of wrap(message.text, width - 4)) lines.push(color(indent(2) + mark + " " + line));
   }
+  return lines;
+}
 
-  // Resposta chegando token a token (e o "thinking" do modelo, se houver).
+/**
+ * "Cauda" da conversa: bloco de streaming, indicador de "trabalhando" etc.
+ * Fica separado do historico porque muda a cada token e nao vale cachear.
+ */
+function messageTailLines(state, width) {
+  const lines = [];
   const streaming = state.streaming;
   if (streaming && (streaming.reasoning || streaming.text)) {
     if (streaming.reasoning) {
@@ -1134,7 +1198,6 @@ function messageLines(state, width) {
       lines.push(...markdownLines(streaming.text, width - 2, state.theme));
     }
   }
-
   if (state.busy && !streaming?.text) {
     lines.push("");
     lines.push(indent(2) + chalk.dim("trabalhando" + ".".repeat(state.frame % 4)));
@@ -1142,6 +1205,47 @@ function messageLines(state, width) {
   return lines;
 }
 
+/**
+ * Monta o corpo da conversa gastando o minimo: processa mensagens de tras pra
+ * frente ate cobrir o viewport pedido (ou ate acabar o historico). Fora do
+ * viewport nem tocamos no markdown. Devolve o array ja "padded" no topo para
+ * preencher a altura do terminal.
+ */
+function messageLines(state, width, budget = Infinity) {
+  const need = budget === Infinity ? Infinity : Math.max(0, budget);
+  const blocks = [];
+  let total = 0;
+
+  const tail = messageTailLines(state, width);
+  if (tail.length) {
+    blocks.push({ start: 0, lines: tail });
+    total += tail.length;
+  }
+
+  for (let index = state.messages.length - 1; index >= 0; index -= 1) {
+    const message = state.messages[index];
+    const lines = messageBlock(message, width, state);
+    blocks.push({ lines });
+    total += lines.length;
+    // Ja cobrimos o viewport (com uma folga para o padding do topo)? Paramos.
+    if (total >= need + 4) break;
+  }
+
+  const lines = [];
+  for (let index = blocks.length - 1; index >= 0; index -= 1) {
+    lines.push(...blocks[index].lines);
+  }
+  return lines;
+}
+
+function messageLinesFull(state, width) {
+  const lines = [];
+  for (const message of state.messages) lines.push(...messageBlock(message, width, state));
+  lines.push(...messageTailLines(state, width));
+  return lines;
+}
+
+
 function filteredCommands(state, commands) {
   if (state.menuDismissed) return [];
   if (!state.input.startsWith("/") || state.input.includes(" ")) return [];
@@ -1228,6 +1332,22 @@ function sidebarLines(state, width) {
   lines.push(chalk.dim(`${formatTokens(tokens)} tokens · ${messages} msg${messages === 1 ? "" : "s"}`));
   lines.push(chalk.dim(state.balance == null ? "saldo --" : `R$ ${(state.balance / 1_000_000).toFixed(2)}`));
 
+  // Saldo dos provedores externos (unlid etc.): so aparece quando o backend
+  // consegue ler. Moeda vem do provedor; "sem consulta" quando falha.
+  if (state.balanceLoading) lines.push(chalk.dim("atualizando…"));
+  for (const item of state.providerBalances || []) {
+    const label = truncate(item.label || item.id || "provider", Math.max(6, width - 12));
+    if (item.ok && item.balance != null) {
+      const money =
+        item.currency === "BRL"
+          ? `R$ ${Number(item.balance).toFixed(2)}`
+          : `${Number(item.balance).toFixed(2)} ${item.currency || "USD"}`;
+      lines.push(chalk.dim(`${label} `) + chalk.cyan(money));
+    } else {
+      lines.push(chalk.dim(`${label} `) + chalk.dim("--"));
+    }
+  }
+
   lines.push("");
   lines.push(border(state, "MCP"));
   if (state.mcp.loading) {
@@ -1636,7 +1756,7 @@ function buildFrame(state, cols, rows, commands = {}) {
   const bodyHeight = Math.max(0, rows - head.length - chrome.length);
   state.pageSize = Math.max(1, bodyHeight);
 
-  let body = hero ? [] : messageLines(state, inner);
+  let body = hero ? [] : messageLines(state, inner, bodyHeight + state.scroll);
   const maxScroll = Math.max(0, body.length - bodyHeight);
   state.scroll = clamp(state.scroll, 0, maxScroll);
   const end = body.length - state.scroll;
@@ -1755,19 +1875,35 @@ async function runTUI({
     renderTimer.unref?.();
   }
 
+  // Digitar/apagar dispara uma tecla por evento: render() sincrono a cada tecla
+  // reconstroi a conversa inteira e trava o input em chats longos. Este
+  // agendador curto (~60fps) mantem a resposta visual imediata e coalesce
+  // rajadas (segurar backspace/colar) num unico frame.
+  let inputTimer = null;
+  function scheduleInputRender() {
+    if (inputTimer || closed) return;
+    inputTimer = setTimeout(() => {
+      inputTimer = null;
+      render();
+    }, 16);
+    inputTimer.unref?.();
+  }
+
   const mouseMode = () => (state.mouse ? "\x1b[?1000h\x1b[?1006h" : "\x1b[?1000l\x1b[?1006l");
   const enterScreen = () =>
     write(`\x1b[?1049h\x1b[?25l\x1b[H\x1b[2J${mouseMode()}\x1b[?2004h`);
   const leaveScreen = () =>
     write("\x1b[?2004l\x1b[?1000l\x1b[?1006l\x1b[?25h\x1b[?1049l");
 
-  async function refreshAccount() {
+  async function refreshAccount({ fresh = false } = {}) {
     const token = await ensureSession();
     if (!token) return;
-    const response = await fetchApi("/api/bootstrap").catch(() => null);
+    const response = await fetchApi(`/api/bootstrap${fresh ? "?fresh=1" : ""}`).catch(() => null);
     if (!response || !response.ok) return;
     const data = await response.json().catch(() => null);
     if (data?.user) state.balance = data.user.balance_micros;
+    // Saldo (credits) dos provedores externos, ex.: unlid/uncensored.
+    state.providerBalances = Array.isArray(data?.provider_balances) ? data.provider_balances : [];
 
     if (!state.model) {
       const pricing = await fetchApi("/api/public/pricing")
@@ -1777,6 +1913,19 @@ async function runTUI({
     }
   }
 
+  /** Atalho/botão de atualizar: re-busca saldo da conta e dos provedores. */
+  async function refreshBalance() {
+    if (state.balanceLoading) return;
+    state.balanceLoading = true;
+    render();
+    try {
+      await refreshAccount({ fresh: true });
+    } finally {
+      state.balanceLoading = false;
+      render();
+    }
+  }
+
   function applyMcp() {
     state.mcp.statuses = mcp.statuses();
     state.mcp.tools = state.mcp.statuses.reduce((total, item) => total + item.tools, 0);
@@ -2617,7 +2766,7 @@ async function runTUI({
     state.cursor = cursor == null ? value.length : clamp(cursor, 0, value.length);
     state.menuIndex = 0;
     state.menuDismissed = false;
-    render();
+    scheduleInputRender();
   }
 
   function moveApproval(delta) {
@@ -2682,6 +2831,7 @@ async function runTUI({
 
     if (key.name === "f2") return toggleMouse();
     if (key.ctrl && key.name === "y") return copyLastAnswer();
+    if (key.ctrl && key.name === "r") return refreshBalance();
 
     // Modal de texto: qualquer tecla fecha — e se for texto, ele vai para o
     // input em vez de ser engolido (quem digita nao perde o que escreveu).