kiosapi 0.1.7 → 0.1.9

package/dist/agent/run.js

@@ -1,9 +1,199 @@
-import { writeFileSync } from 'node:fs';
-import { chatComplete, generateImage, resolveMediaModel, } from '../api.js';
-import { cyan, dim, green, prompt, rupiah, thinking, yellow } from '../ui.js';
+import { existsSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs';
+import { extname } from 'node:path';
+import { chatComplete, generateImage, resolveMediaModel, streamVision, } from '../api.js';
+import { CHECKPOINT_PATH } from '../config.js';
+import { cyan, dim, green, idn, prompt, red, rupiah, thinking, yellow } from '../ui.js';
 import { systemPrompt, toolsForMode } from './schemas.js';
-import { bacaFile, cari, daftarFile, editFile, jalankan, tulisFile } from './tools.js';
-const MAX_STEPS = 25;
+import { bacaFile, cari, daftarFile, editFile, hapusFile, jalankan, pindahFile, safePath, tulisFile, } from './tools.js';
+const MAX_STEPS = 50;
+// ---------------------------------------------------------------------------
+// Context trimming: bound what is sent to the API (and stored in checkpoint)
+// ---------------------------------------------------------------------------
+/**
+ * How many messages (excluding the system prompt) to keep when trimming. Each agent "step" is
+ * roughly 1 assistant + 1-3 tool results, so 40 messages ≈ 10-15 full steps of recent history —
+ * enough for continuity while preventing multi-MB payloads on long sessions.
+ */
+const MAX_CONTEXT_MESSAGES = 40;
+/**
+ * Return a context-bounded slice of the message history. Never mutates the input.
+ *
+ * The kept slice always:
+ *  - starts with the original system prompt
+ *  - contains at most MAX_CONTEXT_MESSAGES non-system messages
+ *  - begins on a `user` turn boundary (never mid tool-call sequence, which providers reject)
+ *  - prepends a system note so the model knows early context was dropped
+ *
+ * Used both before every chatComplete call (to cap API payload) and when writing the checkpoint
+ * (to keep checkpoint.json small — a resumed session gets the same bounded window anyway).
+ */
+function trimContext(messages) {
+    if (messages.length === 0)
+        return messages;
+    const [system, ...rest] = messages;
+    if (rest.length <= MAX_CONTEXT_MESSAGES)
+        return messages;
+    // Take the tail we want to keep, then advance past any leading tool/assistant messages so
+    // the slice always starts on a complete user turn. Orphaned tool results (whose paired
+    // assistant message was trimmed) cause provider errors on the next API call.
+    let tail = rest.slice(-MAX_CONTEXT_MESSAGES);
+    let skip = 0;
+    while (skip < tail.length && tail[skip]?.role !== 'user')
+        skip++;
+    tail = tail.slice(skip);
+    const dropped = rest.length - tail.length;
+    if (dropped <= 0)
+        return messages; // nothing actually trimmed
+    const note = {
+        role: 'system',
+        content: `[Kiosapi: ${dropped} pesan awal dihapus dari konteks untuk menghemat token. Lanjutkan dari konteks terkini di bawah.]`,
+    };
+    return [system, note, ...tail];
+}
+function saveCheckpoint(s) {
+    try {
+        const data = {
+            model: s.model,
+            mode: s.mode,
+            otomatis: s.otomatis,
+            // Trim before persisting: a resumed session gets the same bounded window the API would
+            // have seen anyway, and the file stays small even after many baca_file calls.
+            messages: trimContext(s.messages),
+            teamModels: s.teamModels,
+            cwd: process.cwd(),
+            savedAt: new Date().toISOString(),
+            totalTokens: s.totalTokens,
+            maxSteps: s.maxSteps,
+        };
+        writeFileSync(CHECKPOINT_PATH, `${JSON.stringify(data, null, 2)}\n`);
+    }
+    catch {
+        // best-effort — never crash the agent loop over a checkpoint failure
+    }
+}
+/** Load the last auto-saved session, or null if none exists. */
+export function loadCheckpoint() {
+    if (!existsSync(CHECKPOINT_PATH))
+        return null;
+    try {
+        const data = JSON.parse(readFileSync(CHECKPOINT_PATH, 'utf8'));
+        return {
+            ...data,
+            teamModels: data.teamModels ?? {},
+            totalTokens: data.totalTokens ?? 0,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/** Remove the checkpoint file (call when task is fully done or user starts fresh). */
+export function clearCheckpoint() {
+    try {
+        unlinkSync(CHECKPOINT_PATH);
+    }
+    catch {
+        // already gone — fine
+    }
+}
+function computeLineDiff(oldLines, newLines) {
+    const m = oldLines.length;
+    const n = newLines.length;
+    // Guard against O(m*n) blowout on very large text blocks
+    if (m * n > 400_000) {
+        return [
+            ...oldLines.map((l) => ({ op: '-', line: l })),
+            ...newLines.map((l) => ({ op: '+', line: l })),
+        ];
+    }
+    // LCS DP: dp[i][j] = LCS length of oldLines[i:] vs newLines[j:]
+    const dp = Array.from({ length: m + 1 }, () => new Array(n + 1).fill(0));
+    for (let i = m - 1; i >= 0; i--) {
+        for (let j = n - 1; j >= 0; j--) {
+            if (oldLines[i] === newLines[j]) {
+                dp[i][j] = 1 + (dp[i + 1]?.[j + 1] ?? 0);
+            }
+            else {
+                dp[i][j] = Math.max(dp[i + 1]?.[j] ?? 0, dp[i]?.[j + 1] ?? 0);
+            }
+        }
+    }
+    // Traceback: prefer delete before insert (del-then-ins reads more naturally)
+    const ops = [];
+    let i = 0;
+    let j = 0;
+    while (i < m || j < n) {
+        if (i < m && j < n && oldLines[i] === newLines[j]) {
+            ops.push({ op: '=', line: oldLines[i] });
+            i++;
+            j++;
+        }
+        else if (j < n && (i >= m || (dp[i + 1]?.[j] ?? 0) < (dp[i]?.[j + 1] ?? 0))) {
+            ops.push({ op: '+', line: newLines[j] });
+            j++;
+        }
+        else {
+            ops.push({ op: '-', line: oldLines[i] });
+            i++;
+        }
+    }
+    return ops;
+}
+const DIFF_CONTEXT = 3;
+function showEditDiff(filePath, oldText, newText) {
+    const ops = computeLineDiff(oldText.split('\n'), newText.split('\n'));
+    // Mark lines to show: every changed line plus DIFF_CONTEXT around it
+    const show = new Set();
+    for (let k = 0; k < ops.length; k++) {
+        if (ops[k].op !== '=') {
+            for (let c = Math.max(0, k - DIFF_CONTEXT); c <= Math.min(ops.length - 1, k + DIFF_CONTEXT); c++) {
+                show.add(c);
+            }
+        }
+    }
+    if (show.size === 0) {
+        console.log(dim(`\n  diff ${filePath}: tidak ada perubahan`));
+        return;
+    }
+    console.log(dim(`\n  diff ${filePath}`));
+    let lastShown = -1;
+    for (let k = 0; k < ops.length; k++) {
+        if (!show.has(k))
+            continue;
+        if (lastShown >= 0 && k > lastShown + 1)
+            console.log(dim('  ···'));
+        const { op, line } = ops[k];
+        if (op === '-')
+            console.log(red(`  - ${line}`));
+        else if (op === '+')
+            console.log(green(`  + ${line}`));
+        else
+            console.log(dim(`    ${line}`));
+        lastShown = k;
+    }
+    console.log('');
+}
+function showFilePreview(filePath, konten) {
+    const lines = konten.split('\n');
+    const preview = lines.slice(0, 10);
+    console.log(dim(`\n  +++ ${filePath}`));
+    for (const l of preview)
+        console.log(green(`  + ${l}`));
+    if (lines.length > 10)
+        console.log(dim(`  … ${lines.length - 10} baris lagi`));
+    console.log('');
+}
+/**
+ * After a `jalankan` call, output was already streamed live to stdout. This just adds a red
+ * exit-code marker so failures are clearly flagged at the bottom of the output block.
+ */
+function showCommandOutput(out) {
+    const firstNl = out.indexOf('\n');
+    const exitLine = firstNl === -1 ? out : out.slice(0, firstNl);
+    const failed = exitLine.startsWith('exit=') && exitLine !== 'exit=0' && exitLine !== 'exit=null';
+    if (failed)
+        console.log(red(`  ✗ ${exitLine}`));
+}
 /** Ask y/t before a destructive action (unless --otomatis). */
 async function allow(otomatis, question) {
     if (otomatis)
@@ -11,8 +201,15 @@ async function allow(otomatis, question) {
     const ans = (await prompt(`${yellow('? ')}${question} (y/t) `)).trim().toLowerCase();
     return ans === 'y' || ans === 'ya';
 }
+const IMAGE_MIME = {
+    '.png': 'image/png',
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.webp': 'image/webp',
+    '.gif': 'image/gif',
+};
 /** Execute one tool call (with permission gating for destructive tools). */
-async function runTool(call, otomatis) {
+async function runTool(call, otomatis, model) {
     let args = {};
     try {
         args = JSON.parse(call.function.arguments || '{}');
@@ -36,16 +233,36 @@ async function runTool(call, otomatis) {
                 const p = str('path');
                 const isi = str('konten');
                 console.log(`  ${cyan('tulis')} ${p} ${dim(`(${isi.length} char)`)}`);
+                showFilePreview(p, isi);
                 if (!(await allow(otomatis, `Tulis file ${p}?`)))
                     return { output: 'Ditolak oleh pengguna.' };
-                return { output: tulisFile(p, isi) };
+                return { output: tulisFile(p, isi), modifiedPath: p };
             }
             case 'edit_file': {
                 const p = str('path');
                 console.log(`  ${cyan('edit')} ${p}`);
+                showEditDiff(p, str('cari'), str('ganti'));
                 if (!(await allow(otomatis, `Edit file ${p}?`)))
                     return { output: 'Ditolak oleh pengguna.' };
-                return { output: editFile(p, str('cari'), str('ganti')) };
+                const editOut = editFile(p, str('cari'), str('ganti'));
+                return { output: editOut, modifiedPath: editOut.startsWith('OK:') ? p : undefined };
+            }
+            case 'hapus_file': {
+                const p = str('path');
+                console.log(`  ${cyan('hapus')} ${p}`);
+                if (!(await allow(otomatis, `Hapus file ${p}?`)))
+                    return { output: 'Ditolak oleh pengguna.' };
+                const hapusOut = hapusFile(p);
+                return { output: hapusOut, modifiedPath: hapusOut.startsWith('OK:') ? p : undefined };
+            }
+            case 'pindah_file': {
+                const dari = str('dari');
+                const ke = str('ke');
+                console.log(`  ${cyan('pindah')} ${dari} → ${ke}`);
+                if (!(await allow(otomatis, `Pindah ${dari} → ${ke}?`)))
+                    return { output: 'Ditolak oleh pengguna.' };
+                const pindahOut = pindahFile(dari, ke);
+                return { output: pindahOut, modifiedPath: pindahOut.startsWith('OK:') ? ke : undefined };
             }
             case 'jalankan': {
                 const cmd = str('perintah');
@@ -53,7 +270,9 @@ async function runTool(call, otomatis) {
                 if (!(await allow(otomatis, 'Jalankan perintah ini?'))) {
                     return { output: 'Ditolak oleh pengguna.' };
                 }
-                return { output: jalankan(cmd) };
+                const cmdOut = await jalankan(cmd);
+                showCommandOutput(cmdOut);
+                return { output: cmdOut };
             }
             case 'buat_gambar': {
                 const p = str('path');
@@ -61,11 +280,41 @@ async function runTool(call, otomatis) {
                 if (!(await allow(otomatis, `Buat gambar ${p}? (berbayar)`))) {
                     return { output: 'Ditolak oleh pengguna.' };
                 }
-                const model = await resolveMediaModel(undefined, 'image');
-                const img = await generateImage(model, str('prompt'));
+                const imgModel = await resolveMediaModel(undefined, 'image');
+                const img = await generateImage(imgModel, str('prompt'));
                 writeFileSync(p, Buffer.from(img.b64, 'base64'));
                 return { output: `OK: ${p} dibuat (${rupiah(img.cost)}).` };
             }
+            case 'lihat_gambar': {
+                const p = str('path');
+                const pertanyaan = str('pertanyaan') || 'Jelaskan gambar ini.';
+                console.log(dim(`  lihat ${p} — "${pertanyaan.slice(0, 60)}"`));
+                const { abs } = safePath(p);
+                if (!existsSync(abs))
+                    return { output: `Error: file tidak ada: ${p}` };
+                const mime = IMAGE_MIME[extname(p).toLowerCase()] ?? 'image/png';
+                const dataUrl = `data:${mime};base64,${readFileSync(abs).toString('base64')}`;
+                const stop = thinking();
+                let answer = '';
+                let printed = false;
+                try {
+                    for await (const piece of streamVision(model, dataUrl, pertanyaan)) {
+                        if (!printed) {
+                            stop();
+                            printed = true;
+                        }
+                        process.stdout.write(piece);
+                        answer += piece;
+                    }
+                }
+                finally {
+                    if (!printed)
+                        stop();
+                }
+                if (answer)
+                    process.stdout.write('\n');
+                return { output: answer || '(tidak ada respons dari model)' };
+            }
             case 'selesai':
                 return { output: str('ringkasan') || 'selesai', done: true };
             default:
@@ -84,12 +333,26 @@ export function newSession(model, mode, otomatis) {
         otomatis,
         messages: [{ role: 'system', content: systemPrompt(mode) }],
         teamModels: {},
+        totalTokens: 0,
     };
 }
 /** Reset the conversation, keeping the current mode/model/otomatis. */
 export function resetSession(s) {
     s.messages = [{ role: 'system', content: systemPrompt(s.mode) }];
 }
+/**
+ * Remove the last user turn and everything that followed it (the agent's response + tool calls).
+ * Returns true if something was removed, false if there were no user turns to undo.
+ */
+export function undoLastTurn(s) {
+    for (let i = s.messages.length - 1; i > 0; i--) {
+        if (s.messages[i]?.role === 'user') {
+            s.messages = s.messages.slice(0, i);
+            return true;
+        }
+    }
+    return false;
+}
 /**
  * Process one user turn: run the tool-use loop, appending to the session's history. Returns the
  * agent's final text (last answer or the `selesai` summary) — useful for chaining agents in a team.
@@ -98,13 +361,26 @@ export async function runTurn(s, userText) {
     s.messages.push({ role: 'user', content: userText });
     const tools = toolsForMode(s.mode);
     let lastText = '';
-    for (let step = 0; step < MAX_STEPS; step++) {
+    let totalIn = 0;
+    let totalOut = 0;
+    const showUsage = () => {
+        if (totalIn + totalOut > 0) {
+            console.log(dim(`  ↳ ${idn(totalIn + totalOut)} token (${idn(totalIn)} in · ${idn(totalOut)} out)`));
+        }
+    };
+    // Sliding window of recent tool-call signatures (name + serialised args) across all steps.
+    // Used to detect the model repeating the same call in a stuck loop (e.g. daftar . × 20).
+    const recentSigs = [];
+    const LOOP_THRESHOLD = 3;
+    const stepLimit = s.maxSteps ?? MAX_STEPS;
+    for (let step = 0; step < stepLimit; step++) {
         const stop = thinking();
         let streamed = false;
         let reply;
         try {
             // Stream the reply live: stop the spinner on the first token and print as it arrives.
-            reply = await chatComplete(s.model, s.messages, tools, (delta) => {
+            // trimContext caps the payload — long sessions with many baca_file results don't balloon.
+            reply = await chatComplete(s.model, trimContext(s.messages), tools, (delta) => {
                 if (!streamed) {
                     stop();
                     streamed = true;
@@ -118,6 +394,10 @@ export async function runTurn(s, userText) {
         }
         if (streamed)
             process.stdout.write('\n');
+        if (reply.usage) {
+            totalIn += reply.usage.promptTokens;
+            totalOut += reply.usage.completionTokens;
+        }
         s.messages.push({ role: 'assistant', content: reply.content, tool_calls: reply.tool_calls });
         if (reply.content)
             lastText = reply.content;
@@ -126,18 +406,60 @@ export async function runTurn(s, userText) {
             if (step === 0) {
                 console.log(dim('(Model tidak memakai tool — pilih model ber-🔧 untuk agen, mis. /model deepseek/deepseek-v4-flash.)'));
             }
-            return lastText; // final text answer
+            showUsage();
+            s.totalTokens += totalIn + totalOut;
+            return lastText;
+        }
+        // --- Loop detection: push new signatures, then check if last N are identical ---
+        for (const call of calls) {
+            recentSigs.push(`${call.function.name}:${call.function.arguments}`);
+        }
+        if (recentSigs.length > LOOP_THRESHOLD * 3) {
+            recentSigs.splice(0, recentSigs.length - LOOP_THRESHOLD * 3);
+        }
+        if (recentSigs.length >= LOOP_THRESHOLD) {
+            const tail = recentSigs.slice(-LOOP_THRESHOLD);
+            if (tail.every((sig) => sig === tail[0])) {
+                const loopName = calls[0]?.function.name ?? 'unknown';
+                console.log(red(`\n⚠ Loop terdeteksi: "${loopName}" dipanggil ${LOOP_THRESHOLD}× berturut-turut dengan argumen sama.`));
+                console.log(yellow('Berikan instruksi baru, atau ketik /bersih untuk mulai ulang.'));
+                // Push error tool results for all calls in this step so history stays balanced.
+                const loopMsg = `⚠ LOOP TERDETEKSI: "${loopName}" sudah dipanggil ${LOOP_THRESHOLD}× dengan argumen yang sama. BERHENTI memanggil tool ini. Gunakan tool "selesai" dengan penjelasan bahwa tugas tidak dapat diselesaikan, atau tunggu instruksi baru dari pengguna.`;
+                for (const call of calls) {
+                    s.messages.push({ role: 'tool', content: loopMsg, tool_call_id: call.id });
+                }
+                saveCheckpoint(s);
+                showUsage();
+                s.totalTokens += totalIn + totalOut;
+                return lastText;
+            }
         }
+        const stepModified = new Set();
         for (const call of calls) {
-            const result = await runTool(call, s.otomatis);
+            const result = await runTool(call, s.otomatis, s.model);
             s.messages.push({ role: 'tool', content: result.output, tool_call_id: call.id });
+            if (result.modifiedPath)
+                stepModified.add(result.modifiedPath);
             if (result.done) {
+                if (stepModified.size > 0)
+                    console.log(dim(`  ✎ ${[...stepModified].join(' · ')}`));
                 console.log(green(`\n✓ Selesai: ${result.output}`));
+                showUsage();
+                s.totalTokens += totalIn + totalOut;
+                clearCheckpoint();
                 return result.output;
             }
         }
+        if (stepModified.size > 0)
+            console.log(dim(`  ✎ ${[...stepModified].join(' · ')}`));
+        // Save after ALL tool results for this step are appended — a partial save (mid-step) would
+        // leave the history with an assistant message whose tool_calls have no matching tool results,
+        // which providers reject on the next call.
+        saveCheckpoint(s);
     }
-    console.log(yellow(`\nBerhenti setelah ${MAX_STEPS} langkah. Lanjutkan dengan perintah berikutnya.`));
+    console.log(yellow(`\nBerhenti setelah ${stepLimit} langkah. Lanjutkan dengan perintah berikutnya.`));
+    showUsage();
+    s.totalTokens += totalIn + totalOut;
     return lastText;
 }
 /** One-shot: run a single task in a mode (used by the `rencana`/`edit`/`buat` subcommands). */

package/dist/agent/schemas.js

@@ -99,6 +99,51 @@ const TOOLS = {
             },
         },
     },
+    lihat_gambar: {
+        type: 'function',
+        function: {
+            name: 'lihat_gambar',
+            description: 'Lihat dan analisis gambar dari file lokal (vision). Berguna untuk membaca screenshot UI, diagram, atau aset gambar.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    path: { type: 'string', description: 'Path file gambar (.png, .jpg, .webp, .gif)' },
+                    pertanyaan: {
+                        type: 'string',
+                        description: 'Pertanyaan atau instruksi tentang gambar ini',
+                    },
+                },
+                required: ['path', 'pertanyaan'],
+            },
+        },
+    },
+    hapus_file: {
+        type: 'function',
+        function: {
+            name: 'hapus_file',
+            description: 'Hapus sebuah file. Lebih aman dari menjalankan del/rm.',
+            parameters: {
+                type: 'object',
+                properties: { path: { type: 'string', description: 'Path file yang akan dihapus' } },
+                required: ['path'],
+            },
+        },
+    },
+    pindah_file: {
+        type: 'function',
+        function: {
+            name: 'pindah_file',
+            description: 'Pindahkan atau ganti nama file/folder.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    dari: { type: 'string', description: 'Path asal' },
+                    ke: { type: 'string', description: 'Path tujuan' },
+                },
+                required: ['dari', 'ke'],
+            },
+        },
+    },
     selesai: {
         type: 'function',
         function: {
@@ -113,11 +158,11 @@ const TOOLS = {
     },
 };
 const READ_TOOLS = ['baca_file', 'daftar_file', 'cari'];
-const WRITE_TOOLS = ['tulis_file', 'edit_file'];
+const WRITE_TOOLS = ['tulis_file', 'edit_file', 'hapus_file', 'pindah_file'];
 const MODE_TOOLS = {
-    rencana: [...READ_TOOLS, 'selesai'],
-    edit: [...READ_TOOLS, ...WRITE_TOOLS, 'buat_gambar', 'selesai'],
-    buat: [...READ_TOOLS, ...WRITE_TOOLS, 'jalankan', 'buat_gambar', 'selesai'],
+    rencana: [...READ_TOOLS, 'lihat_gambar', 'selesai'],
+    edit: [...READ_TOOLS, ...WRITE_TOOLS, 'lihat_gambar', 'buat_gambar', 'selesai'],
+    buat: [...READ_TOOLS, ...WRITE_TOOLS, 'jalankan', 'lihat_gambar', 'buat_gambar', 'selesai'],
 };
 /** The tool specs available in a given mode. */
 export function toolsForMode(mode) {
@@ -135,13 +180,22 @@ const MODE_BRIEF = {
 };
 /** System prompt (Indonesian) that frames the agent's role, mode, and workflow. */
 export function systemPrompt(mode) {
+    const platform = process.platform;
+    const osName = platform === 'win32' ? 'Windows' : platform === 'darwin' ? 'macOS' : 'Linux';
+    const shellNote = platform === 'win32'
+        ? 'Shell: cmd.exe — gunakan sintaks Windows: mkdir folder (bukan mkdir -p), del file (bukan rm), move src dst (bukan mv), copy src dst (bukan cp). JANGAN pakai perintah bash/unix.'
+        : 'Shell: bash';
     return `Kamu adalah asisten coding Kiosapi yang bekerja di terminal developer Indonesia.
 ${MODE_BRIEF[mode]}
 
 Direktori kerja: ${process.cwd()}
+OS: ${osName} · ${shellNote}
 Aturan:
 - Bekerja langkah demi langkah: pakai tool untuk membaca sebelum mengubah.
 - Path selalu relatif ke direktori kerja; akses ke luar ditolak.
+- Gunakan hapus_file/pindah_file untuk menghapus/memindahkan file (lebih aman dari jalankan del/rm).
 - Buat perubahan kecil dan jelas. Setelah tugas beres, panggil tool "selesai" dengan ringkasan.
+- JANGAN memanggil tool yang sama dengan argumen yang sama lebih dari 1× berturut-turut. Jika sudah mendapat hasil daftar_file atau baca_file, langsung lanjutkan — JANGAN ulangi panggilan yang sama.
+- Jika tidak tahu harus berbuat apa selanjutnya, gunakan tool "selesai" dan jelaskan apa yang sudah ditemukan.
 - Jawab dan jelaskan dalam Bahasa Indonesia.`;
 }

package/dist/agent/team.js

@@ -1,4 +1,5 @@
-import { bold, dim, green } from '../ui.js';
+import { modelSupportsTools } from '../api.js';
+import { bold, dim, green, yellow } from '../ui.js';
 import { newSession, runTurn } from './run.js';
 const ROLES = {
     perencana: {
@@ -34,3 +35,39 @@ export async function runTeam(task, opts) {
     await runRole('peninjau', `Tinjau hasil implementasi untuk tugas: ${task}`, opts);
     console.log(green('\n✓ Tim selesai.'));
 }
+/**
+ * Run a custom team defined by a TeamConfig. Each role runs sequentially; the output of one role
+ * is passed as context to the next.
+ */
+export async function runCustomTeam(task, opts) {
+    const { config, otomatis, modelOverrides = {} } = opts;
+    const alur = config.alur.filter((r) => r in config.peran);
+    console.log(bold(`👥 Tim "${config.nama}": ${alur.join(' → ')}`));
+    // Warn about models that may lack tool support (best-effort, silent on network error)
+    const uniqueModels = [
+        ...new Set(alur.map((r) => modelOverrides[r] ?? config.peran[r]?.model).filter(Boolean)),
+    ];
+    await Promise.all(uniqueModels.map(async (m) => {
+        if (!(await modelSupportsTools(m).catch(() => true))) {
+            console.log(yellow(`⚠ Model "${m}" mungkin tidak mendukung tool calling — agen mungkin tidak berjalan.`));
+        }
+    }));
+    let context = task;
+    for (let i = 0; i < alur.length; i++) {
+        const roleName = alur[i] ?? '';
+        const roleCfg = config.peran[roleName];
+        if (!roleCfg) {
+            console.log(yellow(`⚠ Peran "${roleName}" tidak ada dalam config — dilewati.`));
+            continue;
+        }
+        const model = modelOverrides[roleName] ?? roleCfg.model;
+        const mode = roleCfg.mode ?? 'buat';
+        console.log(`\n${bold(`${String(i + 1).padStart(2)}. ${roleName}`)} ${dim(`(${model}, mode: ${mode})`)}`);
+        const s = newSession(model, mode, otomatis);
+        if (roleCfg.brief)
+            s.messages.push({ role: 'system', content: roleCfg.brief });
+        const result = await runTurn(s, context);
+        context = `Tugas asal: ${task}\n\nOutput dari ${roleName}:\n${result || '(tidak ada output eksplisit)'}`;
+    }
+    console.log(green(`\n✓ Tim "${config.nama}" selesai.`));
+}