brito-cli 0.6.3 → 0.7.0

package/dist/provider/openai-compat.js

@@ -0,0 +1,151 @@
+import { buildChatBody, mapFinish, mapUsage, toBlocks } from "./openai-wire.js";
+import { parseSSE } from "./sse.js";
+const RETRIES = 2;
+export const missingKeyMessage = (p) => `defina a variável de ambiente ${p.apiKeyEnv} com a chave do endpoint "${p.name}"`;
+/**
+ * Junta os pedaços do streaming. O raciocínio é guardado e sai de uma vez (a UI desenha uma caixa por chamada), no
+ * primeiro pedaço de resposta ou de tool; o texto sai sem os espaços que o vLLM põe antes da resposta.
+ */
+export class ChatStreamAccumulator {
+    reasoning = "";
+    reasoningOut = false;
+    text = "";
+    emitted = 0;
+    calls = [];
+    finish = null;
+    usage;
+    push(chunk) {
+        const out = {};
+        // O vLLM manda falhas depois que o stream começou como `data: {"error": …}`.
+        if (chunk?.error)
+            throw new Error(`o endpoint falhou no meio da resposta: ${chunk.error.message ?? JSON.stringify(chunk.error)}`);
+        if (chunk?.usage)
+            this.usage = chunk.usage;
+        const choice = chunk?.choices?.[0];
+        if (!choice)
+            return out;
+        const d = choice.delta ?? {};
+        if (typeof d.reasoning_content === "string")
+            this.reasoning += d.reasoning_content;
+        if (typeof d.reasoning === "string")
+            this.reasoning += d.reasoning;
+        for (const tc of d.tool_calls ?? []) {
+            const i = Number(tc.index ?? 0);
+            const call = (this.calls[i] ??= { id: "", name: "", arguments: "" });
+            if (tc.id)
+                call.id = String(tc.id);
+            if (tc.function?.name)
+                call.name = String(tc.function.name);
+            if (tc.function?.arguments)
+                call.arguments += String(tc.function.arguments);
+        }
+        if (typeof d.content === "string")
+            this.text += d.content;
+        if (choice.finish_reason)
+            this.finish = choice.finish_reason;
+        const visible = this.text.trimStart();
+        const answering = visible.length > this.emitted || this.calls.length > 0;
+        if (answering)
+            Object.assign(out, this.flushThinking());
+        if (visible.length > this.emitted) {
+            out.text = visible.slice(this.emitted);
+            this.emitted = visible.length;
+        }
+        return out;
+    }
+    /** O servidor disse que terminou? Sem isso, a conexão caiu no meio. */
+    get finished() { return this.finish !== null; }
+    /** Raciocínio ainda não entregue (uma vez só). */
+    flushThinking() {
+        if (this.reasoningOut || !this.reasoning.trim())
+            return {};
+        this.reasoningOut = true;
+        return { thinking: this.reasoning.trim() };
+    }
+    finishMessage() {
+        const calls = this.calls.filter(Boolean).map((c, i) => ({ ...c, id: c.id || `call_${i}` }));
+        return { content: toBlocks(this.text, calls), stopReason: mapFinish(this.finish), usage: mapUsage(this.usage), reasoning: this.reasoning };
+    }
+}
+/** Motivo legível de um erro do endpoint: o OCI embrulha o erro do vLLM em JSON dentro de JSON. */
+function errorReason(body) {
+    let v = body.trim();
+    for (let i = 0; i < 3 && typeof v === "string"; i++) {
+        try {
+            v = JSON.parse(v);
+        }
+        catch {
+            break;
+        }
+        v = v?.error?.message ?? v?.message ?? v?.error ?? v;
+    }
+    const s = (typeof v === "string" ? v : JSON.stringify(v ?? "")).trim();
+    return s.length > 300 ? s.slice(0, 300) + "…" : s;
+}
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+const retryable = (status) => status === 429 || status >= 500;
+/** Endpoint compatível com a API Chat Completions da OpenAI (ex.: Qwen num cluster dedicado do OCI). Sempre em streaming. */
+export class OpenAICompatProvider {
+    profile;
+    fetchImpl;
+    env;
+    retryDelayMs;
+    kind = "openai";
+    constructor(profile, fetchImpl = fetch, env = process.env, retryDelayMs = 500) {
+        this.profile = profile;
+        this.fetchImpl = fetchImpl;
+        this.env = env;
+        this.retryDelayMs = retryDelayMs;
+    }
+    async send(req, hooks = {}) {
+        const p = this.profile;
+        const key = this.env[p.apiKeyEnv]?.trim();
+        if (!key)
+            throw new Error(missingKeyMessage(p));
+        const url = `${p.baseURL.replace(/\/+$/, "")}/chat/completions`;
+        const init = {
+            method: "POST",
+            headers: { "content-type": "application/json", accept: "text/event-stream", authorization: `Bearer ${key}` },
+            body: JSON.stringify(buildChatBody(req, p, true)),
+            signal: hooks.signal,
+        };
+        let res;
+        for (let attempt = 0;; attempt++) {
+            try {
+                res = await this.fetchImpl(url, init);
+            }
+            catch (e) {
+                if (hooks.signal?.aborted || attempt >= RETRIES)
+                    throw new Error(`não consegui falar com o endpoint ${p.label}: ${e?.message ?? e}`);
+                await sleep(this.retryDelayMs * 2 ** attempt);
+                continue;
+            }
+            if (res.ok || !retryable(res.status) || attempt >= RETRIES || hooks.signal?.aborted)
+                break;
+            await res.body?.cancel().catch(() => { });
+            await sleep(this.retryDelayMs * 2 ** attempt);
+        }
+        if (!res.ok) {
+            const reason = errorReason(await res.text().catch(() => ""));
+            const hint = res.status === 401 || res.status === 403 ? ` — confira a chave em ${p.apiKeyEnv}` : "";
+            throw new Error(`endpoint ${p.label} respondeu HTTP ${res.status}${reason ? `: ${reason}` : ""} (opc-request-id: ${res.headers.get("opc-request-id") ?? "?"})${hint}`);
+        }
+        if (!res.body)
+            throw new Error(`endpoint ${p.label} respondeu sem corpo`);
+        const acc = new ChatStreamAccumulator();
+        for await (const chunk of parseSSE(res.body)) {
+            const out = acc.push(chunk);
+            if (out.thinking)
+                hooks.onThinking?.(out.thinking);
+            if (out.text)
+                hooks.onText?.(out.text);
+        }
+        if (!acc.finished)
+            throw new Error(`a conexão com o endpoint ${p.label} caiu antes do fim da resposta`);
+        const last = acc.flushThinking();
+        if (last.thinking)
+            hooks.onThinking?.(last.thinking);
+        const { reasoning: _r, ...msg } = acc.finishMessage();
+        return msg;
+    }
+}

