@botconnector/bccli 0.5.0-rc.4 → 0.5.0

package/legacy/dist/acp-HWHF25KU.js

@@ -0,0 +1,221 @@
+#!/usr/bin/env node
+import {
+  t
+} from "./chunk-IDZLHEVL.js";
+
+// src/acp.ts
+var ACP_PROTOCOL_VERSION = 1;
+var TOOL_KINDS = {
+  read: "read",
+  repo_map: "read",
+  edit: "edit",
+  write: "edit",
+  grep: "search",
+  glob: "search",
+  bash: "execute",
+  powershell: "execute",
+  fetch: "fetch",
+  web_search: "fetch"
+};
+var kindOf = (tool) => TOOL_KINDS[tool] ?? "other";
+var titleOf = (tool, target) => (target ? `${tool}: ${target}` : tool).slice(0, 200);
+var MAX_OUTPUT = 4e3;
+var PERMISSION_OPTIONS = [
+  { optionId: "allow", name: "Allow", kind: "allow_once" },
+  { optionId: "allow_session", name: "Allow for this session", kind: "allow_always" },
+  { optionId: "reject", name: "Reject", kind: "reject_once" }
+];
+var ANSWERS = { allow: "yes", allow_session: "session", reject: "no" };
+function runAcp(input, output, opts) {
+  const sessions = /* @__PURE__ */ new Map();
+  const awaiting = /* @__PURE__ */ new Map();
+  let nextSession = 1;
+  let nextRequest = 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 update = (sessionId, body) => write({ jsonrpc: "2.0", method: "session/update", params: { sessionId, update: body } });
+  const ioFor = (sid, session) => ({
+    onThinking(delta) {
+      update(sid, { sessionUpdate: "agent_thought_chunk", content: { type: "text", text: delta } });
+    },
+    toolStart(id, tool, target) {
+      session.open.push({ id, tool, target });
+      update(sid, { sessionUpdate: "tool_call", toolCallId: id, title: titleOf(tool, target), kind: kindOf(tool), status: "in_progress", rawInput: { target } });
+    },
+    toolEnd(id, output2, isError) {
+      session.open = session.open.filter((c) => c.id !== id);
+      const text = output2.length > MAX_OUTPUT ? `${output2.slice(0, MAX_OUTPUT)}
+[truncated]` : output2;
+      update(sid, {
+        sessionUpdate: "tool_call_update",
+        toolCallId: id,
+        status: isError ? "failed" : "completed",
+        ...text ? { content: [{ type: "content", content: { type: "text", text } }] } : {}
+      });
+    },
+    askPermission(req) {
+      return new Promise((resolve) => {
+        const requestId = nextRequest++;
+        const call = [...session.open].reverse().find((c) => c.tool === req.tool && c.target === req.target);
+        const settle = (answer) => {
+          session.pending.delete(settle);
+          awaiting.delete(requestId);
+          resolve(answer);
+        };
+        session.pending.add(settle);
+        awaiting.set(requestId, (message) => {
+          const outcome = message.result?.outcome;
+          settle(outcome?.outcome === "selected" ? ANSWERS[outcome.optionId ?? ""] ?? "no" : "no");
+        });
+        write({
+          jsonrpc: "2.0",
+          id: requestId,
+          method: "session/request_permission",
+          params: {
+            sessionId: sid,
+            toolCall: { toolCallId: call?.id ?? `permission-${requestId}`, title: titleOf(req.tool, req.target), kind: kindOf(req.tool), status: "pending" },
+            options: PERMISSION_OPTIONS
+          }
+        });
+      });
+    }
+  });
+  const handle = async (msg) => {
+    const { id, method, params } = msg ?? {};
+    if (method === void 0 && id !== void 0 && (msg.result !== void 0 || msg.error !== void 0)) {
+      awaiting.get(id)?.(msg);
+      return;
+    }
+    if (method === "initialize") {
+      return reply(id, {
+        protocolVersion: ACP_PROTOCOL_VERSION,
+        agentCapabilities: {
+          loadSession: false,
+          promptCapabilities: { image: false, audio: false, embeddedContext: true }
+        }
+      });
+    }
+    if (method === "session/new") {
+      const sessionId = `s${nextSession++}`;
+      sessions.set(sessionId, { controller: null, pending: /* @__PURE__ */ new Set(), open: [] });
+      return reply(id, { sessionId });
+    }
+    if (method === "session/cancel") {
+      const session = sessions.get(params?.sessionId ?? "");
+      session?.controller?.abort();
+      for (const settle of [...session?.pending ?? []]) settle("no");
+      return;
+    }
+    if (method === "session/prompt") {
+      const sid = params?.sessionId ?? "";
+      const session = sessions.get(sid);
+      if (!session) return replyError(id, -32602, "Unknown session");
+      if (session.controller) return replyError(id, -32e3, "Session is busy");
+      const text = (params?.prompt ?? []).map((p) => {
+        if (p?.type === "text") return String(p.text ?? "");
+        if ((p?.type === "resource" || p?.type === "embeddedContext") && p.resource?.text) {
+          const label = p.resource.uri ? `
+[${p.resource.uri}]
+` : "\n";
+          return `${label}${p.resource.text}`;
+        }
+        return "";
+      }).filter(Boolean).join("\n");
+      const controller = new AbortController();
+      session.controller = controller;
+      let cancelled = false;
+      controller.signal.addEventListener("abort", () => {
+        cancelled = true;
+      });
+      try {
+        session.agent ??= opts.newAgent(params?.cwd ?? opts.cwd);
+        await session.agent.run(text, (chunk) => update(sid, { sessionUpdate: "agent_message_chunk", content: { type: "text", text: chunk } }), controller.signal, ioFor(sid, session));
+      } catch (e) {
+        if (cancelled) return reply(id, { stopReason: "cancelled" });
+        return replyError(id, -32603, e.message);
+      } finally {
+        if (session.controller === controller) {
+          session.controller = null;
+          session.open = [];
+        }
+      }
+      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);
+      for (const session of sessions.values()) {
+        session.controller?.abort();
+        for (const settle of [...session.pending]) settle("no");
+      }
+      resolve();
+    };
+    input.on("data", onData);
+    input.on("end", onEnd);
+  });
+}
+function planDecisionFrom(answer) {
+  if (answer === "no") return "no";
+  if (answer === "session") return "acceptEdits";
+  return "default";
+}
+function runtimeAgent(cwd, allowAll = false, deps = {}) {
+  let rt;
+  return {
+    async run(text, onChunk, signal, io) {
+      if (!rt) {
+        if (deps.createRuntime) rt = deps.createRuntime({ cwd, allowAll });
+        else {
+          const { parseCliArgs } = await import("./args-XA77XUMD.js");
+          const { createRuntime } = await import("./setup-3YB6EKYX.js");
+          rt = createRuntime({ cwd, args: { ...parseCliArgs([]), allowAll } });
+        }
+      }
+      if (io && !allowAll) {
+        rt.agent.askPermission = (req) => io.askPermission(req);
+        rt.interaction.approvePlan = async (plan) => planDecisionFrom(await io.askPermission({ tool: "exit_plan", kind: "edit", target: t("plan"), preview: plan }));
+      }
+      let turnError;
+      rt.agent.onEvent = (event) => {
+        if (event.type === "text") onChunk(event.delta);
+        else if (event.type === "thinking") io?.onThinking?.(event.delta);
+        else if (event.type === "toolStart") io?.toolStart(event.id, event.tool, event.target);
+        else if (event.type === "toolEnd") io?.toolEnd(event.id, event.output, event.isError);
+        else if (event.type === "error") turnError = event.message;
+        else if (event.type === "budgetExceeded") turnError = `Budget exceeded (${event.kind})`;
+      };
+      await rt.agent.run(text, signal);
+      if (turnError) throw new Error(turnError);
+    }
+  };
+}
+export {
+  ACP_PROTOCOL_VERSION,
+  planDecisionFrom,
+  runAcp,
+  runtimeAgent
+};

