@chispear/vibekit 0.4.0 → 0.6.0

package/dist/mcp.js

@@ -0,0 +1,389 @@
+/**
+ * Client MCP (Model Context Protocol) — ditulis dari nol di atas JSON-RPC 2.0,
+ * tanpa dependency baru. VibeKit berperan sebagai MCP *client*: tool dari
+ * server MCP mana pun (lokal lewat stdio, remote lewat Streamable HTTP)
+ * digabung ke daftar tool agent dengan nama ter-namespace
+ * `mcp__<namaServer>__<namaTool>`.
+ *
+ * Alur handshake per server: request `initialize` (menawarkan versi protokol
+ * di bawah; versi jawaban server diterima apa adanya) → notifikasi
+ * `notifications/initialized` → `tools/list`. Pemanggilan tool lewat
+ * `tools/call`.
+ */
+import { spawn } from "node:child_process";
+/** Versi protokol MCP yang ditawarkan saat initialize. */
+const VERSI_PROTOKOL = "2025-03-26";
+/** Samakan dengan "version" di package.json (nama/versi clientInfo handshake). */
+const VERSI_KLIEN = "0.6.0";
+/** Batas waktu satu request JSON-RPC (kedua transport). */
+const TIMEOUT_REQUEST_MS = 60_000;
+/** Ubah pesan error JSON-RPC menjadi Error yang terbaca manusia. */
+function errorDariPesan(pesan) {
+    const e = pesan.error;
+    return new Error(`error JSON-RPC${e?.code !== undefined ? ` ${e.code}` : ""}: ${e?.message ?? "tanpa pesan"}`);
+}
+/* ------------------------------------------------------------------ */
+/* Transport stdio: proses anak, pesan JSON dipisah newline (NDJSON).  */
+/* ------------------------------------------------------------------ */
+function buatKoneksiStdio(cfg) {
+    const perintah = cfg.perintah;
+    const anak = spawn(perintah, cfg.argumen ?? [], {
+        env: { ...process.env, ...(cfg.env ?? {}) },
+        stdio: ["pipe", "pipe", "pipe"],
+    });
+    // stderr server tidak dipakai protokol; tampung & buang agar pipa tidak penuh.
+    anak.stderr.on("data", () => { });
+    const menunggu = new Map();
+    let idBerikut = 0;
+    let sisaBaris = "";
+    let ditutup = false;
+    let gagalFatal = null;
+    const gagalkanSemua = (err) => {
+        if (!gagalFatal)
+            gagalFatal = err;
+        for (const m of menunggu.values()) {
+            clearTimeout(m.pengatur);
+            m.reject(gagalFatal);
+        }
+        menunggu.clear();
+    };
+    anak.on("error", (e) => {
+        gagalkanSemua(new Error(`gagal menjalankan server MCP "${cfg.nama}" (${perintah}): ${e.message}`));
+    });
+    anak.on("exit", (kode) => {
+        if (!ditutup) {
+            gagalkanSemua(new Error(`server MCP "${cfg.nama}" berhenti sebelum menjawab (kode keluar ${kode ?? "?"})`));
+        }
+    });
+    anak.stdout.on("data", (potongan) => {
+        sisaBaris += potongan.toString("utf8");
+        let idx;
+        // Respons bisa terpotong antar-chunk: proses hanya baris yang sudah utuh.
+        while ((idx = sisaBaris.indexOf("\n")) >= 0) {
+            const baris = sisaBaris.slice(0, idx).trim();
+            sisaBaris = sisaBaris.slice(idx + 1);
+            if (!baris)
+                continue;
+            let pesan;
+            try {
+                pesan = JSON.parse(baris);
+            }
+            catch {
+                continue; // baris bukan JSON (mis. log server) — abaikan
+            }
+            if (pesan.id === undefined)
+                continue; // notifikasi dari server — abaikan
+            const idNum = typeof pesan.id === "number" ? pesan.id : Number(pesan.id);
+            const m = menunggu.get(idNum);
+            if (!m)
+                continue; // respons tak dikenal / permintaan dari server — abaikan
+            menunggu.delete(idNum);
+            clearTimeout(m.pengatur);
+            if (pesan.error)
+                m.reject(errorDariPesan(pesan));
+            else
+                m.resolve(pesan.result);
+        }
+    });
+    const tulis = (obj) => {
+        anak.stdin.write(JSON.stringify(obj) + "\n");
+    };
+    return {
+        minta: (method, params) => {
+            if (gagalFatal)
+                return Promise.reject(gagalFatal);
+            if (ditutup)
+                return Promise.reject(new Error(`koneksi MCP "${cfg.nama}" sudah ditutup`));
+            const id = ++idBerikut;
+            return new Promise((resolve, reject) => {
+                const pengatur = setTimeout(() => {
+                    menunggu.delete(id);
+                    reject(new Error(`server MCP "${cfg.nama}" tidak menjawab "${method}" dalam 60 detik (timeout)`));
+                }, TIMEOUT_REQUEST_MS);
+                menunggu.set(id, { resolve, reject, pengatur });
+                try {
+                    tulis({ jsonrpc: "2.0", id, method, ...(params !== undefined ? { params } : {}) });
+                }
+                catch (e) {
+                    clearTimeout(pengatur);
+                    menunggu.delete(id);
+                    reject(new Error(`gagal mengirim ke server MCP "${cfg.nama}": ${e.message}`));
+                }
+            });
+        },
+        beriTahu: async (method, params) => {
+            if (ditutup || gagalFatal)
+                return;
+            try {
+                tulis({ jsonrpc: "2.0", method, ...(params !== undefined ? { params } : {}) });
+            }
+            catch {
+                // Notifikasi gagal terkirim tidak menggagalkan koneksi.
+            }
+        },
+        tutup: async () => {
+            ditutup = true;
+            gagalkanSemua(new Error(`koneksi MCP "${cfg.nama}" ditutup`));
+            try {
+                anak.stdin.end();
+            }
+            catch {
+                // abaikan
+            }
+            anak.kill();
+        },
+    };
+}
+/* ------------------------------------------------------------------ */
+/* Transport HTTP: Streamable HTTP — POST JSON-RPC, jawaban JSON / SSE */
+/* ------------------------------------------------------------------ */
+function buatKoneksiHttp(cfg) {
+    const url = cfg.url;
+    let idBerikut = 0;
+    let idSesi = null;
+    let ditutup = false;
+    const headerDasar = () => ({
+        "Content-Type": "application/json",
+        Accept: "application/json, text/event-stream",
+        ...(cfg.headers ?? {}),
+        ...(idSesi ? { "Mcp-Session-Id": idSesi } : {}),
+    });
+    /** Satu POST dengan timeout; simpan Mcp-Session-Id jawaban bila ada. */
+    async function kirimHttp(payload) {
+        const kontroler = new AbortController();
+        const pengatur = setTimeout(() => kontroler.abort(), TIMEOUT_REQUEST_MS);
+        try {
+            const respons = await fetch(url, {
+                method: "POST",
+                headers: headerDasar(),
+                body: JSON.stringify(payload),
+                signal: kontroler.signal,
+            });
+            const sesiBaru = respons.headers.get("mcp-session-id");
+            if (sesiBaru)
+                idSesi = sesiBaru;
+            return {
+                status: respons.status,
+                tipeKonten: respons.headers.get("content-type") ?? "",
+                teks: await respons.text(),
+            };
+        }
+        catch (e) {
+            if (e.name === "AbortError") {
+                throw new Error(`server MCP "${cfg.nama}" tidak menjawab dalam 60 detik (timeout)`);
+            }
+            throw new Error(`gagal menghubungi server MCP "${cfg.nama}" (${url}): ${e.message}`);
+        }
+        finally {
+            clearTimeout(pengatur);
+        }
+    }
+    /** Cari pesan JSON-RPC ber-id `id` di dalam teks SSE (kumpulan baris `data:` per event). */
+    function cariDiSse(teks, id) {
+        let dataGabungan = [];
+        const kandidat = [];
+        for (const barisMentah of teks.split(/\r?\n/)) {
+            const baris = barisMentah.trimEnd();
+            if (baris === "") {
+                if (dataGabungan.length > 0)
+                    kandidat.push(dataGabungan.join("\n"));
+                dataGabungan = [];
+            }
+            else if (baris.startsWith("data:")) {
+                dataGabungan.push(baris.slice("data:".length).trim());
+            }
+        }
+        if (dataGabungan.length > 0)
+            kandidat.push(dataGabungan.join("\n"));
+        for (const mentah of kandidat) {
+            try {
+                const pesan = JSON.parse(mentah);
+                if (pesan && (pesan.id === id || Number(pesan.id) === id))
+                    return pesan;
+            }
+            catch {
+                // bukan JSON — lewati
+            }
+        }
+        return null;
+    }
+    return {
+        minta: async (method, params) => {
+            if (ditutup)
+                throw new Error(`koneksi MCP "${cfg.nama}" sudah ditutup`);
+            const id = ++idBerikut;
+            const { status, tipeKonten, teks } = await kirimHttp({
+                jsonrpc: "2.0",
+                id,
+                method,
+                ...(params !== undefined ? { params } : {}),
+            });
+            if (status < 200 || status >= 300) {
+                throw new Error(`server MCP "${cfg.nama}" menjawab HTTP ${status}${teks ? `: ${teks.replace(/\s+/g, " ").slice(0, 200)}` : ""}`);
+            }
+            let pesan = null;
+            if (tipeKonten.includes("text/event-stream")) {
+                pesan = cariDiSse(teks, id);
+                if (!pesan)
+                    throw new Error(`server MCP "${cfg.nama}" tidak mengirim jawaban untuk "${method}" dalam aliran SSE-nya`);
+            }
+            else {
+                if (!teks.trim())
+                    throw new Error(`server MCP "${cfg.nama}" menjawab kosong untuk "${method}"`);
+                try {
+                    pesan = JSON.parse(teks);
+                }
+                catch {
+                    throw new Error(`server MCP "${cfg.nama}" menjawab bukan JSON yang valid untuk "${method}"`);
+                }
+            }
+            if (pesan.error)
+                throw errorDariPesan(pesan);
+            return pesan.result;
+        },
+        beriTahu: async (method, params) => {
+            if (ditutup)
+                return;
+            try {
+                await kirimHttp({ jsonrpc: "2.0", method, ...(params !== undefined ? { params } : {}) });
+            }
+            catch {
+                // Notifikasi (mis. notifications/initialized) sering dijawab 202 kosong;
+                // kegagalannya tidak menggagalkan koneksi.
+            }
+        },
+        tutup: async () => {
+            ditutup = true;
+            // Akhiri sesi secara sopan bila server memberi id sesi (best-effort).
+            if (idSesi) {
+                try {
+                    const kontroler = new AbortController();
+                    const pengatur = setTimeout(() => kontroler.abort(), 5000);
+                    try {
+                        await fetch(url, { method: "DELETE", headers: headerDasar(), signal: kontroler.signal });
+                    }
+                    finally {
+                        clearTimeout(pengatur);
+                    }
+                }
+                catch {
+                    // abaikan — sesi akan kedaluwarsa di sisi server
+                }
+                idSesi = null;
+            }
+        },
+    };
+}
+/* ------------------------------------------------------------------ */
+/* Handshake + pengelola gabungan                                      */
+/* ------------------------------------------------------------------ */
+/** Sanitasi nama menjadi karakter yang sah untuk nama tool OpenAI: [a-zA-Z0-9_-]. */
+function sanitasi(nama) {
+    return nama.replace(/[^a-zA-Z0-9_-]/g, "_");
+}
+/** Handshake MCP: initialize → notifications/initialized → tools/list. */
+async function jabatTangan(koneksi) {
+    // Versi jawaban server diterima apa adanya (tidak divalidasi ketat): server
+    // yang lebih baru/lama tetap dicoba dipakai selama tools/list berhasil.
+    await koneksi.minta("initialize", {
+        protocolVersion: VERSI_PROTOKOL,
+        capabilities: {},
+        clientInfo: { name: "vibekit", version: VERSI_KLIEN },
+    });
+    await koneksi.beriTahu("notifications/initialized");
+    const daftar = (await koneksi.minta("tools/list", {}));
+    const mentah = Array.isArray(daftar?.tools) ? daftar.tools : [];
+    return mentah.filter((t) => !!t && typeof t === "object" && typeof t.name === "string" && t.name.trim() !== "");
+}
+/** Ubah hasil tools/call (content blocks) menjadi teks untuk model. */
+function hasilKeTeks(hasil) {
+    const obj = (hasil ?? {});
+    const blok = Array.isArray(obj.content) ? obj.content : [];
+    const bagian = blok.map((b) => {
+        const blokObj = (b ?? {});
+        if (blokObj.type === "text" && typeof blokObj.text === "string")
+            return blokObj.text;
+        return `[konten ${typeof blokObj.type === "string" ? blokObj.type : "?"}]`;
+    });
+    const teks = bagian.join("\n");
+    if (obj.isError)
+        return `ERROR: ${teks || "(server melaporkan error tanpa teks)"}`;
+    return teks || "(tool selesai tanpa keluaran teks)";
+}
+/**
+ * Sambungkan semua server MCP dari konfigurasi. Kegagalan SATU server tidak
+ * menggagalkan yang lain: server yang gagal dicatat di `peringatan`, server
+ * sehat tetap terdaftar tool-nya.
+ */
+export async function sambungkanMcpServers(configs) {
+    const tools = [];
+    const rincianServer = [];
+    const peringatan = [];
+    const rute = new Map();
+    const koneksiAktif = [];
+    for (const cfg of configs) {
+        let koneksi = null;
+        try {
+            koneksi = cfg.url ? buatKoneksiHttp(cfg) : buatKoneksiStdio(cfg);
+            const daftarTool = await jabatTangan(koneksi);
+            if (daftarTool.length === 0) {
+                peringatan.push(`${cfg.nama}: server tersambung tetapi tidak menyediakan tool yang valid — dilewati.`);
+                await koneksi.tutup().catch(() => { });
+                continue;
+            }
+            const ringkas = [];
+            for (const t of daftarTool) {
+                const namaLengkap = `mcp__${sanitasi(cfg.nama)}__${sanitasi(t.name)}`;
+                if (rute.has(namaLengkap)) {
+                    peringatan.push(`${cfg.nama}: nama tool ter-namespace "${namaLengkap}" bertabrakan — yang kedua dilewati.`);
+                    continue;
+                }
+                rute.set(namaLengkap, { koneksi, namaTool: t.name });
+                tools.push({
+                    type: "function",
+                    function: {
+                        name: namaLengkap,
+                        description: typeof t.description === "string" ? t.description : "",
+                        parameters: t.inputSchema && typeof t.inputSchema === "object"
+                            ? t.inputSchema
+                            : { type: "object", properties: {} },
+                    },
+                });
+                ringkas.push({
+                    nama: t.name,
+                    namaLengkap,
+                    deskripsi: typeof t.description === "string" ? t.description : "",
+                });
+            }
+            koneksiAktif.push(koneksi);
+            rincianServer.push({ nama: cfg.nama, tools: ringkas });
+        }
+        catch (e) {
+            peringatan.push(`${cfg.nama}: gagal tersambung — ${e.message}`);
+            if (koneksi)
+                await koneksi.tutup().catch(() => { });
+        }
+    }
+    return {
+        tools,
+        rincianServer,
+        peringatan,
+        panggilTool: async (namaLengkap, argumen) => {
+            const r = rute.get(namaLengkap);
+            if (!r)
+                throw new Error(`tool MCP tidak ditemukan: ${namaLengkap}`);
+            const hasil = await r.koneksi.minta("tools/call", { name: r.namaTool, arguments: argumen ?? {} });
+            return hasilKeTeks(hasil);
+        },
+        tutupSemua: async () => {
+            for (const k of koneksiAktif) {
+                try {
+                    await k.tutup();
+                }
+                catch {
+                    // abaikan — penutupan best-effort
+                }
+            }
+        },
+    };
+}

