@botconnector/bccli 0.4.0-beta.38 → 0.4.0-beta.39

package/README.md

@@ -160,6 +160,14 @@ seperti Claude Code). Semua alat MCP selalu minta izin.
 
 `.bccli/mcp.json` di dalam repo tidak dijalankan sebelum kamu setujui (ditanya sekali per folder).
 
+`bccli mcp serve` menjalankan MCP server stdio dengan tools BotConnector milikmu
+(`bc_search`, `bc_fetch`, `bc_models`, `bc_chat`) untuk dipakai Claude Code, Cursor,
+opencode, dan host MCP lain. Butuh `bccli login` (atau `BOTCONNECTOR_API_KEY`):
+
+```bash
+claude mcp add botconnector -- npx -y @botconnector/bccli mcp serve
+```
+
 ## Subagent
 
 Agent bisa mendelegasikan pekerjaan lewat alat `task`:

package/dist/acp-4XE2KOIJ.js

@@ -0,0 +1,114 @@
+#!/usr/bin/env node
+
+// src/acp.ts
+var ACP_PROTOCOL_VERSION = 1;
+function runAcp(input, output, opts) {
+  const sessions = /* @__PURE__ */ new Map();
+  let nextSession = 1;
+  const write = (msg) => {
+    output.write(`${JSON.stringify(msg)}
+`);
+  };
+  const reply = (id, result) => write({ jsonrpc: "2.0", id, result });
+  const replyError = (id, code, message) => write({ jsonrpc: "2.0", id, error: { code, message } });
+  const handle = async (msg) => {
+    const { id, method, params } = msg ?? {};
+    if (method === "initialize") {
+      return reply(id, {
+        protocolVersion: ACP_PROTOCOL_VERSION,
+        agentCapabilities: {
+          loadSession: false,
+          promptCapabilities: { image: false, audio: false, embeddedContext: false }
+        }
+      });
+    }
+    if (method === "session/new") {
+      const sessionId = `s${nextSession++}`;
+      sessions.set(sessionId, { controller: null });
+      return reply(id, { sessionId });
+    }
+    if (method === "session/cancel") {
+      sessions.get(params?.sessionId ?? "")?.controller?.abort();
+      return;
+    }
+    if (method === "session/prompt") {
+      const sid = params?.sessionId ?? "";
+      const session = sessions.get(sid);
+      if (!session) return replyError(id, -32602, "Unknown session");
+      const text = (params?.prompt ?? []).filter((p) => p?.type === "text").map((p) => String(p.text ?? "")).join("\n");
+      const controller = new AbortController();
+      session.controller = controller;
+      let cancelled = false;
+      controller.signal.addEventListener("abort", () => {
+        cancelled = true;
+      });
+      try {
+        const agent = opts.newAgent(params?.cwd ?? opts.cwd);
+        await agent.run(
+          text,
+          (chunk) => {
+            write({
+              jsonrpc: "2.0",
+              method: "session/update",
+              params: {
+                sessionId: sid,
+                update: { sessionUpdate: "agent_message_chunk", content: { type: "text", text: chunk } }
+              }
+            });
+          },
+          controller.signal
+        );
+      } catch (e) {
+        return replyError(id, -32603, e.message);
+      } finally {
+        session.controller = null;
+      }
+      return reply(id, { stopReason: cancelled ? "cancelled" : "end_turn" });
+    }
+    if (id !== void 0) return replyError(id, -32601, "Method not found");
+  };
+  return new Promise((resolve) => {
+    let buf = "";
+    const onData = (chunk) => {
+      buf += chunk.toString();
+      let idx = buf.indexOf("\n");
+      while (idx >= 0) {
+        const line = buf.slice(0, idx);
+        buf = buf.slice(idx + 1);
+        idx = buf.indexOf("\n");
+        if (!line.trim()) continue;
+        let msg;
+        try {
+          msg = JSON.parse(line);
+        } catch {
+          continue;
+        }
+        void handle(msg);
+      }
+    };
+    const onEnd = () => {
+      input.removeListener("data", onData);
+      resolve();
+    };
+    input.on("data", onData);
+    input.on("end", onEnd);
+  });
+}
+function runtimeAgent(cwd) {
+  return {
+    async run(text, onChunk, signal) {
+      const { parseCliArgs } = await import("./args-BD2PHEKG.js");
+      const { createRuntime } = await import("./setup-FGCFKC7Z.js");
+      const rt = createRuntime({ cwd, args: { ...parseCliArgs([]), allowAll: true } });
+      rt.agent.onEvent = (event) => {
+        if (event.type === "text") onChunk(event.delta);
+      };
+      await rt.agent.run(text, signal);
+    }
+  };
+}
+export {
+  ACP_PROTOCOL_VERSION,
+  runAcp,
+  runtimeAgent
+};