package/legacy/dist/acp.d.ts

@@ -0,0 +1,44 @@
+import type { PermissionAnswer, PermissionAsk } from './agent';
+import type { Runtime } from './setup';
+import type { PlanDecision } from './tools/plan';
+export declare const ACP_PROTOCOL_VERSION = 1;
+/** What the agent reports to the editor besides text: tool calls, and permission questions the editor answers. */
+export interface AcpIo {
+    toolStart(id: string, tool: string, target: string): void;
+    toolEnd(id: string, output: string, isError: boolean): void;
+    askPermission(req: PermissionAsk): Promise<PermissionAnswer>;
+    onThinking?(delta: string): void;
+}
+/** The minimum an ACP client needs: run one prompt, stream text chunks, allow cancellation. */
+export interface AcpAgent {
+    run(text: string, onChunk: (text: string) => void, signal: AbortSignal, io?: AcpIo): Promise<void>;
+}
+/**
+ * Agent Client Protocol over newline-delimited JSON-RPC (the transport editors like Zed use).
+ * Implements the subset: initialize, session/new, session/prompt (streaming session/update
+ * notifications: text chunks and tool calls), session/request_permission, session/cancel;
+ * anything else with an id gets -32601.
+ */
+export declare function runAcp(input: NodeJS.ReadableStream, output: NodeJS.WritableStream, opts: {
+    cwd: string;
+    newAgent: (cwd: string) => AcpAgent;
+}): Promise<void>;
+/**
+ * A plan has no ACP primitive of its own, so it is asked through session/request_permission.
+ * 'yes' approves and keeps the normal per-tool prompts; 'session' also stops asking for edits
+ * for the rest of the session (acceptEdits). A plan answer never turns on allowAll, which stays
+ * an explicit user choice.
+ */
+export declare function planDecisionFrom(answer: PermissionAnswer): PlanDecision;
+export interface AcpRuntimeDeps {
+    /** Test seam: build the runtime without reading config/plugins. */
+    createRuntime?: (opts: {
+        cwd: string;
+        allowAll: boolean;
+    }) => Runtime;
+}
+/**
+ * Production agent: one bccli runtime per ACP session. Permission questions go to the editor
+ * (session/request_permission); `allowAll` skips them and runs everything unasked.
+ */
+export declare function runtimeAgent(cwd: string, allowAll?: boolean, deps?: AcpRuntimeDeps): AcpAgent;