package/dist/prompt.js

@@ -15,11 +15,11 @@ export function systemPromptHemat(gaya) {
         case "poin-penting":
         default:
             return [
-                "Jawablah SANGAT ringkas, hanya poin-poin penting, dalam format poin (bullet list) bila cocok.",
-                "DILARANG: basa-basi, pembuka/penutup sopan-santun, mengulang atau parafrase pertanyaan,",
-                "menjelaskan hal yang tidak ditanyakan, dan kalimat pengisi.",
+                "Jawabanmu WAJIB hanya berisi poin-poin penting dalam format poin (bullet list); tidak ada satu kata pun di luar poin.",
+                "DILARANG KERAS: kalimat pembuka atau penutup dalam bentuk apa pun — termasuk sapaan, \"Berikut...\", \"Tentu!\", \"Semoga membantu\", dan sejenisnya.",
+                "DILARANG: paragraf naratif, basa-basi, mengulang atau parafrase pertanyaan, menjelaskan hal yang tidak ditanyakan, dan kalimat pengisi.",
                 "Satu poin = satu ide, sesingkat mungkin sambil tetap akurat dan lengkap pada intinya.",
-                "Untuk kode: berikan kodenya saja ditambah penjelasan maksimal satu baris bila perlu.",
+                "Satu-satunya pengecualian: kode diberikan sebagai blok kode, tanpa penjelasan pendamping selain maksimal satu baris.",
             ].join(" ");
     }
 }

