faberwright 0.3.0

package/dist/indexer.js

@@ -0,0 +1,292 @@
+/**
+ * Code graph indexer v2 — nodes AND edges, incrementally maintained.
+ *
+ * Nodes:  symbols (functions, classes, ...) as before.
+ * Edges:  calls   (enclosing function -> called name, resolved against the
+ *                  symbol table) and imports (file -> file/module).
+ * Incremental: file mtimes are stored; refresh() re-parses only changed
+ * files and prunes deleted ones — milliseconds on large repos after the
+ * first build. Tasks call refresh() at start so the map is never stale.
+ *
+ * HONESTY NOTE (also stated in tool descriptions): edges come from
+ * line-based static parsing. Dynamic dispatch, callbacks, DI and
+ * metaprogramming produce missing or extra edges. Treat the graph as strong
+ * hints for navigation, and read the code where precision matters.
+ * Tree-sitter is the documented upgrade path.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { DatabaseSync } from "node:sqlite";
+const SKIP_DIRS = new Set([
+    ".git", ".faber", ".codewright", "node_modules", ".venv", "venv", "__pycache__",
+    "dist", "build", ".mypy_cache", ".pytest_cache", "target", ".next", "dist-test",
+]);
+const LANG = {
+    ".py": [["function", /^\s*(?:async\s+)?def\s+(\w+)/], ["class", /^\s*class\s+(\w+)/]],
+    ".js": [["function", /function\s+(\w+)/], ["class", /class\s+(\w+)/],
+        ["function", /(?:const|let|var)\s+(\w+)\s*=\s*(?:async\s*)?\(/]],
+    ".ts": [["function", /function\s+(\w+)/], ["class", /class\s+(\w+)/],
+        ["interface", /interface\s+(\w+)/], ["type", /^\s*type\s+(\w+)\s*=/],
+        ["function", /(?:const|let)\s+(\w+)\s*=\s*(?:async\s*)?\(/]],
+    ".go": [["function", /func\s+(?:\([^)]*\)\s*)?(\w+)/], ["type", /type\s+(\w+)/]],
+    ".rs": [["function", /fn\s+(\w+)/], ["struct", /struct\s+(\w+)/],
+        ["enum", /enum\s+(\w+)/], ["trait", /trait\s+(\w+)/]],
+    ".java": [["class", /class\s+(\w+)/], ["interface", /interface\s+(\w+)/],
+        ["method", /(?:public|private|protected)\s+[\w<>[\]]+\s+(\w+)\s*\(/]],
+    ".c": [["function", /^[\w*]+\s+(\w+)\s*\([^;]*\)\s*\{/]],
+    ".cpp": [["function", /^[\w*:<>]+\s+(\w+)\s*\([^;]*\)\s*\{/], ["class", /class\s+(\w+)/]],
+    ".rb": [["function", /^\s*def\s+(\w+)/], ["class", /^\s*class\s+(\w+)/], ["module", /^\s*module\s+(\w+)/]],
+    ".php": [["function", /function\s+(\w+)/], ["class", /class\s+(\w+)/]],
+};
+LANG[".jsx"] = LANG[".js"];
+LANG[".tsx"] = LANG[".ts"];
+LANG[".mjs"] = LANG[".js"];
+LANG[".cjs"] = LANG[".js"];
+LANG[".h"] = LANG[".c"];
+LANG[".hpp"] = LANG[".cpp"];
+const IMPORT_RX = {
+    ".py": [/^\s*from\s+([\w.]+)\s+import/, /^\s*import\s+([\w.]+)/],
+    ".js": [/from\s+["']([^"']+)["']/, /require\(\s*["']([^"']+)["']\s*\)/],
+    ".go": [/^\s*"([\w./-]+)"/],
+    ".rs": [/^\s*use\s+([\w:]+)/],
+    ".java": [/^\s*import\s+([\w.]+)/],
+    ".rb": [/^\s*require(?:_relative)?\s+["']([^"']+)["']/],
+    ".php": [/^\s*use\s+([\w\\]+)/],
+};
+IMPORT_RX[".ts"] = IMPORT_RX[".js"];
+IMPORT_RX[".jsx"] = IMPORT_RX[".js"];
+IMPORT_RX[".tsx"] = IMPORT_RX[".js"];
+IMPORT_RX[".mjs"] = IMPORT_RX[".js"];
+// identifiers that look like calls but aren't
+const CALL_KEYWORDS = new Set([
+    "if", "for", "while", "switch", "catch", "return", "function", "typeof",
+    "super", "constructor", "def", "class", "print", "await", "async", "new",
+    "assert", "yield", "match", "case", "elif", "except", "raise", "sizeof",
+]);
+const CALL_RX = /(\w+)\s*\(/g;
+export class CodeIndexer {
+    workspace;
+    db;
+    constructor(dbPath, workspace) {
+        this.workspace = workspace;
+        this.db = new DatabaseSync(dbPath);
+        this.db.exec("PRAGMA journal_mode = WAL");
+        this.db.exec("CREATE TABLE IF NOT EXISTS symbols (name TEXT, kind TEXT, path TEXT, line INTEGER, signature TEXT)");
+        this.db.exec("CREATE INDEX IF NOT EXISTS idx_name ON symbols(name)");
+        this.db.exec("CREATE TABLE IF NOT EXISTS edges (caller TEXT, callee TEXT, path TEXT, line INTEGER)");
+        this.db.exec("CREATE INDEX IF NOT EXISTS idx_callee ON edges(callee)");
+        this.db.exec("CREATE INDEX IF NOT EXISTS idx_caller ON edges(caller)");
+        this.db.exec("CREATE TABLE IF NOT EXISTS imports (src TEXT, target TEXT, line INTEGER)");
+        this.db.exec("CREATE TABLE IF NOT EXISTS files (path TEXT PRIMARY KEY, mtime_ms REAL)");
+        this.db.exec("CREATE TABLE IF NOT EXISTS meta (key TEXT PRIMARY KEY, value TEXT)");
+    }
+    // ------------------------------------------------------------- building
+    /** Full rebuild. */
+    build() {
+        this.db.exec("DELETE FROM symbols; DELETE FROM edges; DELETE FROM imports; DELETE FROM files;");
+        return this.refresh();
+    }
+    /** Incremental: (re)parse only new/changed files, prune deleted ones. */
+    refresh() {
+        const known = new Map(this.db.prepare("SELECT path, mtime_ms FROM files").all()
+            .map((r) => [r.path, r.mtime_ms]));
+        const seen = new Set();
+        const changed = [];
+        for (const abs of walk(this.workspace)) {
+            if (!LANG[path.extname(abs)])
+                continue;
+            const rel = path.relative(this.workspace, abs);
+            seen.add(rel);
+            let mtime;
+            try {
+                mtime = fs.statSync(abs).mtimeMs;
+            }
+            catch {
+                continue;
+            }
+            if (known.get(rel) !== mtime)
+                changed.push({ rel, abs, mtime });
+        }
+        const removed = [...known.keys()].filter((p) => !seen.has(p));
+        const delSym = this.db.prepare("DELETE FROM symbols WHERE path = ?");
+        const delEdge = this.db.prepare("DELETE FROM edges WHERE path = ?");
+        const delImp = this.db.prepare("DELETE FROM imports WHERE src = ?");
+        const delFile = this.db.prepare("DELETE FROM files WHERE path = ?");
+        for (const p of removed) {
+            delSym.run(p);
+            delEdge.run(p);
+            delImp.run(p);
+            delFile.run(p);
+        }
+        const insSym = this.db.prepare("INSERT INTO symbols VALUES (?, ?, ?, ?, ?)");
+        const insEdge = this.db.prepare("INSERT INTO edges VALUES (?, ?, ?, ?)");
+        const insImp = this.db.prepare("INSERT INTO imports VALUES (?, ?, ?)");
+        const upFile = this.db.prepare("INSERT OR REPLACE INTO files VALUES (?, ?)");
+        // pass 1: symbols for changed files (so calls in pass 2 can resolve)
+        const parsed = new Map();
+        for (const f of changed) {
+            delSym.run(f.rel);
+            delEdge.run(f.rel);
+            delImp.run(f.rel);
+            let text;
+            try {
+                text = fs.readFileSync(f.abs, "utf8");
+            }
+            catch {
+                continue;
+            }
+            const lines = text.split("\n");
+            const syms = [];
+            const patterns = LANG[path.extname(f.abs)];
+            for (let i = 0; i < lines.length; i++) {
+                for (const [kind, rx] of patterns) {
+                    const m = rx.exec(lines[i]);
+                    if (m?.[1] && !CALL_KEYWORDS.has(m[1])) {
+                        syms.push([m[1], kind, i + 1, lines[i].trim().slice(0, 120)]);
+                        break;
+                    }
+                }
+            }
+            for (const [name, kind, line, sig] of syms)
+                insSym.run(name, kind, f.rel, line, sig);
+            parsed.set(f.rel, { symbols: syms, lines });
+            upFile.run(f.rel, f.mtime);
+        }
+        // known symbol names across the whole repo (for call resolution)
+        const knownNames = new Set(this.db.prepare("SELECT DISTINCT name FROM symbols").all().map((r) => r.name));
+        // pass 2: edges + imports for changed files
+        for (const [rel, { symbols, lines }] of parsed) {
+            const importRxs = IMPORT_RX[path.extname(rel)] ?? [];
+            // caller attribution: nearest preceding symbol definition in the file
+            const defLines = symbols.map(([name, , line]) => ({ name, line })).sort((a, b) => a.line - b.line);
+            const callerAt = (lineNo) => {
+                let cur = "<module>";
+                for (const d of defLines) {
+                    if (d.line <= lineNo)
+                        cur = d.name;
+                    else
+                        break;
+                }
+                return cur;
+            };
+            for (let i = 0; i < lines.length; i++) {
+                const line = lines[i];
+                for (const rx of importRxs) {
+                    const m = rx.exec(line);
+                    if (m?.[1])
+                        insImp.run(rel, m[1], i + 1);
+                }
+                const defHere = new Set(defLines.filter((d) => d.line === i + 1).map((d) => d.name));
+                CALL_RX.lastIndex = 0;
+                let m;
+                while ((m = CALL_RX.exec(line))) {
+                    const name = m[1];
+                    if (CALL_KEYWORDS.has(name) || defHere.has(name) || !knownNames.has(name))
+                        continue;
+                    const caller = callerAt(i + 1);
+                    if (caller === name)
+                        continue; // skip trivial self-attribution noise
+                    insEdge.run(caller, name, rel, i + 1);
+                }
+            }
+        }
+        this.db.prepare("INSERT OR REPLACE INTO meta VALUES ('built_at', ?)").run(String(Date.now()));
+        const nSym = this.db.prepare("SELECT COUNT(*) c FROM symbols").get().c;
+        const nEdge = this.db.prepare("SELECT COUNT(*) c FROM edges").get().c;
+        return { files: changed.length, symbols: nSym, edges: nEdge };
+    }
+    // -------------------------------------------------------------- queries
+    search(query, limit = 20) {
+        return this.db.prepare(`SELECT * FROM symbols WHERE name LIKE ?
+       ORDER BY CASE WHEN name = ? THEN 0 ELSE 1 END, name LIMIT ?`).all(`%${query}%`, query, limit);
+    }
+    whoCalls(name, limit = 30) {
+        return this.db.prepare("SELECT * FROM edges WHERE callee = ? ORDER BY path, line LIMIT ?").all(name, limit);
+    }
+    callsFrom(name, limit = 30) {
+        return this.db.prepare("SELECT DISTINCT caller, callee, path, line FROM edges WHERE caller = ? ORDER BY line LIMIT ?").all(name, limit);
+    }
+    /** BFS shortest path over call edges: from -> ... -> to. */
+    tracePath(from, to, maxDepth = 12) {
+        const next = this.db.prepare("SELECT DISTINCT callee FROM edges WHERE caller = ?");
+        const prev = new Map([[from, ""]]);
+        let frontier = [from];
+        for (let d = 0; d < maxDepth && frontier.length; d++) {
+            const upcoming = [];
+            for (const node of frontier) {
+                for (const row of next.all(node)) {
+                    const callee = row.callee;
+                    if (prev.has(callee))
+                        continue;
+                    prev.set(callee, node);
+                    if (callee === to) {
+                        const chain = [to];
+                        let cur = to;
+                        while (prev.get(cur)) {
+                            cur = prev.get(cur);
+                            chain.unshift(cur);
+                        }
+                        return chain;
+                    }
+                    upcoming.push(callee);
+                }
+            }
+            frontier = upcoming;
+        }
+        return undefined;
+    }
+    /** Call tree from an entry symbol, cycle-safe, for `faber map`. */
+    callTree(entry, maxDepth = 4) {
+        const out = [];
+        const seen = new Set();
+        const walkTree = (name, depth) => {
+            const mark = seen.has(name) ? " ↩ (seen)" : "";
+            out.push(`${"  ".repeat(depth)}${name}${mark}`);
+            if (seen.has(name) || depth >= maxDepth || out.length > 200)
+                return;
+            seen.add(name);
+            for (const e of this.callsFrom(name, 15))
+                walkTree(e.callee, depth + 1);
+        };
+        walkTree(entry, 0);
+        return out.join("\n");
+    }
+    /** Compact repo map (most-connected symbols) for system-prompt orientation. */
+    repoMap(limit = 15) {
+        const rows = this.db.prepare(`SELECT s.name, s.kind, s.path,
+              (SELECT COUNT(*) FROM edges e WHERE e.callee = s.name) +
+              (SELECT COUNT(*) FROM edges e WHERE e.caller = s.name) AS degree
+       FROM symbols s GROUP BY s.name, s.path
+       ORDER BY degree DESC LIMIT ?`).all(limit);
+        return rows.filter((r) => r.degree > 0)
+            .map((r) => `${r.name} [${r.kind}] ${r.path} (${r.degree} connections)`)
+            .join("\n");
+    }
+    isBuilt() {
+        return this.db.prepare("SELECT value FROM meta WHERE key='built_at'").get() != null;
+    }
+    close() { this.db.close(); }
+}
+function* walk(dir) {
+    let entries;
+    try {
+        entries = fs.readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const e of entries) {
+        if (SKIP_DIRS.has(e.name) || e.name.startsWith("."))
+            continue;
+        const full = path.join(dir, e.name);
+        if (e.isDirectory())
+            yield* walk(full);
+        else if (e.isFile()) {
+            try {
+                if (fs.statSync(full).size <= 1_000_000)
+                    yield full;
+            }
+            catch { /* skip */ }
+        }
+    }
+}