package/dist/{args-MNVI2OJI.js → args-BD2PHEKG.js}

@@ -2,11 +2,11 @@
 import {
   helpText,
   parseCliArgs
-} from "./chunk-ASTNW3X2.js";
+} from "./chunk-ZG7HCXYA.js";
 import "./chunk-R3ND76LW.js";
-import "./chunk-YURAIW7A.js";
-import "./chunk-H5N4ST6B.js";
-import "./chunk-4RMP4CNT.js";
+import "./chunk-NI5JZUZ3.js";
+import "./chunk-M7LLJQ7M.js";
+import "./chunk-M23QBX3V.js";
 export {
   helpText,
   parseCliArgs

package/dist/{chunk-TASYQW7B.js → chunk-AVB6M4JE.js}

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
 import {
   ConfigError
-} from "./chunk-H5N4ST6B.js";
+} from "./chunk-M7LLJQ7M.js";
 import {
   t
-} from "./chunk-4RMP4CNT.js";
+} from "./chunk-M23QBX3V.js";
 
 // src/mcp/config.ts
 import { createHash } from "crypto";

package/dist/{chunk-OB7FN66F.js → chunk-EONFDWBE.js}

@@ -35,8 +35,8 @@ function readSecret(prompt) {
   });
 }
 async function runLogin(providerId, cwd) {
-  const { runProviderCommand } = await import("./providerCli-TGDE3633.js");
-  const { parseCliArgs } = await import("./args-MNVI2OJI.js");
+  const { runProviderCommand } = await import("./providerCli-DDH4ZZUY.js");
+  const { parseCliArgs } = await import("./args-BD2PHEKG.js");
   return runProviderCommand(parseCliArgs(["provider", "add", providerId]), {
     env: process.env,
     cwd,

package/dist/{chunk-H66PC2EB.js → chunk-GGNXHJL6.js}

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
 import {
   reasoningPayload
-} from "./chunk-YURAIW7A.js";
+} from "./chunk-NI5JZUZ3.js";
 import {
   t
-} from "./chunk-4RMP4CNT.js";
+} from "./chunk-M23QBX3V.js";
 
 // src/provider.ts
 import OpenAI from "openai";

package/dist/chunk-HE33XAPZ.js

@@ -0,0 +1,341 @@
+#!/usr/bin/env node
+import {
+  defineTool
+} from "./chunk-PSO7R5AD.js";
+import {
+  t
+} from "./chunk-M23QBX3V.js";
+
+// src/tools/websearch.ts
+import { z } 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: z.object({
+      query: z.string().min(1).max(500).describe("Search query"),
+      max_results: z.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/fetch.ts
+import { lookup as dnsCbLookup } from "dns";
+import { lookup as dnsLookup } from "dns/promises";
+import { isIP } from "net";
+import { Agent, fetch as undiciFetch } from "undici";
+import { z as z2 } from "zod";
+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();
+  if (!reader) return { text: "", truncated: false };
+  const chunks = [];
+  let size = 0;
+  for (; ; ) {
+    const { done, value } = await reader.read();
+    if (done) return { text: Buffer.concat(chunks).toString("utf8"), truncated: false };
+    size += value.length;
+    if (size > MAX_BYTES) {
+      chunks.push(value.subarray(0, value.length - (size - MAX_BYTES)));
+      await reader.cancel();
+      return { text: Buffer.concat(chunks).toString("utf8"), truncated: true };
+    }
+    chunks.push(value);
+  }
+}
+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");
+}
+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 pinLookup(pinned) {
+  return (hostname, options, callback) => {
+    const opts = typeof options === "object" && options !== null ? options : {};
+    const family = typeof options === "number" ? options : opts.family;
+    const realDns = () => dnsCbLookup(hostname, typeof options === "number" ? { family: options } : opts, callback);
+    if (!pinned.length) return realDns();
+    const list = family ? pinned.filter((a) => a.family === family) : pinned;
+    if (!list.length) {
+      callback(Object.assign(new Error(`no pinned address for family ${family}`), { code: "ENOTFOUND" }), "");
+      return;
+    }
+    if (opts.all) callback(null, list);
+    else callback(null, list[0].address, list[0].family);
+  };
+}
+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;
+  const lookup = opts.lookup ?? ((hostname) => dnsLookup(hostname, { all: true }));
+  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: z2.object({
+      url: z2.string().describe("Absolute http(s) URL"),
+      prompt: z2.string().max(2e3).optional().describe("What to look for in the page; returns only the relevant excerpt"),
+      offset: z2.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);
+      let pinned;
+      if (!isPrivate(target.hostname) && isIP(target.hostname) === 0) {
+        try {
+          const addresses = await lookup(target.hostname);
+          const internal = addresses.find((a) => isPrivate(a.address));
+          if (internal) {
+            return {
+              output: t("Blocked: {host} resolves to a private address ({addr}). Fetching an internal host through a public DNS name is not allowed.", { host: target.hostname, addr: internal.address }),
+              isError: true
+            };
+          }
+          pinned = addresses;
+        } catch {
+        }
+      }
+      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, pinned, opts.fetchPage);
+        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, pinned, fetchPage) {
+  let url = new URL(inputUrl);
+  const dispatcher = pinned?.length ? new Agent({ connect: { lookup: pinLookup(pinned) } }) : void 0;
+  const doFetch = fetchPage ?? (dispatcher ? undiciFetch : fetch);
+  try {
+    let res;
+    for (let hop = 0; hop < 5; hop++) {
+      res = await doFetch(url, {
+        headers: { accept: ACCEPT },
+        signal: AbortSignal.any([signal, AbortSignal.timeout(3e4)]),
+        redirect: "manual",
+        ...dispatcher ? { dispatcher } : {}
+      });
+      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 { error: `Redirect to another host: ${next.href}. Call fetch again with that URL if needed (permission will be requested).` };
+      }
+      await res.body?.cancel();
+      url = next;
+    }
+    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() };
+  } catch (error) {
+    return { error: `Failed to fetch ${inputUrl}: ${describeFetchError(error)}` };
+  } finally {
+    await dispatcher?.close().catch(() => {
+    });
+  }
+}
+var fetchTool = createFetchTool();
+
+export {
+  isPrivateHost,
+  createFetchTool,
+  fetchTool,
+  createWebSearchTool
+};

