brito-cli 0.6.4 → 0.7.1

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",

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brito-cli",
-  "version": "0.6.4",
+  "version": "0.7.1",
   "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": {