package/dist/provider/openai-wire.js

@@ -0,0 +1,89 @@
+/** Texto de um tool_result (string ou lista de blocos; imagens dentro do resultado não têm equivalente e caem). */
+const resultText = (c) => typeof c === "string" ? c : (c ?? []).map((b) => (b.type === "text" ? b.text : "")).join("");
+export function toChatMessages(system, msgs, vision) {
+    const out = [{ role: "system", content: system }];
+    let droppedImages = 0;
+    for (const m of msgs) {
+        if (typeof m.content === "string") {
+            out.push(m.role === "user" ? { role: "user", content: m.content } : { role: "assistant", content: m.content });
+            continue;
+        }
+        if (m.role === "assistant") {
+            const text = m.content.flatMap((b) => (b.type === "text" ? [b.text] : [])).join("");
+            const calls = m.content.flatMap((b) => b.type === "tool_use" ? [{ id: b.id, type: "function", function: { name: b.name, arguments: JSON.stringify(b.input ?? {}) } }] : []);
+            out.push(calls.length ? { role: "assistant", content: text || null, tool_calls: calls } : { role: "assistant", content: text });
+            continue;
+        }
+        // Usuário: resultados de tool viram mensagens `tool` (logo após o assistant que pediu); o resto vira uma mensagem `user`.
+        const parts = [];
+        for (const b of m.content) {
+            if (b.type === "tool_result")
+                out.push({ role: "tool", tool_call_id: b.tool_use_id, content: (b.is_error ? "ERRO: " : "") + resultText(b.content) });
+            else if (b.type === "text")
+                parts.push({ type: "text", text: b.text });
+            else if (b.type === "image" && b.source.type === "base64") {
+                if (vision)
+                    parts.push({ type: "image_url", image_url: { url: `data:${b.source.media_type};base64,${b.source.data}` } });
+                // Sem visão a imagem vira um marcador: o modelo sabe que havia uma (ex.: histórico herdado do Claude no fallback).
+                else {
+                    droppedImages++;
+                    parts.push({ type: "text", text: "[imagem omitida]" });
+                }
+            }
+        }
+        if (!parts.length)
+            continue;
+        const onlyText = parts.every((p) => p.type === "text");
+        out.push({ role: "user", content: onlyText ? parts.map((p) => p.text).join("\n") : parts });
+    }
+    return { messages: out, droppedImages };
+}
+export const toChatTools = (tools) => tools.map((t) => ({ type: "function", function: { name: t.name, description: t.description, parameters: t.input_schema } }));
+export function buildChatBody(req, p, stream) {
+    const body = {
+        model: p.model,
+        messages: toChatMessages(req.system, req.messages, p.vision).messages,
+        max_tokens: req.maxTokens,
+        stream,
+    };
+    // Qwen/vLLM: liga/desliga o raciocínio pelo template do chat. Só com `thinkingToggle`: a OpenAI e outros servidores
+    // recusam parâmetro desconhecido.
+    if (p.thinkingToggle)
+        body.chat_template_kwargs = { enable_thinking: req.thinking !== false };
+    if (stream)
+        body.stream_options = { include_usage: true };
+    if (req.tools?.length)
+        body.tools = toChatTools(req.tools);
+    return body;
+}
+export function mapFinish(reason) {
+    return reason === "tool_calls" ? "tool_use" : reason === "stop" ? "end_turn" : reason === "length" ? "max_tokens" : "other";
+}
+/** JSON inválido vira um input que o schema da tool rejeita: o modelo recebe "Input inválido" e tenta de novo. */
+export function parseToolArgs(raw) {
+    if (!raw.trim())
+        return {};
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return { _argumentosInvalidos: raw };
+    }
+}
+export const mapUsage = (u) => ({ input: u?.prompt_tokens ?? 0, output: u?.completion_tokens ?? 0, cacheRead: u?.prompt_tokens_details?.cached_tokens ?? 0 });
+/** Junta texto e chamadas de tool na ordem do formato interno (texto primeiro). O vLLM põe "\n\n" antes da resposta. */
+export function toBlocks(text, calls) {
+    const blocks = [];
+    const t = text.trimStart();
+    if (t)
+        blocks.push({ type: "text", text: t });
+    for (const c of calls)
+        blocks.push({ type: "tool_use", id: c.id, name: c.name, input: parseToolArgs(c.arguments) });
+    return blocks;
+}
+export function fromChatCompletion(json) {
+    const choice = json?.choices?.[0];
+    const msg = choice?.message ?? {};
+    const calls = (msg.tool_calls ?? []).map((c) => ({ id: String(c.id), name: String(c.function?.name ?? ""), arguments: String(c.function?.arguments ?? "") }));
+    return { content: toBlocks(msg.content ?? "", calls), stopReason: mapFinish(choice?.finish_reason), usage: mapUsage(json?.usage), reasoning: msg.reasoning_content ?? "" };
+}