package/dist/router.js

@@ -1,6 +1,6 @@
 import { selesaikanApiKey } from "./config.js";
 import { systemPromptHemat } from "./prompt.js";
-import { akhirHariIni, formatJam, muatState, sedangCooldown, simpanState, statePenyedia, } from "./state.js";
+import { akhirHariIni, catatPemakaianHarian, formatJam, muatState, sedangCooldown, simpanState, statePenyedia, } from "./state.js";
 import { formatAngka, hitungToken } from "./token.js";
 const POLA_KUOTA = /insufficient_quota|resource_exhausted|quota exceeded|exceeded your quota|kuota|insufficient balance|balance is too low|credit balance|billing/i;
 /** Klasifikasikan kegagalan HTTP: kuota habis, rate-limit singkat, atau error lain. */
@@ -17,6 +17,130 @@ export function klasifikasiError(status, bodyTeks) {
     }
     return { jenis: "lainnya", ringkas: `HTTP ${status} ${potongan}`.trim() };
 }
+/**
+ * Baca aliran SSE (mode streaming) dari respons penyedia dan rakit menjadi
+ * objek `data` yang SETARA BENTUKNYA dengan respons non-streaming:
+ * `choices[0].message` berisi content terakumulasi dan tool_calls yang sudah
+ * digabung per `index` — termasuk `extra_content` (thought_signature Gemini)
+ * bila muncul pada delta tool_call, agar riwayat & kompaksi tetap bekerja.
+ *
+ * Hasil dibedakan menurut kapan kegagalan terjadi:
+ * - "pra-token": aliran gagal sebelum ada keluaran apa pun → pemanggil boleh
+ *   memperlakukannya sebagai kegagalan penyedia biasa (failover).
+ * - "tengah": aliran putus SETELAH ada token keluar → pemanggil TIDAK BOLEH
+ *   failover karena akan menggandakan keluaran ke pengguna.
+ */
+async function bacaAliranSSE(respons, provider, opsi, timeoutMs) {
+    const body = respons.body;
+    if (!body)
+        return { jenis: "pra-token", alasan: "respons streaming tidak memiliki body" };
+    const pembaca = body.getReader();
+    const dekoder = new TextDecoder();
+    let buffer = "";
+    let konten = "";
+    const perIndeks = new Map();
+    let usage;
+    let adaKeluaran = false;
+    let tokenPertamaDilaporkan = false;
+    const prosesBaris = (baris) => {
+        const rapi = baris.trim();
+        if (!rapi.startsWith("data:"))
+            return;
+        const muatan = rapi.slice("data:".length).trim();
+        if (!muatan || muatan === "[DONE]")
+            return;
+        let potong;
+        try {
+            potong = JSON.parse(muatan);
+        }
+        catch {
+            return; // baris data rusak/komentar: lewati, jangan gagalkan aliran
+        }
+        if (potong?.usage)
+            usage = potong.usage;
+        const delta = Array.isArray(potong?.choices) ? potong.choices[0]?.delta : undefined;
+        if (!delta)
+            return;
+        if (typeof delta.content === "string" && delta.content !== "") {
+            konten += delta.content;
+            adaKeluaran = true;
+            if (!tokenPertamaDilaporkan) {
+                tokenPertamaDilaporkan = true;
+                opsi.onTokenPertama?.(provider);
+            }
+            opsi.onToken?.(delta.content);
+        }
+        if (Array.isArray(delta.tool_calls)) {
+            for (const dtc of delta.tool_calls) {
+                const indeks = typeof dtc?.index === "number" ? dtc.index : 0;
+                let entri = perIndeks.get(indeks);
+                if (!entri) {
+                    entri = { id: "", nama: "", argumen: "" };
+                    perIndeks.set(indeks, entri);
+                }
+                if (typeof dtc.id === "string" && dtc.id)
+                    entri.id = dtc.id;
+                if (typeof dtc.function?.name === "string")
+                    entri.nama += dtc.function.name;
+                if (typeof dtc.function?.arguments === "string")
+                    entri.argumen += dtc.function.arguments;
+                if (dtc.extra_content !== undefined)
+                    entri.extraContent = dtc.extra_content;
+                adaKeluaran = true;
+            }
+        }
+    };
+    let waktuHabis = false;
+    const pengatur = setTimeout(() => {
+        waktuHabis = true;
+        pembaca.cancel().catch(() => { });
+    }, timeoutMs);
+    try {
+        for (;;) {
+            const { done, value } = await pembaca.read();
+            if (done)
+                break;
+            buffer += dekoder.decode(value, { stream: true });
+            let idx = buffer.indexOf("\n");
+            while (idx >= 0) {
+                prosesBaris(buffer.slice(0, idx));
+                buffer = buffer.slice(idx + 1);
+                idx = buffer.indexOf("\n");
+            }
+        }
+        if (buffer.trim())
+            prosesBaris(buffer);
+    }
+    catch (e) {
+        const alasan = `aliran streaming terputus: ${e.message}`;
+        return adaKeluaran ? { jenis: "tengah", alasan } : { jenis: "pra-token", alasan };
+    }
+    finally {
+        clearTimeout(pengatur);
+    }
+    if (waktuHabis) {
+        const alasan = `aliran streaming melewati batas waktu ${timeoutMs} ms`;
+        return adaKeluaran ? { jenis: "tengah", alasan } : { jenis: "pra-token", alasan };
+    }
+    const toolCalls = [...perIndeks.entries()]
+        .sort((a, b) => a[0] - b[0])
+        .map(([, e]) => ({
+        ...(e.id ? { id: e.id } : {}),
+        type: "function",
+        function: { name: e.nama, arguments: e.argumen },
+        ...(e.extraContent !== undefined ? { extra_content: e.extraContent } : {}),
+    }));
+    const pesan = {
+        role: "assistant",
+        content: konten === "" ? null : konten,
+    };
+    if (toolCalls.length > 0)
+        pesan.tool_calls = toolCalls;
+    return {
+        jenis: "sukses",
+        data: { choices: [{ message: pesan }], ...(usage !== undefined ? { usage } : {}) },
+    };
+}
 /**
  * Mesin router: coba penyedia sesuai urutan prioritas konfigurasi.
  * - Penyedia yang cooldown / anggaran hariannya tercapai dilewati tanpa dipanggil.
@@ -27,6 +151,10 @@ export function klasifikasiError(status, bodyTeks) {
  *   2 kali dengan jeda (3 dtk, 8 dtk) sebelum menyerah ke penyedia berikutnya;
  *   503 tidak memicu cooldown.
  * - Error lain (401, 400, jaringan) tidak dianggap kuota habis; dicatat dan lanjut ke berikutnya.
+ * - Mode streaming (opsi.stream): aturan di atas berlaku untuk error yang
+ *   terjadi SEBELUM token pertama (status HTTP / aliran kosong). Error di
+ *   tengah aliran setelah token keluar TIDAK di-failover; hasilnya gagal
+ *   dengan `streamTerputus: true`.
  */
 export async function tanyaRouter(opsi) {
     const fetchImpl = opsi.fetchImpl ?? fetch;
@@ -81,13 +209,22 @@ export async function tanyaRouter(opsi) {
             continue;
         }
         const url = provider.baseUrl.replace(/\/+$/, "") + "/chat/completions";
+        // max_tokens hanya dikirim bila plafon diatur > 0. Nilai 0/kosong/tidak diisi
+        // = tanpa batas: field tidak dikirim sama sekali, batas bawaan model berlaku.
+        const maksToken = opsi.config.gaya.maksTokenJawaban;
         const body = {
             model: provider.model,
             messages: semuaPesan,
-            max_tokens: opsi.config.gaya.maksTokenJawaban,
+            ...(typeof maksToken === "number" && maksToken > 0 ? { max_tokens: maksToken } : {}),
             ...(opsi.tools && opsi.tools.length > 0 ? { tools: opsi.tools } : {}),
             ...(provider.extraBody ?? {}),
         };
+        if (opsi.stream) {
+            // include_usage agar token terpakai tetap dilaporkan penyedia di akhir
+            // aliran; penyedia yang tidak mengirim usage diestimasi secara lokal.
+            body.stream = true;
+            body.stream_options = { include_usage: true };
+        }
         let respons;
         let teks = "";
         let gagalJaringan = null;
@@ -115,10 +252,17 @@ export async function tanyaRouter(opsi) {
                 gagalJaringan = `gagal jaringan: ${e.message}`;
                 break;
             }
-            teks = await respons.text();
             // 503 = server penyedia sedang penuh sesaat: coba ulang penyedia yang sama
-            // dengan jeda sebelum menyerah ke penyedia berikutnya.
+            // dengan jeda sebelum menyerah ke penyedia berikutnya. Keputusan dibuat
+            // dari STATUS (header) sebelum body dibaca, supaya body — terutama aliran
+            // streaming — tidak terkonsumsi oleh percobaan yang akan diulang.
             if (respons.status === 503 && percobaan503 < jedaRetry503.length) {
+                try {
+                    await respons.body?.cancel();
+                }
+                catch {
+                    /* abaikan: body percobaan gagal memang dibuang */
+                }
                 await tunggu(jedaRetry503[percobaan503]);
                 percobaan503++;
                 continue;
@@ -133,6 +277,7 @@ export async function tanyaRouter(opsi) {
             continue;
         }
         if (!respons.ok) {
+            teks = await respons.text();
             const { jenis, ringkas } = klasifikasiError(respons.status, teks);
             entri.alasanTerakhir = ringkas;
             if (jenis === "kuota") {
@@ -153,15 +298,43 @@ export async function tanyaRouter(opsi) {
             continue;
         }
         let data;
-        try {
-            data = JSON.parse(teks);
+        if (opsi.stream && respons.body) {
+            const aliran = await bacaAliranSSE(respons, provider, opsi, timeoutMs);
+            if (aliran.jenis === "pra-token") {
+                // Belum ada token yang keluar: kegagalan penyedia biasa, failover lanjut.
+                entri.alasanTerakhir = aliran.alasan;
+                simpanState(opsi.lokasiState, state);
+                catatan.push({ nama: provider.nama, model: provider.model, status: "gagal", alasan: aliran.alasan });
+                continue;
+            }
+            if (aliran.jenis === "tengah") {
+                // Token sudah keluar ke pengguna: JANGAN failover (keluaran akan
+                // ganda). Laporkan sebagai kegagalan giliran khusus.
+                entri.alasanTerakhir = aliran.alasan;
+                simpanState(opsi.lokasiState, state);
+                catatan.push({ nama: provider.nama, model: provider.model, status: "gagal", alasan: aliran.alasan });
+                return {
+                    ok: false,
+                    pesan: `Aliran jawaban dari ${provider.nama} (${provider.model}) terputus di tengah jalan — ${aliran.alasan}. ` +
+                        "Sebagian jawaban mungkin sudah tampil; permintaan TIDAK diulang ke penyedia lain agar keluaran tidak ganda.",
+                    catatan,
+                    streamTerputus: true,
+                };
+            }
+            data = aliran.data;
         }
-        catch {
-            const alasan = "respons bukan JSON yang valid";
-            entri.alasanTerakhir = alasan;
-            simpanState(opsi.lokasiState, state);
-            catatan.push({ nama: provider.nama, model: provider.model, status: "gagal", alasan });
-            continue;
+        else {
+            teks = await respons.text();
+            try {
+                data = JSON.parse(teks);
+            }
+            catch {
+                const alasan = "respons bukan JSON yang valid";
+                entri.alasanTerakhir = alasan;
+                simpanState(opsi.lokasiState, state);
+                catatan.push({ nama: provider.nama, model: provider.model, status: "gagal", alasan });
+                continue;
+            }
         }
         const pesanMentah = data?.choices?.[0]?.message;
         const jawaban = pesanMentah?.content ?? "";
@@ -204,6 +377,7 @@ export async function tanyaRouter(opsi) {
             tokenSumber = "estimasi";
         }
         entri.totalToken += tokenTerpakai;
+        catatPemakaianHarian(state, provider.nama, tokenTerpakai, sekarang);
         entri.alasanTerakhir = null;
         simpanState(opsi.lokasiState, state);
         return {