package/dist/input.js

@@ -0,0 +1,97 @@
+/**
+ * Composed input: bracketed-paste handling for the terminal.
+ *
+ * Problem: readline emits one 'line' event per newline, so pasting a 50-line
+ * code block becomes 50 separate submissions — each line misread as its own
+ * instruction.
+ *
+ * Mechanism: we enable BRACKETED PASTE (ESC[?2004h) so the terminal wraps
+ * pastes in ESC[200~ ... ESC[201~ markers, and interpose a transform between
+ * stdin and readline that replaces newlines INSIDE a paste with a sentinel
+ * byte (\x00). Readline then sees the entire paste as part of ONE line, the
+ * user can keep typing before/after it (a paste without a trailing newline
+ * just sits in the buffer), and only a real Enter submits. restore() swaps
+ * sentinels back to newlines afterward.
+ *
+ * Terminals without bracketed paste degrade to the old line-per-line
+ * behavior — steering still coalesces those at the drain boundary.
+ */
+import { PassThrough } from "node:stream";
+export const SENTINEL = "\x00";
+const PASTE_START = "\x1b[200~";
+const PASTE_END = "\x1b[201~";
+/** Replace \x00 sentinels with real newlines in a submitted line. */
+export function restore(line) {
+    return line.split(SENTINEL).join("\n");
+}
+/** Human display for a composed submission. */
+export function describeComposed(raw) {
+    const restored = restore(raw);
+    const lines = restored.split("\n");
+    if (lines.length <= 1)
+        return restored.slice(0, 80);
+    const typedTail = lines.at(-1)?.trim();
+    return `[pasted ${lines.length} lines]${typedTail && typedTail.length < 60 ? ` + "${typedTail}"` : ""}`;
+}
+export function createComposedInput(source) {
+    const out = new PassThrough();
+    let inPaste = false;
+    let guard = false;
+    let tail = ""; // carry partial escape markers across chunks
+    const onData = (buf) => {
+        if (guard)
+            return; // selector owns stdin; drop (it consumes keys)
+        let s = tail + buf.toString("utf8");
+        tail = "";
+        // keep a possible partial marker for the next chunk
+        for (let keep = Math.min(PASTE_START.length - 1, s.length); keep > 0; keep--) {
+            const suffix = s.slice(-keep);
+            if (PASTE_START.startsWith(suffix) || PASTE_END.startsWith(suffix)) {
+                tail = suffix;
+                s = s.slice(0, -keep);
+                break;
+            }
+        }
+        let result = "";
+        let i = 0;
+        while (i < s.length) {
+            if (!inPaste && s.startsWith(PASTE_START, i)) {
+                inPaste = true;
+                i += PASTE_START.length;
+                continue;
+            }
+            if (inPaste && s.startsWith(PASTE_END, i)) {
+                inPaste = false;
+                i += PASTE_END.length;
+                continue;
+            }
+            const ch = s[i];
+            if (inPaste && (ch === "\n" || ch === "\r")) {
+                result += SENTINEL;
+                if (ch === "\r" && s[i + 1] === "\n")
+                    i++; // CRLF -> one sentinel
+            }
+            else {
+                result += ch;
+            }
+            i++;
+        }
+        if (result)
+            out.write(result);
+    };
+    source.on("data", onData);
+    source.on("end", () => out.end());
+    return {
+        stream: out,
+        setGuard: (on) => { guard = on; },
+        detach: () => source.removeListener("data", onData),
+    };
+}
+export function enableBracketedPaste() {
+    if (process.stdout.isTTY)
+        process.stdout.write("\x1b[?2004h");
+}
+export function disableBracketedPaste() {
+    if (process.stdout.isTTY)
+        process.stdout.write("\x1b[?2004l");
+}

