agen-vektor 0.3.12 → 0.3.14

package/README.md

@@ -50,7 +50,7 @@ incrementally with no flicker.
 ## Contents
 
 - [Features](#features) · [Installation](#installation) · [Quick start](#quick-start) · [Command line](#command-line) · [TUI commands](#tui-commands)
-- [Provider configuration](#provider-configuration) · [Themes](#themes) · [Security model](#security-model) · [Architecture](#architecture) · [Development](#development)
+- [Provider configuration](#provider-configuration) · [Themes](#themes) · [Security model](#security-model) · [Privacy](#privacy) · [Architecture](#architecture) · [Development](#development)
 - [Testing](#testing) · [Troubleshooting](#troubleshooting) · [Roadmap](#roadmap) · [License](#license)
 
 ## Features
@@ -307,6 +307,23 @@ Every shell command is classified:
 
 `--yolo` auto-approves ASK-level actions but still prompts for DANGEROUS and refuses BLOCKED ones. API keys are never printed to the terminal, logs, diffs, or session history.
 
+## Privacy
+
+**VectorHead collects nothing.** No telemetry, no analytics, no crash reporting, no usage tracking — there is no code in the app that could phone home. Every network destination in the source is auditable:
+
+| Destination | When |
+|---|---|
+| Your configured AI provider (OpenAI, Anthropic, Gemini, OpenRouter, Ollama, custom) | Only when you chat — with **your own** API key |
+| `vector-tui.methatech.eu.org` (VectorHead Free gateway) | Only if you pick the free tier; the shared provider key stays server-side, users never see it |
+| Brave / Exa / Serper | Only when you use the web-search tool with your own key |
+| Raw model catalog (public JSON) | To populate the free-tier model list |
+
+**Stored locally** (all in `~/.vector/`): `config.json` (preferences, no secrets), `credentials.json` (only keys *you* enter, file mode 0600), sessions, memory, logs. Nothing else is written anywhere.
+
+**No device identity.** The app does not generate a device id or send any tracking header (the old anonymous `device-id` + `X-Vector-Device` pair was fully removed in 0.3.14).
+
+**The agent guards itself against secrets** — its own file tools refuse to read or write `.env`, private keys, `credentials.json`, kubeconfig, and similar files (override only via explicit `VECTOR_ALLOW_SENSITIVE=1`), so a prompt cannot accidentally exfiltrate them.
+
 ## Architecture
 
 ```

package/dist/agent/agent.js

@@ -1,6 +1,44 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Agent = void 0;
+/**
+ * Agent — high-level facade bundling provider, tools, permissions
+ * and the loop into a single object the TUI/CLI can drive.
+ */
+const fs = __importStar(require("node:fs"));
 const factory_1 = require("../providers/factory");
 const registry_1 = require("../tools/registry");
 const filesystem_1 = require("../tools/filesystem");
@@ -12,6 +50,8 @@ const extras_1 = require("../tools/extras");
 const apply_patch_1 = require("../tools/apply-patch");
 const permissions_1 = require("../security/permissions");
 const config_1 = require("../config/config");
+const paths_1 = require("../utils/paths");
+const free_tier_1 = require("../config/free-tier");
 const loop_1 = require("./loop");
 const rules_1 = require("./rules");
 const skills_1 = require("./skills");
@@ -24,7 +64,26 @@ class Agent {
     permissions;
     cwd;
     constructor(opts) {
-        this.config = (0, config_1.effectiveConfig)(opts.config);
+        // Free tier (vectorhead-free): define the provider entry and default a
+        // FIRST RUN (no config.json yet) to the free tier so onboarding is
+        // "install & pick a model" with zero keys. Existing configs keep their
+        // active provider; only the free ENTRY is (re)defined. No per-device
+        // identity: the gateway requires none (X-Vector-Device removed 2026-09-05).
+        const firstRun = !opts.config && (0, free_tier_1.isFirstRun)(fs.existsSync((0, paths_1.getConfigPath)()));
+        const seeded = (0, config_1.effectiveConfig)(opts.config);
+        if ((0, free_tier_1.ensureFreeProvider)(seeded)) {
+            try {
+                (0, config_1.saveConfig)(seeded);
+            }
+            catch {
+                /* read-only home — the in-memory def still works this session */
+            }
+        }
+        if (firstRun) {
+            seeded.provider = free_tier_1.FREE_PROVIDER_ID;
+            seeded.model = free_tier_1.FREE_DEFAULT_MODEL;
+        }
+        this.config = seeded;
         this.cwd = opts.cwd || process.cwd();
         // Seed Hermes-style SOUL.md/MEMORY.md/USER.md/SKILL.md on first run
         // (never overwrites existing user files — see src/agent/rules.ts).

package/dist/agent/loop.js

@@ -182,6 +182,11 @@ async function runAgentLoop(userRequest, opts, callbacks = {}) {
             finalContent = `⚠️ Error: ${err.message}`;
             break;
         }
+        // Defense in depth: a misbehaving gateway can yield a sparse toolCalls
+        // array (null holes — e.g. non-0-based stream indices from Anthropic-
+        // backed endpoints). Drop holes here so tool execution and the follow-up
+        // request history stay well-formed even if a provider regresses.
+        result.toolCalls = result.toolCalls.filter((tc) => !!tc && typeof tc.name === 'string' && tc.name !== '');
         const hasToolCalls = result.toolCalls.length > 0;
         // Streaming-free path: collect the assistant message and execute tools.
         messages.push({

package/dist/agent/prompts.js

@@ -66,7 +66,7 @@ Rules:
  */
 function identityPrompt(model, provider) {
     return `You are currently running as the model "${model}" via the "${provider}" provider (OpenAI-compatible API unless stated otherwise).
-If the user asks which model you are or which provider backs you, answer with exactly this — e.g. "Saya dijalankan oleh model deepseek-ai/DeepSeek-V4-Flash lewat provider custom". Do not invent a different model name.`;
+If the user asks which model you are or which provider backs you, answer with exactly this sentence — copy it verbatim, do not substitute any other name: "Saya dijalankan oleh model ${model} lewat provider ${provider}". Do not invent a different model name.`;
 }
 function taskPrompt(userRequest, cwd) {
     return `Working directory: ${cwd}

package/dist/cli/index.js

@@ -312,23 +312,16 @@ async function runTui(opts) {
     // Incremental renderer: keep the previous frame and only rewrite the rows
     // that actually changed. Full-screen redraws every tick caused constant
     // flicker, especially while the agent is running (spinner + timer animate
-    // every frame). Modal overlays are absolutely positioned, so they force a
-    // full repaint.
+    // every frame).
+    // OpenCode single-buffer parity: modal overlays are composed INTO the
+    // frame rows by App.computeFrame, so a selector navigation is diffed per
+    // ROW like everything else. The old modal branch forced a full-screen
+    // repaint per keystroke (lastFrameRows = []) — the ↑/↓ "berkedip" in
+    // /model. The cursor is HIDDEN while a modal is open (menus don't show a
+    // text cursor) and restored at the input row when it closes.
     let lastFrameRows = [];
     let lastCursorPos = '';
     const doRender = () => {
-        if (app.modalActive()) {
-            // A modal (e.g. a permission prompt) is static while open, so only
-            // repaint when something actually changed (open/close/keystroke).
-            // Full-screen redraws every tick while waiting for permission caused
-            // the chat to flicker during multi-tool turns.
-            if (app.isDirty()) {
-                lastFrameRows = [];
-                process.stdout.write(terminal_1.ANSI.hideCursor + DECAWM_OFF + (0, terminal_1.toAsciiSafe)(app.render()) + DECAWM_ON);
-                app.consumeRender();
-            }
-            return;
-        }
         const snap = app.frameSnapshot();
         const rows = snap.rows;
         const out = [];
@@ -338,17 +331,23 @@ async function runTui(opts) {
             }
         }
         lastFrameRows = rows;
-        const cursor = (0, terminal_1.cursorTo)(snap.inputRow, snap.cursorCol);
-        if (cursor !== lastCursorPos)
-            out.push(cursor);
-        lastCursorPos = cursor;
-        out.push(terminal_1.ANSI.showCursor);
+        if (app.modalActive()) {
+            out.push(terminal_1.ANSI.hideCursor);
+            lastCursorPos = '';
+        }
+        else {
+            const cursor = (0, terminal_1.cursorTo)(snap.inputRow, snap.cursorCol);
+            if (cursor !== lastCursorPos)
+                out.push(cursor);
+            lastCursorPos = cursor;
+            out.push(terminal_1.ANSI.showCursor);
+        }
         // DECAWM guard: even one exactly-`cols`-wide row (input-box borders,
         // header at the old width) leaves the cursor in the pending-wrap state;
         // the NEXT repaint — e.g. the ~480ms blink dot — then auto-wraps first
         // and the whole screen scrolls up one line. With auto-wrap disabled for
         // the duration of the paint, that phantom newline is impossible.
-        process.stdout.write(terminal_1.ANSI.hideCursor + DECAWM_OFF + (0, terminal_1.toAsciiSafe)(out.join('')) + DECAWM_ON);
+        process.stdout.write(terminal_1.ANSI.hideCursor + DECAWM_OFF + (0, terminal_1.toAsciiSafe)(out.filter(Boolean).join('')) + DECAWM_ON);
     };
     const onResize = () => {
         app.markDirty();
@@ -382,6 +381,10 @@ async function runTui(opts) {
         // terminals never send \x1b[<...> sequences, so wheel/touch scrolling of
         // the chat is dead even though the parser supports it.
         process.stdout.write(terminal_1.ANSI.enableMouse);
+        // Bracketed paste (Freebuff MultilineInput onPaste): the terminal then
+        // wraps clipboard text in ESC[200~ … ESC[201~ so a paste of thousands of
+        // characters reaches the input as ONE event instead of a keystroke burst.
+        process.stdout.write(terminal_1.ANSI.enablePaste);
         (0, keyboard_1.keyStream)(keyHandler);
         app.start();
         doRender();
@@ -401,6 +404,7 @@ async function runTui(opts) {
     finally {
         process.stdout.write(terminal_1.ANSI.disableAltScreen);
         process.stdout.write(terminal_1.ANSI.disableMouse);
+        process.stdout.write(terminal_1.ANSI.disablePaste);
         process.stdout.write(terminal_1.ANSI.showCursor);
         process.stdout.removeListener('resize', onResize);
         cleanup();

package/dist/cli/keyboard.js

@@ -96,6 +96,22 @@ function parseKey(data) {
                 continue;
             }
         }
+        // Bracketed paste: ESC[200~ … ESC[201~ wraps the WHOLE clipboard text
+        // (Freebuff onPaste). Captured as ONE 'paste' event so multi-line and
+        // multi-thousand-char pastes never burst into per-key events (a raw \n
+        // inside the payload would otherwise submit the half-typed prompt).
+        if (ch === '\x1b' && s.startsWith('\x1b[200~', i)) {
+            const end = s.indexOf('\x1b[201~', i + 6);
+            if (end !== -1) {
+                events.push({ name: 'paste', text: s.slice(i + 6, end) });
+                i = end + 6;
+                continue;
+            }
+            // Unterminated paste (cut off read): take the rest as paste text.
+            events.push({ name: 'paste', text: s.slice(i + 6) });
+            i = s.length;
+            continue;
+        }
         // CSI sequence
         if (ch === '\x1b' && i + 1 < s.length && s[i + 1] === '[') {
             // Find the terminating char
@@ -281,13 +297,50 @@ function enableRawMode() {
             process.stdin.pause();
     };
 }
-/** Create a key stream (async iterable of KeyEvent). */
+/**
+ * Create a key stream. Bracketed pastes are BUFFERED across stdin chunks:
+ * a multi-thousand-char paste often arrives split over several 'data'
+ * events, so the stream waits for the closing ESC[201~ before emitting ONE
+ * 'paste' event (Freebuff onPaste). Everything outside a paste is parsed
+ * and emitted immediately, exactly like before.
+ */
 function keyStream(onKey) {
+    let pending = '';
     process.stdin.on('data', (data) => {
-        for (const ev of parseKey(data))
-            onKey(ev);
+        pending += data.toString('utf8');
+        for (;;) {
+            const start = pending.indexOf('\x1b[200~');
+            if (start === -1) {
+                const evs = parseKeyStr(pending);
+                pending = '';
+                for (const ev of evs)
+                    onKey(ev);
+                return;
+            }
+            if (start > 0) {
+                for (const ev of parseKeyStr(pending.slice(0, start)))
+                    onKey(ev);
+                pending = pending.slice(start);
+            }
+            const end = pending.indexOf('\x1b[201~', 6);
+            if (end === -1) {
+                // Safety valve: a runaway opener without terminator must not buffer
+                // input forever (e.g. a terminal that only half-implements 2004).
+                if (pending.length > 1_000_000) {
+                    onKey({ name: 'paste', text: pending.slice(6) });
+                    pending = '';
+                }
+                return; // wait for the rest of the paste
+            }
+            onKey({ name: 'paste', text: pending.slice(6, end) });
+            pending = pending.slice(end + 6);
+        }
     });
 }
+/** parseKey over a string (keyStream works on accumulated text). */
+function parseKeyStr(s) {
+    return parseKey(Buffer.from(s, 'utf8'));
+}
 function setupReadline(stream) {
     return readline.createInterface({ input: stream, terminal: false });
 }

package/dist/config/free-tier.js

@@ -0,0 +1,159 @@
+"use strict";
+/**
+ * Free-tier provider (`vectorhead-free`) — the "install & just pick a model"
+ * onboarding tier backed by the VectorHead gateway (Cloudflare Worker):
+ *
+ *   https://vector-tui.methatech.eu.org   (see konsep.md and vector-gateway/
+ *   — the worker holds the real BitDeer tokens as server-side secrets and
+ *   enforces the per-device quota; users never see an API key).
+ *
+ * Design:
+ * - `vectorhead-free` is an OpenCode-style entry in config.providers with an
+ *   INLINE placeholder key. The gateway holds the real provider key as a
+ *   server-side secret and does NOT require any per-device or per-user
+ *   identity from the client (per-device quota was removed 2026-09-05 —
+ *   X-Vector-Device is no longer sent), so no real key exists client-side —
+ *   the inline placeholder simply satisfies "custom providers need a key"
+ *   checks without storing anything secret on the user's disk.
+ * - First run (no config.json): the agent starts on this provider so a new
+ *   user can chat immediately — pick BYOK later via /connect. An EXISTING
+ *   config is never touched except to (re)define the free provider entry.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FREE_DEFAULT_MODEL = exports.FREE_PROVIDER_ID = exports.CATALOG_TTL_MS = exports.FREE_CATALOG_URL = exports.FREE_GATEWAY_CATALOG_URL = exports.FREE_GATEWAY_URL = void 0;
+exports.resetFreeCatalogCache = resetFreeCatalogCache;
+exports.freeTierEnabled = freeTierEnabled;
+exports.freeProviderDef = freeProviderDef;
+exports.ensureFreeProvider = ensureFreeProvider;
+exports.isFirstRun = isFirstRun;
+exports.fetchFreeCatalog = fetchFreeCatalog;
+exports.applyFreeCatalog = applyFreeCatalog;
+/** Public gateway base URL (custom Cloudflare domain — stable, no ports). */
+exports.FREE_GATEWAY_URL = 'https://vector-tui.methatech.eu.org/v1';
+/**
+ * Live catalog served BY the gateway itself (admin-editable via the /admin
+ * dashboard — upstream, model list and limits can change without touching
+ * this repo). Kept in sync with FREE_GATEWAY_URL's /v1 root.
+ */
+exports.FREE_GATEWAY_CATALOG_URL = exports.FREE_GATEWAY_URL.replace(/\/v1$/, '') + '/v1/catalog';
+/**
+ * Public catalog (konsep.md tahap 2): JSON WITHOUT secrets committed to the
+ * repo and fetched via the stable RAW URL — models, gateway URL, limits and
+ * the remote kill switch, all updatable without an app release.
+ * FALLBACK only: the gateway's own /v1/catalog (admin-editable) is tried
+ * first; this static file covers the gateway being down / not yet deployed.
+ */
+exports.FREE_CATALOG_URL = 'https://raw.githubusercontent.com/clickmamaheti-prog/vector-agent/main/free-models.json';
+/** Catalog cache lifetime (konsep.md: "Agent fetch saat start, cache 1 jam"). */
+exports.CATALOG_TTL_MS = 60 * 60 * 1000;
+/** In-process catalog cache — once loaded, freeProviderDef() follows it. */
+let catalogCache = null;
+/** Test/edge hook: forget the cached catalog (next fetch starts cold). */
+function resetFreeCatalogCache() {
+    catalogCache = null;
+}
+/** Remote kill switch ("enabled": false in free-models.json) — default true. */
+function freeTierEnabled() {
+    return catalogCache?.data.enabled !== false;
+}
+/** Provider id used in config.provider / providers map. */
+exports.FREE_PROVIDER_ID = 'vectorhead-free';
+/** Default free model (cheap, gateway allowlist-friendly). */
+exports.FREE_DEFAULT_MODEL = 'deepseek-ai/DeepSeek-V4-Flash';
+/** The providers-map entry for the free tier (idempotent — same shape always). */
+function freeProviderDef() {
+    // When a catalog has been fetched in this process, the gateway URL and
+    // model list follow it (konsep.md: katalog bisa diubah remote tanpa rilis
+    // app). No cache → the compile-time defaults.
+    const cat = catalogCache?.data;
+    const models = {};
+    if (cat && Array.isArray(cat.models) && cat.models.length > 0) {
+        for (const m of cat.models) {
+            if (m && typeof m.id === 'string' && m.id.trim() !== '') {
+                models[m.id] = { name: m.label || m.id };
+            }
+        }
+    }
+    return {
+        name: 'VectorHead Free',
+        options: {
+            baseURL: (cat && typeof cat.gateway === 'string' && cat.gateway ? cat.gateway : exports.FREE_GATEWAY_URL),
+            // Placeholder ONLY — the gateway holds the real provider key as a
+            // server-side secret and accepts anonymous requests. Inline (not
+            // {env:}) so no env var is ever required.
+            apiKey: 'vectorhead-free-anonymous',
+        },
+        model: exports.FREE_DEFAULT_MODEL,
+        models: Object.keys(models).length > 0 ? models : {
+            [exports.FREE_DEFAULT_MODEL]: { name: 'DeepSeek V4 Flash (free)' },
+        },
+    };
+}
+/**
+ * Ensure the free provider entry exists in the config's providers map
+ * (create or repair — never touches unrelated providers). Returns true when
+ * the config object was modified.
+ */
+function ensureFreeProvider(config) {
+    const cur = config.providers?.[exports.FREE_PROVIDER_ID];
+    const want = JSON.stringify(freeProviderDef());
+    if (cur && JSON.stringify(cur) === want)
+        return false;
+    config.providers = { ...(config.providers || {}), [exports.FREE_PROVIDER_ID]: freeProviderDef() };
+    return true;
+}
+/**
+ * True when this machine has never run VectorHead before (no config.json).
+ * First-run seeds default to the free tier so onboarding is zero-config.
+ */
+function isFirstRun(configDirHasConfig) {
+    return !configDirHasConfig;
+}
+function isValidCatalog(data) {
+    if (!data || typeof data !== 'object')
+        return false;
+    const c = data;
+    return typeof c.gateway === 'string' && /^https:\/\//.test(c.gateway)
+        && Array.isArray(c.models);
+}
+/**
+ * Fetch the catalog. Sources, in order:
+ *   1. explicit override (opts.url or VECTOR_FREE_CATALOG_URL env) — ONLY source
+ *   2. gateway /v1/catalog  (live, admin-editable via the /admin dashboard)
+ *   3. GitHub RAW free-models.json (static fallback when the gateway is down)
+ * Cached for 1 hour — subsequent calls within the TTL are served from memory
+ * without network. Returns null when every source fails / is malformed (never
+ * throws) so callers can stay best-effort.
+ */
+async function fetchFreeCatalog(opts) {
+    if (!opts?.force && catalogCache && Date.now() - catalogCache.fetchedAt < exports.CATALOG_TTL_MS) {
+        return catalogCache.data;
+    }
+    const override = opts?.url || process.env.VECTOR_FREE_CATALOG_URL;
+    const candidates = override ? [override] : [exports.FREE_GATEWAY_CATALOG_URL, exports.FREE_CATALOG_URL];
+    for (const url of candidates) {
+        try {
+            const res = await fetch(url, { signal: AbortSignal.timeout(opts?.timeoutMs ?? 8_000) });
+            if (!res.ok)
+                continue;
+            const data = await res.json();
+            if (!isValidCatalog(data))
+                continue;
+            catalogCache = { data, fetchedAt: Date.now() };
+            return data;
+        }
+        catch {
+            /* try the next source */
+        }
+    }
+    return null;
+}
+/**
+ * Adopt a fetched catalog: prime the cache (freeProviderDef follows it) and
+ * refresh the free provider entry in the config. Returns true when the
+ * config object was modified (caller decides whether to persist).
+ */
+function applyFreeCatalog(data, config) {
+    catalogCache = { data, fetchedAt: Date.now() };
+    return ensureFreeProvider(config);
+}

package/dist/providers/openai-compat.js

@@ -9,6 +9,62 @@ exports.createThinkTagStreamSplitter = createThinkTagStreamSplitter;
  */
 const provider_1 = require("./provider");
 const credentials_1 = require("../config/credentials");
+/**
+ * Stream delta-collector for tool calls.
+ *
+ * WHY A MAP, NOT AN ARRAY INDEXED BY `part.index`:
+ * OpenAI spec says tool_calls deltas carry a 0-based `index` per tool call,
+ * and arguments arrive in fragments. Most gateways comply. But some gateways
+ * proxy Anthropic models and leak the UPSTREAM content-block positions as
+ * `index` (thinking=0, text=1, tool_use=2, ...) — with one tool call the
+ * chunks arrive with `index:2` (observed live on api.justwoker.icu, 2026-09-04).
+ * Indexing a plain array by that value produces a SPARSE array
+ * ([<hole>, <hole>, call]) which silently breaks `for..of` iteration in the
+ * agent loop (holes are skipped) and corrupts the follow-up request history.
+ * Collect per index in a Map, emit a DENSE array in arrival order, deduped
+ * by id (Anthropic ids are unique per call; OpenAI reuses one id across
+ * argument fragments).
+ */
+class StreamToolCallCollector {
+    byIndex = new Map();
+    /** Feed one delta.tool_calls part; returns the latest complete call, if any. */
+    add(part) {
+        const idx = Number(part.index || 0);
+        const fn = (part.function || {});
+        const existing = this.byIndex.get(idx);
+        if (!existing) {
+            this.byIndex.set(idx, {
+                id: String(part.id || `call_${idx}_${Math.random().toString(36).slice(2)}`),
+                name: String(fn.name || ''),
+                arguments: String(fn.arguments || ''),
+            });
+        }
+        else {
+            if (part.id)
+                existing.id = String(part.id);
+            if (fn.name)
+                existing.name = String(fn.name);
+            if (fn.arguments)
+                existing.arguments += String(fn.arguments);
+        }
+        const finished = this.finished();
+        return finished.length > 0 ? finished[finished.length - 1] : null;
+    }
+    /** All complete calls so far, in arrival order, DENSE (no holes/nulls). */
+    finished() {
+        const seen = new Set();
+        const out = [];
+        for (const call of this.byIndex.values()) {
+            if (!call.name)
+                continue; // incomplete: no function name yet
+            if (seen.has(call.id))
+                continue; // fragment of an already-collected call
+            seen.add(call.id);
+            out.push({ id: call.id, name: call.name, arguments: call.arguments || '{}' });
+        }
+        return out;
+    }
+}
 function toOpenAIMessages(messages) {
     const out = [];
     for (const m of messages) {
@@ -308,7 +364,10 @@ class OpenAICompatProvider {
             let buffer = '';
             let content = '';
             let reasoning = '';
-            const toolCalls = [];
+            // Dense collector — see StreamToolCallCollector: some gateways send
+            // non-0-based tool_calls indices (Anthropic block positions), which
+            // used to produce a sparse toolCalls array the agent loop skipped.
+            const toolCollector = new StreamToolCallCollector();
             // Reasoning models behind OpenAI-compat gateways may inline thinking
             // into delta.content as <think>…</think> (DeepSeek-R1/QwQ/Qwen3).
             // Split it out so the • Thinking card works on EVERY model.
@@ -332,13 +391,14 @@ class OpenAICompatProvider {
                             reasoning += r;
                         for (const c of tail.content)
                             content += c;
+                        const calls = toolCollector.finished();
                         yield {
                             type: 'done',
                             result: {
                                 content,
                                 reasoning: reasoning || undefined,
-                                toolCalls,
-                                stopReason: toolCalls.length > 0 ? 'tool_calls' : 'stop',
+                                toolCalls: calls,
+                                stopReason: calls.length > 0 ? 'tool_calls' : 'stop',
                                 model: params.model,
                             },
                         };
@@ -374,32 +434,14 @@ class OpenAICompatProvider {
                     }
                     const tc = delta.tool_calls;
                     if (Array.isArray(tc)) {
+                        let latest = null;
                         for (const part of tc) {
-                            const idx = Number(part.index || 0);
-                            const fn = (part.function || {});
-                            const existing = toolCalls[idx];
-                            if (!existing) {
-                                toolCalls[idx] = {
-                                    id: String(part.id || `call_${idx}_${Math.random().toString(36).slice(2)}`),
-                                    name: String(fn.name || ''),
-                                    arguments: String(fn.arguments || ''),
-                                };
-                            }
-                            else {
-                                if (part.id)
-                                    existing.id = String(part.id);
-                                if (fn.name)
-                                    existing.name = String(fn.name);
-                                if (fn.arguments)
-                                    existing.arguments += String(fn.arguments);
-                            }
+                            const call = toolCollector.add(part);
+                            if (call)
+                                latest = call;
                         }
-                        const finished = toolCalls.filter((t) => t.name).map((t) => ({
-                            ...t,
-                            arguments: t.arguments || '{}',
-                        }));
-                        if (finished.length > 0) {
-                            yield { type: 'tool_call', toolCall: finished[finished.length - 1] };
+                        if (latest) {
+                            yield { type: 'tool_call', toolCall: latest };
                         }
                     }
                 }
@@ -415,7 +457,7 @@ class OpenAICompatProvider {
                 result: {
                     content,
                     reasoning: reasoning || undefined,
-                    toolCalls: toolCalls.filter((t) => t.name),
+                    toolCalls: toolCollector.finished(),
                     stopReason: 'stop',
                     model: params.model,
                 },