package/legacy/dist/agent.d.ts

@@ -0,0 +1,158 @@
+import type { PermissionRequest, Permissions } from './permissions';
+import { type ChatMessage, type Provider, type Usage } from './provider';
+import type { ReasoningLevel } from './reasoning';
+import { type HookEvent, type HooksConfig } from './hooks';
+import type { Tool } from './tools/types';
+import { type UsageCap } from './budget';
+export type AgentEvent = {
+    type: 'text';
+    delta: string;
+} | {
+    type: 'thinking';
+    delta: string;
+} | {
+    type: 'textReplace';
+    text: string;
+} | {
+    type: 'toolStart';
+    id: string;
+    tool: string;
+    target: string;
+} | {
+    type: 'toolEnd';
+    id: string;
+    tool: string;
+    output: string;
+    display?: string;
+    isError: boolean;
+} | {
+    type: 'usage';
+    inputTokens: number;
+    outputTokens: number;
+    cachedInputTokens?: number;
+    cacheWriteTokens?: number;
+    /** Prompt tokens of the most recent model call: the size of the context, not the session total. */
+    lastInputTokens?: number;
+    /** Cache reads for the most recent model call, rather than the session total. */
+    lastCachedInputTokens?: number;
+    /** True when the provider omitted usage and token counts use the local chars/4 estimate. */
+    estimated?: boolean;
+} | {
+    type: 'compacted';
+} | {
+    type: 'stepLimit';
+    maxSteps: number;
+} | {
+    type: 'budgetExceeded';
+    kind: 'tokens' | 'usd';
+    used: number;
+    limit: number;
+} | {
+    type: 'aborted';
+} | {
+    type: 'error';
+    message: string;
+} | {
+    type: 'done';
+} | {
+    type: 'subagent';
+    parentId: string;
+    agent: string;
+    event: AgentEvent;
+};
+export type PermissionAnswer = 'yes' | 'session' | 'all' | 'no';
+export type PermissionAsk = PermissionRequest & {
+    preview?: string;
+    sessionRules?: string[];
+    agent?: string;
+};
+export type AskPermission = (req: PermissionAsk) => Promise<PermissionAnswer>;
+export interface AgentOptions {
+    provider: Provider;
+    tools: Tool[];
+    permissions: Permissions;
+    systemPrompt: string;
+    cwd: string;
+    history?: ChatMessage[];
+    maxSteps?: number | null;
+    contextWindow?: number;
+    onMessage?: (message: ChatMessage) => void;
+    onReset?: () => void;
+    /** Per-turn token usage delta (provider-reported or estimated); the session persists it for stats. */
+    onUsage?: (usage: Usage) => void;
+    /** Marks the start of a user turn (undo boundary). */
+    onTurnStart?: () => void;
+    checkpoint?: (absPath: string) => Promise<void>;
+    /** Subagent name, shown on its permission prompts. */
+    label?: string;
+    reasoning?: ReasoningLevel;
+    /** Tool/session hooks (global config only). */
+    hooks?: HooksConfig;
+    /** In-process plugin observers fired alongside the shell hooks (global config plugins). */
+    pluginEmit?: (event: HookEvent, payload?: {
+        tool?: string;
+        input?: unknown;
+        output?: string;
+    }) => Promise<void>;
+    /** Base environment handed to hook processes (defaults to the process env at spawn). */
+    env?: NodeJS.ProcessEnv;
+    /** Per-session token/USD budget (global config usageCap); blocks model calls once exceeded. */
+    usageCap?: UsageCap;
+    /** Model ref used to match usageCap.prices keys. */
+    budgetModel?: string;
+}
+export declare class Agent {
+    private readonly opts;
+    provider: Provider;
+    permissions: Permissions;
+    messages: ChatMessage[];
+    totalUsage: Usage;
+    lastInputTokens: number;
+    lastInputEstimated: boolean;
+    onEvent: (event: AgentEvent) => void;
+    reasoning: ReasoningLevel;
+    askPermission: AskPermission;
+    tools: Tool[];
+    private definitions;
+    private turnTools;
+    private turnDefinitions;
+    readonly readFiles: Set<string>;
+    private readonly webBudget;
+    private readonly maxSteps?;
+    private contextWindow;
+    private budgetModel;
+    private systemPrompt;
+    constructor(opts: AgentOptions);
+    setSystemPrompt(text: string): void;
+    setContextWindow(window: number): void;
+    getContextWindow(): number;
+    setBudgetModel(model: string): void;
+    getBudgetModel(): string;
+    setTools(tools: Tool[]): void;
+    private isParallelSafe;
+    private push;
+    private estimateCurrentInputTokens;
+    private seedEstimatedContext;
+    /** Publish the latest context after prompt/history changes, without changing session usage totals. */
+    private publishContextMetadata;
+    /** Swaps in another conversation (resume, new session) without writing to the session log. */
+    load(messages: ChatMessage[]): void;
+    clear(): void;
+    compact(signal: AbortSignal): Promise<void>;
+    /**
+     * 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).
+     */
+    private report;
+    run(text: string, signal: AbortSignal): Promise<void>;
+    /** Current cap status; undefined means the budget is not exhausted. */
+    private overBudget;
+    /** Every tool call needs an answer in the history, or the next request to the model is rejected. */
+    private cancelCalls;
+    /**
+     * Every tool call must resolve with text: a rejected one would leave the assistant tool_calls
+     * without answers, and the next request to the model would be rejected until a restart.
+     */
+    private runTool;
+    private executeTool;
+}