package/dist/llm.js

@@ -0,0 +1,260 @@
+import { FatalError, TransientAPIError, withRetries, CancelledError } from "./errors.js";
+const RETRYABLE = new Set([408, 409, 429, 500, 502, 503, 504, 529]);
+export class LLMClient {
+    config;
+    constructor(config) {
+        this.config = config;
+        if (!config.apiKey) {
+            const v = config.provider === "anthropic" ? "ANTHROPIC_API_KEY" : "OPENAI_API_KEY";
+            throw new FatalError(`No API key found. Set ${v} or add it to .faber/config.json.`);
+        }
+    }
+    complete(system, messages, tools, onText, signal, modelOverride) {
+        return withRetries(() => this.config.provider === "anthropic"
+            ? this.anthropicStream(system, messages, tools, onText, signal, modelOverride)
+            : this.openaiStream(system, messages, tools, onText, signal, modelOverride), { maxAttempts: this.config.retryMaxAttempts, signal });
+    }
+    /** Internal summarization: routed to the cheap weak model when configured. */
+    async summarize(text, instruction) {
+        const resp = await this.complete("You are a precise summarizer. Output only the summary.", [{ role: "user", content: [{ type: "text", text: `${instruction}\n\n${text}` }] }], [], undefined, undefined, this.config.weakModel);
+        return resp.text;
+    }
+    // ------------------------------------------------------------- anthropic
+    async anthropicStream(system, messages, tools, onText, signal, modelOverride) {
+        // PROMPT CACHING: mark the stable prefix so repeated loop iterations pay
+        // ~10% for everything already sent. Three breakpoints (max 4 allowed):
+        // last tool schema, the system prompt, and the last message — the message
+        // breakpoint moves forward each iteration, caching the growing history.
+        const cachedTools = tools.map((t, i) => i === tools.length - 1 ? { ...t, cache_control: { type: "ephemeral" } } : t);
+        const cachedMessages = messages.map((m, i) => {
+            if (i !== messages.length - 1 || !Array.isArray(m.content) || m.content.length === 0)
+                return m;
+            const content = m.content.map((b, j) => j === m.content.length - 1 ? { ...b, cache_control: { type: "ephemeral" } } : b);
+            return { ...m, content };
+        });
+        const body = {
+            model: modelOverride ?? this.config.model,
+            max_tokens: this.config.maxTokens,
+            system: [{ type: "text", text: system, cache_control: { type: "ephemeral" } }],
+            messages: cachedMessages,
+            stream: true,
+        };
+        if (tools.length)
+            body.tools = cachedTools;
+        const res = await this.post(`${this.config.baseUrl}/v1/messages`, {
+            "x-api-key": this.config.apiKey,
+            "anthropic-version": "2023-06-01",
+            "content-type": "application/json",
+        }, body, signal);
+        const blocks = [];
+        let stopReason = "end_turn";
+        const usage = { input: 0, cacheRead: 0, cacheWrite: 0, output: 0 };
+        // accumulate streamed tool_use JSON per block index
+        const partialJson = new Map();
+        for await (const evt of sseEvents(res, signal)) {
+            const data = evt;
+            switch (data.type) {
+                case "content_block_start": {
+                    const cb = data.content_block;
+                    if (cb.type === "text")
+                        blocks[data.index] = { type: "text", text: "" };
+                    else if (cb.type === "tool_use") {
+                        blocks[data.index] = { type: "tool_use", id: cb.id, name: cb.name, input: {} };
+                        partialJson.set(data.index, "");
+                    }
+                    break;
+                }
+                case "content_block_delta": {
+                    const d = data.delta;
+                    const blk = blocks[data.index];
+                    if (d.type === "text_delta" && blk?.type === "text") {
+                        blk.text += d.text;
+                        onText?.(d.text);
+                    }
+                    else if (d.type === "input_json_delta") {
+                        partialJson.set(data.index, (partialJson.get(data.index) ?? "") + d.partial_json);
+                    }
+                    break;
+                }
+                case "content_block_stop": {
+                    const blk = blocks[data.index];
+                    if (blk?.type === "tool_use") {
+                        const raw = partialJson.get(data.index) ?? "";
+                        try {
+                            blk.input = raw ? JSON.parse(raw) : {};
+                        }
+                        catch {
+                            throw new TransientAPIError("Malformed tool JSON in stream; retrying.");
+                        }
+                    }
+                    break;
+                }
+                case "message_start": {
+                    const u = data.message?.usage;
+                    if (u) {
+                        usage.input = u.input_tokens ?? 0;
+                        usage.cacheRead = u.cache_read_input_tokens ?? 0;
+                        usage.cacheWrite = u.cache_creation_input_tokens ?? 0;
+                    }
+                    break;
+                }
+                case "message_delta":
+                    if (data.delta?.stop_reason)
+                        stopReason = data.delta.stop_reason;
+                    if (data.usage?.output_tokens != null)
+                        usage.output = data.usage.output_tokens;
+                    break;
+                case "error":
+                    throw new TransientAPIError(`Stream error: ${JSON.stringify(data.error).slice(0, 300)}`);
+            }
+        }
+        const content = blocks.filter(Boolean);
+        return {
+            text: content.filter((b) => b.type === "text").map((b) => b.text).join(""),
+            toolCalls: content.filter((b) => b.type === "tool_use").map((b) => ({ id: b.id, name: b.name, input: b.input })),
+            rawContent: content,
+            stopReason,
+            usage,
+        };
+    }
+    // ---------------------------------------------------------------- openai
+    async openaiStream(system, messages, tools, onText, signal, modelOverride) {
+        const oaMessages = [{ role: "system", content: system }];
+        for (const m of messages)
+            oaMessages.push(...toOpenAI(m));
+        const body = { model: modelOverride ?? this.config.model, messages: oaMessages, stream: true, stream_options: { include_usage: true } };
+        if (tools.length) {
+            body.tools = tools.map((t) => ({
+                type: "function",
+                function: { name: t.name, description: t.description, parameters: t.input_schema },
+            }));
+        }
+        const res = await this.post(`${this.config.baseUrl}/chat/completions`, {
+            Authorization: `Bearer ${this.config.apiKey}`,
+            "content-type": "application/json",
+        }, body, signal);
+        let text = "";
+        const usage = { input: 0, cacheRead: 0, cacheWrite: 0, output: 0 };
+        const calls = new Map();
+        for await (const evt of sseEvents(res, signal)) {
+            const u = evt.usage;
+            if (u) {
+                usage.input = (u.prompt_tokens ?? 0) - (u.prompt_tokens_details?.cached_tokens ?? 0);
+                usage.cacheRead = u.prompt_tokens_details?.cached_tokens ?? 0;
+                usage.output = u.completion_tokens ?? 0;
+            }
+            const delta = evt.choices?.[0]?.delta;
+            if (!delta)
+                continue;
+            if (delta.content) {
+                text += delta.content;
+                onText?.(delta.content);
+            }
+            for (const tc of delta.tool_calls ?? []) {
+                const cur = calls.get(tc.index) ?? { id: "", name: "", args: "" };
+                if (tc.id)
+                    cur.id = tc.id;
+                if (tc.function?.name)
+                    cur.name += tc.function.name;
+                if (tc.function?.arguments)
+                    cur.args += tc.function.arguments;
+                calls.set(tc.index, cur);
+            }
+        }
+        const toolCalls = [...calls.values()].map((c) => {
+            let input = {};
+            try {
+                input = c.args ? JSON.parse(c.args) : {};
+            }
+            catch { /* leave empty */ }
+            return { id: c.id, name: c.name, input };
+        });
+        const rawContent = [];
+        if (text)
+            rawContent.push({ type: "text", text });
+        for (const c of toolCalls)
+            rawContent.push({ type: "tool_use", id: c.id, name: c.name, input: c.input });
+        return { text, toolCalls, rawContent, stopReason: toolCalls.length ? "tool_use" : "end_turn", usage };
+    }
+    // ------------------------------------------------------------------ http
+    async post(url, headers, body, signal) {
+        let res;
+        try {
+            res = await fetch(url, { method: "POST", headers, body: JSON.stringify(body), signal });
+        }
+        catch (err) {
+            if (err?.name === "AbortError")
+                throw new CancelledError();
+            throw new TransientAPIError(`network error: ${err?.message ?? err}`);
+        }
+        if (RETRYABLE.has(res.status)) {
+            const ra = res.headers.get("retry-after");
+            throw new TransientAPIError(`HTTP ${res.status}: ${(await res.text()).slice(0, 300)}`, ra ? Number(ra) || undefined : undefined);
+        }
+        if (res.status === 401 || res.status === 403) {
+            throw new FatalError(`Authentication failed (HTTP ${res.status}). Check your API key.`);
+        }
+        if (!res.ok)
+            throw new FatalError(`API error HTTP ${res.status}: ${(await res.text()).slice(0, 500)}`);
+        return res;
+    }
+}
+/** Parse an SSE response body into JSON events; tolerates chunk boundaries mid-line. */
+async function* sseEvents(res, signal) {
+    if (!res.body)
+        throw new TransientAPIError("Empty response body.");
+    const reader = res.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    try {
+        while (true) {
+            if (signal?.aborted)
+                throw new CancelledError();
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            buffer += decoder.decode(value, { stream: true });
+            let nl;
+            while ((nl = buffer.indexOf("\n")) !== -1) {
+                const line = buffer.slice(0, nl).trim();
+                buffer = buffer.slice(nl + 1);
+                if (!line.startsWith("data:"))
+                    continue;
+                const payload = line.slice(5).trim();
+                if (payload === "[DONE]")
+                    return;
+                try {
+                    yield JSON.parse(payload);
+                }
+                catch { /* skip malformed keep-alive lines */ }
+            }
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+}
+function toOpenAI(m) {
+    const out = [];
+    const texts = [];
+    const toolCalls = [];
+    const toolResults = [];
+    for (const b of m.content) {
+        if (b.type === "text")
+            texts.push(b.text);
+        else if (b.type === "tool_use") {
+            toolCalls.push({ id: b.id, type: "function", function: { name: b.name, arguments: JSON.stringify(b.input) } });
+        }
+        else if (b.type === "tool_result") {
+            toolResults.push({ role: "tool", tool_call_id: b.tool_use_id, content: b.content });
+        }
+    }
+    if (texts.length || toolCalls.length) {
+        const msg = { role: m.role, content: texts.join("\n") || null };
+        if (toolCalls.length)
+            msg.tool_calls = toolCalls;
+        out.push(msg);
+    }
+    out.push(...toolResults);
+    return out;
+}