@botconnector/bccli 0.5.0-rc.4 → 0.5.0

package/legacy/dist/update-5V425FIK.js

@@ -0,0 +1,145 @@
+#!/usr/bin/env node
+import {
+  VERSION
+} from "./chunk-XP5MTJN2.js";
+import {
+  t
+} from "./chunk-IDZLHEVL.js";
+
+// src/update.ts
+import { spawnSync } from "child_process";
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "fs";
+import { dirname, join } from "path";
+var REGISTRY_URL = "https://registry.npmjs.org/-/package/@botconnector/bccli/dist-tags";
+var CHECK_INTERVAL_MS = 24 * 60 * 60 * 1e3;
+function splitVersion(v) {
+  const i = v.indexOf("-");
+  const coreStr = i < 0 ? v : v.slice(0, i);
+  const preStr = i < 0 ? "" : v.slice(i + 1);
+  return {
+    core: coreStr.split(".").map((p) => Number.parseInt(p, 10) || 0),
+    pre: preStr ? preStr.split(".") : []
+  };
+}
+function compareVersions(a, b) {
+  const A = splitVersion(a);
+  const B = splitVersion(b);
+  for (let i = 0; i < Math.max(A.core.length, B.core.length); i++) {
+    const x = A.core[i] ?? 0;
+    const y = B.core[i] ?? 0;
+    if (x !== y) return x < y ? -1 : 1;
+  }
+  if (!A.pre.length && !B.pre.length) return 0;
+  if (!A.pre.length) return 1;
+  if (!B.pre.length) return -1;
+  for (let i = 0; i < Math.max(A.pre.length, B.pre.length); i++) {
+    const x = A.pre[i];
+    const y = B.pre[i];
+    if (x === void 0) return -1;
+    if (y === void 0) return 1;
+    const nx = Number.parseInt(x, 10);
+    const ny = Number.parseInt(y, 10);
+    if (String(nx) === x && String(ny) === y) {
+      if (nx !== ny) return nx < ny ? -1 : 1;
+    } else if (x !== y) {
+      return x < y ? -1 : 1;
+    }
+  }
+  return 0;
+}
+function channelFor(version) {
+  return version.includes("-") ? "next" : "latest";
+}
+function cachePath(home) {
+  return join(home, "update-check.json");
+}
+function readCache(home) {
+  try {
+    const parsed = JSON.parse(readFileSync(cachePath(home), "utf8"));
+    return typeof parsed?.checkedAt === "string" ? parsed : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function writeCache(home, cache) {
+  mkdirSync(home, { recursive: true });
+  const tmp = `${cachePath(home)}.tmp`;
+  writeFileSync(tmp, JSON.stringify(cache));
+  renameSync(tmp, cachePath(home));
+}
+function dueForCheck(cache, now, intervalMs = CHECK_INTERVAL_MS) {
+  if (!cache) return true;
+  const at = Date.parse(cache.checkedAt);
+  if (!Number.isFinite(at)) return true;
+  return now.getTime() - at >= intervalMs;
+}
+function updateNotice(current, latest) {
+  if (!latest || latest.length > 64 || !/^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/.test(latest) || compareVersions(current, latest) >= 0) return void 0;
+  return t("A new bccli is available: {latest} (you have {current}). Run: bccli update", { latest, current });
+}
+function notifyOnce(home, cache) {
+  const message = updateNotice(VERSION, cache?.latest);
+  if (!message || !cache?.latest || cache.notified === cache.latest) return void 0;
+  writeCache(home, { ...cache, notified: cache.latest });
+  return message;
+}
+async function checkForUpdate(deps) {
+  try {
+    const cached = readCache(deps.home);
+    if (!dueForCheck(cached, deps.now)) return notifyOnce(deps.home, cached);
+    const res = await deps.fetch(REGISTRY_URL, { signal: AbortSignal.timeout(deps.timeoutMs ?? 3e3) });
+    if (!res.ok) return notifyOnce(deps.home, cached);
+    const tags = await res.json();
+    const latest = tags[channelFor(VERSION)] ?? tags.latest;
+    const updated = { checkedAt: deps.now.toISOString(), latest, notified: cached?.notified };
+    writeCache(deps.home, updated);
+    return notifyOnce(deps.home, updated);
+  } catch {
+    return void 0;
+  }
+}
+function updateSpawnCommand(version, platform = process.platform, nodeExecPath = process.execPath, targetVersion) {
+  const spec = `@botconnector/bccli@${targetVersion ?? channelFor(version)}`;
+  if (platform !== "win32") return { command: "npm", args: ["i", "-g", spec] };
+  const npmCli = join(dirname(nodeExecPath), "node_modules", "npm", "bin", "npm-cli.js");
+  return { command: nodeExecPath, args: [npmCli, "i", "-g", spec], npmCli };
+}
+async function runUpdateCommand(deps) {
+  const current = deps.env.BCCLI_VERSION_OVERRIDE ?? VERSION;
+  let target;
+  try {
+    const response = await (deps.fetch ?? fetch)(REGISTRY_URL, {
+      signal: AbortSignal.timeout(8e3),
+      cache: "no-store",
+      headers: { "cache-control": "no-cache" }
+    });
+    if (!response.ok) throw new Error(`HTTP ${response.status}`);
+    const tags = await response.json();
+    target = tags[channelFor(current)];
+    if (!/^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/.test(target ?? "")) throw new Error("invalid registry version");
+  } catch (error) {
+    console.error(`Could not verify BCCLI update version: ${String(error)}. No changes made.`);
+    return 1;
+  }
+  if (compareVersions(target, current) <= 0) {
+    console.log(`BCCLI ${current} is already up to date (registry: ${target}); no changes made.`);
+    return 0;
+  }
+  const spec = updateSpawnCommand(current, deps.platform, deps.nodeExecPath, target);
+  if (spec.npmCli && !existsSync(spec.npmCli)) {
+    console.error(`npm CLI was not found at ${spec.npmCli}. Update manually with: npm install -g @botconnector/bccli@${channelFor(deps.env.BCCLI_VERSION_OVERRIDE ?? VERSION)}`);
+    return 1;
+  }
+  const r = (deps.spawn ?? spawnSync)(spec.command, spec.args, { stdio: "inherit", env: deps.env, shell: false });
+  if (r.error) console.error(`BCCLI update failed: ${r.error.message}. Try: npm install -g @botconnector/bccli@${channelFor(deps.env.BCCLI_VERSION_OVERRIDE ?? VERSION)}`);
+  return typeof r.status === "number" ? r.status : 1;
+}
+export {
+  channelFor,
+  checkForUpdate,
+  compareVersions,
+  dueForCheck,
+  runUpdateCommand,
+  updateNotice,
+  updateSpawnCommand
+};

package/legacy/dist/update.d.ts

@@ -0,0 +1,30 @@
+import { spawnSync } from 'node:child_process';
+export interface UpdateCache {
+    checkedAt: string;
+    latest?: string;
+    notified?: string;
+}
+/** Simplified semver: numeric cores, prerelease sorts below release, numeric prerelease parts compare numerically. */
+export declare function compareVersions(a: string, b: string): number;
+export declare function channelFor(version: string): 'next' | 'latest';
+export declare function dueForCheck(cache: UpdateCache | undefined, now: Date, intervalMs?: number): boolean;
+export declare function updateNotice(current: string, latest: string | undefined): string | undefined;
+/** Best-effort registry check with a 24h cache; never throws, never blocks startup for long. */
+export declare function checkForUpdate(deps: {
+    home: string;
+    fetch: typeof fetch;
+    now: Date;
+    timeoutMs?: number;
+}): Promise<string | undefined>;
+export declare function updateSpawnCommand(version: string, platform?: NodeJS.Platform, nodeExecPath?: string, targetVersion?: string): {
+    command: string;
+    args: string[];
+    npmCli?: string;
+};
+export declare function runUpdateCommand(deps: {
+    env: NodeJS.ProcessEnv;
+    spawn?: typeof spawnSync;
+    platform?: NodeJS.Platform;
+    nodeExecPath?: string;
+    fetch?: typeof fetch;
+}): Promise<number>;

package/legacy/dist/verify.d.ts

@@ -0,0 +1,16 @@
+import { runCommand } from './tools/bash';
+export interface VerifyFailure {
+    cmd: string;
+    exitCode: number;
+    output: string;
+}
+/** Fix rounds per user turn; keeps a failing verify command from looping forever. */
+export declare const MAX_VERIFY_ROUNDS = 2;
+export declare function runVerify(commands: string[], opts: {
+    cwd: string;
+    env: NodeJS.ProcessEnv;
+    signal: AbortSignal;
+    timeoutMs?: number;
+    run?: typeof runCommand;
+}): Promise<VerifyFailure[]>;
+export declare function verifyFollowup(failures: VerifyFailure[], maxBytes?: number): string;

package/legacy/dist/version.d.ts

@@ -0,0 +1 @@
+export declare const VERSION: string;

package/legacy/dist/webBudget.d.ts

@@ -0,0 +1,25 @@
+import type { ChatMessage } from './provider';
+export declare const isStub: (content: string) => boolean;
+/**
+ * Replaces old `fetch` results with a one-line stub, in one batch and only once they add up to more than
+ * PRUNE_MIN_TOKENS, so the prompt prefix (and its cache) changes rarely. The newest KEEP_TOKENS worth stay intact.
+ */
+export declare function pruneOldFetches(messages: ChatMessage[]): boolean;
+export interface WebBudgetLimits {
+    perTurn?: number;
+    sessionChars?: number;
+}
+export declare class WebBudget {
+    private fetches;
+    private chars;
+    private readonly perTurn;
+    private readonly sessionChars;
+    constructor(limits?: WebBudgetLimits);
+    startTurn(): void;
+    /** Gives back a reservation, e.g. when the fetch was served from cache and cost nothing. */
+    refund(): void;
+    reset(): void;
+    /** Reserves one fetch; returns the refusal to show the model when over budget. */
+    take(): string | undefined;
+    record(chars: number): void;
+}

package/legacy/dist/worktree.d.ts

@@ -0,0 +1,12 @@
+export interface WorktreePlan {
+    path: string;
+    created: boolean;
+}
+/**
+ * Resolve (creating when needed) the sibling worktree for `-w <name>`: always derived from the
+ * MAIN checkout, so running inside an existing worktree nests nothing. The returned path becomes
+ * the session cwd, so config, prompts, sessions, and permissions all follow it.
+ */
+export declare function resolveWorktree(cwd: string, name: string, bin?: string): Promise<WorktreePlan>;
+/** Read-only status for /worktree: what exists and how to remove it safely. */
+export declare function worktreeListText(cwd: string, bin?: string): Promise<string>;

package/legacy/package.json

@@ -0,0 +1,77 @@
+{
+  "name": "@botconnector/bccli",
+  "version": "0.4.17",
+  "description": "BCCLI — BotConnector AI coding agent for the terminal",
+  "type": "module",
+  "bin": {
+    "bccli": "dist/cli.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=22"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/farijarifriyanto-debug/bccli.git"
+  },
+  "license": "MIT",
+  "scripts": {
+    "build": "tsup && tsc -p tsconfig.build.json",
+    "typecheck": "tsc --noEmit",
+    "lint": "biome lint --error-on-warnings src test",
+    "test": "vitest run",
+    "coverage": "vitest run --coverage"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.32.1",
+    "diff": "^9.0.0",
+    "ink": "^8.0.0",
+    "openai": "^7.27.0",
+    "react": "^19.3.0",
+    "undici": "^8.12.1",
+    "ws": "^8.22.0",
+    "yaml": "^2.9.1",
+    "zod": "^4.6.5"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^2.5.14",
+    "@types/node": "^26.6.3",
+    "@types/react": "^19.3.0",
+    "@types/ws": "^8.18.2",
+    "@vitest/coverage-v8": "^5.0.5",
+    "ink-testing-library": "^4.0.0",
+    "tsup": "^9.0.0",
+    "typescript": "^7.0.2",
+    "vitest": "^5.0.2"
+  },
+  "overrides": {
+    "esbuild": "0.28.2"
+  },
+  "main": "dist/sdk.js",
+  "types": "dist/sdk.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/sdk.d.ts",
+      "default": "./dist/sdk.js"
+    }
+  },
+  "keywords": [
+    "bccli",
+    "ai",
+    "coding-agent",
+    "agent",
+    "cli",
+    "tui",
+    "terminal",
+    "mcp",
+    "openai",
+    "indonesia"
+  ],
+  "author": "BotConnector (https://botconnector.id)",
+  "bugs": {
+    "url": "https://github.com/farijarifriyanto-debug/bccli/issues"
+  },
+  "homepage": "https://github.com/farijarifriyanto-debug/bccli#readme"
+}