package/legacy/dist/agents.d.ts

@@ -0,0 +1,4 @@
+import type { AgentDef } from './extensions';
+export declare const EXPLORE_PROMPT = "You are a read-only research agent working for another agent. Search and read the codebase to answer the request. You cannot edit files or run commands. Reply with a concise report: the answer, the relevant file paths with line numbers, and nothing else.";
+export declare const GENERAL_PROMPT = "You are an agent handling a delegated task for another agent. Complete the task end to end with the tools you have, verify the result, and reply with a short report of what you did and what you found.";
+export declare const BUILTIN_AGENTS: AgentDef[];

package/legacy/dist/args-XA77XUMD.js

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+import {
+  helpText,
+  parseCliArgs
+} from "./chunk-M5T4AM4I.js";
+import "./chunk-YYTFJUO2.js";
+import "./chunk-NGFWBVHD.js";
+import "./chunk-ZXWRLN7E.js";
+import "./chunk-IDZLHEVL.js";
+export {
+  helpText,
+  parseCliArgs
+};

package/legacy/dist/args.d.ts

@@ -0,0 +1,59 @@
+import { type PermissionMode } from './config';
+import { type ReasoningLevel } from './reasoning';
+import { type Lang } from './i18n';
+export interface CliArgs {
+    command: 'run' | 'login' | 'models' | 'update' | 'acp' | 'serve' | 'plugins' | 'gh-bot' | 'provider' | 'mcp' | 'connect' | 'disconnect' | 'integrations' | 'completion' | 'stats' | 'export' | 'import' | 'pr';
+    subArgs: string[];
+    url?: string;
+    /** `bccli mcp add <name> --command <cmd>`: server stdio, bukan HTTP. */
+    stdioCommand?: string;
+    /** Argumen untuk server stdio (dipisah spasi). */
+    stdioArgs?: string;
+    name?: string;
+    keyEnv?: string;
+    values: string[];
+    prompt?: string;
+    print: boolean;
+    model?: string;
+    reasoning?: ReasoningLevel;
+    lang?: Lang;
+    continue: boolean;
+    resume: boolean;
+    allowAll: boolean;
+    /** `-p` untuk CI: kegagalan tool apa pun membuat exit code 1. */
+    failOnToolError: boolean;
+    allowedTools: string[];
+    worktree?: string;
+    outputFormat?: 'text' | 'json' | 'stream-json';
+    permissionMode?: PermissionMode;
+    help: boolean;
+    version: boolean;
+    loginProvider?: string;
+    /** `bccli login` — pakai prompt API key lama, bukan OAuth. */
+    key: boolean;
+    /** `bccli login` — hapus credential tersimpan (hanya openrouter via OAuth path). */
+    logout: boolean;
+    /** `bccli serve` listener port (0 = ephemeral). */
+    port?: number;
+    /** `bccli serve` bind address — loopback only. */
+    host?: string;
+    /** `bccli serve` bearer token override. */
+    token?: string;
+    /** Base URL override for `bccli mcp serve`. */
+    baseUrl?: string;
+    /** `bccli stats` — only count sessions from the last N days (default 7). */
+    days?: number;
+    /** `bccli stats` - cap the tool-usage list to the top N tools. */
+    tools?: number;
+    /** `bccli stats [--models [N|all]]` - show per-model token usage (top N or all). */
+    models?: string;
+    /** `bccli stats --project <slug>` - filter rows; empty string = current project. */
+    project?: string;
+    /** `bccli pr` — explicit owner/name repo when cwd is not a git checkout of the PR. */
+    repo?: string;
+    /** Automatic fallback model ref when the primary model fails with 429 or 5xx. */
+    fallbackModel?: string;
+}
+/** Help text in the current language (call it after the language is set). */
+export declare const helpText: () => string;
+export declare function parseCliArgs(argv: string[]): CliArgs;