package/dist/provider/resolve.js

@@ -0,0 +1,27 @@
+import { MODEL_ALIASES, loadProfiles } from "../model.js";
+/** Janela dos modelos Claude quando nada informa outra. */
+const CLAUDE_WINDOW = 200_000;
+const COMPACT_DEFAULT = 120_000;
+/** Nome → provedor: perfil configurado (sem diferenciar maiúsculas) > alias do Claude > id cru do Claude. */
+export function resolveModel(name) {
+    const key = name.trim().toLowerCase();
+    const profile = loadProfiles().profiles[key];
+    if (profile)
+        return { kind: "openai", name: key, wireModel: profile.model, label: profile.label, contextWindow: profile.contextWindow, profile };
+    const wire = MODEL_ALIASES[key] ?? name.trim();
+    return { kind: "anthropic", name: wire, wireModel: wire, label: wire, contextWindow: CLAUDE_WINDOW };
+}
+/** Janela mostrada na barra/`/context`: BRITO_CONTEXT_WINDOW > perfil > padrão do Claude. */
+export function contextWindowFor(name) {
+    const env = Number(process.env.BRITO_CONTEXT_WINDOW);
+    return env > 0 ? env : resolveModel(name).contextWindow;
+}
+/**
+ * Quando compactar: BRITO_COMPACT_TOKENS (ou 120k). Em perfis de endpoint, nunca acima de 60% da janela (janelas
+ * pequenas estourariam antes); no Claude fica como sempre foi.
+ */
+export function compactAtFor(name) {
+    const env = Number(process.env.BRITO_COMPACT_TOKENS);
+    const base = env > 0 ? env : COMPACT_DEFAULT;
+    return resolveModel(name).kind === "openai" ? Math.min(base, Math.floor(0.6 * contextWindowFor(name))) : base;
+}

