@botconnector/bccli 0.4.0-beta.3 → 0.4.0-beta.31

package/dist/cli.js

@@ -1,16 +1,4 @@
 #!/usr/bin/env node
-import {
-  HELP_TEXT,
-  parseCliArgs
-} from "./chunk-UN7QXPCB.js";
-import {
-  addProviderKey,
-  createProvider,
-  listAllModels
-} from "./chunk-2JBRLGKD.js";
-import {
-  runLogin
-} from "./chunk-L7L4RGKG.js";
 import {
   BUILTIN_AGENTS,
   buildSystemPrompt,
@@ -18,15 +6,33 @@ import {
   loadAgentDefs,
   loadCommands,
   loadSkills,
+  normalizeGlobPath,
   parseFrontmatter,
-  runPrint
-} from "./chunk-OSWQPSA4.js";
+  runPrint,
+  validateGlobPattern
+} from "./chunk-NWVFCTTO.js";
+import {
+  helpText,
+  parseCliArgs
+} from "./chunk-NM3C75BT.js";
 import {
   Permissions
 } from "./chunk-ELML4KVQ.js";
 import {
-  providerName
-} from "./chunk-U7DLMVPZ.js";
+  addProviderKey,
+  completionAssistantMessage,
+  createProvider,
+  hasPendingProgrammaticReplay,
+  listAllModels
+} from "./chunk-CX5U4EHX.js";
+import {
+  providerName,
+  readGlobalConfigFile
+} from "./chunk-AOVIQXXO.js";
+import "./chunk-UJH2JT6H.js";
+import {
+  runLogin
+} from "./chunk-Z37BR5H4.js";
 import {
   Session,
   pruneSessions
@@ -35,8 +41,76 @@ import {
   ConfigError,
   bccliHome,
   loadConfig,
-  resolveModel
-} from "./chunk-RZUJYAQV.js";
+  resolveLanguage,
+  resolveModel,
+  setLanguage,
+  t
+} from "./chunk-IJGTX7RC.js";
+
+// src/textToolCalls.ts
+var PAIR = /(?:<arg_key>\s*|`)?([A-Za-z_]\w*)(?:\s*<\/arg_key>)?`?\s*(?:=\s*`|<arg_value>)([\s\S]*?)<\/arg_value>/g;
+var CALL_START = /<tool_call>|\n?[^\n]*\bTool call list\b[^\n]*|\n\s*\d+\.\s*Tool:/g;
+function coerce(value, type) {
+  const types = Array.isArray(type) ? type : [type];
+  const v = value.trim();
+  if ((types.includes("integer") || types.includes("number")) && v !== "" && !Number.isNaN(Number(v))) return Number(v);
+  if (types.includes("boolean") && /^(true|false)$/i.test(v)) return v.toLowerCase() === "true";
+  if ((types.includes("object") || types.includes("array")) && /^[[{]/.test(v)) {
+    try {
+      return JSON.parse(v);
+    } catch {
+    }
+  }
+  return value.replace(/^\n+|\n+$/g, "");
+}
+function pickTool(name, keys, tools) {
+  const named = name && tools.find((t2) => t2.function.name === name);
+  if (named) return named;
+  let best;
+  let bestScore = 0;
+  let tie = false;
+  for (const t2 of tools) {
+    const params = t2.function.parameters;
+    const props = Object.keys(params.properties ?? {});
+    if (!(params.required ?? []).every((r) => keys.includes(r))) continue;
+    const score = keys.filter((k) => props.includes(k)).length;
+    if (score > bestScore) [best, bestScore, tie] = [t2, score, false];
+    else if (score === bestScore && score > 0) tie = true;
+  }
+  return tie ? void 0 : best;
+}
+function recoverTextToolCalls(text, tools) {
+  if (!/<\/arg_value>|<tool_call>/.test(text)) return null;
+  const starts = [...text.matchAll(CALL_START)].map((m) => m.index ?? 0);
+  const firstPair = text.search(PAIR);
+  const cut = Math.min(...[...starts, firstPair].filter((i) => i >= 0));
+  const bounds = starts.filter((i) => i >= cut);
+  if (!bounds.length || bounds[0] > cut) bounds.unshift(cut);
+  const toolCalls = [];
+  bounds.forEach((start, n) => {
+    const segment = text.slice(start, bounds[n + 1] ?? text.length);
+    const name = /<tool_call>\s*([A-Za-z_][\w.-]*)/.exec(segment)?.[1] ?? /Tool:\s*`?([A-Za-z_][\w.-]*)`?/.exec(segment)?.[1];
+    let args = [];
+    const flush = () => {
+      if (!args.length) return;
+      const keys = args.map(([k]) => k);
+      const tool = pickTool(name, keys, tools);
+      if (tool) {
+        const props = tool.function.parameters.properties ?? {};
+        const input = Object.fromEntries(args.filter(([k]) => k in props).map(([k, v]) => [k, coerce(v, props[k].type)]));
+        toolCalls.push({ id: `text_call_${toolCalls.length}`, name: tool.function.name, arguments: JSON.stringify(input) });
+      }
+      args = [];
+    };
+    for (const m of segment.matchAll(PAIR)) {
+      if (args.some(([k]) => k === m[1])) flush();
+      args.push([m[1], m[2]]);
+    }
+    flush();
+  });
+  if (!toolCalls.length) return null;
+  return { text: text.slice(0, cut).trim(), toolCalls };
+}
 
 // src/tools/index.ts
 import { z as z8 } from "zod";
@@ -136,7 +210,7 @@ function runCommand(command, opts) {
       clearTimeout(timer);
       opts.signal.removeEventListener("abort", onAbort);
       const output = dropped ? `${head}
-\u2026 [${dropped} karakter dipotong] \u2026
+\u2026 [${dropped} characters truncated] \u2026
 ${tail}` : head + tail;
       resolve2({ output: output + extra, exitCode, timedOut, aborted });
     };
@@ -155,7 +229,7 @@ var bashTool = defineTool({
   target: (input) => input.command,
   async run(input, ctx) {
     const r = await runCommand(input.command, { cwd: ctx.cwd, timeoutMs: input.timeout_ms ?? 12e4, signal: ctx.signal });
-    const status = r.timedOut ? `[dihentikan: timeout ${Math.round((input.timeout_ms ?? 12e4) / 1e3)} detik]` : r.aborted ? "[dibatalkan user]" : `[exit code ${r.exitCode}]`;
+    const status = r.timedOut ? `[stopped: timeout after ${Math.round((input.timeout_ms ?? 12e4) / 1e3)} seconds]` : r.aborted ? "[cancelled by the user]" : `[exit code ${r.exitCode}]`;
     return { output: `${r.output.trimEnd()}
 ${status}`.trimStart(), isError: r.exitCode !== 0 };
   }
@@ -214,7 +288,7 @@ function countOccurrences(haystack, needle) {
 }
 function applyEdit(content, input) {
   if (input.old_string === input.new_string) {
-    return { output: "old_string dan new_string sama; tidak ada perubahan.", isError: true };
+    return { output: "old_string and new_string are identical; nothing to change.", isError: true };
   }
   const eol = content.includes("\r\n") ? "\r\n" : "\n";
   const toEol = (s) => s.replace(/\r?\n/g, eol);
@@ -225,13 +299,13 @@ function applyEdit(content, input) {
     if (count === 0) continue;
     if (count > 1 && !input.replace_all) {
       return {
-        output: `old_string muncul ${count} kali di ${input.path}. Tambah konteks agar unik, atau pakai replace_all.`,
+        output: `old_string appears ${count} times in ${input.path}. Add more context to make it unique, or use replace_all.`,
         isError: true
       };
     }
     return input.replace_all ? content.split(oldText).join(newText) : content.replace(oldText, () => newText);
   }
-  return { output: `old_string tidak ditemukan di ${input.path}. Baca ulang file-nya.`, isError: true };
+  return { output: `old_string not found in ${input.path}. Re-read the file.`, isError: true };
 }
 var editTool = defineTool({
   name: "edit",
@@ -241,12 +315,12 @@ var editTool = defineTool({
   target: (input) => input.path,
   async validate(input, ctx) {
     const abs = resolvePath(ctx.cwd, input.path);
-    if (!ctx.readFiles.has(abs)) return `Baca ${input.path} dulu dengan read sebelum mengedit.`;
+    if (!ctx.readFiles.has(abs)) return `Read ${input.path} with read before editing it.`;
     let content;
     try {
       content = await readFile(abs, "utf8");
     } catch (error) {
-      return `Tidak bisa membaca ${input.path}: ${errorCode(error)}`;
+      return `Cannot read ${input.path}: ${errorCode(error)}`;
     }
     const next = applyEdit(content, input);
     return typeof next === "string" ? void 0 : next.output;
@@ -260,25 +334,30 @@ var editTool = defineTool({
   async run(input, ctx) {
     const abs = resolvePath(ctx.cwd, input.path);
     if (!ctx.readFiles.has(abs)) {
-      return { output: `Baca ${input.path} dulu dengan read sebelum mengedit.`, isError: true };
+      return { output: `Read ${input.path} with read before editing it.`, isError: true };
     }
     let content;
     try {
       content = await readFile(abs, "utf8");
     } catch (error) {
-      return { output: `Tidak bisa membaca ${input.path}: ${errorCode(error)}`, isError: true };
+      return { output: `Cannot read ${input.path}: ${errorCode(error)}`, isError: true };
     }
     const next = applyEdit(content, input);
     if (typeof next !== "string") return next;
     await ctx.checkpoint?.(abs);
     await writeFile(abs, next);
-    return { output: `Mengedit ${input.path}.`, display: formatDiff(diffLines(content, next)) };
+    return { output: `Edited ${input.path}.`, display: formatDiff(diffLines(content, next)) };
   }
 });
 
 // src/tools/fetch.ts
 import { z as z3 } from "zod";
-var MAX_CHARS = 5e4;
+var MAX_CHARS = 12e3;
+var FOCUS_CHUNKS = 3;
+var FOCUS_SIZE = 800;
+var CACHE_MAX = 16;
+var CACHE_TTL_MS = 15 * 6e4;
+var CACHE_MAX_CHARS = 2e6;
 var MAX_BYTES = 5 * 1024 * 1024;
 async function readCapped(res) {
   const reader = res.body?.getReader();
@@ -300,49 +379,238 @@ async function readCapped(res) {
 function htmlToText(html) {
   return html.replace(/<(script|style|noscript)[\s\S]*?<\/\1>/gi, "").replace(/<(br|\/p|\/div|\/h[1-6]|\/li|\/tr)\s*\/?>/gi, "\n").replace(/<[^>]+>/g, "").replace(/&nbsp;/g, " ").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/&amp;/g, "&").split("\n").map((l) => l.replace(/\s+/g, " ").trim()).filter(Boolean).join("\n");
 }
-var fetchTool = defineTool({
-  name: "fetch",
-  description: "Fetch a URL (http/https). HTML is converted to plain text. Max 50k characters.",
-  schema: z3.object({ url: z3.string().describe("Absolute http(s) URL") }),
-  kind: "fetch",
-  target: (input) => input.url,
-  async run(input, ctx) {
-    if (!/^https?:\/\//i.test(input.url)) return { output: "URL harus diawali http:// atau https://", isError: true };
-    let url = new URL(input.url);
-    let res;
-    try {
-      for (let hop = 0; hop < 5; hop++) {
-        res = await fetch(url, { signal: AbortSignal.any([ctx.signal, AbortSignal.timeout(3e4)]), redirect: "manual" });
-        const location = res.status >= 300 && res.status < 400 ? res.headers.get("location") : null;
-        if (!location) break;
-        const next = new URL(location, url);
-        if (next.host !== url.host) {
-          await res.body?.cancel();
-          return {
-            output: `Redirect ke host lain: ${next.href}. Panggil fetch lagi dengan URL itu kalau memang perlu (akan diminta izin).`,
-            isError: true
-          };
+function describeFetchError(error) {
+  const cause = error.cause;
+  const code = cause?.code ?? "";
+  const detail = cause?.message ?? error.message;
+  if (error.name === "TimeoutError") return "no response within 30 seconds";
+  if (code === "ENOTFOUND" || code === "EAI_AGAIN") return `${detail} \u2014 DNS could not find the host (typo, offline, or blocked by DNS/ISP)`;
+  if (/CERT|SELF_SIGNED|UNABLE_TO/.test(code)) {
+    return `${detail} \u2014 TLS certificate rejected; often caused by an antivirus or proxy that inspects HTTPS. Try running with NODE_OPTIONS=--use-system-ca`;
+  }
+  if (/ECONNRESET|ECONNREFUSED|ETIMEDOUT|EHOSTUNREACH|ENETUNREACH|UND_ERR_CONNECT_TIMEOUT|UND_ERR_SOCKET/.test(code)) {
+    return `${detail} \u2014 connection failed (firewall, proxy, or the site is blocked by the network)`;
+  }
+  return code ? `${detail} (${code})` : detail;
+}
+var tokensOf = (text) => Math.ceil(text.length / 4);
+function isPrivateHost(host) {
+  const h = host.toLowerCase().replace(/^\[|\]$/g, "");
+  if (h === "localhost" || /\.(local|internal|lan|localdomain|home\.arpa)$/.test(h)) return true;
+  if (h.includes(":")) return /^(::1?$|f[cd]|fe[89ab]|::ffff:)/.test(h);
+  const v4 = h.match(/^(\d+)\.(\d+)\.\d+\.\d+$/);
+  if (v4) {
+    const [a, b] = [Number(v4[1]), Number(v4[2])];
+    return a === 0 || a === 10 || a === 127 || a === 169 && b === 254 || a === 172 && b >= 16 && b <= 31 || a === 192 && b === 168 || a === 100 && b >= 64 && b <= 127;
+  }
+  return !h.includes(".");
+}
+var words = (s) => s.toLowerCase().match(/[\p{L}\p{N}]{2,}/gu) ?? [];
+function pickRelevant(text, query, count = FOCUS_CHUNKS, size = FOCUS_SIZE) {
+  const chunks = [];
+  let cur = "";
+  for (const line of text.split("\n")) {
+    for (let i = 0; i < Math.max(line.length, 1); i += size) {
+      cur += `${line.slice(i, i + size)}
+`;
+      if (cur.length >= size) {
+        chunks.push(cur.trimEnd());
+        cur = "";
+      }
+    }
+  }
+  if (cur.trim()) chunks.push(cur.trimEnd());
+  const q = [...new Set(words(query))];
+  const docs = chunks.map(words);
+  const avg = docs.reduce((n, d) => n + d.length, 0) / (docs.length || 1) || 1;
+  const idf = q.map((t2) => {
+    const df = docs.filter((d) => d.includes(t2)).length;
+    return Math.log(1 + (docs.length - df + 0.5) / (df + 0.5));
+  });
+  const scored = docs.map((d, i) => ({
+    i,
+    score: q.reduce((sum, t2, k) => {
+      const tf = d.filter((w) => w === t2).length;
+      return sum + idf[k] * tf * 2.2 / (tf + 1.2 * (0.25 + 0.75 * d.length / avg));
+    }, 0)
+  })).filter((c) => c.score > 0).sort((a, b) => b.score - a.score).slice(0, count).sort((a, b) => a.i - b.i);
+  return scored.length ? scored.map((c) => chunks[c.i]).join("\n\u2026\n") : null;
+}
+var cache = /* @__PURE__ */ new Map();
+function remember(key, value, size) {
+  if (size > CACHE_MAX_CHARS) return;
+  cache.delete(key);
+  cache.set(key, value);
+  if (cache.size > CACHE_MAX) cache.delete(cache.keys().next().value);
+}
+function recall(key) {
+  const hit = cache.get(key);
+  if (typeof hit === "object" && Date.now() - hit.at > CACHE_TTL_MS) {
+    cache.delete(key);
+    return void 0;
+  }
+  return hit;
+}
+var ACCEPT = "text/markdown, text/html;q=0.9, text/plain;q=0.8, */*;q=0.5";
+var withCost = (text, what) => `${what} \xB7 ${t("~{n} tokens", { n: tokensOf(text) })}`;
+function createFetchTool(opts = {}) {
+  const keenableURL = opts.keenableURL === void 0 ? "https://api.keenable.ai/v1/fetch/public" : opts.keenableURL;
+  const isPrivate = opts.isPrivate ?? isPrivateHost;
+  return defineTool({
+    name: "fetch",
+    description: `Fetch a URL (http/https) as text/markdown. Costs the user tokens, so ask for as little as you need:
+- Pass \`prompt\` (what you want to know from the page) to get only the relevant excerpt instead of the whole page. Prefer this whenever you are looking for specific facts.
+- Without \`prompt\` you get the first ${MAX_CHARS} characters; the reply tells you the \`offset\` to continue from.
+- Fetching a page that is already in this conversation is wasteful; reuse what you have.`,
+    schema: z3.object({
+      url: z3.string().describe("Absolute http(s) URL"),
+      prompt: z3.string().max(2e3).optional().describe("What to look for in the page; returns only the relevant excerpt"),
+      offset: z3.number().int().min(0).optional().describe("Start reading at this character (to continue a truncated page)")
+    }),
+    kind: "fetch",
+    target: (input) => input.url,
+    async run(input, ctx) {
+      if (!/^https?:\/\//i.test(input.url)) return { output: "URL must start with http:// or https://", isError: true };
+      const target = new URL(input.url);
+      const prompt = input.prompt?.trim();
+      const askKeenable = !!prompt && !input.offset && !!keenableURL && !target.username && !target.password && !isPrivate(target.hostname);
+      if (askKeenable) {
+        const key = `x
+${input.url}
+${prompt}`;
+        const hit = recall(key);
+        if (hit) {
+          ctx.refundFetch?.();
+          return { output: hit, display: withCost(hit, t("focused excerpt \xB7 cache")) };
+        }
+        const out = await extractWithKeenable(keenableURL, input.url, prompt, ctx.signal);
+        if (out) {
+          const output2 = `[Excerpt from ${input.url} for "${prompt}" (extracted by Keenable). If it says the answer is not there, try fetch without a prompt.]
+${out}`;
+          remember(key, output2, output2.length);
+          return { output: output2, display: withCost(output2, t("focused excerpt (Keenable)")) };
+        }
+      }
+      let page = recall(`p
+${input.url}`);
+      const cached = !!page;
+      if (cached) ctx.refundFetch?.();
+      if (!page) {
+        const loaded = await loadPage(input.url, ctx.signal);
+        if ("error" in loaded) return { output: loaded.error, isError: true };
+        page = loaded;
+        remember(`p
+${input.url}`, page, page.text.length);
+      }
+      const { text, truncated } = page;
+      const via = cached ? " \xB7 cache" : "";
+      if (prompt && !input.offset) {
+        const picked = pickRelevant(text, prompt);
+        if (picked) {
+          const output2 = `[Most relevant excerpt from ${input.url} for "${prompt}" (${text.length} characters total). Full page: fetch without a prompt.]
+${picked}`;
+          return { output: output2, display: withCost(output2, `${t("focused excerpt (local)")}${via}`) };
         }
+      }
+      const offset = input.offset ?? 0;
+      if (offset >= text.length && text.length > 0) {
+        return { output: `offset ${offset} is past the end of the page (${text.length} characters).`, isError: true };
+      }
+      const end = Math.min(offset + MAX_CHARS, text.length);
+      let output = text.slice(offset, end);
+      if (end < text.length || truncated) {
+        const total = truncated ? `${text.length}+` : text.length;
+        output += `
+\u2026 [truncated: characters ${offset}-${end} of ${total}. Continue with offset=${end}, or use prompt for a focused excerpt.]`;
+      }
+      const size = truncated ? t("over 5 MB, truncated") : t("{n} characters", { n: text.length });
+      return { output, display: withCost(output, `${size}${via}`) };
+    }
+  });
+}
+async function extractWithKeenable(endpoint, url, prompt, signal) {
+  try {
+    const u = new URL(endpoint);
+    u.searchParams.set("url", url);
+    u.searchParams.set("prompt", prompt);
+    u.searchParams.set("live", "true");
+    u.searchParams.set("max_chars", String(MAX_CHARS));
+    const res = await fetch(u, { headers: { "X-Keenable-Title": "BotConnector" }, signal: AbortSignal.any([signal, AbortSignal.timeout(25e3)]) });
+    if (!res.ok) return void 0;
+    const content = (await res.json()).content;
+    return typeof content === "string" && content.trim() ? content.slice(0, MAX_CHARS) : void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function loadPage(inputUrl, signal) {
+  let url = new URL(inputUrl);
+  let res;
+  try {
+    for (let hop = 0; hop < 5; hop++) {
+      res = await fetch(url, { headers: { accept: ACCEPT }, signal: AbortSignal.any([signal, AbortSignal.timeout(3e4)]), redirect: "manual" });
+      const location = res.status >= 300 && res.status < 400 ? res.headers.get("location") : null;
+      if (!location) break;
+      const next = new URL(location, url);
+      if (next.host !== url.host) {
         await res.body?.cancel();
-        url = next;
+        return { error: `Redirect to another host: ${next.href}. Call fetch again with that URL if needed (permission will be requested).` };
       }
-    } catch (error) {
-      return { output: `Gagal mengambil ${input.url}: ${error.message}`, isError: true };
+      await res.body?.cancel();
+      url = next;
     }
-    if (!res) return { output: `Gagal mengambil ${input.url}`, isError: true };
-    const { text: body, truncated } = await readCapped(res);
-    if (!res.ok) return { output: `HTTP ${res.status} dari ${input.url}: ${body.slice(0, 500)}`, isError: true };
-    const text = (res.headers.get("content-type") ?? "").includes("html") ? htmlToText(body) : body;
-    const clipped = text.length > MAX_CHARS || truncated ? `${text.slice(0, MAX_CHARS)}
-\u2026 [dipotong]` : text;
-    const display = truncated ? "lebih dari 5 MB, dipotong" : `${text.length} karakter`;
-    return { output: clipped, display };
+  } catch (error) {
+    return { error: `Failed to fetch ${inputUrl}: ${describeFetchError(error)}` };
   }
-});
+  if (!res) return { error: `Failed to fetch ${inputUrl}` };
+  const { text: body, truncated } = await readCapped(res);
+  const type = res.headers.get("content-type") ?? "";
+  const text = type.includes("html") ? htmlToText(body) : body;
+  if (!res.ok) return { error: `HTTP ${res.status} from ${inputUrl}: ${text.slice(0, 500)}` };
+  return { text, truncated, at: Date.now() };
+}
+var fetchTool = createFetchTool();
 
 // src/tools/glob.ts