package/legacy/dist/budget.d.ts

@@ -0,0 +1,26 @@
+export interface UsageCap {
+    /** Total tokens (input + output) per session. */
+    tokens?: number;
+    /** Total USD per session; requires `prices`. */
+    usd?: number;
+    /** USD per 1M tokens. `cachedInput` is optional: without it cache reads cost the input price. */
+    prices?: Record<string, {
+        input: number;
+        output: number;
+        cachedInput?: number;
+    }>;
+}
+export declare function priceFor(cap: UsageCap, model: string): {
+    input: number;
+    output: number;
+    cachedInput?: number;
+} | undefined;
+export declare function budgetStatus(usage: {
+    inputTokens: number;
+    outputTokens: number;
+    cachedInputTokens?: number;
+}, cap: UsageCap | undefined, model: string): {
+    kind: 'tokens' | 'usd';
+    used: number;
+    limit: number;
+} | undefined;

package/legacy/dist/checkpoints.d.ts

@@ -0,0 +1,35 @@
+interface UndoResult {
+    restored: string[];
+    deleted: string[];
+    skipped: string[];
+    failed: string[];
+}
+export declare class CheckpointStore {
+    private readonly history;
+    private current;
+    private pendingRedo;
+    private offset;
+    beginTurn(): void;
+    /** Call before writing a file; only the first snapshot per file per turn is kept. */
+    snapshot(path: string): Promise<void>;
+    turns(): number;
+    /** Total entries including empty ones; used to align file snapshots with conversation turns. */
+    entries(): number;
+    undo(): Promise<UndoResult | undefined>;
+    /**
+     * Revert every snapshot taken at or after the `keep`-th entry, newest first, so the files
+     * end in the state from before the turn that created entry `keep`. Used by /rewind, which
+     * pairs conversation turns with the entry count recorded when each turn started.
+     */
+    undoTo(keep: number): Promise<UndoResult | undefined>;
+    /**
+     * Re-apply the file state captured right before the last undo/undoTo.
+     * Only file edits are redone, never conversation history. Invalidated by
+     * any new snapshot turn or clear(), so redo can't resurrect stale content.
+     */
+    redo(): Promise<UndoResult | undefined>;
+    /** Records the on-disk state of a turn's paths so redo() can put it back. */
+    private captureFor;
+    clear(): void;
+}
+export {};

package/legacy/dist/chunk-2IP5F3EK.js

@@ -0,0 +1,56 @@
+#!/usr/bin/env node
+import {
+  hasKey,
+  providerName
+} from "./chunk-FY543EQW.js";
+import {
+  createProvider
+} from "./chunk-OCEQ2TRJ.js";
+import {
+  PRESETS,
+  readCredentials
+} from "./chunk-ZXWRLN7E.js";
+import {
+  t
+} from "./chunk-IDZLHEVL.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) || readCredentials(env)[id] || (provider.apiKeyEnv ? env[provider.apiKeyEnv] : void 0) || 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
+};