@botconnector/bccli 0.4.0-beta.4 → 0.4.0-beta.40

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-UESQNU4A.js → chunk-ISCT3PN3.js}

@@ -1,23 +1,28 @@
 #!/usr/bin/env node
 import {
   ConfigError
-} from "./chunk-RZUJYAQV.js";
+} from "./chunk-M7LLJQ7M.js";
+import {
+  t
+} from "./chunk-M23QBX3V.js";
 
 // src/mcp/catalog.ts
 var CATALOG = [
-  { name: "playwright", description: "kontrol browser (buka halaman, klik, isi form, screenshot)", config: { command: "npx", args: ["-y", "@playwright/mcp@latest"] } },
-  { name: "context7", description: "dokumentasi library terbaru", config: { type: "http", url: "https://mcp.context7.com/mcp" } },
-  { name: "fetch", description: "ambil halaman web jadi markdown (butuh uv)", config: { command: "uvx", args: ["mcp-server-fetch"] } },
+  { name: "playwright", description: "control a browser (open pages, click, fill forms, screenshot)", config: { command: "npx", args: ["-y", "@playwright/mcp@latest"] } },
+  { name: "context7", description: "up-to-date library documentation", config: { type: "http", url: "https://mcp.context7.com/mcp" } },
+  { name: "fetch", description: "fetch web pages as markdown (needs uv)", config: { command: "uvx", args: ["mcp-server-fetch"] } },
   {
     name: "filesystem",
-    description: "akses folder di luar project",
+    description: "access folders outside the project",
+    // biome-ignore lint/suspicious/noTemplateCurlyInString: ${dir} is filled by fillTemplate, not a template literal
     config: { command: "npx", args: ["-y", "@modelcontextprotocol/server-filesystem", "${dir}"] },
-    inputs: [{ key: "dir", label: "Folder yang boleh diakses" }]
+    inputs: [{ key: "dir", label: "Folder the server may access" }]
   },
-  { name: "git", description: "operasi git terstruktur (butuh uv)", config: { command: "uvx", args: ["mcp-server-git"] } },
+  { name: "git", description: "structured git operations (needs uv)", config: { command: "uvx", args: ["mcp-server-git"] } },
   {
     name: "github",
-    description: "issue, PR, dan repo GitHub",
+    description: "GitHub issues, PRs, and repos",
+    // biome-ignore lint/suspicious/noTemplateCurlyInString: ${token} is filled by fillTemplate, not a template literal
     config: { type: "http", url: "https://api.githubcopilot.com/mcp/", headers: { Authorization: "Bearer ${token}" } },
     inputs: [{ key: "token", label: "GitHub Personal Access Token", secret: true }]
   }
@@ -35,7 +40,7 @@ function fillTemplate(config, values) {
     ...config.args ? { args: config.args.map(fill) } : {},
     ...config.env ? { env: mapValues(config.env) } : {}
   };
-  if (missing.size) throw new ConfigError(`Isian MCP belum lengkap: ${[...missing].join(", ")}`);
+  if (missing.size) throw new ConfigError(t("Missing MCP fields: {fields}", { fields: [...missing].join(", ") }));
   return out;
 }
 

package/dist/chunk-JROUQ5YS.js

@@ -0,0 +1,76 @@
+#!/usr/bin/env node
+import {
+  listAllModels
+} from "./chunk-LN32JIZR.js";
+import {
+  hasKey,
+  providerName,
+  removeGlobalProvider,
+  writeGlobalConfig
+} from "./chunk-SESBH44L.js";
+import {
+  PRESETS,
+  loadConfig,
+  saveCredential
+} from "./chunk-M7LLJQ7M.js";
+import {
+  t
+} from "./chunk-M23QBX3V.js";
+
+// src/providerCli.ts
+async function addProviderKey(providerId, key, deps) {
+  const config = loadConfig(deps.cwd, deps.env);
+  const [group] = await listAllModels(config, deps.env, { only: providerId, fetch: deps.fetch, keyOverride: key || void 0 });
+  if (!group || group.error) return { ok: false, error: t("The API key was rejected or {provider} could not be reached.", { provider: providerName(config, providerId) }) };
+  if (key) saveCredential(providerId, key, deps.env);
+  return { ok: true, models: group.models.length };
+}
+async function runProviderCommand(args, deps) {
+  const [action = "list", id] = args.subArgs;
+  const config = loadConfig(deps.cwd, deps.env);
+  if (action === "list") {
+    for (const pid of Object.keys(config.providers)) {
+      const mark = hasKey(config, pid, deps.env) ? "\u2713" : "\u25CB";
+      deps.out(`${mark} ${pid.padEnd(14)} ${providerName(config, pid).padEnd(20)} ${config.providers[pid].baseURL}`);
+    }
+    return 0;
+  }
+  if (!id) {
+    deps.err(t("Usage: bccli provider {action} <id>", { action }));
+    return 1;
+  }
+  if (action === "remove") {
+    removeGlobalProvider(id, deps.env);
+    deps.out(t("{id} removed.", { id }));
+    return 0;
+  }
+  if (action !== "add") {
+    deps.err(t("Unknown action: {action}. Use list, add, or remove.", { action }));
+    return 1;
+  }
+  const preset = PRESETS.find((p) => p.id === id);
+  if (!preset && !config.providers[id]) {
+    if (!args.url) {
+      deps.err(t("{id} is not a preset. For a custom provider add --url <OpenAI-compatible base URL>.", { id }));
+      return 1;
+    }
+    writeGlobalConfig(
+      { providers: { [id]: { baseURL: args.url, ...args.name ? { name: args.name } : {}, ...args.keyEnv ? { apiKeyEnv: args.keyEnv } : {} } } },
+      deps.env
+    );
+  }
+  const needsKey = !!loadConfig(deps.cwd, deps.env).providers[id].apiKeyEnv || !preset;
+  const key = needsKey ? await deps.readSecret(t("API key for {id} (leave empty if not needed): ", { id })) : "";
+  const result = await addProviderKey(id, key, deps);
+  if (!result.ok) {
+    deps.err(result.error);
+    return 1;
+  }
+  deps.out(t("{id} is ready. {n} models available.", { id, n: result.models }));
+  return 0;
+}
+
+export {
+  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
+};