package/legacy-compat.mjs

@@ -0,0 +1,42 @@
+// Stable CLI compatibility bridge. There is only one user-visible executable:
+// bccli. Explicit legacy commands continue to use the original BCCLI 0.4.17
+// implementation bundled within the same distribution. Never reinterpret a
+// legacy subcommand as a chargeable AI prompt.
+import { spawn } from 'node:child_process'
+import { existsSync } from 'node:fs'
+import { fileURLToPath } from 'node:url'
+
+const LEGACY_COMMANDS = new Set([
+  'login', 'logout', 'mcp', 'connect', 'disconnect', 'integrations',
+  'update', 'serve', 'acp', 'plugins', 'gh-bot', 'completion',
+  'stats', 'export', 'import', 'pr',
+])
+const LEGACY_OPTIONS = new Set([
+  '--output-format', '--fail-on-tool-error', '--allow-all',
+  '--allowed-tools', '--reasoning', '--lang', '--permission-mode',
+  '--worktree', '-w', '--fallback-model', '--base-url',
+])
+
+export function legacyCompatibilityMode(argv) {
+  if (!Array.isArray(argv) || argv.length === 0) return false
+  if (LEGACY_COMMANDS.has(argv[0])) return true
+  // Explicit flags from BCCLI 0.4.17 preserve that version's exact
+  // semantics, rather than silently mapping to the new engine.
+  if (argv.some(arg => LEGACY_OPTIONS.has(arg) || [...LEGACY_OPTIONS].some(flag => arg.startsWith(flag + '=')))) return true
+  // The old provider CLI permits custom providers, whereas the new CLI
+  // accepts only fixed HTTPS presets. Keep the legacy route explicit.
+  if (argv[0] === 'provider' && argv[1] === 'add' && argv.some(arg => ['--url','--name','--key-env'].includes(arg))) return true
+  return false
+}
+
+export async function runLegacyCli(argv, { spawnImpl = spawn, node = process.execPath, env = process.env, cwd = process.cwd() } = {}) {
+  const entrypoint = fileURLToPath(new URL('./legacy/dist/cli.js', import.meta.url))
+  if (spawnImpl === spawn && !existsSync(entrypoint)) throw Error('Bundled BCCLI compatibility files are missing; reinstall the release package. No AI request was sent.')
+  const child = spawnImpl(node, [entrypoint, ...argv], {
+    cwd, env, stdio: 'inherit', shell: false, windowsHide: false,
+  })
+  return new Promise((resolve, reject) => {
+    child.once('error', reject)
+    child.once('exit', (code, signal) => resolve(code ?? (signal ? 130 : 1)))
+  })
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@botconnector/bccli",
-  "version": "0.5.0-rc.4",
-  "description": "BCCLI | BotConnector coding agent powered by Qwen Code",
+  "version": "0.5.0",
+  "description": "BCCLI | BotConnector multi-provider coding agent with stable CLI/SDK compatibility",
   "type": "module",
   "bin": {
     "bccli": "./cli.mjs"
@@ -10,6 +10,15 @@
     "node": ">=22"
   },
   "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.32.1",
+    "diff": "^9.0.0",
+    "ink": "^8.0.0",
+    "openai": "^7.27.0",
+    "react": "^19.3.0",
+    "undici": "^8.12.1",
+    "ws": "^8.22.0",
+    "yaml": "^2.9.1",
+    "zod": "^4.6.5",
     "@qwen-code/qwen-code": "0.26.3"
   },
   "scripts": {
@@ -21,6 +30,7 @@
   },
   "license": "Apache-2.0",
   "overrides": {
+    "esbuild": "0.28.2",
     "sharp": "0.35.5"
   },
   "files": [
@@ -35,17 +45,27 @@
     "model-command.mjs",
     "providers.mjs",
     "provider-cli.mjs",
-    "startup-menu.mjs"
+    "startup-menu.mjs",
+    "legacy-compat.mjs",
+    "legacy"
   ],
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/farijarifriyanto-debug/bccli-qwen-engine.git"
+    "url": "git+https://github.com/farijarifriyanto-debug/bccli-runtime.git"
   },
   "homepage": "https://github.com/farijarifriyanto-debug/bccli#readme",
   "bugs": {
     "url": "https://github.com/farijarifriyanto-debug/bccli/issues"
   },
   "author": "BICO Inovasi Digital / BotConnector",