package/dist/provider/sse.js

@@ -0,0 +1,33 @@
+/**
+ * Lê um corpo `text/event-stream` e devolve o JSON de cada linha `data:`. Linhas podem chegar partidas entre pedaços
+ * da rede e com `\r\n`; `data: [DONE]` encerra. Linha que não é JSON é ignorada (comentários/keep-alive).
+ */
+export async function* parseSSE(body) {
+    const decoder = new TextDecoder();
+    let buf = "";
+    const reader = body.getReader();
+    try {
+        for (;;) {
+            const { done, value } = await reader.read();
+            buf += done ? decoder.decode() : decoder.decode(value, { stream: true });
+            const lines = buf.split(/\r?\n/);
+            buf = done ? "" : lines.pop();
+            for (const line of lines) {
+                if (!line.startsWith("data:"))
+                    continue;
+                const data = line.slice(5).trim();
+                if (data === "[DONE]")
+                    return;
+                try {
+                    yield JSON.parse(data);
+                }
+                catch { /* não é JSON */ }
+            }
+            if (done)
+                return;
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+}

package/dist/provider/types.js

@@ -0,0 +1 @@
+export {};

package/dist/repl.js

@@ -19,6 +19,56 @@ const userName = () => {
 import { listPending, listSkills, deleteSkill, promoteSkill, globalHome } from "./skills/store.js";
 import { listAgents } from "./agent/agents.js";
 import { perms, cycleMode, MODE_LABEL } from "./permissions.js";
+/**
+ * Backend com o motor substituível no meio da sessão (claude CLI → qwen): o REPL monta o menu uma vez, então os
+ * comandos ficam estáveis e o que o motor atual não tem responde "indisponível". `usage`/`cost` somam todos os
+ * motores já usados (cada um uma vez, mesmo que volte a ser o atual).
+ */
+export function switchableBackend(initial) {
+    let cur = initial;
+    const seen = new Set([initial]);
+    const commands = {};
+    const delegate = (name, desc) => {
+        commands[name] = {
+            desc,
+            run: async (args) => {
+                const cmd = cur.commands[name];
+                if (cmd)
+                    await cmd.run(args);
+                else
+                    ui.warn(`${name} não está disponível no ${cur.model()}`);
+            },
+        };
+    };
+    const adopt = (b) => { for (const [name, v] of Object.entries(b.commands))
+        if (!commands[name])
+            delegate(name, v.desc); };
+    adopt(initial);
+    return {
+        model: () => cur.model(),
+        contextTokens: () => cur.contextTokens(),
+        usage: () => {
+            const all = [...seen].map((b) => b.usage());
+            return { input: all.reduce((s, u) => s + u.input, 0), output: all.reduce((s, u) => s + u.output, 0), cacheRead: all.reduce((s, u) => s + (u.cacheRead ?? 0), 0) };
+        },
+        get ctxWindow() { return cur.ctxWindow; },
+        cost: () => {
+            const all = [...seen].map((b) => b.cost?.()).filter((x) => x !== undefined);
+            return all.length ? all.reduce((s, x) => s + x, 0) : undefined;
+        },
+        turn: (text, signal) => cur.turn(text, signal),
+        abort: () => cur.abort?.(),
+        // Todos os motores: o claude CLI fora de uso guarda a sessão (--resume) e os turnos que o fallback herdaria.
+        reset: () => { for (const b of seen)
+            b.reset(); },
+        afterTurn: async () => { await cur.afterTurn?.(); },
+        onShell: () => cur.onShell?.(),
+        commands,
+        close: async () => { await cur.close(); },
+        swap: (next) => { cur = next; seen.add(next); adopt(next); },
+        current: () => cur,
+    };
+}
 const COMMON = {
     "/help": "esta ajuda",
     "/agents": "subagentes disponíveis",
@@ -188,15 +238,16 @@ export async function runRepl(b, o) {
             await shutdown();
             return;
         }
-        if (line.startsWith("/")) {
-            const run = common[key] ?? b.commands[key]?.run;
-            if (!run) {
-                ui.warn(`comando desconhecido: ${cmd}. Digite /help.`);
-                return;
-            }
+        const run = line.startsWith("/") ? common[key] ?? b.commands[key]?.run : undefined;
+        if (run) {
             await run(args);
             return;
         }
+        // "/Users/x/arquivo.pdf" é caminho, não comando: segue como mensagem ao agente
+        if (line.startsWith("/") && !cmd.slice(1).includes("/")) {
+            ui.warn(`comando desconhecido: ${cmd}. Digite /help.`);
+            return;
+        }
         const ac = (running = new AbortController());
         dock?.setBusy(true);
         try {

package/dist/skills/learn.js

@@ -1,4 +1,4 @@
-import Anthropic from "@anthropic-ai/sdk";
+import { providerFor } from "../provider/index.js";
 import { z } from "zod";
 import { execTool, toApiTools } from "../tools/registry.js";
 import { perms } from "../permissions.js";
@@ -99,7 +99,8 @@ export function recordOutcomes(turn, ctx) {
     return [...(ctx.loadedSkills ?? [])].flatMap((n) => recordOutcome(ctx.root, n, verdict === "win") ?? []);
 }
 export const defaultComplete = async ({ model, system, user, tools, maxTokens }) => {
-    const res = await new Anthropic().messages.create({ model, max_tokens: maxTokens, system, tools, messages: [{ role: "user", content: user }] });
+    // Raciocínio desligado: o julgamento cabe no orçamento e a resposta útil é a chamada de skill_save.
+    const res = await providerFor(model).send({ model, maxTokens, system, tools, messages: [{ role: "user", content: user }], thinking: false });
     return res.content;
 };
 /**

package/dist/tools/delegate.js

@@ -3,6 +3,8 @@ import { defineTool, allTools, execTool } from "./registry.js";
 import { Agent } from "../agent/loop.js";
 import { getAgent, listAgents } from "../agent/agents.js";
 import { buildSubagentPrompt } from "../agent/prompt.js";
+import { subagentModel } from "../engine.js";
+import { initialModel } from "../model.js";
 import { ui } from "../ui/ui.js";
 let seq = 0;
 /** Conjunto de tools de um agente; `delegate` nunca é repassada (sem recursão). */
@@ -47,7 +49,7 @@ defineTool({
         }
         log(`iniciado: ${task.slice(0, 100).replace(/\s+/g, " ")}`);
         const sub = new Agent(buildSubagentPrompt(ctx.root, def), ctx, {
-            model: def.model,
+            model: subagentModel(def, ctx.model?.() ?? initialModel(), process.env),
             maxSteps: 25,
             quiet: true,
             tools: toolSet(def),

package/dist/ui/dock.js

@@ -8,7 +8,7 @@ const graphemes = (s) => Array.from(seg.segment(s), (x) => x.segment);
 const ANSI = /\x1b\[[0-9;]*[A-Za-z]/y;
 const MAX_INPUT_ROWS = 8;
 const MAX_MENU = 7;
-const PASTE_RE = /\[(?:colado|imagem) #(\d+): [^\]]*\]/g;
+const PASTE_RE = /\[(?:colado|imagem|anexo) #(\d+): [^\]]*\]/g;
 export class Dock {
     opts;
     onSubmit = () => { };
@@ -415,7 +415,7 @@ export class Dock {
         if (imgs.length) {
             const n = ++this.pasteN;
             this.pastes.set(n, imgs.map((i) => (/\s/.test(i.path) ? `"${i.path}"` : i.path)).join(" "));
-            this.insert(`[imagem #${n}: ${imgs.length === 1 ? imgs[0].name : `${imgs.length} imagens`}] `);
+            this.insert(`[anexo #${n}: ${imgs.length === 1 ? imgs[0].name : `${imgs.length} arquivos`}] `);
         }
         else if (lines >= 2 || text.length > 300) {
             const n = ++this.pasteN;

package/dist/util/images.js

@@ -2,10 +2,13 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
-const TYPES = { png: "image/png", jpg: "image/jpeg", jpeg: "image/jpeg", gif: "image/gif", webp: "image/webp" };
-const IMG_EXT = /\.(png|jpe?g|gif|webp)$/i;
-/** Limite da API por imagem (5 MB) e teto de anexos por mensagem. */
+const TYPES = { png: "image/png", jpg: "image/jpeg", jpeg: "image/jpeg", gif: "image/gif", webp: "image/webp", pdf: "application/pdf" };
+const IMG_EXT = /\.(png|jpe?g|gif|webp|pdf)$/i;
+/** Limite da API por imagem (5 MB), por PDF (32 MB) e teto de anexos por mensagem. */
 export const MAX_IMAGE_BYTES = 5 * 1024 * 1024;
+export const MAX_PDF_BYTES = 32 * 1024 * 1024;
+export const limitOf = (i) => (i.mediaType === "application/pdf" ? MAX_PDF_BYTES : MAX_IMAGE_BYTES);
+export const isPdf = (i) => i.mediaType === "application/pdf";
 export const MAX_IMAGES = 5;
 /** Divide o texto em tokens, respeitando aspas e (fora do Windows) `\ ` como espaço do nome do arquivo. */
 function tokens(text) {
@@ -67,9 +70,11 @@ export function droppedImages(text, root = process.cwd()) {
 export const fmtBytes = (n) => (n >= 1_048_576 ? `${(n / 1_048_576).toFixed(1)} MB` : `${Math.max(1, Math.round(n / 1024))} kB`);
 /** Separa o que dá para enviar do que passa do limite da API. */
 export function splitOversize(imgs) {
-    return { ok: imgs.filter((i) => i.bytes <= MAX_IMAGE_BYTES), tooBig: imgs.filter((i) => i.bytes > MAX_IMAGE_BYTES) };
+    return { ok: imgs.filter((i) => i.bytes <= limitOf(i)), tooBig: imgs.filter((i) => i.bytes > limitOf(i)) };
 }
-/** Bloco `image` da API da Anthropic, com o arquivo em base64. */
+/** Bloco `image` (ou `document`, para PDF) da API da Anthropic, com o arquivo em base64. */
 export function imageBlock(img) {
+    if (isPdf(img))
+        return { type: "document", source: { type: "base64", media_type: "application/pdf", data: fs.readFileSync(img.path).toString("base64") } };
     return { type: "image", source: { type: "base64", media_type: img.mediaType, data: fs.readFileSync(img.path).toString("base64") } };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brito-cli",
-  "version": "0.6.3",
+  "version": "0.7.0",
   "description": "Coding-agent CLI with a code knowledge graph, memory and reviewable skills / CLI de agente de código com grafo de conhecimento, memória e skills revisáveis",
   "type": "module",
   "bin": {