package/dist/{chunk-HPZSXX4W.js → chunk-ISCT3PN3.js}

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
 import {
   ConfigError
-} from "./chunk-H5N4ST6B.js";
+} from "./chunk-M7LLJQ7M.js";
 import {
   t
-} from "./chunk-4RMP4CNT.js";
+} from "./chunk-M23QBX3V.js";
 
 // src/mcp/catalog.ts
 var CATALOG = [

package/dist/{chunk-C6PKRYUX.js → chunk-JROUQ5YS.js}

@@ -1,59 +1,21 @@
 #!/usr/bin/env node
+import {
+  listAllModels
+} from "./chunk-LN32JIZR.js";
 import {
   hasKey,
   providerName,
   removeGlobalProvider,
   writeGlobalConfig
-} from "./chunk-U66JJ6RN.js";
-import {
-  createProvider
-} from "./chunk-H66PC2EB.js";
+} from "./chunk-SESBH44L.js";
 import {
   PRESETS,
   loadConfig,
-  readCredentials,
   saveCredential
-} from "./chunk-H5N4ST6B.js";
+} from "./chunk-M7LLJQ7M.js";
 import {
   t
-} from "./chunk-4RMP4CNT.js";
-
-// src/models.ts
-function order(ids) {
-  const presetIds = PRESETS.map((p) => p.id);
-  const presets = presetIds.filter((id) => ids.includes(id));
-  const custom = ids.filter((id) => !presetIds.includes(id)).sort();
-  return [...presets, ...custom];
-}
-async function listAllModels(config, env = process.env, opts = {}) {
-  const timeoutMs = opts.timeoutMs ?? 5e3;
-  const baseFetch = opts.fetch ?? fetch;
-  const untrusted = new Set(config.projectProviders ?? []);
-  const ids = order(Object.keys(config.providers)).filter((id) => opts.only ? id === opts.only : !untrusted.has(id) && hasKey(config, id, env));
-  const results = await Promise.all(
-    ids.map(async (id) => {
-      const provider = config.providers[id];
-      const apiKey = (opts.keyOverride && id === opts.only ? opts.keyOverride : void 0) || (provider.apiKeyEnv ? env[provider.apiKeyEnv] : void 0) || readCredentials(env)[id] || void 0;
-      const local = !provider.apiKeyEnv;
-      const timedFetch = ((input, init) => baseFetch(input, { ...init, signal: AbortSignal.timeout(timeoutMs) }));
-      const list = createProvider({ baseURL: provider.baseURL.replace(/\/+$/, ""), apiKey, model: "", fetch: timedFetch }).listModels();
-      let timer;
-      const timeout = new Promise((_, reject) => {
-        timer = setTimeout(() => reject(new Error("timeout")), timeoutMs);
-      });
-      try {
-        const models = await Promise.race([list, timeout]);
-        return { providerId: id, providerName: providerName(config, id), models };
-      } catch {
-        if (local && !opts.only) return void 0;
-        return { providerId: id, providerName: providerName(config, id), models: [], error: t("could not be reached") };
-      } finally {
-        clearTimeout(timer);
-      }
-    })
-  );
-  return results.filter((g) => !!g);
-}
+} from "./chunk-M23QBX3V.js";
 
 // src/providerCli.ts
 async function addProviderKey(providerId, key, deps) {
@@ -109,7 +71,6 @@ async function runProviderCommand(args, deps) {
 }
 
 export {
-  listAllModels,
   addProviderKey,
   runProviderCommand
 };

package/dist/chunk-LN32JIZR.js

@@ -0,0 +1,56 @@
+#!/usr/bin/env node
+import {
+  hasKey,
+  providerName
+} from "./chunk-SESBH44L.js";
+import {
+  createProvider
+} from "./chunk-GGNXHJL6.js";
+import {
+  PRESETS,
+  readCredentials
+} from "./chunk-M7LLJQ7M.js";
+import {
+  t
+} from "./chunk-M23QBX3V.js";
+
+// src/models.ts
+function order(ids) {
+  const presetIds = PRESETS.map((p) => p.id);
+  const presets = presetIds.filter((id) => ids.includes(id));
+  const custom = ids.filter((id) => !presetIds.includes(id)).sort();
+  return [...presets, ...custom];
+}
+async function listAllModels(config, env = process.env, opts = {}) {
+  const timeoutMs = opts.timeoutMs ?? 5e3;
+  const baseFetch = opts.fetch ?? fetch;
+  const untrusted = new Set(config.projectProviders ?? []);
+  const ids = order(Object.keys(config.providers)).filter((id) => opts.only ? id === opts.only : !untrusted.has(id) && hasKey(config, id, env));
+  const results = await Promise.all(
+    ids.map(async (id) => {
+      const provider = config.providers[id];
+      const apiKey = (opts.keyOverride && id === opts.only ? opts.keyOverride : void 0) || (provider.apiKeyEnv ? env[provider.apiKeyEnv] : void 0) || readCredentials(env)[id] || void 0;
+      const local = !provider.apiKeyEnv;
+      const timedFetch = ((input, init) => baseFetch(input, { ...init, signal: AbortSignal.timeout(timeoutMs) }));
+      const list = createProvider({ baseURL: provider.baseURL.replace(/\/+$/, ""), apiKey, model: "", fetch: timedFetch }).listModels();
+      let timer;
+      const timeout = new Promise((_, reject) => {
+        timer = setTimeout(() => reject(new Error("timeout")), timeoutMs);
+      });
+      try {
+        const models = await Promise.race([list, timeout]);
+        return { providerId: id, providerName: providerName(config, id), models };
+      } catch {
+        if (local && !opts.only) return void 0;
+        return { providerId: id, providerName: providerName(config, id), models: [], error: t("could not be reached") };
+      } finally {
+        clearTimeout(timer);
+      }
+    })
+  );
+  return results.filter((g) => !!g);
+}
+
+export {
+  listAllModels
+};