+  "main": "./legacy/dist/sdk.js",
+  "types": "./legacy/dist/sdk.d.ts",
+  "exports": {
+    ".": {
+      "types": "./legacy/dist/sdk.d.ts",
+      "default": "./legacy/dist/sdk.js"
+    }
+  },
   "publishConfig": {
     "access": "public",
     "tag": "next"

package/provider-cli.mjs

@@ -57,8 +57,7 @@ export async function runProviderCommand(words, {
   }
   providerDefinition(id)
   if (action === 'add') {
-    if (id === 'botconnector') throw Error('For BotConnector, use the existing "bccli-legacy login bc-cloud".')
-    out('Provider: ' + PROVIDERS[id].name + ' (direct API; provider billing and terms apply).')
+    out('Provider: ' + PROVIDERS[id].name + ' (API use may incur charges; entering a key does not send an AI prompt).')
     const key = await getKey()
     save(id, key)
     select(id,{env})

package/providers.mjs

@@ -40,7 +40,7 @@ function ownerDirectory(root, { create = false } = {}) {
   return true
 }
 function keyPath(root, id) {
-  if (!ID.test(id) || id === 'botconnector') throw Error('Provider key storage requires a supported non-BotConnector provider.')
+  if (!ID.test(id)) throw Error('Provider key storage requires a supported provider.')
   return join(root, 'provider-' + id + '.dpapi')
 }
 function dpapi(script, input, { platform = process.platform, runner = spawnSync } = {}) {
@@ -54,7 +54,6 @@ function dpapi(script, input, { platform = process.platform, runner = spawnSync
 }
 export function saveProviderKey(id, key, { root = providerRoot(), platform = process.platform, runner = spawnSync } = {}) {
   providerDefinition(id)
-  if (id === 'botconnector') throw Error('Use bccli-legacy login bc-cloud or BOTCONNECTOR_API_KEY for BotConnector credentials.')
   if (typeof key !== 'string' || !key.trim() || key.length > 8192 || /[\r\n]/.test(key)) throw Error('API key cannot be empty, multiline, or oversized.')
   if (platform !== 'win32') throw Error('On non-Windows systems, use the provider API key environment variable.')
   ownerDirectory(root, { create: true })
@@ -70,7 +69,6 @@ export function saveProviderKey(id, key, { root = providerRoot(), platform = pro
 }
 export function storedProviderKey(id, { root = providerRoot(), platform = process.platform, runner = spawnSync } = {}) {
   providerDefinition(id)
-  if (id === 'botconnector') throw Error('BotConnector credentials are managed by public BCCLI.')
   if (!ownerDirectory(root)) throw Error('Provider not configured. Run provider add.')
   const path = keyPath(root, id)
   let info
@@ -83,7 +81,16 @@ export function storedProviderKey(id, { root = providerRoot(), platform = proces
 }
 export function isConfigured(id, { env = process.env, root = providerRoot({env}) } = {}) {
   providerDefinition(id)
-  if (id === 'botconnector') return botConnectorCredentialStatus({ env }).configured
+  if (id === 'botconnector') {
+    if (env.BOTCONNECTOR_API_KEY?.trim()) return true
+    try {
+      if (ownerDirectory(root)) {
+        const info = lstatSync(keyPath(root, id))
+        if (info.isFile() && !info.isSymbolicLink() && info.size <= MAX_BLOB_BYTES) return true
+      }
+    } catch {}
+    return botConnectorCredentialStatus({ env }).configured
+  }
   if (env[PROVIDERS[id].env]?.trim()) return true
   try { return ownerDirectory(root) && lstatSync(keyPath(root, id)).isFile() && !lstatSync(keyPath(root, id)).isSymbolicLink() }
   catch { return false }
@@ -138,7 +145,6 @@ export function useProvider(id, { env = process.env, root = providerRoot({env})
 }
 export function removeProvider(id, { env = process.env, root = providerRoot({env}) } = {}) {
   providerDefinition(id)
-  if (id === 'botconnector') throw Error('BotConnector credentials are managed by bccli-legacy or BOTCONNECTOR_API_KEY.')
   if (!ownerDirectory(root)) return
   const path = keyPath(root, id)
   if (existsSync(path)) {
@@ -152,7 +158,14 @@ export function removeProvider(id, { env = process.env, root = providerRoot({env
 }
 export function resolveProvider(id, { env = process.env, root = providerRoot({env}) } = {}) {
   const info = providerDefinition(id)
-  if (id === 'botconnector') return { id, ...info, key: botConnectorKey({env}) }
+  if (id === 'botconnector') {
+    // Saved keys take precedence; legacy credentials are read only as fallback.
+    try { return { id, ...info, key: storedProviderKey(id, { root }) } }
+    catch (error) {
+      if (error?.message !== 'Provider not configured. Run provider add.') throw error
+      return { id, ...info, key: botConnectorKey({ env }) }
+    }
+  }
   // An explicit key saved through "provider add" must win over stale environment
   // variables. Never silently fall back if the encrypted file is corrupted.
   let key

package/startup-menu.mjs

@@ -74,22 +74,19 @@ export async function startupMenu({
     providerId = selectedName(value, ids, active)
     if (!providerId) { out('Pilihan provider tidak dikenal.'); continue }
     replace = value.endsWith('!')
-    if (providerId === 'botconnector' && replace) {
-      out('Gunakan bccli-legacy login bc-cloud untuk mengubah key BotConnector lama; key tidak akan diubah dari menu ini.')
-      continue
-    }
     break
   }
-  if ((replace || !configured(providerId)) && providerId !== 'botconnector') {
+  let pendingKey
+  if (replace || !configured(providerId)) {
     out('Masukkan API key ' + PROVIDERS[providerId].name + ' (input tersembunyi).')
-    const key = await askSecret()
-    // A cancel or missing key cannot silently select an unusable provider.
-    if (!key) throw Error('Tidak ada API key; provider tidak diubah.')
-    saveKey(providerId, key)
-    out('API key disimpan terlindungi untuk akun Windows. Tidak ada request AI.')
+    pendingKey = await askSecret()
+    if (!pendingKey) throw Error('Tidak ada API key; provider tidak diubah.')
   }
-  if (!configured(providerId)) throw Error('Provider ' + providerId + ' belum memiliki API key. Tidak ada permintaan AI.')
-  const profile = resolve(providerId)
+  if (!pendingKey && !configured(providerId)) throw Error('Provider ' + providerId + ' belum memiliki API key. Tidak ada permintaan AI.')
+  // Validate before saving so a bad replacement never destroys a working key.
+  const profile = pendingKey
+    ? { id: providerId, key: pendingKey, endpoint: PROVIDERS[providerId].endpoint }
+    : resolve(providerId)
   const models = await list({ key: profile.key, endpoint: profile.endpoint })
   if (!models.length) throw Error('Tidak ada model untuk provider ini.')
   const all = [...models].sort((a, b) => a.id.localeCompare(b.id))
@@ -112,7 +109,11 @@ export async function startupMenu({
     const candidate = !value ? preferred : /^[0-9]+$/.test(value) ? filtered[Number(value) - 1]?.id : value
     if (!candidate || !all.some(m => m.id === candidate)) { out('Pilih nomor atau ID model yang tampil.'); continue }
     selectModel(all, candidate)
-    // Save active provider only after valid credentials and model are confirmed.
+    // Save only after authenticated model discovery and selection.
+    if (pendingKey) {
+      saveKey(providerId, pendingKey)
+      out('API key tersimpan terlindungi. Tidak ada permintaan chat AI.')
+    }
     use(providerId)
     saveModel(providerId, candidate)
     return { providerId, model: candidate, key: profile.key, endpoint: profile.endpoint }