-import fg from "fast-glob";
+import { glob as nativeGlob } from "fs/promises";
 import { z as z4 } from "zod";
+
+// src/abort.ts
+var ABORTED = /* @__PURE__ */ Symbol("aborted");
+function raceAbort(promise, signal) {
+  if (signal.aborted) return Promise.resolve(ABORTED);
+  return new Promise((resolve2, reject) => {
+    const onAbort = () => resolve2(ABORTED);
+    signal.addEventListener("abort", onAbort, { once: true });
+    promise.then(
+      (value) => {
+        signal.removeEventListener("abort", onAbort);
+        resolve2(value);
+      },
+      (error) => {
+        signal.removeEventListener("abort", onAbort);
+        reject(error);
+      }
+    );
+  });
+}
+async function collectUntilAbort(iterable, signal, onItem) {
+  const iterator = iterable[Symbol.asyncIterator]();
+  try {
+    for (; ; ) {
+      const next = signal ? await raceAbort(iterator.next(), signal) : await iterator.next();
+      if (next === ABORTED) return false;
+      if (next.done) return true;
+      onItem(next.value);
+    }
+  } finally {
+    Promise.resolve(iterator.return?.(void 0)).catch(() => {
+    });
+  }
+}
+
+// src/tools/glob.ts
+var MAX_OUTPUT_CHARS = 24e3;
 var globTool = defineTool({
   name: "glob",
   description: 'Find files by glob pattern, e.g. "src/**/*.ts". Respects .gitignore. Max 500 results.',
@@ -353,12 +621,31 @@ var globTool = defineTool({
   kind: "read",
   target: (input) => input.pattern,
   async run(input, ctx) {
+    const invalid = validateGlobPattern(input.pattern);
+    if (invalid) return { output: invalid, isError: true };
     const root = resolvePath(ctx.cwd, input.path ?? ".");
-    const files = (await fg(input.pattern, { cwd: root, ignore: ignorePatterns(root), onlyFiles: true, dot: true })).sort();
-    if (!files.length) return { output: "Tidak ada file yang cocok." };
-    const shown = files.slice(0, 500);
-    const more = files.length > shown.length ? `
-\u2026 ${files.length - shown.length} file lagi` : "";
+    const files = [];
+    const finished = await collectUntilAbort(
+      nativeGlob(input.pattern, { cwd: root, exclude: ignorePatterns(root) }),
+      ctx.signal,
+      (file) => files.push(normalizeGlobPath(file))
+    );
+    if (!finished) return { output: "Cancelled by the user.", isError: true };
+    files.sort();
+    if (!files.length) return { output: "No matching files." };
+    const first = files.slice(0, 500);
+    const shown = [];
+    let size = 0;
+    for (const file of first) {
+      const extra = file.length + (shown.length ? 1 : 0);
+      if (shown.length && size + extra > MAX_OUTPUT_CHARS) break;
+      shown.push(file);
+      size += extra;
+      if (size >= MAX_OUTPUT_CHARS) break;
+    }
+    const omitted = files.length - shown.length;
+    const more = omitted > 0 ? `
+\u2026 ${omitted} more files omitted (narrow pattern/path)` : "";
     return { output: shown.join("\n") + more, display: `${files.length} file` };
   }
 });
@@ -366,14 +653,22 @@ var globTool = defineTool({
 // src/tools/grep.ts
 import { execFile } from "child_process";
 import { readFile as readFile2 } from "fs/promises";
-import fg2 from "fast-glob";
+import { glob as nativeGlob2 } from "fs/promises";
 import { z as z5 } from "zod";
 var MAX_MATCHES = 200;
+var MAX_OUTPUT_CHARS2 = 24e3;
 async function grepJs(pattern, opts) {
   const regex = new RegExp(pattern, opts.ignoreCase ? "i" : "");
-  const files = await fg2(opts.glob ?? "**/*", { cwd: opts.root, ignore: ignorePatterns(opts.root), onlyFiles: true, dot: true });
+  const files = [];
+  const finished = await collectUntilAbort(
+    nativeGlob2(opts.glob ?? "**/*", { cwd: opts.root, exclude: ignorePatterns(opts.root) }),
+    opts.signal,
+    (file) => files.push(normalizeGlobPath(file))
+  );
   const out = [];
+  if (!finished) return out;
   for (const file of files.sort()) {
+    if (opts.signal?.aborted) break;
     let text;
     try {
       const buffer = await readFile2(resolvePath(opts.root, file));
@@ -396,7 +691,8 @@ function grepRg(pattern, opts) {
   if (opts.glob) args.push("-g", opts.glob);
   args.push(".");
   return new Promise((resolve2) => {
-    execFile("rg", args, { cwd: opts.root, maxBuffer: 10 * 1024 * 1024 }, (error, stdout) => {
+    execFile("rg", args, { cwd: opts.root, maxBuffer: 10 * 1024 * 1024, signal: opts.signal }, (error, stdout) => {
+      if (opts.signal?.aborted) return resolve2([]);
       const code = error?.code;
       if (code === "ENOENT") return resolve2(void 0);
       if (error && error.code !== 1) return resolve2(void 0);
@@ -416,15 +712,32 @@ var grepTool = defineTool({
   kind: "read",
   target: (input) => input.pattern,
   async run(input, ctx) {
-    const opts = { root: resolvePath(ctx.cwd, input.path ?? "."), glob: input.glob, ignoreCase: input.ignore_case };
+    if (input.glob) {
+      const invalid = validateGlobPattern(input.glob);
+      if (invalid) return { output: invalid, isError: true };
+    }
+    const opts = { root: resolvePath(ctx.cwd, input.path ?? "."), glob: input.glob, ignoreCase: input.ignore_case, signal: ctx.signal };
     try {
       new RegExp(input.pattern);
     } catch (error) {
-      return { output: `Regex tidak valid: ${error.message}`, isError: true };
+      return { output: `Invalid regex: ${error.message}`, isError: true };
     }
     const matches = await grepRg(input.pattern, opts) ?? await grepJs(input.pattern, opts);
-    if (!matches.length) return { output: "Tidak ada yang cocok." };
-    return { output: matches.join("\n"), display: `${matches.length} hasil` };
+    if (ctx.signal.aborted) return { output: "Cancelled by the user.", isError: true };
+    if (!matches.length) return { output: "No matches." };
+    const shown = [];
+    let size = 0;
+    for (const match of matches) {
+      const extra = match.length + (shown.length ? 1 : 0);
+      if (shown.length && size + extra > MAX_OUTPUT_CHARS2) break;
+      shown.push(match);
+      size += extra;
+      if (size >= MAX_OUTPUT_CHARS2) break;
+    }
+    const omitted = matches.length - shown.length;
+    const suffix = omitted > 0 ? `
+\u2026 ${omitted} more matches omitted (narrow pattern/path/glob)` : "";
+    return { output: shown.join("\n") + suffix, display: t("{n} results", { n: matches.length }) };
   }
 });
 
@@ -432,6 +745,7 @@ var grepTool = defineTool({
 import { readFile as readFile3 } from "fs/promises";
 import { z as z6 } from "zod";
 var MAX_LINE = 2e3;
+var MAX_OUTPUT_CHARS3 = 4e4;
 var readTool = defineTool({
   name: "read",
   description: "Read a text file. Returns numbered lines (default first 2000). Use offset/limit for large files. Always read a file before editing it.",
@@ -448,25 +762,37 @@ var readTool = defineTool({
     try {
       buffer = await readFile3(abs);
     } catch (error) {
-      return { output: `Tidak bisa membaca ${input.path}: ${errorCode(error)}`, isError: true };
+      return { output: `Cannot read ${input.path}: ${errorCode(error)}`, isError: true };
     }
     if (buffer.subarray(0, 8e3).includes(0)) {
-      return { output: `${input.path} adalah file biner, tidak dibaca.`, isError: true };
+      return { output: `${input.path} is a binary file; not read.`, isError: true };
     }
     const lines = buffer.toString("utf8").split(/\r?\n/);
     const start = (input.offset ?? 1) - 1;
     const limit = input.limit ?? 2e3;
-    const slice = lines.slice(start, start + limit);
-    const body = slice.map((line, i) => {
-      const text = line.length > MAX_LINE ? `${line.slice(0, MAX_LINE)}\u2026 [baris dipotong]` : line;
-      return `${String(start + i + 1).padStart(6)}	${text}`;
-    }).join("\n");
-    const remaining = lines.length - start - slice.length;
+    const requested = lines.slice(start, start + limit);
+    const shown = [];
+    let size = 0;
+    for (let i = 0; i < requested.length; i++) {
+      const line = requested[i];
+      const text = line.length > MAX_LINE ? `${line.slice(0, MAX_LINE)}\u2026 [line truncated]` : line;
+      const rendered = `${String(start + i + 1).padStart(6)}	${text}`;
+      const extra = rendered.length + (shown.length ? 1 : 0);
+      if (shown.length && size + extra > MAX_OUTPUT_CHARS3) break;
+      shown.push(rendered);
+      size += extra;
+      if (size >= MAX_OUTPUT_CHARS3) break;
+    }
+    const body = shown.join("\n");
+    const remaining = lines.length - start - shown.length;
+    const tokenBudgetHit = shown.length < requested.length;
+    const nextOffset = start + shown.length + 1;
     ctx.readFiles.add(abs);
     return {
-      output: remaining > 0 ? `${body}
-\u2026 ${remaining} baris lagi (pakai offset)` : body,
-      display: `${slice.length} baris`
+      output: remaining > 0 ? tokenBudgetHit ? `${body}
+\u2026 ${remaining} more lines (token budget reached; continue with offset=${nextOffset})` : `${body}
+\u2026 ${remaining} more lines (use offset)` : body,
+      display: t("{n} lines", { n: shown.length })
     };
   }
 });
@@ -487,7 +813,7 @@ var writeTool = defineTool({
   target: (input) => input.path,
   async validate(input, ctx) {
     const abs = resolvePath(ctx.cwd, input.path);
-    return existsSync(abs) && !ctx.readFiles.has(abs) ? `${input.path} sudah ada. Baca dulu dengan read sebelum menimpanya.` : void 0;
+    return existsSync(abs) && !ctx.readFiles.has(abs) ? `${input.path} already exists. Read it with read before overwriting it.` : void 0;
   },
   async preview(input, ctx) {
     const abs = resolvePath(ctx.cwd, input.path);
@@ -497,18 +823,18 @@ var writeTool = defineTool({
   async run(input, ctx) {
     const abs = resolvePath(ctx.cwd, input.path);
     if (existsSync(abs) && !ctx.readFiles.has(abs)) {
-      return { output: `${input.path} sudah ada. Baca dulu dengan read sebelum menimpanya.`, isError: true };
+      return { output: `${input.path} already exists. Read it with read before overwriting it.`, isError: true };
     }
     try {
       await ctx.checkpoint?.(abs);
       await mkdir(dirname(abs), { recursive: true });
       await writeFile2(abs, input.content);
     } catch (error) {
-      return { output: `Gagal menulis ${input.path}: ${errorCode(error)}`, isError: true };
+      return { output: `Failed to write ${input.path}: ${errorCode(error)}`, isError: true };
     }
     ctx.readFiles.add(abs);
     const lines = input.content.split("\n").length;
-    return { output: `Menulis ${input.path} (${lines} baris).`, display: `${lines} baris ditulis` };
+    return { output: `Wrote ${input.path} (${lines} lines).`, display: t("{lines} lines written", { lines }) };
   }
 });
 
@@ -517,76 +843,86 @@ var ALL_TOOLS = [readTool, writeTool, editTool, bashTool, grepTool, globTool, fe
 function toolDefinitions(tools) {
   return tools.map((tool) => {
     const { $schema: _ignored, ...parameters } = tool.jsonSchema ?? z8.toJSONSchema(tool.schema);
-    return { type: "function", function: { name: tool.name, description: tool.description, parameters } };
+    return { type: "function", function: { name: tool.name, description: tool.description, parameters, ...tool.outputJsonSchema ? { output_schema: tool.outputJsonSchema } : {} } };
   });
 }
 
-// src/textToolCalls.ts
-var PAIR = /(?:<arg_key>\s*|`)?([A-Za-z_]\w*)(?:\s*<\/arg_key>)?`?\s*(?:=\s*`|<arg_value>)([\s\S]*?)<\/arg_value>/g;
-var CALL_START = /<tool_call>|\n?[^\n]*\bTool call list\b[^\n]*|\n\s*\d+\.\s*Tool:/g;
-function coerce(value, type) {
-  const types = Array.isArray(type) ? type : [type];
-  const v = value.trim();
-  if ((types.includes("integer") || types.includes("number")) && v !== "" && !Number.isNaN(Number(v))) return Number(v);
-  if (types.includes("boolean") && /^(true|false)$/i.test(v)) return v.toLowerCase() === "true";
-  if ((types.includes("object") || types.includes("array")) && /^[[{]/.test(v)) {
-    try {
-      return JSON.parse(v);
-    } catch {
+// src/webBudget.ts
+var KEEP_TOKENS = 4e4;
+var PRUNE_MIN_TOKENS = 2e4;
+var STUB = "[old tool result removed:";
+var tokens = (text) => Math.ceil(text.length / 4);
+var isStub = (content) => content.startsWith(STUB);
+function pruneOldFetches(messages) {
+  const urls = /* @__PURE__ */ new Map();
+  for (const m of messages) {
+    if (m.role !== "assistant") continue;
+    for (const c of m.tool_calls ?? []) {
+      if (c.function.name !== "fetch") continue;
+      try {
+        urls.set(c.id, String(JSON.parse(c.function.arguments).url ?? ""));
+      } catch {
+        urls.set(c.id, "");
+      }
     }
   }
-  return value.replace(/^\n+|\n+$/g, "");
-}
-function pickTool(name, keys, tools) {
-  const named = name && tools.find((t) => t.function.name === name);
-  if (named) return named;
-  let best;
-  let bestScore = 0;
-  let tie = false;
-  for (const t of tools) {
-    const params = t.function.parameters;
-    const props = Object.keys(params.properties ?? {});
-    if (!(params.required ?? []).every((r) => keys.includes(r))) continue;
-    const score = keys.filter((k) => props.includes(k)).length;
-    if (score > bestScore) [best, bestScore, tie] = [t, score, false];
-    else if (score === bestScore && score > 0) tie = true;
+  let kept = 0;
+  let oldTokens = 0;
+  const old = [];
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const m = messages[i];
+    if (m.role !== "tool" || !urls.has(m.tool_call_id) || isStub(m.content)) continue;
+    kept += tokens(m.content);
+    if (kept > KEEP_TOKENS) {
+      old.push(i);
+      oldTokens += tokens(m.content);
+    }
   }
-  return tie ? void 0 : best;
+  if (oldTokens <= PRUNE_MIN_TOKENS) return false;
+  for (const i of old) {
+    const m = messages[i];
+    messages[i] = { ...m, content: `${STUB} fetch ${urls.get(m.tool_call_id)}. Fetch it again (use prompt for a focused excerpt) if still needed.]` };
+  }
+  return true;
 }
-function recoverTextToolCalls(text, tools) {
-  if (!/<\/arg_value>|<tool_call>/.test(text)) return null;
-  const starts = [...text.matchAll(CALL_START)].map((m) => m.index ?? 0);
-  const firstPair = text.search(PAIR);
-  const cut = Math.min(...[...starts, firstPair].filter((i) => i >= 0));
-  const bounds = starts.filter((i) => i >= cut);
-  if (!bounds.length || bounds[0] > cut) bounds.unshift(cut);
-  const toolCalls = [];
-  bounds.forEach((start, n) => {
-    const segment = text.slice(start, bounds[n + 1] ?? text.length);
-    const name = /<tool_call>\s*([A-Za-z_][\w.-]*)/.exec(segment)?.[1] ?? /Tool:\s*`?([A-Za-z_][\w.-]*)`?/.exec(segment)?.[1];
-    let args = [];
-    const flush = () => {
-      if (!args.length) return;
-      const keys = args.map(([k]) => k);
-      const tool = pickTool(name, keys, tools);
-      if (tool) {
-        const props = tool.function.parameters.properties ?? {};
-        const input = Object.fromEntries(args.filter(([k]) => k in props).map(([k, v]) => [k, coerce(v, props[k].type)]));
-        toolCalls.push({ id: `text_call_${toolCalls.length}`, name: tool.function.name, arguments: JSON.stringify(input) });
-      }
-      args = [];
-    };
-    for (const m of segment.matchAll(PAIR)) {
-      if (args.some(([k]) => k === m[1])) flush();
-      args.push([m[1], m[2]]);
+var WebBudget = class {
+  fetches = 0;
+  chars = 0;
+  perTurn;
+  sessionChars;
+  constructor(limits = {}) {
+    this.perTurn = limits.perTurn ?? 8;
+    this.sessionChars = limits.sessionChars ?? 3e5;
+  }
+  startTurn() {
+    this.fetches = 0;
+  }
+  /** Gives back a reservation, e.g. when the fetch was served from cache and cost nothing. */
+  refund() {
+    if (this.fetches > 0) this.fetches--;
+  }
+  reset() {
+    this.fetches = 0;
+    this.chars = 0;
+  }
+  /** Reserves one fetch; returns the refusal to show the model when over budget. */
+  take() {
+    if (this.fetches >= this.perTurn) {
+      return `Limit of ${this.perTurn} fetches per question reached (each fetch uses the user's tokens). Answer from the results you already have; if that is not enough, tell the user what is still missing.`;
     }
-    flush();
-  });
-  if (!toolCalls.length) return null;
-  return { text: text.slice(0, cut).trim(), toolCalls };
-}
+    if (this.chars >= this.sessionChars) {
+      return `Total web page limit for this session reached (~${Math.round(this.sessionChars / 4e3)}k tokens). Answer from the results you already have and ask the user whether to search more.`;
+    }
+    this.fetches++;
+    return void 0;
+  }
+  record(chars) {
+    this.chars += chars;
+  }
+};
 
 // src/agent.ts
+var CANCELLED = "Cancelled by the user.";
 var estimateTokens = (text) => Math.ceil(text.length / 4);
 var COMPACT_PROMPT = "Summarize the conversation so far for yourself so you can continue the work with no other context. Include: the user goals, decisions made, files touched and their current state, commands run and results, the task in progress and the next step. Be concise but complete.";
 var Agent = class {
@@ -602,6 +938,7 @@ var Agent = class {
     this.maxSteps = opts.maxSteps ?? 50;
     this.contextWindow = opts.contextWindow ?? 128e3;
     this.systemPrompt = opts.systemPrompt;
+    this.reasoning = opts.reasoning ?? "auto";
   }
   opts;
   provider;
@@ -611,6 +948,7 @@ var Agent = class {
   lastInputTokens = 0;
   onEvent = () => {
   };
+  reasoning;
   askPermission = async () => "no";
   tools;
   definitions;
@@ -618,6 +956,7 @@ var Agent = class {
   turnTools;
   turnDefinitions;
   readFiles = /* @__PURE__ */ new Set();
+  webBudget = new WebBudget();
   maxSteps;
   // ponytail: one window for every model; read it from /v1/models metadata when providers expose it.
   contextWindow;
@@ -630,7 +969,7 @@ var Agent = class {
     this.definitions = toolDefinitions(tools);
   }
   isParallelSafe(call) {
-    const tool = this.turnTools.find((t) => t.name === call.name);
+    const tool = this.turnTools.find((t2) => t2.name === call.name);
     if (!tool?.parallelSafe) return false;
     try {
       const parsed = tool.schema.safeParse(JSON.parse(call.arguments || "{}"));
@@ -647,11 +986,13 @@ var Agent = class {
   load(messages) {
     this.messages = messages;
     this.readFiles.clear();
+    this.webBudget.reset();
     this.lastInputTokens = 0;
   }
   clear() {
     this.messages = [];
     this.readFiles.clear();
+    this.webBudget.reset();
     this.lastInputTokens = 0;
     this.opts.onReset?.();
   }
@@ -660,31 +1001,47 @@ var Agent = class {
       messages: [{ role: "system", content: this.systemPrompt }, ...this.messages, { role: "user", content: COMPACT_PROMPT }],
       // Some gateways reject tool_calls in history when no tools are declared.
       tools: this.definitions,
-      signal
+      signal,
+      reasoning: this.reasoning
     });
     this.clear();
-    this.push({ role: "user", content: `Ringkasan percakapan sebelumnya:
+    this.push({ role: "user", content: `Summary of the previous conversation:
 ${completion.text}` });
-    this.push({ role: "assistant", content: "Oke, saya lanjutkan dari ringkasan ini." });
+    this.push({ role: "assistant", content: "OK, I will continue from this summary." });
     this.onEvent({ type: "compacted" });
   }
+  /**
+   * Events of one tool execution. A cancelled turn gives up on a tool that does not stop, and whatever that tool
+   * reports later must not reach the screen or a newer turn, so this is per execution and not per call id (ids repeat).
+   */
+  report(ticket, event) {
+    if (ticket.abandoned) return;
+    if (event.type === "toolStart") ticket.open = true;
+    if (event.type === "toolEnd") ticket.open = false;
+    this.onEvent(event);
+  }
   async run(text, signal) {
     this.turnTools = this.tools;
     this.turnDefinitions = this.definitions;
     this.opts.onTurnStart?.();
+    this.webBudget.startTurn();
     try {
-      if (this.lastInputTokens > this.contextWindow * 0.8) await this.compact(signal);
+      if (this.lastInputTokens > this.contextWindow * 0.8 && !hasPendingProgrammaticReplay(this.messages)) await this.compact(signal);
       this.push({ role: "user", content: text });
       for (let step = 0; step < this.maxSteps; step++) {
-        if (step > 0 && this.lastInputTokens > this.contextWindow * 0.8) {
+        if (step > 0 && this.lastInputTokens > this.contextWindow * 0.8 && !hasPendingProgrammaticReplay(this.messages)) {
           await this.compact(signal);
-          this.push({ role: "user", content: `Lanjutkan tugas ini sesuai ringkasan di atas: ${text}` });
+          this.push({ role: "user", content: `Continue this task using the summary above: ${text}` });
         }
+        pruneOldFetches(this.messages);
         let completion = await this.provider.chat({
           messages: [{ role: "system", content: this.systemPrompt }, ...this.messages],
           tools: this.turnDefinitions,
+          programmaticToolNames: this.turnTools.filter((tool) => tool.programmaticSafe).map((tool) => tool.name),
           signal,
-          onText: (delta) => this.onEvent({ type: "text", delta })
+          onText: (delta) => this.onEvent({ type: "text", delta }),
+          onThinking: (delta) => this.onEvent({ type: "thinking", delta }),
+          reasoning: this.reasoning
         });
         if (!completion.toolCalls.length && completion.finishReason !== "repetition") {
           const recovered = recoverTextToolCalls(completion.text, this.turnDefinitions);
@@ -701,26 +1058,17 @@ ${completion.text}` });
         this.totalUsage.outputTokens += usage.outputTokens;
         this.lastInputTokens = usage.inputTokens;
         this.onEvent({ type: "usage", ...this.totalUsage });
-        this.push({
-          role: "assistant",
-          content: completion.text || null,
-          ...completion.toolCalls.length ? {
-            tool_calls: completion.toolCalls.map((c) => ({
-              id: c.id,
-              type: "function",
-              function: { name: c.name, arguments: c.arguments }
-            }))
-          } : {}
-        });
+        this.push(completionAssistantMessage(completion));
         if (completion.finishReason === "repetition") {
           this.onEvent({ type: "textReplace", text: completion.text });
           this.onEvent({
             type: "error",
-            message: "Model terjebak mengulang teks, jawaban dihentikan. Coba ulangi atau ganti model dengan /model."
+            message: t("The model got stuck repeating text, so the answer was stopped. Try again or switch models with /model.")
           });
           return;
         }
         if (!completion.toolCalls.length) {
+          if (completion.finishReason === "continue") continue;
           this.onEvent({ type: "done" });
           return;
         }
@@ -728,16 +1076,35 @@ ${completion.text}` });
         let i = 0;
         while (i < calls.length) {
           if (signal.aborted) {
-            for (const pending of calls.slice(i)) this.push({ role: "tool", tool_call_id: pending.id, content: "Dibatalkan oleh user." });
+            this.cancelCalls(calls.slice(i));
             this.onEvent({ type: "aborted" });
             return;
           }
           let j = i + 1;
           if (this.isParallelSafe(calls[i])) while (j < calls.length && this.isParallelSafe(calls[j])) j++;
           const batch = calls.slice(i, j);
-          const results = await Promise.all(batch.map((c) => this.runTool(c, signal)));
+          const tickets = batch.map(() => ({ abandoned: false, open: false }));
+          const running = Promise.all(batch.map((c, k) => this.runTool(c, signal, tickets[k])));
+          const outcome = await raceAbort(running, signal);
+          if (outcome === ABORTED) {
+            batch.forEach((c, k) => {
+              const ticket = tickets[k];
+              ticket.abandoned = true;
+              if (ticket.open) this.onEvent({ type: "toolEnd", id: c.id, tool: c.name, output: CANCELLED, isError: true });
+            });
+            running.catch(() => {
+            });
+            this.cancelCalls(calls.slice(i));
+            this.onEvent({ type: "aborted" });
+            return;
+          }
           batch.forEach((c, k) => {
-            this.push({ role: "tool", tool_call_id: c.id, content: results[k] });
+            this.push({
+              role: "tool",
+              tool_call_id: c.id,
+              content: outcome[k],
+              ...c.caller ? { responses_caller: c.caller } : {}
+            });
           });
           i = j;
         }
@@ -757,48 +1124,62 @@ ${completion.text}` });
       this.onEvent({
         type: "error",
         message: noTools ? `${message}
-Model ini sepertinya tidak mendukung tool calling. Coba model lain dengan /model.` : message
+${t("This model may not support tool calling. Try another model with /model.")}` : message
       });
     }
   }
-  async runTool(call, signal) {
+  /** Every tool call needs an answer in the history, or the next request to the model is rejected. */
+  cancelCalls(calls) {
+    for (const pending of calls)
+      this.push({
+        role: "tool",
+        tool_call_id: pending.id,
+        content: CANCELLED,
+        ...pending.caller ? { responses_caller: pending.caller } : {}
+      });
+  }
+  async runTool(call, signal, ticket) {
+    const emit = (event) => this.report(ticket, event);
     const fail = (output, target2 = "") => {
-      this.onEvent({ type: "toolStart", id: call.id, tool: call.name, target: target2 });
-      this.onEvent({ type: "toolEnd", id: call.id, tool: call.name, output, isError: true });
+      emit({ type: "toolStart", id: call.id, tool: call.name, target: target2 });
+      emit({ type: "toolEnd", id: call.id, tool: call.name, output, isError: true });
       return output;
     };
-    const tool = this.turnTools.find((t) => t.name === call.name);
-    if (!tool) return fail(`Alat "${call.name}" tidak ada. Alat yang tersedia: ${this.turnTools.map((t) => t.name).join(", ")}`);
+    const tool = this.turnTools.find((t2) => t2.name === call.name);
+    if (!tool) return fail(`Tool "${call.name}" does not exist. Available tools: ${this.turnTools.map((t2) => t2.name).join(", ")}`);
     let args;
     try {
       args = JSON.parse(call.arguments || "{}");
     } catch {
-      return fail(`Argumen bukan JSON valid: ${call.arguments.slice(0, 200)}`);
+      return fail(`Arguments are not valid JSON: ${call.arguments.slice(0, 200)}`);
     }
     const parsed = tool.schema.safeParse(args);
     if (!parsed.success) {
-      return fail(`Argumen tidak valid: ${parsed.error.issues.map((i) => `${i.path.join(".") || "(root)"}: ${i.message}`).join("; ")}`);
+      return fail(`Invalid arguments: ${parsed.error.issues.map((i) => `${i.path.join(".") || "(root)"}: ${i.message}`).join("; ")}`);
     }
     const input = parsed.data;
     const target = tool.target(input);
+    const overBudget = tool.name === "fetch" ? this.webBudget.take() : void 0;
+    if (overBudget) return fail(overBudget, target);
     const ctx = {
       cwd: this.opts.cwd,
       signal,
       readFiles: this.readFiles,
       callId: call.id,
-      emit: (event) => this.onEvent(event),
+      emit,
       ask: (req) => this.askPermission(req),
       checkpoint: this.opts.checkpoint,
+      refundFetch: () => this.webBudget.refund(),
       addUsage: (u) => {
         this.totalUsage.inputTokens += u.inputTokens;
         this.totalUsage.outputTokens += u.outputTokens;
         this.onEvent({ type: "usage", ...this.totalUsage });
       }
     };
-    this.onEvent({ type: "toolStart", id: call.id, tool: tool.name, target });
+    emit({ type: "toolStart", id: call.id, tool: tool.name, target });
     const invalid = await tool.validate?.(input, ctx).catch((error) => error.message);
     if (invalid) {
-      this.onEvent({ type: "toolEnd", id: call.id, tool: tool.name, output: invalid, isError: true });
+      emit({ type: "toolEnd", id: call.id, tool: tool.name, output: invalid, isError: true });
       return invalid;
     }
     const request = { tool: tool.name, kind: tool.kind, target };
@@ -816,8 +1197,8 @@ Model ini sepertinya tidak mendukung tool calling. Coba model lain dengan /model
       decision = answer === "no" ? "deny" : "allow";
     }
     if (decision === "deny") {
-      const output = this.permissions.mode === "plan" ? "Ditolak: mode plan hanya boleh membaca dan mencari. Susun rencana untuk user tanpa mengubah apa pun." : "User menolak menjalankan alat ini. Tanyakan ke user apa yang diinginkan, atau coba cara lain.";
-      this.onEvent({ type: "toolEnd", id: call.id, tool: tool.name, output, isError: true });
+      const output = this.permissions.mode === "plan" ? "Denied: plan mode only allows reading and searching. Write the plan for the user without changing anything." : "The user declined to run this tool. Ask the user what they want, or try another approach.";
+      emit({ type: "toolEnd", id: call.id, tool: tool.name, output, isError: true });
       return output;
     }
     let result;
@@ -826,7 +1207,8 @@ Model ini sepertinya tidak mendukung tool calling. Coba model lain dengan /model
     } catch (error) {
       result = { output: `Error: ${error.message}`, isError: true };
     }
-    this.onEvent({ type: "toolEnd", id: call.id, tool: tool.name, output: result.output, display: result.display, isError: !!result.isError });
+    if (tool.name === "fetch" && !result.isError) this.webBudget.record(result.output.length);
+    emit({ type: "toolEnd", id: call.id, tool: tool.name, output: result.output, display: result.display, isError: !!result.isError });
     return result.output;
   }
 };
@@ -855,7 +1237,7 @@ var CheckpointStore = class {
     while (this.turns() > MAX_TURNS) this.history.shift();
   }
   turns() {
-    return this.history.filter((t) => t.size).length;
+    return this.history.filter((t2) => t2.size).length;
   }
   async undo() {
     while (this.history.length && !this.history.at(-1)?.size) this.history.pop();
@@ -890,9 +1272,10 @@ import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
 import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
 import { z as z9 } from "zod";
+var MCP_OUTPUT_MAX_CHARS = 32e3;
 function mcpToolName(server, tool, taken) {
-  const clean = (s) => s.replace(/[^A-Za-z0-9_-]+/g, "_");
-  const base = `mcp__${clean(server)}__${clean(tool)}`.slice(0, 64);
+  const clean2 = (s) => s.replace(/[^A-Za-z0-9_-]+/g, "_");
+  const base = `mcp__${clean2(server)}__${clean2(tool)}`.slice(0, 64);
   let name = base;
   for (let n = 2; taken.has(name); n++) name = `${base.slice(0, 64 - String(n).length - 1)}_${n}`;
   taken.add(name);
@@ -901,7 +1284,7 @@ function mcpToolName(server, tool, taken) {
 function withTimeout(promise, ms) {
   let timer;
   const timeout = new Promise((_, reject) => {
-    timer = setTimeout(() => reject(new Error(`timeout ${Math.round(ms / 1e3)} detik`)), ms);
+    timer = setTimeout(() => reject(new Error(t("timeout after {n} seconds", { n: Math.round(ms / 1e3) }))), ms);
   });
   return Promise.race([promise, timeout]).finally(() => clearTimeout(timer));
 }
@@ -938,7 +1321,7 @@ var McpManager = class {
         });
         return;
       }
-      entry.tools = tools.map((t) => this.wrap(spec.name, client, t));
+      entry.tools = tools.map((t2) => this.wrap(spec.name, client, t2));
       entry.state = { ...entry.state, status: "ready", tools: entry.tools.length };
     } catch (error) {
       entry.state = { ...entry.state, status: "error", error: error.message };
@@ -954,7 +1337,9 @@ var McpManager = class {
       description: `[MCP ${server}] ${tool.description ?? tool.name}`.slice(0, 1024),
       schema: z9.record(z9.string(), z9.unknown()),
       jsonSchema: tool.inputSchema,
+      ...tool.outputSchema ? { outputJsonSchema: tool.outputSchema } : {},
       kind: "mcp",
+      programmaticSafe: tool.annotations?.readOnlyHint === true,
       target: (input) => {
         const text = JSON.stringify(input);
         return text.length > 80 ? `${text.slice(0, 77)}\u2026` : text;
@@ -962,9 +1347,12 @@ var McpManager = class {
       async run(input, ctx) {
         try {
           const result = await client.callTool({ name: tool.name, arguments: input }, void 0, { signal: ctx.signal });
-          const output = (result.content ?? []).map((c) => c.type === "text" ? c.text ?? "" : `[${c.type}]`).join("\n") || "(kosong)";
-          return { output: output.length > 5e4 ? `${output.slice(0, 5e4)}
-\u2026 [dipotong]` : output, isError: !!result.isError };
+          const output = (result.content ?? []).map((c) => c.type === "text" ? c.text ?? "" : `[${c.type}]`).join("\n") || "(empty)";
+          return {
+            output: output.length > MCP_OUTPUT_MAX_CHARS ? `${output.slice(0, MCP_OUTPUT_MAX_CHARS)}
+\u2026 [truncated at ${MCP_OUTPUT_MAX_CHARS} characters; narrow the MCP request if possible]` : output,
+            isError: !!result.isError
+          };
         } catch (error) {
           return { output: `Server MCP ${server} error: ${error.message}`, isError: true };
         }
@@ -975,14 +1363,14 @@ var McpManager = class {
     const entry = this.servers.get(name);
     if (!entry) return;
     this.servers.delete(name);
-    for (const t of entry.tools) this.taken.delete(t.name);
-    if (entry.tools.length) this.opts.onToolsRemoved?.(entry.tools.map((t) => t.name));
+    for (const t2 of entry.tools) this.taken.delete(t2.name);
+    if (entry.tools.length) this.opts.onToolsRemoved?.(entry.tools.map((t2) => t2.name));
     await entry.client?.close().catch(() => {
     });
     this.opts.onChange?.();
   }
   tools() {
-    return [...this.servers.values()].flatMap((s) => s.tools);
+    return [...this.servers.values()].flatMap((s) => s.tools).sort((a, b) => a.name.localeCompare(b.name));
   }
   states() {
     return [...this.servers.values()].map((s) => s.state);
@@ -1003,15 +1391,15 @@ function createExitPlanTool(opts) {
     description: "Plan mode only: present the finished plan to the user for approval. If approved you may start implementing it.",
     schema: z10.object({ plan: z10.string().describe("The plan, in markdown") }),
     kind: "read",
-    target: () => "rencana",
+    target: () => t("plan"),
     async run(input) {
-      if (opts.permissions.mode !== "plan") return { output: "exit_plan hanya dipakai di mode plan.", isError: true };
+      if (opts.permissions.mode !== "plan") return { output: "exit_plan is only used in plan mode.", isError: true };
       const decision = await opts.interaction.approvePlan(input.plan);
       if (decision === "no") {
-        return { output: "User belum menyetujui. Tanyakan apa yang perlu diperbaiki, perbaiki rencananya, lalu panggil exit_plan lagi." };
+        return { output: "The user has not approved yet. Ask what needs to change, revise the plan, then call exit_plan again." };
       }
       opts.permissions.mode = decision;
-      return { output: `Rencana disetujui. Mode sekarang ${decision}. Mulai kerjakan rencananya sekarang.` };
+      return { output: `Plan approved. The mode is now ${decision}. Start carrying out the plan now.` };
     }
   });
 }
@@ -1028,7 +1416,7 @@ function createSkillTool(skills) {
     target: (input) => input.name,
     async run(input) {
       const skill = skills.find((s) => s.name === input.name);
-      if (!skill) return { output: `Skill "${input.name}" tidak ada. Tersedia: ${skills.map((s) => s.name).join(", ") || "(tidak ada)"}`, isError: true };
+      if (!skill) return { output: `Skill "${input.name}" does not exist. Available: ${skills.map((s) => s.name).join(", ") || "(none)"}`, isError: true };
       const { body } = parseFrontmatter(readFileSync(skill.file, "utf8"));
       return { output: `Base directory for this skill: ${skill.dir}
 
@@ -1037,8 +1425,69 @@ ${body}`, display: skill.description.slice(0, 60) };
   });
 }
 
-// src/tools/task.ts
+// src/tools/websearch.ts
 import { z as z12 } from "zod";
+var clean = (items, max) => (Array.isArray(items) ? items : []).filter((r) => typeof r?.url === "string" && /^https?:\/\//.test(r.url)).slice(0, max).map((r) => ({
+  title: String(r.title || r.url).slice(0, 200),
+  url: r.url,
+  snippet: String(r.snippet || r.description || "").replace(/\s+/g, " ").trim().slice(0, 600)
+}));
+async function postJson(url, body, headers, signal) {
+  const res = await fetch(url, {
+    method: "POST",
+    headers: { "content-type": "application/json", ...headers },
+    body: JSON.stringify(body),
+    signal: AbortSignal.any([signal, AbortSignal.timeout(3e4)])
+  });
+  if (!res.ok) throw new Error(`HTTP ${res.status}`);
+  return res.json();
+}
+function createWebSearchTool(opts) {
+  const keenableURL = opts.keenableURL ?? "https://api.keenable.ai/v1/search/public";
+  return defineTool({
+    name: "web_search",
+    description: "Search the web. Returns titles, URLs and short snippets. Use it to find the right pages instead of guessing URLs; then fetch a result URL when you need the full page.",
+    schema: z12.object({
+      query: z12.string().min(1).max(500).describe("Search query"),
+      max_results: z12.number().int().min(1).max(10).optional().describe("Number of results (default 6)")
+    }),
+    kind: "read",
+    target: (input) => input.query,
+    parallelSafe: () => true,
+    async run(input, ctx) {
+      const max = input.max_results ?? 6;
+      const errors = [];
+      let results = [];
+      const bc = opts.botconnector();
+      if (bc) {
+        try {
+          const data = await postJson(`${bc.baseURL.replace(/\/+$/, "")}/web/search`, { query: input.query, max_results: max }, { authorization: `Bearer ${bc.apiKey}` }, ctx.signal);
+          results = clean(data.results, max);
+        } catch (error) {
+          errors.push(`BotConnector: ${error.message}`);
+        }
+      }
+      if (!results.length) {
+        try {
+          const data = await postJson(keenableURL, { query: input.query }, { "x-keenable-title": "BotConnector" }, ctx.signal);
+          results = clean(data.results, max);
+        } catch (error) {
+          errors.push(`Keenable: ${error.message}`);
+        }
+      }
+      if (!results.length) {
+        return { output: errors.length ? `Web search failed (${errors.join("; ")}).` : "No results.", isError: errors.length > 0 };
+      }
+      const output = results.map((r, i) => `${i + 1}. ${r.title}
+   ${r.url}${r.snippet ? `
+   ${r.snippet}` : ""}`).join("\n");
+      return { output, display: t("{n} results", { n: results.length }) };
+    }
+  });
+}
+
+// src/tools/task.ts
+import { z as z13 } from "zod";
 function createTaskTool(opts) {
   const byName = new Map(opts.agents.map((a) => [a.name, a]));
   const list = opts.agents.map((a) => `- ${a.name}: ${a.description}`).join("\n");
@@ -1046,10 +1495,10 @@ function createTaskTool(opts) {
     name: "task",
     description: `Delegate a self-contained sub-task to a subagent. It starts with an empty context and returns only its final report. Available agents:
 ${list}`,
-    schema: z12.object({
-      agent: z12.string().describe("Agent name"),
-      description: z12.string().describe("3-6 word summary shown to the user"),
-      prompt: z12.string().describe("Full instructions; the subagent sees nothing else")
+    schema: z13.object({
+      agent: z13.string().describe("Agent name"),
+      description: z13.string().describe("3-6 word summary shown to the user"),
+      prompt: z13.string().describe("Full instructions; the subagent sees nothing else")
     }),
     kind: "read",
     target: (input) => `[${input.agent}] ${input.description}`,
@@ -1058,16 +1507,16 @@ ${list}`,
       const allowed = byName.get(input.agent)?.tools;
       if (!allowed) return false;
       const base = opts.baseTools();
-      return allowed.every((name) => base.find((t) => t.name === name)?.kind === "read");
+      return allowed.every((name) => base.find((t2) => t2.name === name)?.kind === "read");
     },
     async run(input, ctx) {
       const def = byName.get(input.agent);
-      if (!def) return { output: `Agent "${input.agent}" tidak ada. Tersedia: ${[...byName.keys()].join(", ")}`, isError: true };
-      const base = opts.baseTools().filter((t) => t.name !== "task" && t.name !== "exit_plan");
-      const unknown = (def.tools ?? []).filter((n) => !base.some((t) => t.name === n));
-      if (unknown.length) return { output: `Agent "${def.name}": alat tidak dikenal: ${unknown.join(", ")}`, isError: true };
+      if (!def) return { output: `Agent "${input.agent}" does not exist. Available: ${[...byName.keys()].join(", ")}`, isError: true };
+      const base = opts.baseTools().filter((t2) => t2.name !== "task" && t2.name !== "exit_plan");
+      const unknown = (def.tools ?? []).filter((n) => !base.some((t2) => t2.name === n));
+      if (unknown.length) return { output: `Agent "${def.name}": unknown tools: ${unknown.join(", ")}`, isError: true };
       const allowed = def.tools;
-      const tools = allowed ? base.filter((t) => allowed.includes(t.name)) : base;
+      const tools = allowed ? base.filter((t2) => allowed.includes(t2.name)) : base;
       let provider;
       try {
         provider = def.model ? opts.providerFor(def.model) : opts.provider();
@@ -1085,6 +1534,7 @@ ${def.prompt}`,
         cwd: opts.cwd,
         maxSteps: def.maxSteps ?? 50,
         label: def.name,
+        reasoning: opts.reasoning?.() ?? "auto",
         // Subagent edits belong to the parent's turn so /undo reverts them too.
         checkpoint: ctx.checkpoint
       });
@@ -1098,22 +1548,22 @@ ${def.prompt}`,
       if (ctx.ask) child.askPermission = ctx.ask;
       await child.run(input.prompt, ctx.signal);
       ctx.addUsage?.(child.totalUsage);
-      const tokens = child.totalUsage.inputTokens + child.totalUsage.outputTokens;
-      const display = `${steps} langkah \xB7 ${tokens >= 1e3 ? `${Math.round(tokens / 1e3)}k` : tokens} token`;
-      if (outcome?.type === "error") return { output: `Subagent ${def.name} gagal: ${outcome.message}`, isError: true, display };
-      if (outcome?.type === "aborted") return { output: `Subagent ${def.name} dibatalkan.`, isError: true, display };
+      const tokens2 = child.totalUsage.inputTokens + child.totalUsage.outputTokens;
+      const display = t("{steps} steps \xB7 {tokens} tokens", { steps, tokens: tokens2 >= 1e3 ? `${Math.round(tokens2 / 1e3)}k` : tokens2 });
+      if (outcome?.type === "error") return { output: `Subagent ${def.name} failed: ${outcome.message}`, isError: true, display };
+      if (outcome?.type === "aborted") return { output: `Subagent ${def.name} was cancelled.`, isError: true, display };
       const last = [...child.messages].reverse().find((m) => m.role === "assistant" && m.content);
-      const report = last && typeof last.content === "string" ? last.content : "(tidak ada laporan)";
+      const report = last && typeof last.content === "string" ? last.content : "(no report)";
       const suffix = outcome?.type === "stepLimit" ? `
 
-(Subagent berhenti di batas ${def.maxSteps ?? 50} langkah.)` : "";
+(The subagent stopped at its ${def.maxSteps ?? 50}-step limit.)` : "";
       return { output: report + suffix, display };
     }
   });
 }
 
 // src/tools/todo.ts
-import { z as z13 } from "zod";
+import { z as z14 } from "zod";
 var TodoStore = class {
   items = [];
   listeners = /* @__PURE__ */ new Set();
@@ -1130,36 +1580,47 @@ function createTodoTool(store) {
   return defineTool({
     name: "todo_write",
     description: "Write the task list for multi-step work (3+ steps). Send the whole list every time; exactly one item in_progress while working. Mark items completed as soon as they are done.",
-    schema: z13.object({
-      todos: z13.array(z13.object({ content: z13.string(), status: z13.enum(["pending", "in_progress", "completed"]) }))
+    schema: z14.object({
+      todos: z14.array(z14.object({ content: z14.string(), status: z14.enum(["pending", "in_progress", "completed"]) }))
     }),
     kind: "read",
     target: (input) => `${input.todos.length} item`,
     async run(input) {
-      if (input.todos.filter((t) => t.status === "in_progress").length > 1) {
-        return { output: "Hanya boleh satu item in_progress.", isError: true };
+      if (input.todos.filter((t2) => t2.status === "in_progress").length > 1) {
+        return { output: "Only one item may be in_progress.", isError: true };
       }
       store.set(input.todos);
-      const done = input.todos.filter((t) => t.status === "completed").length;
-      return { output: `Todo diperbarui: ${done}/${input.todos.length} selesai.` };
+      const done = input.todos.filter((t2) => t2.status === "completed").length;
+      return { output: `Todo updated: ${done}/${input.todos.length} completed.` };
     }
   });
 }
 
 // src/setup.ts
 var TOOL_RULES = { bash: "bash", edit: "edit", write: "edit", fetch: "fetch" };
+function lunaPtcAutoEnabled(env) {
+  const value = String(env.BCCLI_LUNA_PTC ?? "").trim().toLowerCase();
+  return !["0", "false", "off", "no"].includes(value);
+}
 function createRuntime(opts) {
   const env = opts.env ?? process.env;
   const home = bccliHome(env);
   let config = loadConfig(opts.cwd, env);
   let modelRef = opts.args.model ?? config.model;
+  let reasoning = opts.args.reasoning ?? config.reasoning;
   const makeProvider = (ref) => {
     const resolved = resolveModel(config, ref, env);
-    return opts.provider ?? createProvider({ baseURL: resolved.baseURL, apiKey: resolved.apiKey, model: resolved.model });
+    return opts.provider ?? createProvider({
+      baseURL: resolved.baseURL,
+      apiKey: resolved.apiKey,
+      model: resolved.model,
+      providerId: resolved.providerId,
+      enableProgrammaticToolCalling: lunaPtcAutoEnabled(env)
+    });
   };
   const provider = makeProvider(modelRef);
   const mode = opts.args.allowAll ? "allowAll" : opts.args.permissionMode ?? config.permissionMode;
-  const rules = [...config.allow, ...opts.args.allowedTools.map((t) => TOOL_RULES[t] ?? t)];
+  const rules = [...config.allow, ...opts.args.allowedTools.map((t2) => TOOL_RULES[t2] ?? t2)];
   const permissions = new Permissions(mode, rules, opts.cwd);
   const roots = { cwd: opts.cwd, home, userHome: opts.userHome ?? homedir() };
   const skills = loadSkills(roots);
@@ -1179,16 +1640,27 @@ function createRuntime(opts) {
     }
   }
   const systemPrompt = buildSystemPrompt({ cwd: opts.cwd, home, model: modelRef, skills });
-  const baseTools = [...ALL_TOOLS, createSkillTool(skills), createTodoTool(todos), createExitPlanTool({ permissions, interaction })];
+  const webSearch = createWebSearchTool({
+    botconnector: () => {
+      try {
+        const bc = resolveModel(config, "bc-cloud/search", env);
+        return bc.apiKey ? { baseURL: bc.baseURL, apiKey: bc.apiKey } : void 0;
+      } catch {
+        return void 0;
+      }
+    }
+  });
+  const baseTools = [...ALL_TOOLS, webSearch, createSkillTool(skills), createTodoTool(todos), createExitPlanTool({ permissions, interaction })];
   const task = createTaskTool({
     agents: [...BUILTIN_AGENTS, ...agentDefs],
     // Subagents get whatever the main agent has right now (incl. MCP tools), minus task itself.
-    baseTools: () => agent.tools.filter((t) => t.name !== "task"),
+    baseTools: () => agent.tools.filter((t2) => t2.name !== "task"),
     permissions,
     provider: () => agent.provider,
     providerFor: makeProvider,
     systemPrompt,
-    cwd: opts.cwd
+    cwd: opts.cwd,
+    reasoning: () => reasoning
   });
   const agent = new Agent({
     provider,
@@ -1197,6 +1669,7 @@ function createRuntime(opts) {
     systemPrompt,
     cwd: opts.cwd,
     history,
+    reasoning,
     onMessage: (m) => session.append(m),
     onReset: () => session.reset(),
     onTurnStart: () => checkpoints.beginTurn(),
@@ -1238,6 +1711,9 @@ function createRuntime(opts) {
     get modelRef() {
       return modelRef;
     },
+    get reasoning() {
+      return reasoning;
+    },
     agent,
     get session() {
       return session;
@@ -1267,36 +1743,59 @@ function createRuntime(opts) {
     setModel(ref) {
       agent.provider = makeProvider(ref);
       modelRef = ref;
+    },
+    setReasoning(level) {
+      reasoning = level;
+      agent.reasoning = level;
     }
   };
 }
 
 // src/version.ts
-var VERSION = true ? "0.4.0-beta.3" : "0.0.0-dev";
+var VERSION = true ? "0.4.0-beta.31" : "0.0.0-dev";
 
 // src/cli.ts
+function chooseLanguage(argv) {
+  let fromConfig;
+  try {
+    fromConfig = readGlobalConfigFile(process.env).language;
+  } catch {
+  }
+  setLanguage(resolveLanguage(argv, process.env, fromConfig));
+}
 async function main() {
+  chooseLanguage(process.argv.slice(2));
   const args = parseCliArgs(process.argv.slice(2));
   if (args.version) {
     console.log(VERSION);
     return 0;
   }
   if (args.help) {
-    console.log(HELP_TEXT);
+    console.log(helpText());
     return 0;
   }
   const cwd = process.cwd();
   if (args.command === "login") return runLogin(args.loginProvider ?? "bc-cloud", cwd);
   if (args.command === "mcp") {
-    const { runMcpCommand } = await import("./mcpCli-Q2H63ISP.js");
-    const { readSecret } = await import("./login-KHU7ONSR.js");
+    const { runMcpCommand } = await import("./mcpCli-UGNEDBMU.js");
+    const { readSecret } = await import("./login-AP2ODLJX.js");
     return runMcpCommand(args, { env: process.env, cwd, out: (s) => console.log(s), err: (s) => console.error(s), readSecret });
   }
   if (args.command === "provider") {
-    const { runProviderCommand } = await import("./providerCli-G3X7KENO.js");
-    const { readSecret } = await import("./login-KHU7ONSR.js");
+    const { runProviderCommand } = await import("./providerCli-J4Y7D6PF.js");
+    const { readSecret } = await import("./login-AP2ODLJX.js");
     return runProviderCommand(args, { env: process.env, cwd, out: (s) => console.log(s), err: (s) => console.error(s), readSecret });
   }
+  if (args.command === "connect" || args.command === "disconnect" || args.command === "integrations") {
+    const { runIntegrationCommand } = await import("./integrationCli-G4C6XQUE.js");
+    return runIntegrationCommand(args, {
+      env: process.env,
+      cwd,
+      out: (s) => console.log(s),
+      err: (s) => console.error(s),
+      fetch: globalThis.fetch
+    });
+  }
   if (args.command === "models") {
     const config = loadConfig(cwd);
     const resolved = resolveModel(config, args.model ?? config.model);
@@ -1310,11 +1809,11 @@ async function main() {
   } catch {
   }
   if (args.print) {
-    if (!args.prompt) throw new ConfigError('Mode -p butuh tugas, contoh: bccli -p "jelaskan repo ini"');
-    const { serversToStart } = await import("./config-NPSYFAFD.js");
+    if (!args.prompt) throw new ConfigError(t('-p mode needs a task, e.g. bccli -p "explain this repo"'));
+    const { serversToStart } = await import("./config-DMF4AO7E.js");
     const plan = serversToStart(rt.home, cwd);
     for (const s of plan.needTrust) {
-      console.error(`Server MCP project "${s.name}" dilewati (belum diizinkan; jalankan bccli interaktif sekali untuk menyetujuinya).`);
+      console.error(t('Project MCP server "{name}" skipped (not approved yet; run interactive bccli once to approve it).', { name: s.name }));
     }
     await rt.startMcp(plan.start);
     try {
@@ -1323,8 +1822,8 @@ async function main() {
       await rt.mcp.stop();
     }
   }
-  if (!process.stdin.isTTY) throw new ConfigError('Mode interaktif butuh terminal. Untuk skrip/CI pakai: bccli -p "tugas"');
-  const { startInteractive } = await import("./ui-A32PTF4F.js");
+  if (!process.stdin.isTTY) throw new ConfigError(t('Interactive mode needs a terminal. For scripts/CI use: bccli -p "task"'));
+  const { startInteractive } = await import("./ui-EFY7SNIW.js");
   return startInteractive(rt, { initialPrompt: args.prompt, resume: args.resume, version: VERSION });
 }
 main().then(