@ashx-j/lunr 0.2.21 → 0.2.22

package/dist/node-runtime/chunk-GS66LV4M.js

@@ -0,0 +1,2830 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+import {
+  require_proper_lockfile
+} from "./chunk-URD2SLIT.js";
+import {
+  getShellConfig
+} from "./chunk-CSFI6YXL.js";
+import {
+  clearPlanUsageCache
+} from "./chunk-2MI5OPMN.js";
+import {
+  VERSION,
+  getAgentDir,
+  getPackageDir,
+  normalizePath
+} from "./chunk-FQMM2EZ2.js";
+import {
+  __toESM
+} from "./chunk-BRJX2PRC.js";
+
+// packages/coding-agent/dist/core/model-runtime.js
+import { dirname as dirname5, join as join7 } from "node:path";
+import { createModels, lazyStream as lazyStream2, ModelsError } from "@ashx-j/lunr-ai";
+import * as builtinProviderCatalog from "@ashx-j/lunr-ai/providers/all";
+
+// packages/coding-agent/dist/core/auth-storage.js
+var import_proper_lockfile = __toESM(require_proper_lockfile(), 1);
+import { chmodSync, existsSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "fs";
+import { dirname, join } from "path";
+
+// packages/coding-agent/dist/core/resolve-config-value.js
+import { execSync, spawnSync } from "child_process";
+var commandResultCache = /* @__PURE__ */ new Map(), ENV_VAR_NAME_RE = /^[A-Za-z_][A-Za-z0-9_]*$/, ENV_VAR_NAME_PREFIX_RE = /^[A-Za-z_][A-Za-z0-9_]*/;
+function appendLiteral(parts, value) {
+  if (!value)
+    return;
+  let previousPart = parts[parts.length - 1];
+  if (previousPart?.type === "literal") {
+    previousPart.value += value;
+    return;
+  }
+  parts.push({ type: "literal", value });
+}
+function parseConfigValueTemplate(config) {
+  let parts = [], index = 0;
+  for (; index < config.length; ) {
+    let dollarIndex = config.indexOf("$", index);
+    if (dollarIndex < 0) {
+      appendLiteral(parts, config.slice(index));
+      break;
+    }
+    appendLiteral(parts, config.slice(index, dollarIndex));
+    let nextChar = config[dollarIndex + 1];
+    if (nextChar === "$" || nextChar === "!") {
+      appendLiteral(parts, nextChar), index = dollarIndex + 2;
+      continue;
+    }
+    if (nextChar === "{") {
+      let endIndex = config.indexOf("}", dollarIndex + 2);
+      if (endIndex < 0) {
+        appendLiteral(parts, "$"), index = dollarIndex + 1;
+        continue;
+      }
+      let name = config.slice(dollarIndex + 2, endIndex);
+      ENV_VAR_NAME_RE.test(name) ? parts.push({ type: "env", name }) : appendLiteral(parts, config.slice(dollarIndex, endIndex + 1)), index = endIndex + 1;
+      continue;
+    }
+    let match = config.slice(dollarIndex + 1).match(ENV_VAR_NAME_PREFIX_RE);
+    if (match) {
+      parts.push({ type: "env", name: match[0] }), index = dollarIndex + 1 + match[0].length;
+      continue;
+    }
+    appendLiteral(parts, "$"), index = dollarIndex + 1;
+  }
+  return parts;
+}
+function parseConfigValueReference(config) {
+  return config.startsWith("!") ? { type: "command", config } : { type: "template", parts: parseConfigValueTemplate(config) };
+}
+function resolveEnvConfigValue(name, env) {
+  return env?.[name] || process.env[name] || void 0;
+}
+function getTemplateEnvVarNames(parts) {
+  let names = [];
+  for (let part of parts)
+    part.type !== "env" || names.includes(part.name) || names.push(part.name);
+  return names;
+}
+function resolveTemplate(parts, env) {
+  let resolved = "";
+  for (let part of parts) {
+    if (part.type === "literal") {
+      resolved += part.value;
+      continue;
+    }
+    let envValue = resolveEnvConfigValue(part.name, env);
+    if (envValue === void 0)
+      return;
+    resolved += envValue;
+  }
+  return resolved;
+}
+function getConfigValueEnvVarNames(config) {
+  let reference = parseConfigValueReference(config);
+  return reference.type === "template" ? getTemplateEnvVarNames(reference.parts) : [];
+}
+function getMissingConfigValueEnvVarNames(config, env) {
+  return getConfigValueEnvVarNames(config).filter((name) => resolveEnvConfigValue(name, env) === void 0);
+}
+function isCommandConfigValue(config) {
+  return parseConfigValueReference(config).type === "command";
+}
+function isConfigValueConfigured(config, env) {
+  return getMissingConfigValueEnvVarNames(config, env).length === 0;
+}
+function resolveConfigValue(config, env) {
+  let reference = parseConfigValueReference(config);
+  return reference.type === "command" ? executeCommand(reference.config) : resolveTemplate(reference.parts, env);
+}
+function executeWithConfiguredShell(command) {
+  try {
+    let { shell, args, commandTransport } = getShellConfig(), commandFromStdin = commandTransport === "stdin", result = spawnSync(shell, commandFromStdin ? args : [...args, command], {
+      encoding: "utf-8",
+      input: commandFromStdin ? command : void 0,
+      timeout: 1e4,
+      stdio: [commandFromStdin ? "pipe" : "ignore", "pipe", "ignore"],
+      shell: !1,
+      windowsHide: !0
+    });
+    return result.error ? result.error.code === "ENOENT" ? { executed: !1, value: void 0 } : { executed: !0, value: void 0 } : result.status !== 0 ? { executed: !0, value: void 0 } : { executed: !0, value: (result.stdout ?? "").trim() || void 0 };
+  } catch {
+    return { executed: !1, value: void 0 };
+  }
+}
+function executeWithDefaultShell(command) {
+  try {
+    return execSync(command, {
+      encoding: "utf-8",
+      timeout: 1e4,
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim() || void 0;
+  } catch {
+    return;
+  }
+}
+function executeCommandUncached(commandConfig) {
+  let command = commandConfig.slice(1);
+  return process.platform === "win32" ? (() => {
+    let configuredResult = executeWithConfiguredShell(command);
+    return configuredResult.executed ? configuredResult.value : executeWithDefaultShell(command);
+  })() : executeWithDefaultShell(command);
+}
+function executeCommand(commandConfig) {
+  if (commandResultCache.has(commandConfig))
+    return commandResultCache.get(commandConfig);
+  let result = executeCommandUncached(commandConfig);
+  return commandResultCache.set(commandConfig, result), result;
+}
+function resolveConfigValueUncached(config, env) {
+  let reference = parseConfigValueReference(config);
+  return reference.type === "command" ? executeCommandUncached(reference.config) : resolveTemplate(reference.parts, env);
+}
+function resolveConfigValueOrThrow(config, description, env) {
+  let resolvedValue = resolveConfigValueUncached(config, env);
+  if (resolvedValue !== void 0)
+    return resolvedValue;
+  let reference = parseConfigValueReference(config);
+  if (reference.type === "command")
+    throw new Error(`Failed to resolve ${description} from shell command: ${reference.config.slice(1)}`);
+  if (reference.type === "template") {
+    let missingEnvVars = getMissingConfigValueEnvVarNames(config, env);
+    if (missingEnvVars.length === 1)
+      throw new Error(`Failed to resolve ${description} from environment variable: ${missingEnvVars[0]}`);
+    if (missingEnvVars.length > 1)
+      throw new Error(`Failed to resolve ${description} from environment variables: ${missingEnvVars.join(", ")}`);
+  }
+  throw new Error(`Failed to resolve ${description}`);
+}
+function resolveHeadersOrThrow(headers, description, env) {
+  if (!headers)
+    return;
+  let resolved = {};
+  for (let [key, value] of Object.entries(headers))
+    resolved[key] = resolveConfigValueOrThrow(value, `${description} header "${key}"`, env);
+  return Object.keys(resolved).length > 0 ? resolved : void 0;
+}
+
+// packages/coding-agent/dist/core/auth-storage.js
+var AUTH_FILE_WRITE_OPTIONS = { encoding: "utf-8", mode: 384 }, AUTH_LOCK_STALE_MS = 12e4;
+function writeAuthFileAtomic(authPath, contents) {
+  let tmp = `${authPath}.${process.pid}.${Date.now()}.tmp`;
+  writeFileSync(tmp, contents, AUTH_FILE_WRITE_OPTIONS);
+  try {
+    chmodSync(tmp, 384);
+  } catch {
+  }
+  try {
+    if (process.platform === "win32" && existsSync(authPath)) {
+      writeFileSync(authPath, contents, AUTH_FILE_WRITE_OPTIONS), chmodSync(authPath, 384);
+      return;
+    }
+    renameSync(tmp, authPath);
+    try {
+      chmodSync(authPath, 384);
+    } catch {
+    }
+  } finally {
+    try {
+      unlinkSync(tmp);
+    } catch {
+    }
+  }
+}
+var FileAuthStorageBackend = class {
+  authPath;
+  constructor(authPath = join(getAgentDir(), "auth.json")) {
+    this.authPath = normalizePath(authPath);
+  }
+  ensureParentDir() {
+    let dir = dirname(this.authPath);
+    existsSync(dir) || mkdirSync(dir, { recursive: !0, mode: 448 });
+  }
+  ensureFileExists() {
+    existsSync(this.authPath) || (writeFileSync(this.authPath, "{}", AUTH_FILE_WRITE_OPTIONS), chmodSync(this.authPath, 384));
+  }
+  acquireLockSyncWithRetry(path) {
+    let lastError;
+    for (let attempt = 1; attempt <= 10; attempt++)
+      try {
+        return import_proper_lockfile.default.lockSync(path, { realpath: !1, stale: AUTH_LOCK_STALE_MS });
+      } catch (error) {
+        if ((typeof error == "object" && error !== null && "code" in error ? String(error.code) : void 0) !== "ELOCKED" || attempt === 10)
+          throw error;
+        lastError = error;
+        let start = Date.now();
+        for (; Date.now() - start < 20; )
+          ;
+      }
+    throw lastError ?? new Error("Failed to acquire auth storage lock");
+  }
+  withLock(fn) {
+    this.ensureParentDir(), this.ensureFileExists();
+    let release;
+    try {
+      release = this.acquireLockSyncWithRetry(this.authPath);
+      let current = existsSync(this.authPath) ? readFileSync(this.authPath, "utf-8") : void 0, { result, next } = fn(current);
+      return next !== void 0 && writeAuthFileAtomic(this.authPath, next), result;
+    } finally {
+      release && release();
+    }
+  }
+  async withLockAsync(fn) {
+    this.ensureParentDir(), this.ensureFileExists();
+    let release, lockCompromised = !1, lockCompromisedError, throwIfCompromised = () => {
+      if (lockCompromised)
+        throw lockCompromisedError ?? new Error("Auth storage lock was compromised");
+    };
+    try {
+      release = await import_proper_lockfile.default.lock(this.authPath, {
+        retries: {
+          retries: 10,
+          factor: 2,
+          minTimeout: 100,
+          maxTimeout: 1e4,
+          randomize: !0
+        },
+        stale: AUTH_LOCK_STALE_MS,
+        onCompromised: (err) => {
+          lockCompromised = !0, lockCompromisedError = err;
+        }
+      }), throwIfCompromised();
+      let current = existsSync(this.authPath) ? readFileSync(this.authPath, "utf-8") : void 0, { result, next } = await fn(current);
+      return throwIfCompromised(), next !== void 0 && writeAuthFileAtomic(this.authPath, next), throwIfCompromised(), result;
+    } finally {
+      if (release)
+        try {
+          await release();
+        } catch {
+        }
+    }
+  }
+}, InMemoryAuthStorageBackend = class {
+  value;
+  withLock(fn) {
+    let { result, next } = fn(this.value);
+    return next !== void 0 && (this.value = next), result;
+  }
+  async withLockAsync(fn) {
+    let { result, next } = await fn(this.value);
+    return next !== void 0 && (this.value = next), result;
+  }
+}, AuthStorage = class _AuthStorage {
+  data = {};
+  storage;
+  constructor(storage) {
+    this.storage = storage, this.reload();
+  }
+  static create(authPath) {
+    return new _AuthStorage(new FileAuthStorageBackend(authPath ?? join(getAgentDir(), "auth.json")));
+  }
+  static fromStorage(storage) {
+    return new _AuthStorage(storage);
+  }
+  static inMemory(data = {}) {
+    let storage = new InMemoryAuthStorageBackend();
+    return storage.withLock(() => ({ result: void 0, next: JSON.stringify(data, null, 2) })), _AuthStorage.fromStorage(storage);
+  }
+  parseStorageData(content) {
+    return content ? JSON.parse(content) : {};
+  }
+  /**
+   * Reload credentials from storage.
+   */
+  reload() {
+    let content;
+    try {
+      this.storage.withLock((current) => (content = current, { result: void 0 })), this.data = this.parseStorageData(content);
+    } catch {
+    }
+  }
+  async read(provider) {
+    let credential = this.data[provider];
+    return credential?.type !== "api_key" || credential.key === void 0 ? credential : { ...credential, key: resolveConfigValue(credential.key, credential.env) };
+  }
+  async modify(provider, fn) {
+    return this.storage.withLockAsync(async (content) => {
+      let currentData = this.parseStorageData(content), next = await fn(currentData[provider]);
+      if (next === void 0)
+        return this.data = currentData, { result: currentData[provider] };
+      let merged = { ...currentData, [provider]: next };
+      return this.data = merged, { result: next, next: JSON.stringify(merged, null, 2) };
+    });
+  }
+  async delete(provider) {
+    await this.storage.withLockAsync(async (content) => {
+      let currentData = this.parseStorageData(content);
+      return delete currentData[provider], this.data = currentData, { result: void 0, next: JSON.stringify(currentData, null, 2) };
+    });
+  }
+  /** List credential metadata without resolving configured key values. */
+  async list() {
+    return Object.entries(this.data).map(([providerId, credential]) => ({ providerId, type: credential.type }));
+  }
+};
+function readStoredCredential(providerId, authPath = join(getAgentDir(), "auth.json")) {
+  try {
+    return JSON.parse(readFileSync(normalizePath(authPath), "utf-8"))[providerId];
+  } catch {
+    return;
+  }
+}
+
+// packages/coding-agent/dist/core/catalog-cache-scope.js
+import { createHash } from "node:crypto";
+function catalogCacheScope(provider, baseUrl, credential) {
+  let identity = credential?.type === "oauth" ? typeof credential.accountId == "string" ? credential.accountId : credential.refresh || credential.access : credential?.key;
+  return createHash("sha256").update(JSON.stringify([provider, baseUrl.replace(/\/+$/, ""), identity ?? null])).digest("hex");
+}
+
+// packages/coding-agent/dist/core/catalog-merge.js
+import { withOpenAiEffortMetadata, withXaiEffortMetadata } from "@ashx-j/lunr-ai";
+
+// packages/coding-agent/dist/core/official-catalog.js
+import { createHash as createHash2, randomUUID } from "node:crypto";
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, renameSync as renameSync2, unlinkSync as unlinkSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { dirname as dirname2, join as join2 } from "node:path";
+import { fileURLToPath } from "node:url";
+
+// packages/coding-agent/dist/utils/pi-user-agent.js
+function getPiUserAgent(version) {
+  let runtime = process.versions.bun ? `bun/${process.versions.bun}` : `node/${process.version}`;
+  return `pi/${version} (${process.platform}; ${runtime}; ${process.arch})`;
+}
+
+// packages/coding-agent/dist/core/official-catalog.js
+var OFFICIAL_CATALOG_DEFAULT_URL = "https://raw.githubusercontent.com/ashx-j/lunR/master/catalog", VERSIONED_CATALOG_URL = "https://raw.githubusercontent.com/ashx-j/lunR/model-catalog/catalog", OFFICIAL_CATALOG_TIMEOUT_MS = 4e3, OFFICIAL_CATALOG_CACHE_FILENAME = "official-catalog-cache.json", THINKING_LEVEL_KEYS = ["off", "minimal", "low", "medium", "high", "xhigh", "max"], META_KEYS = /* @__PURE__ */ new Set(["version", "updatedAt", "generatedAt", "sourceCommit", "providerCount", "modelCount"]), BUNDLED_OFFICIAL_CATALOG = {
+  version: 1,
+  updatedAt: "2026-08-15T00:00:00Z",
+  models: [
+    {
+      id: "grok-4.6",
+      name: "Grok 4.6",
+      api: "openai-completions",
+      provider: "xai",
+      baseUrl: "https://api.x.ai/v1",
+      reasoning: !0,
+      input: ["text", "image"],
+      cost: { input: 2, output: 6, cacheRead: 0.5, cacheWrite: 0 },
+      contextWindow: 5e5,
+      maxTokens: 5e5
+    }
+  ]
+};
+function officialCatalogCachePath(agentDir = getAgentDir()) {
+  return join2(agentDir, OFFICIAL_CATALOG_CACHE_FILENAME);
+}
+function officialCatalogBaseUrl(override) {
+  return ((override ?? process.env.LUNR_OFFICIAL_CATALOG_URL)?.trim() || OFFICIAL_CATALOG_DEFAULT_URL).replace(/\/+$/, "");
+}
+function officialCatalogUrlFor(path, base) {
+  let normalized = path.replace(/^\/+/, "");
+  return `${officialCatalogBaseUrl(base)}/${normalized}`;
+}
+function modelKey(provider, id) {
+  return `${provider}/${id}`;
+}
+function isRecord(value) {
+  return typeof value == "object" && value !== null && !Array.isArray(value);
+}
+function asFiniteNumber(value) {
+  if (typeof value == "number" && Number.isFinite(value))
+    return value;
+  if (typeof value == "string" && value.trim()) {
+    let parsed = Number(value);
+    if (Number.isFinite(parsed))
+      return parsed;
+  }
+}
+function parseCost(value) {
+  if (!isRecord(value))
+    return;
+  let input = asFiniteNumber(value.input), output = asFiniteNumber(value.output);
+  if (!(input === void 0 || output === void 0))
+    return {
+      input,
+      output,
+      cacheRead: asFiniteNumber(value.cacheRead) ?? 0,
+      cacheWrite: asFiniteNumber(value.cacheWrite) ?? 0,
+      ...Array.isArray(value.tiers) ? {
+        tiers: value.tiers.flatMap((tier) => {
+          if (!isRecord(tier) || !(typeof tier.inputTokensAbove == "number" && tier.inputTokensAbove >= 0))
+            return [];
+          let rates = parseCost({
+            input: tier.input,
+            output: tier.output,
+            cacheRead: tier.cacheRead,
+            cacheWrite: tier.cacheWrite
+          });
+          return rates ? [{ ...rates, inputTokensAbove: tier.inputTokensAbove }] : [];
+        })
+      } : {}
+    };
+}
+function parseInput(value) {
+  if (!Array.isArray(value))
+    return;
+  let input = [];
+  for (let entry of value)
+    (entry === "text" || entry === "image") && input.push(entry);
+  return input.length > 0 ? input : void 0;
+}
+function parseThinkingLevelMap(value) {
+  if (!isRecord(value))
+    return;
+  let map = {}, any = !1;
+  for (let level of THINKING_LEVEL_KEYS) {
+    let mapped = value[level];
+    (mapped === null || typeof mapped == "string") && (map[level] = mapped, any = !0);
+  }
+  return any ? map : void 0;
+}
+function parseHeaders(value) {
+  if (!isRecord(value))
+    return;
+  let headers = {};
+  for (let [name, headerValue] of Object.entries(value))
+    typeof headerValue == "string" && (headers[name] = headerValue);
+  return Object.keys(headers).length > 0 ? headers : void 0;
+}
+function parseOfficialEntry(value) {
+  if (!isRecord(value))
+    return;
+  let id = typeof value.id == "string" ? value.id.trim() : "", provider = typeof value.provider == "string" ? value.provider.trim() : "";
+  if (!id || !provider)
+    return;
+  let api = typeof value.api == "string" && value.api.trim() ? value.api.trim() : "openai-completions", name = typeof value.name == "string" && value.name.trim() ? value.name.trim() : id, baseUrl = typeof value.baseUrl == "string" ? value.baseUrl.trim() : "", cost = parseCost(value.cost) ?? { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 }, input = parseInput(value.input) ?? ["text"], compat = isRecord(value.compat) ? value.compat : void 0, thinkingLevelMap = parseThinkingLevelMap(value.thinkingLevelMap), headers = parseHeaders(value.headers);
+  return {
+    id,
+    ...isRecord(value.catalog) && value.catalog.source === "provider" && Array.isArray(value.catalog.supplied) ? { catalog: value.catalog } : {},
+    name,
+    api,
+    provider,
+    baseUrl,
+    reasoning: value.reasoning === !0,
+    input,
+    cost,
+    contextWindow: asFiniteNumber(value.contextWindow) ?? 128e3,
+    maxTokens: asFiniteNumber(value.maxTokens) ?? 8192,
+    ...compat ? { compat } : {},
+    ...thinkingLevelMap ? { thinkingLevelMap } : {},
+    ...headers ? { headers } : {}
+  };
+}
+function catalogFile(models, value) {
+  let version = value ? asFiniteNumber(value.version) ?? 1 : 1, updatedAt = value && typeof value.updatedAt == "string" && value.updatedAt.trim() ? value.updatedAt : "";
+  return { version, updatedAt, models };
+}
+function parseKeyedCatalog(value) {
+  let models = [];
+  for (let [key, entry] of Object.entries(value))
+    if (!(META_KEYS.has(key) || !isRecord(entry))) {
+      if (typeof entry.id == "string") {
+        let parsed = parseOfficialEntry(entry);
+        parsed && models.push(parsed);
+        continue;
+      }
+      for (let [modelId, model] of Object.entries(entry)) {
+        if (!isRecord(model))
+          continue;
+        let parsed = parseOfficialEntry({
+          ...model,
+          id: typeof model.id == "string" && model.id.trim() ? model.id : modelId,
+          provider: typeof model.provider == "string" && model.provider.trim() ? model.provider : key
+        });
+        parsed && models.push(parsed);
+      }
+    }
+  return models.length > 0 ? catalogFile(models, value) : void 0;
+}
+function parseOfficialCatalog(value) {
+  if (isRecord(value)) {
+    if (Array.isArray(value.models)) {
+      let models = [];
+      for (let entry of value.models) {
+        let parsed = parseOfficialEntry(entry);
+        parsed && models.push(parsed);
+      }
+      return catalogFile(models, value);
+    }
+    if (!("models" in value))
+      return parseKeyedCatalog(value);
+  }
+}
+function parseProviderIndex(value) {
+  if (!(!Array.isArray(value) || !value.every((entry) => typeof entry == "string")))
+    return value;
+}
+function readCatalogFile(path) {
+  try {
+    return existsSync2(path) ? parseOfficialCatalog(JSON.parse(readFileSync2(path, "utf-8"))) : void 0;
+  } catch {
+    return;
+  }
+}
+function bundledCatalogCandidates() {
+  let here = dirname2(fileURLToPath(new URL("../core/official-catalog.js", import.meta.url).href)), packageDir = getPackageDir();
+  return [
+    join2(packageDir, "dist", "catalog", "models.json"),
+    join2(packageDir, "..", "..", "catalog", "models.json"),
+    join2(here, "../../../../catalog/models.json"),
+    join2(packageDir, "catalog", "models.json"),
+    join2(here, "../catalog/models.json"),
+    join2(here, "models.json"),
+    join2(packageDir, "dist", "catalog", "official-models.json"),
+    join2(packageDir, "..", "..", "catalog", "official-models.json"),
+    join2(here, "../../../../catalog/official-models.json"),
+    join2(here, "official-models.json"),
+    join2(here, "../catalog/official-models.json")
+  ];
+}
+function loadBundledOfficialCatalog() {
+  for (let path of bundledCatalogCandidates()) {
+    let parsed = readCatalogFile(path);
+    if (parsed)
+      return parsed;
+  }
+  return BUNDLED_OFFICIAL_CATALOG;
+}
+function loadCachedOfficialCatalog(cachePath) {
+  if (cachePath)
+    return readCatalogFile(cachePath);
+}
+function writeOfficialCatalogCache(catalog, cachePath) {
+  let temporary = `${cachePath}.${randomUUID()}.tmp`;
+  try {
+    mkdirSync2(dirname2(cachePath), { recursive: !0, mode: 448 }), writeFileSync2(temporary, `${JSON.stringify(catalog, null, 2)}
+`, { encoding: "utf-8", mode: 384 }), renameSync2(temporary, cachePath);
+  } catch {
+  } finally {
+    try {
+      unlinkSync2(temporary);
+    } catch {
+    }
+  }
+}
+function officialModelsByProvider(catalog) {
+  let byProvider = /* @__PURE__ */ new Map();
+  for (let model of catalog.models) {
+    let list = byProvider.get(model.provider) ?? [];
+    list.push(model), byProvider.set(model.provider, list);
+  }
+  return byProvider;
+}
+function mergeOfficialCatalogByProvider(base, replacements, updatedAt) {
+  let byProvider = officialModelsByProvider(base);
+  for (let [providerId, models] of replacements)
+    byProvider.set(providerId, models);
+  return {
+    version: base.version || 1,
+    updatedAt: updatedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+    models: [...byProvider.values()].flat()
+  };
+}
+function officialCatalogBase(bundled, cachePath) {
+  let cached = loadCachedOfficialCatalog(cachePath);
+  return cached ? mergeOfficialCatalogByProvider(bundled, officialModelsByProvider(cached), cached.updatedAt) : bundled;
+}
+function preferOfficialCatalog(previous, next) {
+  return next.source === "github" ? next : previous?.source === "github" ? { ...previous, errors: next.errors } : next;
+}
+function officialModelKeys(catalog) {
+  return new Set(catalog.models.map((model) => modelKey(model.provider, model.id)));
+}
+var ZERO_COST = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
+function officialEntryToModel(entry, template) {
+  return {
+    catalog: entry.catalog,
+    id: entry.id,
+    name: entry.name,
+    api: entry.api || template?.api || "openai-completions",
+    provider: entry.provider,
+    baseUrl: entry.baseUrl || template?.baseUrl || "",
+    reasoning: entry.reasoning,
+    input: entry.input.length > 0 ? entry.input : template?.input ?? ["text"],
+    cost: entry.cost ?? template?.cost ?? ZERO_COST,
+    contextWindow: entry.contextWindow,
+    maxTokens: entry.maxTokens,
+    compat: entry.compat ?? template?.compat,
+    thinkingLevelMap: entry.thinkingLevelMap ?? template?.thinkingLevelMap,
+    headers: entry.headers ?? template?.headers
+  };
+}
+function resolveBundledCatalog(bundled) {
+  return bundled || loadBundledOfficialCatalog();
+}
+function fallbackCatalog(bundled, cachePath) {
+  let cached = loadCachedOfficialCatalog(cachePath);
+  if (cached)
+    return { catalog: cached, source: "cache" };
+  let resolved = resolveBundledCatalog(bundled);
+  return resolved.models.length > 0 ? { catalog: resolved, source: "bundled" } : { catalog: BUNDLED_OFFICIAL_CATALOG, source: "bundled" };
+}
+async function fetchJson(url, options) {
+  let controller = new AbortController(), timer = setTimeout(() => controller.abort(), options.timeoutMs), onParentAbort = () => controller.abort();
+  options.signal?.addEventListener("abort", onParentAbort, { once: !0 }), options.signal?.aborted && controller.abort();
+  try {
+    let abortError = () => {
+      let error = new Error("The operation was aborted");
+      return error.name = "AbortError", error;
+    };
+    return await Promise.race([
+      (async () => {
+        let response = await options.fetchImpl(url, {
+          headers: options.headers,
+          signal: controller.signal
+        });
+        return response.ok ? { ok: !0, value: await response.json() } : { ok: !1, status: response.status };
+      })(),
+      new Promise((_, reject) => {
+        controller.signal.addEventListener("abort", () => reject(abortError()), { once: !0 }), controller.signal.aborted && reject(abortError());
+      })
+    ]);
+  } catch {
+    return { ok: !1 };
+  } finally {
+    clearTimeout(timer), options.signal?.removeEventListener("abort", onParentAbort);
+  }
+}
+async function loadOfficialCatalog(options = {}) {
+  let cachePath = options.cachePath;
+  if (!options.allowNetwork)
+    return fallbackCatalog(options.bundled, cachePath);
+  let bundled = resolveBundledCatalog(options.bundled), timeoutMs = options.timeoutMs ?? OFFICIAL_CATALOG_TIMEOUT_MS, fetchImpl = options.fetchImpl ?? fetch, headers = {
+    accept: "application/json",
+    "User-Agent": getPiUserAgent(VERSION)
+  }, fetchOptions = { timeoutMs, signal: options.signal, fetchImpl, headers }, unavailable = () => ({
+    ...fallbackCatalog(bundled, cachePath),
+    errors: Object.fromEntries((options.providerIds ?? []).map((id) => [id, "Published catalog unavailable; using cached metadata"]))
+  }), base = options.url ?? officialCatalogBaseUrl(), manifest;
+  if (!options.url && !process.env.LUNR_OFFICIAL_CATALOG_URL) {
+    let result = await fetchJson(`${VERSIONED_CATALOG_URL}/publication.json`, fetchOptions);
+    result.ok && isRecord(result.value) && result.value.version === 2 && typeof result.value.revision == "string" && /^sha256-[a-f0-9]{64}$/.test(result.value.revision) && isRecord(result.value.shards) && parseProviderIndex(result.value.providers) && (manifest = result.value, base = `${VERSIONED_CATALOG_URL}/snapshots/${result.value.revision}`);
+  }
+  try {
+    let indexResult = manifest ? { ok: !0, value: manifest.providers } : await fetchJson(officialCatalogUrlFor("providers.json", base), fetchOptions);
+    if (!indexResult.ok)
+      return unavailable();
+    let index = parseProviderIndex(indexResult.value);
+    if (!index)
+      return unavailable();
+    let wanted = new Set(index), shardIds = (options.providerIds ?? []).filter((providerId) => wanted.has(providerId));
+    if (shardIds.length === 0)
+      return fallbackCatalog(bundled, cachePath);
+    let replacements = /* @__PURE__ */ new Map(), errors = {};
+    if (await Promise.all(shardIds.map(async (providerId) => {
+      let result = await fetchJson(officialCatalogUrlFor(`providers/${encodeURIComponent(providerId)}.json`, base), fetchOptions);
+      if (!result.ok) {
+        errors[providerId] = "Catalog shard unavailable; using cached metadata";
+        return;
+      }
+      if (manifest && manifest.shards[providerId] !== createHash2("sha256").update(JSON.stringify(result.value)).digest("hex")) {
+        errors[providerId] = "Catalog shard checksum mismatch; using cached metadata";
+        return;
+      }
+      let parsed = parseOfficialCatalog(result.value);
+      if (!parsed || parsed.models.length === 0 || parsed.models.some((model) => model.provider !== providerId)) {
+        errors[providerId] = "Invalid catalog shard; using cached metadata";
+        return;
+      }
+      replacements.set(providerId, parsed.models);
+    })), replacements.size === 0)
+      return { ...fallbackCatalog(bundled, cachePath), errors };
+    let catalog = mergeOfficialCatalogByProvider(officialCatalogBase(bundled, cachePath), replacements, typeof manifest?.generatedAt == "string" ? manifest.generatedAt : void 0);
+    return cachePath && writeOfficialCatalogCache(catalog, cachePath), { catalog, source: "github", ...Object.keys(errors).length ? { errors } : {} };
+  } catch {
+    return unavailable();
+  }
+}
+
+// packages/coding-agent/dist/core/catalog-merge.js
+function mergeCatalogLayers(args) {
+  let byId = /* @__PURE__ */ new Map();
+  for (let model of args.bakedIn)
+    byId.set(model.id, model);
+  for (let model of args.live ?? [])
+    byId.set(model.id, model);
+  for (let model of args.user ?? [])
+    byId.set(model.id, model);
+  for (let model of args.official ?? [])
+    byId.set(model.id, model);
+  let seen = /* @__PURE__ */ new Set(), result = [];
+  for (let baked of args.bakedIn) {
+    let merged = byId.get(baked.id);
+    merged && (result.push(merged), seen.add(baked.id));
+  }
+  for (let model of [...args.live ?? [], ...args.user ?? [], ...args.official ?? []]) {
+    if (seen.has(model.id))
+      continue;
+    let winner = byId.get(model.id);
+    winner && (result.push(winner), seen.add(model.id));
+  }
+  let liveById = new Map((args.live ?? []).map((model) => [model.id, model])), pricedIds = new Set([...args.bakedIn, ...args.official ?? [], ...args.user ?? []].filter((model) => model.catalog?.pricing !== "unknown").map((model) => model.id));
+  return result.map((model) => {
+    let resolved = withXaiEffortMetadata(model);
+    model.catalog?.supplied.includes("thinkingLevelMap") || (resolved = withOpenAiEffortMetadata(resolved));
+    let live = liveById.get(model.id);
+    if (!live?.catalog)
+      return resolved;
+    resolved = { ...resolved, catalog: { ...live.catalog } };
+    for (let field of live.catalog.supplied)
+      Object.assign(resolved, { [field]: live[field] });
+    return (pricedIds.has(model.id) || live.catalog.supplied.includes("cost")) && delete resolved.catalog.pricing, resolved;
+  });
+}
+var CatalogOverlaySource = class {
+  official = /* @__PURE__ */ new Map();
+  user = /* @__PURE__ */ new Map();
+  live = /* @__PURE__ */ new Map();
+  setOfficial(models) {
+    this.official = groupByProvider(models);
+  }
+  setUser(models) {
+    this.user = groupByProvider(models);
+  }
+  setLive(providerId, models) {
+    this.live.set(providerId, [...models]);
+  }
+  officialFor(providerId) {
+    return this.official.get(providerId) ?? [];
+  }
+  userFor(providerId) {
+    return this.user.get(providerId) ?? [];
+  }
+  liveFor(providerId) {
+    return this.live.get(providerId) ?? [];
+  }
+  /** Codex's complete account catalog is authoritative for picker availability only. */
+  isAvailable(model) {
+    if (model.catalog?.hidden)
+      return !1;
+    let live = this.liveFor(model.provider);
+    return model.provider !== "openai-codex" || !live.length || live.some((row) => row.id === model.id && !row.catalog?.hidden);
+  }
+};
+function groupByProvider(models) {
+  let byProvider = /* @__PURE__ */ new Map();
+  for (let model of models) {
+    let list = byProvider.get(model.provider) ?? [];
+    list.push(model), byProvider.set(model.provider, list);
+  }
+  return byProvider;
+}
+function withCatalogOverlay(provider, overlay) {
+  let bakedIn = () => provider.getModels();
+  return {
+    ...provider,
+    getModels: () => mergeCatalogLayers({
+      bakedIn: bakedIn(),
+      live: overlay.liveFor(provider.id),
+      user: overlay.userFor(provider.id),
+      official: overlay.officialFor(provider.id)
+    })
+  };
+}
+function formatCatalogRefreshSummary(input) {
+  let parts = [];
+  if (input.official?.source === "github") {
+    let evicted = input.official.evictedUserRows > 0 ? `; replaced ${input.official.evictedUserRows} user-filled row` : "", plural = input.official.evictedUserRows === 1 ? "" : input.official.evictedUserRows > 0 ? "s" : "";
+    parts.push(`Official catalog updated (${input.official.modelCount} models)${evicted}${plural}.`);
+  }
+  let refreshed = [], failed = [];
+  for (let provider of input.providers)
+    if (provider.status === "ok") {
+      let added = provider.added ?? 0, total = provider.total ?? 0;
+      refreshed.push(added > 0 ? `${provider.id} (+${added})` : `${provider.id} (${total})`);
+    } else provider.status === "timeout" ? failed.push(`${provider.id} timed out (cached)`) : provider.status === "error" && failed.push(formatLiveProviderError(provider));
+  return refreshed.length > 0 ? parts.push(`Refreshed ${refreshed.join(", ")}.`) : input.providers.some((provider) => provider.status === "ok") && parts.push("Refreshed model catalogs."), failed.length > 0 && parts.push(`${failed.join("; ")}.`), input.asked && input.asked.length > 0 && parts.push(`Asked for missing metadata on ${input.asked.join(", ")}.`), input.extraDefaults && input.extraDefaults > 0 && parts.push(`+${input.extraDefaults} more using defaults.`), input.ollama && parts.push(input.ollama), parts.length === 0 ? "Model catalogs refreshed." : parts.join(" ");
+}
+function formatLiveProviderError(provider) {
+  return provider.id === "xai" && provider.error && /invalid_grant|refresh token revoked/i.test(provider.error) && !/timed out|aborted|cancelled|ECONN|ENOTFOUND|network/i.test(provider.error) ? "xai login expired (run /login xai)" : provider.error ? `${provider.id} failed (${provider.error})` : `${provider.id} failed`;
+}
+function knownModelKeys(bakedIn, official, user) {
+  let keys = new Set(official);
+  for (let key of user)
+    keys.add(key);
+  for (let model of bakedIn)
+    keys.add(modelKey(model.provider, model.id));
+  return keys;
+}
+
+// packages/coding-agent/dist/core/grok-cli-auth.js
+var import_proper_lockfile2 = __toESM(require_proper_lockfile(), 1);
+import { chmodSync as chmodSync2, existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync3, renameSync as renameSync3, unlinkSync as unlinkSync3, writeFileSync as writeFileSync3 } from "node:fs";
+import { homedir } from "node:os";
+import { dirname as dirname3, join as join3 } from "node:path";
+var XAI_PROVIDER_ID = "xai", XAI_GROK_CLI_CLIENT_ID = "b1a00492-073a-47ea-816f-4c329264a828", REFRESH_SKEW_MS = 300 * 1e3, AUTH_FILE_WRITE_OPTIONS2 = { encoding: "utf-8", mode: 384 };
+function grokHomeDir(grokHome) {
+  if (grokHome)
+    return grokHome;
+  let fromEnv = process.env.GROK_HOME?.trim();
+  return fromEnv || join3(homedir(), ".grok");
+}
+function grokAuthPath(grokHome) {
+  return join3(grokHomeDir(grokHome), "auth.json");
+}
+function grokOidcEntryKey(clientId = XAI_GROK_CLI_CLIENT_ID) {
+  return `https://auth.x.ai::${clientId}`;
+}
+function parseGrokExpiresAt(value) {
+  if (typeof value == "number" && Number.isFinite(value) && value > 0)
+    return value < 1e12 ? Math.round(value * 1e3) : Math.round(value);
+  if (typeof value == "string" && value.trim()) {
+    let numeric = Number(value);
+    if (Number.isFinite(numeric) && numeric > 0)
+      return numeric < 1e12 ? Math.round(numeric * 1e3) : Math.round(numeric);
+    let parsed = Date.parse(value);
+    if (Number.isFinite(parsed))
+      return parsed;
+  }
+}
+function formatGrokExpiresAt(expires) {
+  return new Date(expires).toISOString();
+}
+function grokEntryToOAuth(entry) {
+  if (!entry || typeof entry != "object" || Array.isArray(entry))
+    return;
+  let record = entry, access = typeof record.key == "string" ? record.key : void 0, refresh = typeof record.refresh_token == "string" ? record.refresh_token : void 0, expires = parseGrokExpiresAt(record.expires_at);
+  if (!(!access || !refresh || expires === void 0))
+    return { type: "oauth", access, refresh, expires };
+}
+function readGrokCliXaiOAuth(options = {}) {
+  try {
+    let raw = readFileSync3(grokAuthPath(options.grokHome), "utf-8"), parsed = JSON.parse(raw);
+    return !parsed || typeof parsed != "object" || Array.isArray(parsed) ? void 0 : grokEntryToOAuth(parsed[grokOidcEntryKey()]);
+  } catch {
+    return;
+  }
+}
+function hasGrokCliXaiAuth(options = {}) {
+  return readGrokCliXaiOAuth(options) !== void 0;
+}
+function chooseXaiOAuth(lunr, grok) {
+  if (lunr?.type === "api_key")
+    return lunr;
+  let lunrOAuth = lunr?.type === "oauth" ? lunr : void 0;
+  if (lunrOAuth && grok) {
+    if (lunrOAuth.refresh === grok.refresh)
+      return grok.expires >= lunrOAuth.expires ? grok : lunrOAuth;
+    let now = Date.now(), lunrLive = now < lunrOAuth.expires, grokLive = now < grok.expires;
+    return grokLive && !lunrLive ? grok : lunrLive && !grokLive ? lunrOAuth : !lunrLive && !grokLive && grok.expires >= lunrOAuth.expires ? grok : lunrOAuth;
+  }
+  return grok ?? lunrOAuth ?? lunr;
+}
+function oauthRefreshFailed(error) {
+  let parts = [], current = error, seen = /* @__PURE__ */ new Set();
+  for (; current && typeof current == "object" && !seen.has(current); ) {
+    if (seen.add(current), current instanceof Error) {
+      parts.push(current.message), current = current.cause;
+      continue;
+    }
+    break;
+  }
+  let chain = parts.join(" ");
+  return /timed out|aborted|cancelled|ECONN|ENOTFOUND|network/i.test(chain) ? !1 : /invalid_grant|refresh token revoked/i.test(chain);
+}
+function shouldAdopt(lunr, chosen) {
+  return !chosen || chosen.type !== "oauth" ? !1 : !lunr || lunr.type !== "oauth" ? !0 : lunr.access !== chosen.access || lunr.refresh !== chosen.refresh;
+}
+function writeAuthFileAtomic2(authPath, contents) {
+  let tmp = `${authPath}.${process.pid}.${Date.now()}.tmp`;
+  writeFileSync3(tmp, contents, AUTH_FILE_WRITE_OPTIONS2);
+  try {
+    chmodSync2(tmp, 384);
+  } catch {
+  }
+  try {
+    if (process.platform === "win32" && existsSync3(authPath)) {
+      writeFileSync3(authPath, contents, AUTH_FILE_WRITE_OPTIONS2), chmodSync2(authPath, 384);
+      return;
+    }
+    renameSync3(tmp, authPath);
+    try {
+      chmodSync2(authPath, 384);
+    } catch {
+    }
+  } finally {
+    try {
+      unlinkSync3(tmp);
+    } catch {
+    }
+  }
+}
+function acquireGrokLock(authPath) {
+  let lastError;
+  for (let attempt = 1; attempt <= 10; attempt++)
+    try {
+      return import_proper_lockfile2.default.lockSync(authPath, { realpath: !1, stale: 12e4 });
+    } catch (error) {
+      if ((typeof error == "object" && error !== null && "code" in error ? String(error.code) : void 0) !== "ELOCKED" || attempt === 10)
+        throw error;
+      lastError = error;
+      let start = Date.now();
+      for (; Date.now() - start < 20; )
+        ;
+    }
+  throw lastError ?? new Error("Failed to acquire Grok CLI auth lock");
+}
+function writeGrokCliXaiOAuth(credential, options = {}) {
+  let authPath = grokAuthPath(options.grokHome);
+  if (options.onlyIfFileExists !== !1 && !existsSync3(authPath))
+    return !1;
+  let dir = dirname3(authPath);
+  existsSync3(dir) || mkdirSync3(dir, { recursive: !0, mode: 448 }), existsSync3(authPath) || writeAuthFileAtomic2(authPath, `{}
+`);
+  let release;
+  try {
+    release = acquireGrokLock(authPath);
+    let data = {};
+    try {
+      let parsed = JSON.parse(readFileSync3(authPath, "utf-8"));
+      if (parsed && typeof parsed == "object" && !Array.isArray(parsed))
+        data = parsed;
+      else
+        return !1;
+    } catch {
+      return !1;
+    }
+    let key = grokOidcEntryKey(), previous = data[key] && typeof data[key] == "object" && !Array.isArray(data[key]) ? data[key] : {}, existing = grokEntryToOAuth(previous);
+    return existing && existing.refresh !== credential.refresh && existing.expires > credential.expires + REFRESH_SKEW_MS ? !1 : (data[key] = {
+      ...previous,
+      key: credential.access,
+      refresh_token: credential.refresh,
+      expires_at: formatGrokExpiresAt(credential.expires)
+    }, writeAuthFileAtomic2(authPath, `${JSON.stringify(data, null, 2)}
+`), !0);
+  } finally {
+    if (release)
+      try {
+        release();
+      } catch {
+      }
+  }
+}
+function wrapXaiGrokCliCredentials(store, options = {}) {
+  let grokHome = options.grokHome;
+  return {
+    async read(providerId) {
+      let stored = await store.read(providerId);
+      if (providerId !== XAI_PROVIDER_ID || stored?.type === "api_key")
+        return stored;
+      let grok = readGrokCliXaiOAuth({ grokHome }), chosen = chooseXaiOAuth(stored, grok);
+      if (shouldAdopt(stored, chosen) && chosen?.type === "oauth")
+        try {
+          await store.modify(providerId, async (current) => {
+            if (current?.type === "api_key")
+              return;
+            let latestGrok = readGrokCliXaiOAuth({ grokHome }), latestChosen = chooseXaiOAuth(current, latestGrok);
+            if (shouldAdopt(current, latestChosen) && latestChosen?.type === "oauth")
+              return latestChosen;
+          });
+        } catch {
+        }
+      return chosen;
+    },
+    async list() {
+      let entries = new Map((await store.list()).map((entry) => [entry.providerId, entry]));
+      return !entries.has(XAI_PROVIDER_ID) && hasGrokCliXaiAuth({ grokHome }) && entries.set(XAI_PROVIDER_ID, { providerId: XAI_PROVIDER_ID, type: "oauth" }), [...entries.values()];
+    },
+    modify(providerId, fn) {
+      return providerId !== XAI_PROVIDER_ID ? store.modify(providerId, fn) : store.modify(providerId, async (lunrCurrent) => {
+        if (lunrCurrent?.type === "api_key")
+          return fn(lunrCurrent);
+        let grok = readGrokCliXaiOAuth({ grokHome }), chosen = chooseXaiOAuth(lunrCurrent, grok), next;
+        try {
+          next = await fn(chosen);
+        } catch (error) {
+          let retryGrok = readGrokCliXaiOAuth({ grokHome });
+          if (!(oauthRefreshFailed(error) && retryGrok && !(chosen?.type === "oauth" && retryGrok.refresh === chosen.refresh)))
+            throw error;
+          try {
+            next = await fn(retryGrok);
+          } catch {
+            throw error;
+          }
+        }
+        if (next?.type === "oauth")
+          try {
+            writeGrokCliXaiOAuth(next, { grokHome, onlyIfFileExists: !0 });
+          } catch {
+          }
+        return next;
+      });
+    },
+    delete(providerId) {
+      return store.delete(providerId);
+    }
+  };
+}
+
+// packages/coding-agent/dist/core/live-catalog.js
+import { isOpenAiChatModel, parseOpenAiGptVersion } from "@ashx-j/lunr-ai";
+import { codexModelsUrl, resolveCodexCatalogVersion } from "@ashx-j/lunr-ai/catalog/codex";
+import { normalizeCatalogPricing } from "@ashx-j/lunr-ai/catalog/metadata";
+
+// packages/coding-agent/dist/core/codex-catalog.js
+import { parseCodexCatalog } from "@ashx-j/lunr-ai/catalog/codex";
+function discoverCodexModels(payload, baseUrl) {
+  return parseCodexCatalog(payload, baseUrl).map((model) => ({
+    model,
+    supplied: {
+      name: model.catalog.supplied.includes("name"),
+      contextWindow: model.catalog.supplied.includes("contextWindow"),
+      maxTokens: model.catalog.supplied.includes("maxTokens"),
+      input: model.catalog.supplied.includes("input"),
+      cost: !1,
+      reasoning: model.catalog.supplied.includes("reasoning")
+    }
+  }));
+}
+
+// packages/coding-agent/dist/core/live-catalog.js
+var LIVE_CATALOG_TIMEOUT_MS = 4e3;
+var DEFAULT_CONTEXT_WINDOW = 128e3, DEFAULT_MAX_TOKENS = 8192, LIVE_LIST_PROVIDER_IDS = [
+  "openai-codex",
+  "xai",
+  "openrouter",
+  "qwen-cloud",
+  "qwen-cloud-cn",
+  "groq",
+  "openai",
+  "deepseek"
+], LIVE_LIST_PROVIDER_SET = new Set(LIVE_LIST_PROVIDER_IDS);
+var ZERO_COST2 = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 }, NONE_SUPPLIED = {
+  contextWindow: !1,
+  maxTokens: !1,
+  input: !1,
+  name: !1,
+  cost: !1,
+  reasoning: !1
+};
+function isRecord2(value) {
+  return typeof value == "object" && value !== null && !Array.isArray(value);
+}
+function asFiniteNumber2(value) {
+  if (typeof value == "number" && Number.isFinite(value))
+    return value;
+  if (typeof value == "string" && value.trim()) {
+    let parsed = Number(value);
+    if (Number.isFinite(parsed))
+      return parsed;
+  }
+}
+function roundCost(value) {
+  return Number(value.toFixed(6));
+}
+function modelsListUrl(baseUrl) {
+  return `${baseUrl.replace(/\/+$/u, "")}/models`;
+}
+function credentialAuthHeaders(credential) {
+  return credential ? credential.type === "api_key" && credential.key ? { Authorization: `Bearer ${credential.key}` } : credential.type === "oauth" && typeof credential.access == "string" && credential.access ? { Authorization: `Bearer ${credential.access}` } : {} : {};
+}
+function parseOpenAIModelsList(value) {
+  let entries = isRecord2(value) && Array.isArray(value.data) ? value.data : Array.isArray(value) ? value : [], rows = [];
+  for (let entry of entries) {
+    if (typeof entry == "string" && entry.trim()) {
+      rows.push({ id: entry.trim() });
+      continue;
+    }
+    isRecord2(entry) && typeof entry.id == "string" && entry.id.trim() && rows.push(entry);
+  }
+  return rows;
+}
+function firstBakedInModel(models) {
+  return models[0];
+}
+function selectLiveTemplate(providerId, id, bakedIn) {
+  let exact = bakedIn.find((model) => model.id === id);
+  if (exact)
+    return exact;
+  let version = parseOpenAiGptVersion(id);
+  if (providerId !== "openai" || !version || version.major < 5 || isOpenAiChatModel(id))
+    return firstBakedInModel(bakedIn);
+  let reasoning;
+  for (let model of bakedIn)
+    model.reasoning && parseOpenAiGptVersion(model.id) && (reasoning = model);
+  return reasoning ?? firstBakedInModel(bakedIn);
+}
+function uniqueApis(models) {
+  let seen = /* @__PURE__ */ new Set(), apis = [];
+  for (let model of models)
+    seen.has(model.api) || (seen.add(model.api), apis.push(model.api));
+  return apis;
+}
+function synthesizeLiveModel(id, template, raw = {}) {
+  let name = typeof raw.name == "string" && raw.name.trim() ? raw.name.trim() : id, exact = id === template.id, discovery = {
+    model: {
+      id,
+      name,
+      api: template.api,
+      provider: template.provider,
+      baseUrl: template.baseUrl,
+      reasoning: template.reasoning,
+      input: exact ? template.input : ["text"],
+      cost: ZERO_COST2,
+      contextWindow: DEFAULT_CONTEXT_WINDOW,
+      maxTokens: DEFAULT_MAX_TOKENS,
+      compat: template.compat,
+      thinkingLevelMap: exact ? template.thinkingLevelMap : void 0,
+      catalog: { source: "provider", supplied: typeof raw.name == "string" ? ["name"] : [], pricing: "unknown" }
+    },
+    supplied: {
+      ...NONE_SUPPLIED,
+      name: typeof raw.name == "string" && raw.name.trim().length > 0
+    }
+  }, context = asFiniteNumber2(raw.context_window ?? raw.context_length ?? raw.max_context_length), output = asFiniteNumber2(raw.max_output_tokens ?? raw.max_completion_tokens);
+  if (context && context > 0 && (discovery.model.contextWindow = context, discovery.supplied.contextWindow = !0), output && output > 0 && (discovery.model.maxTokens = output, discovery.supplied.maxTokens = !0), typeof raw.reasoning == "boolean" && (discovery.model.reasoning = raw.reasoning, discovery.supplied.reasoning = !0), Array.isArray(raw.input_modalities)) {
+    let input = raw.input_modalities.filter((value) => value === "text" || value === "image");
+    input.length && (discovery.model.input = input, discovery.supplied.input = !0);
+  }
+  return discovery.model.catalog.supplied = Object.entries(discovery.supplied).filter(([, value]) => value).map(([field]) => field), discovery;
+}
+function mapOpenRouterModel(raw, template) {
+  let id = typeof raw.id == "string" ? raw.id.trim() : "";
+  if (!id)
+    return;
+  let supported = Array.isArray(raw.supported_parameters) ? raw.supported_parameters : [];
+  if (!supported.includes("tools"))
+    return;
+  let architecture = isRecord2(raw.architecture) ? raw.architecture : void 0, modality = typeof architecture?.modality == "string" ? architecture.modality : "", input = ["text"];
+  modality.includes("image") && input.push("image");
+  let pricing = isRecord2(raw.pricing) ? raw.pricing : void 0, inputCost = roundCost((asFiniteNumber2(pricing?.prompt) ?? 0) * 1e6), outputCost = roundCost((asFiniteNumber2(pricing?.completion) ?? 0) * 1e6), cacheReadCost = roundCost((asFiniteNumber2(pricing?.input_cache_read) ?? 0) * 1e6), cacheWriteCost = roundCost((asFiniteNumber2(pricing?.input_cache_write) ?? 0) * 1e6), topProvider = isRecord2(raw.top_provider) ? raw.top_provider : void 0, contextWindow = asFiniteNumber2(topProvider?.context_length) ?? asFiniteNumber2(raw.context_length), maxTokens = asFiniteNumber2(topProvider?.max_completion_tokens) ?? asFiniteNumber2(raw.max_completion_tokens), name = typeof raw.name == "string" && raw.name.trim() ? raw.name.trim() : id;
+  return {
+    model: {
+      id,
+      name,
+      api: template.api,
+      provider: template.provider,
+      baseUrl: template.baseUrl,
+      reasoning: supported.includes("reasoning") || template.reasoning,
+      input,
+      cost: {
+        input: inputCost,
+        output: outputCost,
+        cacheRead: cacheReadCost,
+        cacheWrite: cacheWriteCost
+      },
+      contextWindow: contextWindow ?? DEFAULT_CONTEXT_WINDOW,
+      maxTokens: maxTokens ?? DEFAULT_MAX_TOKENS,
+      compat: template.compat,
+      thinkingLevelMap: template.thinkingLevelMap
+    },
+    supplied: {
+      contextWindow: contextWindow !== void 0,
+      maxTokens: maxTokens !== void 0,
+      input: !0,
+      name: typeof raw.name == "string" && raw.name.trim().length > 0,
+      cost: asFiniteNumber2(pricing?.prompt) !== void 0 && asFiniteNumber2(pricing?.completion) !== void 0,
+      reasoning: supported.includes("reasoning")
+    }
+  };
+}
+function discoverLiveModels(providerId, payload, bakedIn) {
+  if (providerId === "openai-codex")
+    return discoverCodexModels(payload, bakedIn[0]?.baseUrl ?? "https://chatgpt.com/backend-api");
+  let fallback = firstBakedInModel(bakedIn);
+  if (!fallback)
+    return [];
+  let rows = parseOpenAIModelsList(payload), discoveries = [];
+  for (let raw of rows) {
+    let id = typeof raw.id == "string" ? raw.id.trim() : "";
+    if (!id || raw.tool_call === !1 || raw.type === "embedding" || providerId === "openai" && /^(?:text-embedding-|tts-|whisper-|dall-e-|gpt-image-|gpt-audio|gpt-realtime|sora-|.*moderation)/i.test(id))
+      continue;
+    let template = { ...selectLiveTemplate(providerId, id, bakedIn) ?? fallback, provider: providerId };
+    if (providerId === "openrouter") {
+      let mapped = mapOpenRouterModel(raw, template);
+      mapped && (mapped.model.catalog = {
+        source: "provider",
+        ...mapped.supplied.cost ? {} : { pricing: "unknown" },
+        supplied: Object.entries(mapped.supplied).filter(([, supplied]) => supplied).map(([key]) => key)
+      }, mapped.model = normalizeCatalogPricing(mapped.model), mapped.model.catalog?.pricing === "unknown" && (mapped.supplied.cost = !1), discoveries.push(mapped));
+      continue;
+    }
+    discoveries.push(synthesizeLiveModel(id, template, raw));
+  }
+  return discoveries;
+}
+function missingLiveFields(supplied) {
+  let missing = [];
+  return supplied.contextWindow || missing.push("contextWindow"), supplied.maxTokens || missing.push("maxTokens"), supplied.input || missing.push("input"), missing;
+}
+function isLiveModelIncomplete(discovery, knownKeys) {
+  return knownKeys.has(modelKey(discovery.model.provider, discovery.model.id)) ? !1 : missingLiveFields(discovery.supplied).length > 0;
+}
+function collectIncompleteLiveModels(discoveries, bakedIn, knownKeys) {
+  let apis = uniqueApis(bakedIn), incomplete = [];
+  for (let discovery of discoveries)
+    isLiveModelIncomplete(discovery, knownKeys) && incomplete.push({
+      provider: discovery.model.provider,
+      id: discovery.model.id,
+      name: discovery.model.name,
+      missing: missingLiveFields(discovery.supplied),
+      draft: discovery.model,
+      availableApis: apis
+    });
+  return incomplete;
+}
+function buildLiveOverlay(bakedIn, discoveries) {
+  let bakedById = new Map(bakedIn.map((model) => [model.id, model])), overlay = [];
+  for (let discovery of discoveries) {
+    let baked = bakedById.get(discovery.model.id);
+    if (!baked) {
+      overlay.push(discovery.model);
+      continue;
+    }
+    overlay.push({
+      ...baked,
+      catalog: discovery.model.catalog,
+      thinkingLevelMap: discovery.model.catalog?.supplied.includes("thinkingLevelMap") ? discovery.model.thinkingLevelMap : baked.thinkingLevelMap,
+      name: discovery.supplied.name ? discovery.model.name : baked.name,
+      contextWindow: discovery.supplied.contextWindow ? discovery.model.contextWindow : baked.contextWindow,
+      maxTokens: discovery.supplied.maxTokens ? discovery.model.maxTokens : baked.maxTokens,
+      input: discovery.supplied.input ? discovery.model.input : baked.input,
+      cost: discovery.supplied.cost ? discovery.model.cost : baked.cost,
+      reasoning: discovery.supplied.reasoning ? discovery.model.reasoning : baked.reasoning
+    });
+  }
+  return overlay;
+}
+async function fetchLiveProviderModels(options) {
+  let empty = {
+    providerId: options.providerId,
+    status: "skipped",
+    discoveries: [],
+    added: 0,
+    total: 0,
+    incomplete: []
+  };
+  if (!firstBakedInModel(options.bakedIn) && options.providerId !== "openai-codex" || !options.baseUrl)
+    return empty;
+  let timeoutMs = options.timeoutMs ?? LIVE_CATALOG_TIMEOUT_MS, controller = new AbortController(), timedOut = !1, timer = setTimeout(() => {
+    timedOut = !0, controller.abort();
+  }, timeoutMs), onParentAbort = () => controller.abort();
+  options.signal?.addEventListener("abort", onParentAbort, { once: !0 }), options.signal?.aborted && controller.abort();
+  try {
+    let fetchImpl = options.fetchImpl ?? fetch, codex = options.providerId === "openai-codex", accountId = options.credential?.type === "oauth" && typeof options.credential.accountId == "string" ? options.credential.accountId : void 0, discoveryClientVersion = options.discoveryClientVersion, payload = await Promise.race([
+      (async () => {
+        codex && (discoveryClientVersion = await resolveCodexCatalogVersion(fetchImpl, controller.signal, discoveryClientVersion));
+        let response = await fetchImpl(codex ? codexModelsUrl(options.baseUrl, discoveryClientVersion) : modelsListUrl(options.baseUrl), {
+          headers: {
+            accept: "application/json",
+            "User-Agent": getPiUserAgent(VERSION),
+            ...credentialAuthHeaders(options.credential),
+            ...accountId ? { "ChatGPT-Account-ID": accountId } : {}
+          },
+          signal: controller.signal
+        });
+        if (!response.ok)
+          throw new Error(`HTTP ${response.status}`);
+        return response.json();
+      })(),
+      new Promise((_, reject) => {
+        let abortError = new Error("The operation was aborted");
+        abortError.name = "AbortError", controller.signal.addEventListener("abort", () => reject(abortError), { once: !0 }), controller.signal.aborted && reject(abortError);
+      })
+    ]), discoveries = codex ? discoverCodexModels(payload, options.baseUrl) : discoverLiveModels(options.providerId, payload, options.bakedIn);
+    if (!discoveries.length)
+      throw new Error("No usable models returned; retaining cached models");
+    let bakedIds = new Set(options.bakedIn.map((model) => model.id)), added = discoveries.filter((discovery) => !bakedIds.has(discovery.model.id)).length;
+    return {
+      providerId: options.providerId,
+      discoveryClientVersion,
+      status: "ok",
+      discoveries,
+      added,
+      total: discoveries.length,
+      incomplete: collectIncompleteLiveModels(discoveries, options.bakedIn, options.knownKeys)
+    };
+  } catch (error) {
+    return options.signal?.aborted && !timedOut ? { ...empty, status: "skipped", error: "aborted" } : timedOut || error instanceof Error && error.name === "AbortError" ? { ...empty, status: "timeout", error: "timed out" } : {
+      ...empty,
+      status: "error",
+      error: error instanceof Error ? error.message : String(error)
+    };
+  } finally {
+    clearTimeout(timer), options.signal?.removeEventListener("abort", onParentAbort);
+  }
+}
+
+// packages/coding-agent/dist/core/model-config.js
+import { readFile } from "node:fs/promises";
+import { Type } from "typebox";
+import { Compile } from "typebox/compile";
+
+// packages/coding-agent/dist/utils/json.js
+function stripJsonComments(input) {
+  return input.replace(/"(?:\\.|[^"\\])*"|\/\/[^\n]*/g, (m) => m[0] === '"' ? m : "").replace(/"(?:\\.|[^"\\])*"|,(\s*[}\]])/g, (m, tail) => tail ?? (m[0] === '"' ? m : ""));
+}
+
+// packages/coding-agent/dist/core/model-config.js
+var PercentileCutoffsSchema = Type.Object({
+  p50: Type.Optional(Type.Number()),
+  p75: Type.Optional(Type.Number()),
+  p90: Type.Optional(Type.Number()),
+  p99: Type.Optional(Type.Number())
+}), OpenRouterRoutingSchema = Type.Object({
+  allow_fallbacks: Type.Optional(Type.Boolean()),
+  require_parameters: Type.Optional(Type.Boolean()),
+  data_collection: Type.Optional(Type.Union([Type.Literal("deny"), Type.Literal("allow")])),
+  zdr: Type.Optional(Type.Boolean()),
+  enforce_distillable_text: Type.Optional(Type.Boolean()),
+  order: Type.Optional(Type.Array(Type.String())),
+  only: Type.Optional(Type.Array(Type.String())),
+  ignore: Type.Optional(Type.Array(Type.String())),
+  quantizations: Type.Optional(Type.Array(Type.String())),
+  sort: Type.Optional(Type.Union([
+    Type.String(),
+    Type.Object({
+      by: Type.Optional(Type.String()),
+      partition: Type.Optional(Type.Union([Type.String(), Type.Null()]))
+    })
+  ])),
+  max_price: Type.Optional(Type.Object({
+    prompt: Type.Optional(Type.Union([Type.Number(), Type.String()])),
+    completion: Type.Optional(Type.Union([Type.Number(), Type.String()])),
+    image: Type.Optional(Type.Union([Type.Number(), Type.String()])),
+    audio: Type.Optional(Type.Union([Type.Number(), Type.String()])),
+    request: Type.Optional(Type.Union([Type.Number(), Type.String()]))
+  })),
+  preferred_min_throughput: Type.Optional(Type.Union([Type.Number(), PercentileCutoffsSchema])),
+  preferred_max_latency: Type.Optional(Type.Union([Type.Number(), PercentileCutoffsSchema]))
+}), VercelGatewayRoutingSchema = Type.Object({
+  only: Type.Optional(Type.Array(Type.String())),
+  order: Type.Optional(Type.Array(Type.String()))
+}), ThinkingLevelMapValueSchema = Type.Union([Type.String(), Type.Null()]), ThinkingLevelMapSchema = Type.Object({
+  off: Type.Optional(ThinkingLevelMapValueSchema),
+  minimal: Type.Optional(ThinkingLevelMapValueSchema),
+  low: Type.Optional(ThinkingLevelMapValueSchema),
+  medium: Type.Optional(ThinkingLevelMapValueSchema),
+  high: Type.Optional(ThinkingLevelMapValueSchema),
+  xhigh: Type.Optional(ThinkingLevelMapValueSchema),
+  max: Type.Optional(ThinkingLevelMapValueSchema)
+}), ChatTemplateKwargScalarSchema = Type.Union([Type.String(), Type.Number(), Type.Boolean(), Type.Null()]), ChatTemplateKwargVariableSchema = Type.Object({
+  $var: Type.Union([Type.Literal("thinking.enabled"), Type.Literal("thinking.effort")]),
+  omitWhenOff: Type.Optional(Type.Boolean())
+}), ChatTemplateKwargSchema = Type.Union([ChatTemplateKwargScalarSchema, ChatTemplateKwargVariableSchema]), OpenAICompletionsCompatSchema = Type.Object({
+  supportsStore: Type.Optional(Type.Boolean()),
+  supportsDeveloperRole: Type.Optional(Type.Boolean()),
+  supportsReasoningEffort: Type.Optional(Type.Boolean()),
+  supportsUsageInStreaming: Type.Optional(Type.Boolean()),
+  maxTokensField: Type.Optional(Type.Union([Type.Literal("max_completion_tokens"), Type.Literal("max_tokens")])),
+  requiresToolResultName: Type.Optional(Type.Boolean()),
+  requiresAssistantAfterToolResult: Type.Optional(Type.Boolean()),
+  requiresThinkingAsText: Type.Optional(Type.Boolean()),
+  requiresReasoningContentOnAssistantMessages: Type.Optional(Type.Boolean()),
+  thinkingFormat: Type.Optional(Type.Union([
+    Type.Literal("openai"),
+    Type.Literal("openrouter"),
+    Type.Literal("together"),
+    Type.Literal("deepseek"),
+    Type.Literal("zai"),
+    Type.Literal("qwen"),
+    Type.Literal("chat-template"),
+    Type.Literal("qwen-chat-template"),
+    Type.Literal("string-thinking"),
+    Type.Literal("ant-ling")
+  ])),
+  chatTemplateKwargs: Type.Optional(Type.Record(Type.String(), ChatTemplateKwargSchema)),
+  cacheControlFormat: Type.Optional(Type.Literal("anthropic")),
+  openRouterRouting: Type.Optional(OpenRouterRoutingSchema),
+  vercelGatewayRouting: Type.Optional(VercelGatewayRoutingSchema),
+  supportsStrictMode: Type.Optional(Type.Boolean()),
+  sendSessionAffinityHeaders: Type.Optional(Type.Boolean()),
+  deferredToolsMode: Type.Optional(Type.Literal("kimi")),
+  sessionAffinityFormat: Type.Optional(Type.Union([Type.Literal("openai"), Type.Literal("openai-nosession"), Type.Literal("openrouter")])),
+  supportsLongCacheRetention: Type.Optional(Type.Boolean())
+}), OpenAIResponsesCompatSchema = Type.Object({
+  supportsDeveloperRole: Type.Optional(Type.Boolean()),
+  sessionAffinityFormat: Type.Optional(Type.Union([Type.Literal("openai"), Type.Literal("openai-nosession"), Type.Literal("openrouter")])),
+  supportsLongCacheRetention: Type.Optional(Type.Boolean()),
+  supportsToolSearch: Type.Optional(Type.Boolean())
+}), AnthropicMessagesCompatSchema = Type.Object({
+  supportsEagerToolInputStreaming: Type.Optional(Type.Boolean()),
+  supportsLongCacheRetention: Type.Optional(Type.Boolean()),
+  sendSessionAffinityHeaders: Type.Optional(Type.Boolean()),
+  supportsCacheControlOnTools: Type.Optional(Type.Boolean()),
+  forceAdaptiveThinking: Type.Optional(Type.Boolean()),
+  supportsToolReferences: Type.Optional(Type.Boolean())
+}), ProviderCompatSchema = Type.Union([
+  OpenAICompletionsCompatSchema,
+  OpenAIResponsesCompatSchema,
+  AnthropicMessagesCompatSchema
+]), ModelCostRatesSchema = {
+  input: Type.Number(),
+  output: Type.Number(),
+  cacheRead: Type.Number(),
+  cacheWrite: Type.Number()
+}, ModelCostTierSchema = Type.Object({
+  inputTokensAbove: Type.Number(),
+  ...ModelCostRatesSchema
+}), ModelCostSchema = Type.Object({
+  ...ModelCostRatesSchema,
+  tiers: Type.Optional(Type.Array(ModelCostTierSchema))
+}), ModelDefinitionSchema = Type.Object({
+  id: Type.String({ minLength: 1 }),
+  name: Type.Optional(Type.String({ minLength: 1 })),
+  api: Type.Optional(Type.String({ minLength: 1 })),
+  baseUrl: Type.Optional(Type.String({ minLength: 1 })),
+  reasoning: Type.Optional(Type.Boolean()),
+  thinkingLevelMap: Type.Optional(ThinkingLevelMapSchema),
+  input: Type.Optional(Type.Array(Type.Union([Type.Literal("text"), Type.Literal("image")]))),
+  cost: Type.Optional(ModelCostSchema),
+  contextWindow: Type.Optional(Type.Number()),
+  maxTokens: Type.Optional(Type.Number()),
+  headers: Type.Optional(Type.Record(Type.String(), Type.String())),
+  compat: Type.Optional(ProviderCompatSchema)
+}), ModelOverrideSchema = Type.Object({
+  name: Type.Optional(Type.String({ minLength: 1 })),
+  reasoning: Type.Optional(Type.Boolean()),
+  thinkingLevelMap: Type.Optional(ThinkingLevelMapSchema),
+  input: Type.Optional(Type.Array(Type.Union([Type.Literal("text"), Type.Literal("image")]))),
+  cost: Type.Optional(Type.Object({
+    input: Type.Optional(Type.Number()),
+    output: Type.Optional(Type.Number()),
+    cacheRead: Type.Optional(Type.Number()),
+    cacheWrite: Type.Optional(Type.Number()),
+    tiers: Type.Optional(Type.Array(ModelCostTierSchema))
+  })),
+  contextWindow: Type.Optional(Type.Number()),
+  maxTokens: Type.Optional(Type.Number()),
+  headers: Type.Optional(Type.Record(Type.String(), Type.String())),
+  compat: Type.Optional(ProviderCompatSchema)
+}), ProviderConfigSchema = Type.Object({
+  name: Type.Optional(Type.String({ minLength: 1 })),
+  baseUrl: Type.Optional(Type.String({ minLength: 1 })),
+  apiKey: Type.Optional(Type.String({ minLength: 1 })),
+  api: Type.Optional(Type.String({ minLength: 1 })),
+  oauth: Type.Optional(Type.Literal("radius")),
+  headers: Type.Optional(Type.Record(Type.String(), Type.String())),
+  compat: Type.Optional(ProviderCompatSchema),
+  authHeader: Type.Optional(Type.Boolean()),
+  models: Type.Optional(Type.Array(ModelDefinitionSchema)),
+  modelOverrides: Type.Optional(Type.Record(Type.String(), ModelOverrideSchema))
+}), ModelsConfigSchema = Type.Object({
+  providers: Type.Record(Type.String(), ProviderConfigSchema)
+}), validateModelsConfig = Compile(ModelsConfigSchema);
+function formatValidationPath(error) {
+  if (error.keyword === "required") {
+    let requiredProperty = error.params.requiredProperties?.[0];
+    if (requiredProperty) {
+      let basePath = error.instancePath.replace(/^\//, "").replace(/\//g, ".");
+      return basePath ? `${basePath}.${requiredProperty}` : requiredProperty;
+    }
+  }
+  return error.instancePath.replace(/^\//, "").replace(/\//g, ".") || "root";
+}
+function deepFreeze(value) {
+  if (typeof value != "object" || value === null || Object.isFrozen(value))
+    return value;
+  for (let child of Object.values(value))
+    deepFreeze(child);
+  return Object.freeze(value);
+}
+var ModelConfig = class _ModelConfig {
+  providers;
+  error;
+  constructor(providers, error) {
+    this.providers = providers, this.error = error;
+  }
+  static async load(modelsJsonPath) {
+    if (!modelsJsonPath)
+      return new _ModelConfig(/* @__PURE__ */ new Map());
+    let path = normalizePath(modelsJsonPath), content;
+    try {
+      content = await readFile(path, "utf-8");
+    } catch (error) {
+      return error.code === "ENOENT" ? new _ModelConfig(/* @__PURE__ */ new Map()) : new _ModelConfig(/* @__PURE__ */ new Map(), `Failed to load models.json: ${error instanceof Error ? error.message : error}
+
+File: ${path}`);
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(stripJsonComments(content));
+    } catch (error) {
+      return new _ModelConfig(/* @__PURE__ */ new Map(), `Failed to parse models.json: ${error instanceof Error ? error.message : error}
+
+File: ${path}`);
+    }
+    if (!validateModelsConfig.Check(parsed)) {
+      let errors = validateModelsConfig.Errors(parsed).map((error) => `  - ${formatValidationPath(error)}: ${error.message}`).join(`
+`) || "Unknown schema error";
+      return new _ModelConfig(/* @__PURE__ */ new Map(), `Invalid models.json schema:
+${errors}
+
+File: ${path}`);
+    }
+    let config = parsed, providers = /* @__PURE__ */ new Map();
+    for (let [providerId, provider] of Object.entries(config.providers))
+      providers.set(providerId, deepFreeze(structuredClone(provider)));
+    return new _ModelConfig(providers);
+  }
+  getProvider(providerId) {
+    return this.providers.get(providerId);
+  }
+  getProviderIds() {
+    return [...this.providers.keys()];
+  }
+  getError() {
+    return this.error;
+  }
+};
+
+// packages/coding-agent/dist/core/models-store.js
+import { join as join4 } from "node:path";
+var InMemoryCodingAgentModelsStore = class {
+  entries = /* @__PURE__ */ new Map();
+  async read(providerId) {
+    return this.entries.get(providerId);
+  }
+  async write(providerId, entry) {
+    this.entries.set(providerId, entry);
+  }
+  async delete(providerId) {
+    this.entries.delete(providerId);
+  }
+}, FileModelsStore = class {
+  storage;
+  constructor(path = join4(getAgentDir(), "models-store.json")) {
+    this.storage = new FileAuthStorageBackend(path);
+  }
+  parse(content) {
+    let trimmed = content?.replace(/^\uFEFF/, "").trim();
+    if (!trimmed)
+      return {};
+    try {
+      let parsed = JSON.parse(trimmed);
+      return !parsed || typeof parsed != "object" || Array.isArray(parsed) ? {} : parsed;
+    } catch {
+      return {};
+    }
+  }
+  async read(providerId) {
+    return this.storage.withLock((content) => ({
+      result: structuredClone(this.parse(content)[providerId])
+    }));
+  }
+  async write(providerId, entry) {
+    await this.storage.withLockAsync(async (content) => {
+      let current = this.parse(content);
+      return current[providerId] = structuredClone(entry), { result: void 0, next: JSON.stringify(current, null, 2) };
+    });
+  }
+  async delete(providerId) {
+    await this.storage.withLockAsync(async (content) => {
+      let current = this.parse(content);
+      return delete current[providerId], { result: void 0, next: JSON.stringify(current, null, 2) };
+    });
+  }
+};
+
+// packages/coding-agent/dist/core/provider-composer.js
+import { lazyStream } from "@ashx-j/lunr-ai";
+import { getApiProvider } from "@ashx-j/lunr-ai/compat";
+function mergeCompat(base, override) {
+  if (!override)
+    return base;
+  let merged = { ...base, ...override }, baseNested = base, overrideNested = override, mergedNested = merged;
+  for (let key of ["openRouterRouting", "vercelGatewayRouting", "chatTemplateKwargs"]) {
+    let baseValue = baseNested?.[key], overrideValue = overrideNested[key];
+    (typeof baseValue == "object" && baseValue !== null || typeof overrideValue == "object" && overrideValue !== null) && (mergedNested[key] = { ...baseValue, ...overrideValue });
+  }
+  return merged;
+}
+function applyModelOverride(model, override) {
+  return {
+    ...model,
+    name: override.name ?? model.name,
+    reasoning: override.reasoning ?? model.reasoning,
+    thinkingLevelMap: override.thinkingLevelMap ? { ...model.thinkingLevelMap, ...override.thinkingLevelMap } : model.thinkingLevelMap,
+    input: override.input ?? model.input,
+    cost: override.cost ? {
+      input: override.cost.input ?? model.cost.input,
+      output: override.cost.output ?? model.cost.output,
+      cacheRead: override.cost.cacheRead ?? model.cost.cacheRead,
+      cacheWrite: override.cost.cacheWrite ?? model.cost.cacheWrite,
+      tiers: override.cost.tiers ?? model.cost.tiers
+    } : model.cost,
+    contextWindow: override.contextWindow ?? model.contextWindow,
+    maxTokens: override.maxTokens ?? model.maxTokens,
+    compat: mergeCompat(model.compat, override.compat)
+  };
+}
+function modelFromJson(providerId, definition, providerConfig, defaults) {
+  let api = definition.api ?? providerConfig.api ?? defaults?.api;
+  if (!api)
+    throw new Error(`Provider ${providerId}, model ${definition.id}: no "api" specified. Set at provider or model level.`);
+  let baseUrl = definition.baseUrl ?? providerConfig.baseUrl ?? defaults?.baseUrl;
+  if (!baseUrl)
+    throw new Error(`Provider ${providerId}: "baseUrl" is required when defining custom models.`);
+  if (definition.contextWindow !== void 0 && definition.contextWindow <= 0)
+    throw new Error(`Provider ${providerId}, model ${definition.id}: invalid contextWindow`);
+  if (definition.maxTokens !== void 0 && definition.maxTokens <= 0)
+    throw new Error(`Provider ${providerId}, model ${definition.id}: invalid maxTokens`);
+  return {
+    id: definition.id,
+    name: definition.name ?? definition.id,
+    api,
+    provider: providerId,
+    baseUrl,
+    reasoning: definition.reasoning ?? !1,
+    thinkingLevelMap: definition.thinkingLevelMap,
+    input: definition.input ?? ["text"],
+    cost: definition.cost ?? { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+    contextWindow: definition.contextWindow ?? 128e3,
+    maxTokens: definition.maxTokens ?? 16384,
+    headers: void 0,
+    compat: mergeCompat(providerConfig.compat, definition.compat)
+  };
+}
+function applyModelsJson(providerId, baseModels, config) {
+  if (!config)
+    return [...baseModels];
+  if (config.oauth && !config.baseUrl)
+    throw new Error(`Provider ${providerId}: "baseUrl" is required when "oauth" is set.`);
+  let hasOverrides = config.modelOverrides && Object.keys(config.modelOverrides).length > 0;
+  if (!config.models?.length && !config.baseUrl && !config.headers && !config.compat && !hasOverrides && !config.apiKey && !config.oauth && config.authHeader === void 0)
+    throw new Error(`Provider ${providerId}: must specify "baseUrl", "headers", "compat", "modelOverrides", or "models".`);
+  let models = baseModels.map((model) => ({
+    ...model,
+    baseUrl: config.oauth === "radius" ? model.baseUrl : config.baseUrl ?? model.baseUrl,
+    compat: mergeCompat(model.compat, config.compat)
+  }));
+  for (let definition of config.models ?? []) {
+    let existingIndex = models.findIndex((model2) => model2.id === definition.id), defaults = existingIndex >= 0 ? models[existingIndex] : models[0], model = modelFromJson(providerId, definition, config, defaults);
+    existingIndex >= 0 ? models[existingIndex] = model : models.push(model);
+  }
+  return models;
+}
+function applyExtension(providerId, models, config) {
+  return config ? config.models ? config.models.map((definition) => {
+    let defaults = models.find((model) => model.id === definition.id) ?? models[0], api = definition.api ?? config.api ?? defaults?.api;
+    if (!api)
+      throw new Error(`Provider ${providerId}, model ${definition.id}: no "api" specified. Set at provider or model level.`);
+    let baseUrl = definition.baseUrl ?? config.baseUrl ?? defaults?.baseUrl;
+    if (!baseUrl)
+      throw new Error(`Provider ${providerId}: "baseUrl" is required when defining custom models.`);
+    return {
+      ...definition,
+      api,
+      provider: providerId,
+      baseUrl,
+      headers: void 0
+    };
+  }) : config.baseUrl ? models.map((model) => ({ ...model, baseUrl: config.baseUrl })) : [...models] : [...models];
+}
+function adaptOAuth(config) {
+  return {
+    name: config.name,
+    login: async (callbacks) => ({ ...await config.login({
+      onAuth: (info) => callbacks.notify({ type: "auth_url", ...info }),
+      onDeviceCode: (info) => callbacks.notify({ type: "device_code", ...info }),
+      onPrompt: (prompt) => callbacks.prompt({ type: "text", ...prompt }),
+      onProgress: (message) => callbacks.notify({ type: "progress", message }),
+      onManualCodeInput: () => callbacks.prompt({ type: "manual_code", message: "Paste the authorization code" }),
+      onSelect: (prompt) => callbacks.prompt({ type: "select", ...prompt }),
+      signal: callbacks.signal
+    }), type: "oauth" }),
+    refresh: async (credential) => ({ ...await config.refreshToken(credential), type: "oauth" }),
+    toAuth: async (credential) => ({ apiKey: config.getApiKey(credential) })
+  };
+}
+function withConfiguredAuth(auth, headers, authHeader) {
+  let mergedHeaders = auth.headers || headers ? { ...auth.headers, ...headers } : void 0;
+  if (authHeader) {
+    if (!auth.apiKey)
+      throw new Error("authHeader requires a resolved API key");
+    mergedHeaders = { ...mergedHeaders, Authorization: `Bearer ${auth.apiKey}` };
+  }
+  return { ...auth, headers: mergedHeaders };
+}
+function configuredApiKey(config, extension) {
+  return extension?.apiKey ?? config?.apiKey;
+}
+function configuredHeaders(config, extension) {
+  if (!(!config?.headers && !extension?.headers))
+    return { ...config?.headers, ...extension?.headers };
+}
+async function configContextEnv(values, ctx, explicit) {
+  let env = { ...explicit };
+  for (let name of new Set(values.flatMap(getConfigValueEnvVarNames))) {
+    if (env[name] !== void 0)
+      continue;
+    let value = await ctx.env(name);
+    value !== void 0 && (env[name] = value);
+  }
+  return Object.keys(env).length > 0 ? env : void 0;
+}
+function composeApiKeyAuth(providerId, base, config, extension) {
+  let inherited = base?.auth.apiKey, rawKey = configuredApiKey(config, extension), oauth = extension?.oauth ?? base?.auth.oauth;
+  if (!inherited && rawKey === void 0 && oauth)
+    return;
+  let rawHeaders = configuredHeaders(config, extension), authHeader = extension?.authHeader ?? config?.authHeader ?? !1;
+  return {
+    name: inherited?.name ?? "API key",
+    login: inherited?.login ?? (async (interaction) => ({
+      type: "api_key",
+      key: await interaction.prompt({ type: "secret", message: "Enter API key" })
+    })),
+    check: async (input) => {
+      if (input.credential) {
+        if (inherited?.check)
+          return inherited.check(input);
+        if (input.credential.key)
+          return { type: "api_key", source: "stored credential" };
+        let resolved2 = await inherited?.resolve(input);
+        return resolved2 ? { type: "api_key", source: resolved2.source } : void 0;
+      }
+      if (rawKey !== void 0) {
+        if (isCommandConfigValue(rawKey))
+          return { type: "api_key", source: "configured API key" };
+        let envNames = getConfigValueEnvVarNames(rawKey);
+        for (let name of envNames)
+          if (await input.ctx.env(name) === void 0)
+            return;
+        return { type: "api_key", source: "configured API key" };
+      }
+      if (inherited?.check)
+        return inherited.check(input);
+      let resolved = await inherited?.resolve(input);
+      return resolved ? { type: "api_key", source: resolved.source } : void 0;
+    },
+    resolve: async (input) => {
+      let result;
+      if (input.credential)
+        result = inherited ? await inherited.resolve(input) : input.credential.key ? { auth: { apiKey: input.credential.key }, env: input.credential.env, source: "stored credential" } : void 0;
+      else if (rawKey !== void 0) {
+        let env = await configContextEnv([rawKey], input.ctx), key = resolveConfigValueOrThrow(rawKey, `API key for provider "${providerId}"`, env);
+        result = inherited ? await inherited.resolve({ ...input, credential: { type: "api_key", key } }) : { auth: { apiKey: key }, source: "configured API key" };
+      } else
+        result = await inherited?.resolve(input);
+      if (!result)
+        return;
+      let explicitEnv = { ...input.credential?.env ?? {}, ...result.env ?? {} }, headerEnv = await configContextEnv(Object.values(rawHeaders ?? {}), input.ctx, explicitEnv), headers = resolveHeadersOrThrow(rawHeaders, `provider "${providerId}"`, headerEnv);
+      return { ...result, auth: withConfiguredAuth(result.auth, headers, authHeader) };
+    }
+  };
+}
+function composeOAuthAuth(providerId, base, config, extension) {
+  let oauth = extension?.oauth ? adaptOAuth(extension.oauth) : base?.auth.oauth;
+  if (!oauth)
+    return;
+  let rawHeaders = configuredHeaders(config, extension), authHeader = extension?.authHeader ?? config?.authHeader ?? !1;
+  return {
+    ...oauth,
+    toAuth: async (credential) => {
+      let auth = await oauth.toAuth(credential), env = credential.env, headers = resolveHeadersOrThrow(rawHeaders, `provider "${providerId}"`, typeof env == "object" && env !== null ? env : void 0);
+      return withConfiguredAuth(auth, headers, authHeader);
+    }
+  };
+}
+function rawModelHeaders(model, config, extension) {
+  let definition = config?.models?.find((entry) => entry.id === model.id), extensionModel = extension?.models?.find((entry) => entry.id === model.id), headers = {
+    ...config?.modelOverrides?.[model.id]?.headers,
+    ...definition?.headers,
+    ...extensionModel?.headers
+  };
+  return Object.keys(headers).length > 0 ? headers : void 0;
+}
+function validateExtensionProvider(providerId, base, modelsConfig, extension) {
+  if (extension.streamSimple && !extension.api)
+    throw new Error(`Provider ${providerId}: "api" is required when registering streamSimple.`);
+  applyExtension(providerId, applyModelsJson(providerId, base?.getModels() ?? [], modelsConfig), extension);
+}
+function composeModelProvider(providerId, base, modelConfig, extension) {
+  let config = modelConfig.getProvider(providerId), extensionOAuthCredential, refreshedExtensionModels, currentExtension = () => extension && refreshedExtensionModels ? { ...extension, models: refreshedExtensionModels } : extension, getModels = () => {
+    let models = applyExtension(providerId, applyModelsJson(providerId, base?.getModels() ?? [], config), currentExtension());
+    return extensionOAuthCredential && extension?.oauth?.modifyModels && (models = extension.oauth.modifyModels(models, extensionOAuthCredential)), models.map((model) => {
+      let override = config?.modelOverrides?.[model.id];
+      return override ? applyModelOverride(model, override) : model;
+    });
+  };
+  getModels();
+  let apiKey = composeApiKeyAuth(providerId, base, config, extension), oauth = composeOAuthAuth(providerId, base, config, extension);
+  if (!apiKey && !oauth)
+    throw new Error(`Provider ${providerId}: no authentication method configured.`);
+  let supportsBaseApi = (model) => base?.getModels().some((entry) => entry.api === model.api) ?? !1, streamWith = (model, context, options, simple) => lazyStream(model, async () => {
+    if (extension?.streamSimple && model.api === extension.api)
+      return extension.streamSimple(model, context, options);
+    if (base && supportsBaseApi(model))
+      return simple ? base.streamSimple(model, context, options) : base.stream(model, context, options);
+    let api = getApiProvider(model.api);
+    if (!api)
+      throw new Error(`No API provider registered for api: ${model.api}`);
+    return simple ? api.streamSimple(model, context, options) : api.stream(model, context, options);
+  });
+  return {
+    id: providerId,
+    name: extension?.name ?? config?.name ?? base?.name ?? extension?.oauth?.name ?? providerId,
+    baseUrl: extension?.baseUrl ?? config?.baseUrl ?? base?.baseUrl,
+    headers: base?.headers,
+    auth: { ...apiKey ? { apiKey } : {}, ...oauth ? { oauth } : {} },
+    getModels,
+    refreshModels: base?.refreshModels || extension?.refreshModels || extension?.oauth?.modifyModels ? async (context) => {
+      if (await base?.refreshModels?.(context), extension?.refreshModels) {
+        let refreshed = await extension.refreshModels(context);
+        context.signal?.aborted || (applyExtension(providerId, applyModelsJson(providerId, base?.getModels() ?? [], config), {
+          ...extension,
+          models: refreshed
+        }), refreshedExtensionModels = refreshed);
+      }
+      extensionOAuthCredential = context.credential?.type === "oauth" ? context.credential : void 0;
+    } : void 0,
+    filterModels: base?.filterModels ? (models, credential) => base.filterModels(models, credential) : void 0,
+    stream: (model, context, options) => streamWith(model, context, options, !1),
+    streamSimple: (model, context, options) => streamWith(model, context, options, !0)
+  };
+}
+function resolveConfiguredModelHeaders(model, config, extension, env) {
+  return resolveHeadersOrThrow(rawModelHeaders(model, config, extension), `model "${model.provider}/${model.id}"`, env);
+}
+function resolveCompatibilityRequestConfig(model, config, extension) {
+  let configured = resolveHeadersOrThrow({ ...configuredHeaders(config, extension), ...rawModelHeaders(model, config, extension) }, `model "${model.provider}/${model.id}"`);
+  return {
+    headers: model.headers || configured ? { ...model.headers, ...configured } : void 0,
+    authHeader: extension?.authHeader ?? config?.authHeader ?? !1
+  };
+}
+function configuredRequestAuthStatus(config, extension) {
+  let value = configuredApiKey(config, extension);
+  if (value === void 0)
+    return;
+  if (isCommandConfigValue(value))
+    return { configured: !0, source: "models_json_command" };
+  let names = getConfigValueEnvVarNames(value);
+  return names.length > 0 ? isConfigValueConfigured(value) ? { configured: !0, source: "environment", label: names.join(", ") } : { configured: !1 } : { configured: !0, source: extension?.apiKey !== void 0 ? "fallback" : "models_json_key" };
+}
+
+// packages/coding-agent/dist/core/runtime-credentials.js
+var RuntimeCredentials = class {
+  store;
+  overrides = /* @__PURE__ */ new Map();
+  constructor(store) {
+    this.store = store;
+  }
+  setRuntimeApiKey(providerId, apiKey) {
+    this.overrides.set(providerId, apiKey);
+  }
+  removeRuntimeApiKey(providerId) {
+    this.overrides.delete(providerId);
+  }
+  hasRuntimeApiKey(providerId) {
+    return this.overrides.has(providerId);
+  }
+  async read(providerId) {
+    let override = this.overrides.get(providerId);
+    return override ? { type: "api_key", key: override } : this.store.read(providerId);
+  }
+  async list() {
+    let entries = new Map((await this.store.list()).map((entry) => [entry.providerId, entry]));
+    for (let providerId of this.overrides.keys())
+      entries.set(providerId, { providerId, type: "api_key" });
+    return [...entries.values()];
+  }
+  modify(providerId, fn) {
+    return this.store.modify(providerId, fn);
+  }
+  async delete(providerId) {
+    this.overrides.delete(providerId), await this.store.delete(providerId);
+  }
+};
+
+// packages/coding-agent/dist/core/subscriptions.js
+import { join as join5 } from "path";
+
+// packages/coding-agent/dist/core/usage-limit.js
+var USAGE_LIMIT_ERROR_PATTERNS = [
+  // Provider-declared subscription/free-tier limit error types and wording
+  // (pi-ai NON_RETRYABLE_PROVIDER_LIMIT_ERROR_PATTERN spirit).
+  "GoUsageLimitError",
+  "FreeUsageLimitError",
+  "Monthly usage limit reached",
+  "available balance",
+  "insufficient_quota",
+  "out of budget",
+  "quota exceeded",
+  "billing"
+], USAGE_LIMIT_ERROR_REGEXES = [
+  // Goal runtime USAGE_LIMIT_GOAL_ERROR_PATTERNS: usage caps, quota exhaustion,
+  // credit/balance exhaustion, payment required.
+  /usage[_\s-]*(?:limit|cap)|chatgpt.{0,32}usage/i,
+  /quota.{0,32}(?:reached|exceeded|exhausted|depleted)|(?:reached|exceeded|exhausted|depleted).{0,32}quota/i,
+  /insufficient[_\s-]*(?:quota|credits?)|out of credits|out of budget|available balance|payment required/i,
+  /(?:credit|balance).{0,32}(?:low|exhausted|depleted)|billing/i
+], AUTH_INVALID_ERROR_PATTERN = /\b401\b|unauthori[sz]ed|unauthenticated|invalid.{0,16}(?:api.?key|token|credentials?)|authentication.{0,16}failed/i;
+function isUsageLimitError(errorMessage) {
+  return errorMessage ? USAGE_LIMIT_ERROR_PATTERNS.some((pattern) => errorMessage.toLowerCase().includes(pattern.toLowerCase())) ? !0 : USAGE_LIMIT_ERROR_REGEXES.some((pattern) => pattern.test(errorMessage)) : !1;
+}
+function isAuthInvalidError(errorMessage) {
+  return errorMessage ? AUTH_INVALID_ERROR_PATTERN.test(errorMessage) : !1;
+}
+var RESET_TIME_PATTERNS = [
+  /reset(?:s|ting)?\s*(?:in|after|at)?\s*(\d+)\s*s(ec)?/i,
+  /reset(?:s|ting)?\s*(?:in|after|at)?\s*(\d+)\s*m(in)?/i,
+  /reset(?:s|ting)?\s*(?:in|after|at)?\s*(\d+)\s*h(our|r)?/i,
+  /(?:retry|try(?:\s+again)?|available)\s+(?:in|after|at)\s*(\d+)\s*s(ec)?/i,
+  /(?:retry|try(?:\s+again)?|available)\s+(?:in|after|at)\s*(\d+)\s*m(in)?/i,
+  /(?:retry|try(?:\s+again)?|available)\s+(?:in|after|at)\s*(\d+)\s*h(our|r)?/i
+];
+function parseResetTimeMs(errorMessage) {
+  if (!errorMessage)
+    return;
+  let now = Date.now();
+  for (let pattern of RESET_TIME_PATTERNS) {
+    let match = errorMessage.match(pattern);
+    if (!match)
+      continue;
+    let value = Number.parseInt(match[1] ?? "", 10);
+    if (!Number.isFinite(value) || value <= 0)
+      continue;
+    let unit = pattern.source.includes("\\s*h") ? 36e5 : pattern.source.includes("\\s*m") ? 6e4 : 1e3;
+    return now + value * unit;
+  }
+  let isoMatch = errorMessage.match(/(?:reset|available).{0,12}(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(:\d{2})?(?:\.\d+)?(?:Z|[+-]\d{2}:?\d{2})?)/i);
+  if (isoMatch?.[1]) {
+    let parsed = Date.parse(isoMatch[1]);
+    if (Number.isFinite(parsed) && parsed > now)
+      return parsed;
+  }
+}
+
+// packages/coding-agent/dist/core/subscriptions.js
+var SubscriptionManager = class _SubscriptionManager {
+  data = {};
+  loaded = !1;
+  storage;
+  authStorage;
+  // In-process write queue so mutations serialize even before the file lock.
+  queue = Promise.resolve();
+  // Per-provider ids of keys exhausted without a parseable reset time.
+  // Process-local on purpose: infinite exhaustion is never persisted.
+  memoryExhausted = /* @__PURE__ */ new Map();
+  constructor(authStorage, storage) {
+    this.authStorage = authStorage, this.storage = storage;
+  }
+  static create(authStorage, path) {
+    return new _SubscriptionManager(authStorage, new FileAuthStorageBackend(path ?? join5(getAgentDir(), "subscriptions.json")));
+  }
+  static fromStorage(authStorage, storage) {
+    return new _SubscriptionManager(authStorage, storage);
+  }
+  static inMemory(authStorage, data = {}) {
+    let storage = new InMemoryAuthStorageBackend();
+    return storage.withLock(() => ({ result: void 0, next: JSON.stringify(data, null, 2) })), _SubscriptionManager.fromStorage(authStorage, storage);
+  }
+  parseStorageData(content) {
+    return content ? JSON.parse(content) : {};
+  }
+  ensureLoaded() {
+    if (this.loaded)
+      return;
+    this.loaded = !0;
+    let content;
+    try {
+      this.storage.withLock((current) => (content = current, { result: void 0 })), this.data = this.parseStorageData(content);
+    } catch {
+    }
+  }
+  enqueue(fn) {
+    let next = this.queue.then(fn);
+    return this.queue = next.catch(() => {
+    }), next;
+  }
+  persist() {
+    return this.storage.withLockAsync(async () => ({
+      result: void 0,
+      next: JSON.stringify(this.data, null, 2)
+    }));
+  }
+  /** Raw stored credential read via the modify path (returning undefined leaves it unchanged). */
+  async readRawCredential(providerId) {
+    let current;
+    return await this.authStorage.modify(providerId, async (credential) => {
+      current = credential;
+    }), current;
+  }
+  /**
+   * Pool for a provider, lazy-importing an existing stored api_key credential
+   * as "Sub 1" on first access. OAuth credentials are not imported.
+   */
+  async ensurePool(providerId) {
+    this.ensureLoaded();
+    let existing = this.data[providerId];
+    if (existing)
+      return existing;
+    let credential = await this.readRawCredential(providerId);
+    if (credential?.type !== "api_key" || credential.key === void 0)
+      return;
+    let pool = {
+      active: "1",
+      keys: [{ id: "1", name: "Sub 1", key: credential.key, addedAt: Date.now() }]
+    };
+    return this.data = { ...this.data, [providerId]: pool }, await this.persist(), pool;
+  }
+  nextId(pool) {
+    let max = 0;
+    for (let entry of pool.keys) {
+      let numeric = Number.parseInt(entry.id, 10);
+      Number.isFinite(numeric) && numeric > max && (max = numeric);
+    }
+    return String(max + 1);
+  }
+  async mirrorActive(providerId, key) {
+    await this.authStorage.modify(providerId, async () => ({ type: "api_key", key }));
+  }
+  async list(providerId) {
+    return this.enqueue(async () => {
+      let pool = await this.ensurePool(providerId);
+      return pool ? [...pool.keys] : [];
+    });
+  }
+  async getActive(providerId) {
+    return this.enqueue(async () => {
+      let pool = await this.ensurePool(providerId);
+      return pool?.keys.find((entry) => entry.id === pool.active);
+    });
+  }
+  async addKey(providerId, key, name) {
+    return this.enqueue(async () => {
+      this.ensureLoaded();
+      let pool = await this.ensurePool(providerId), id = pool ? this.nextId(pool) : "1", entry = { id, name: name ?? `Sub ${id}`, key, addedAt: Date.now() }, keys = [...pool?.keys ?? [], entry];
+      return this.data = { ...this.data, [providerId]: { active: id, keys } }, await this.persist(), await this.mirrorActive(providerId, key), entry;
+    });
+  }
+  async removeKey(providerId, id) {
+    return this.enqueue(async () => {
+      let pool = await this.ensurePool(providerId);
+      if (!pool || !pool.keys.some((entry) => entry.id === id))
+        return;
+      let keys = pool.keys.filter((entry) => entry.id !== id);
+      if (this.memoryExhausted.get(providerId)?.delete(id), keys.length === 0) {
+        let data = { ...this.data };
+        delete data[providerId], this.data = data, await this.persist(), await this.authStorage.delete(providerId);
+        return;
+      }
+      let active = pool.active;
+      if (active === id) {
+        active = keys[0]?.id ?? active, this.data = { ...this.data, [providerId]: { active, keys } }, await this.persist();
+        let promoted = keys.find((entry) => entry.id === active);
+        promoted && await this.mirrorActive(providerId, promoted.key);
+        return;
+      }
+      this.data = { ...this.data, [providerId]: { active, keys } }, await this.persist();
+    });
+  }
+  async renameKey(providerId, id, name) {
+    return this.enqueue(async () => {
+      let pool = await this.ensurePool(providerId);
+      if (!pool)
+        return;
+      let keys = pool.keys.map((entry) => entry.id === id ? { ...entry, name } : entry);
+      this.data = { ...this.data, [providerId]: { ...pool, keys } }, await this.persist();
+    });
+  }
+  async setActive(providerId, id) {
+    return this.enqueue(async () => {
+      let pool = await this.ensurePool(providerId), entry = pool?.keys.find((candidate) => candidate.id === id);
+      !pool || !entry || (this.data = { ...this.data, [providerId]: { ...pool, active: id } }, await this.persist(), await this.mirrorActive(providerId, entry.key));
+    });
+  }
+  /**
+   * Mark the active key exhausted and rotate to the next non-exhausted key in
+   * round-robin order. A parseable reset time is persisted as exhaustedUntil;
+   * otherwise the exhaustion is process-local only. Returns the new active key,
+   * or null when no non-exhausted alternative exists (current key stays active).
+   */
+  async rotateOnFailure(providerId, errorMessage, now = Date.now()) {
+    return this.enqueue(async () => {
+      let pool = await this.ensurePool(providerId);
+      if (!pool)
+        return null;
+      let currentIndex = pool.keys.findIndex((entry) => entry.id === pool.active);
+      if (currentIndex === -1)
+        return null;
+      let current = pool.keys[currentIndex];
+      if (!current)
+        return null;
+      let resetAt = parseResetTimeMs(errorMessage), keys = pool.keys;
+      if (resetAt !== void 0 && resetAt > now)
+        keys = pool.keys.map((entry) => entry.id === current.id ? { ...entry, exhaustedUntil: resetAt, lastError: errorMessage } : entry);
+      else {
+        let set = this.memoryExhausted.get(providerId) ?? /* @__PURE__ */ new Set();
+        set.add(current.id), this.memoryExhausted.set(providerId, set);
+      }
+      let isExhausted = (entry) => this.memoryExhausted.get(providerId)?.has(entry.id) === !0 || entry.exhaustedUntil !== void 0 && entry.exhaustedUntil > now;
+      for (let offset = 1; offset < keys.length; offset++) {
+        let candidate = keys[(currentIndex + offset) % keys.length];
+        if (!(!candidate || isExhausted(candidate)))
+          return this.data = { ...this.data, [providerId]: { active: candidate.id, keys } }, await this.persist(), await this.mirrorActive(providerId, candidate.key), candidate;
+      }
+      return keys !== pool.keys && (this.data = { ...this.data, [providerId]: { ...pool, keys } }, await this.persist()), null;
+    });
+  }
+  /** Manual reactivate: clears persisted and process-local exhaustion for a key. */
+  async clearExhaustion(providerId, id) {
+    return this.enqueue(async () => {
+      this.memoryExhausted.get(providerId)?.delete(id);
+      let pool = await this.ensurePool(providerId);
+      if (!pool)
+        return;
+      let target = pool.keys.find((entry) => entry.id === id);
+      if (!target || target.exhaustedUntil === void 0 && target.lastError === void 0)
+        return;
+      let keys = pool.keys.map((entry) => {
+        if (entry.id !== id)
+          return entry;
+        let { exhaustedUntil: _exhaustedUntil, lastError: _lastError, ...rest } = entry;
+        return rest;
+      });
+      this.data = { ...this.data, [providerId]: { ...pool, keys } }, await this.persist();
+    });
+  }
+};
+
+// packages/coding-agent/dist/core/user-models.js
+import { existsSync as existsSync4, mkdirSync as mkdirSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync4 } from "node:fs";
+import { dirname as dirname4, join as join6 } from "node:path";
+var USER_MODELS_FILENAME = "user-models.json";
+function userModelsPath(agentDir = getAgentDir()) {
+  return join6(agentDir, USER_MODELS_FILENAME);
+}
+function isRecord3(value) {
+  return typeof value == "object" && value !== null && !Array.isArray(value);
+}
+function asFiniteNumber3(value) {
+  if (typeof value == "number" && Number.isFinite(value))
+    return value;
+}
+function parseUserEntry(value) {
+  if (!isRecord3(value))
+    return;
+  let id = typeof value.id == "string" ? value.id.trim() : "", provider = typeof value.provider == "string" ? value.provider.trim() : "";
+  if (!id || !provider)
+    return;
+  let parsedInput = Array.isArray(value.input) ? value.input.filter((entry) => entry === "text" || entry === "image") : ["text"], input = parsedInput.length > 0 ? parsedInput : ["text"], cost = isRecord3(value.cost) ? {
+    input: asFiniteNumber3(value.cost.input) ?? 0,
+    output: asFiniteNumber3(value.cost.output) ?? 0,
+    cacheRead: asFiniteNumber3(value.cost.cacheRead) ?? 0,
+    cacheWrite: asFiniteNumber3(value.cost.cacheWrite) ?? 0
+  } : { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
+  return {
+    id,
+    name: typeof value.name == "string" && value.name.trim() ? value.name : id,
+    api: typeof value.api == "string" && value.api.trim() ? value.api : "openai-completions",
+    provider,
+    baseUrl: typeof value.baseUrl == "string" ? value.baseUrl : "",
+    reasoning: value.reasoning === !0,
+    input,
+    cost,
+    contextWindow: asFiniteNumber3(value.contextWindow) ?? 128e3,
+    maxTokens: asFiniteNumber3(value.maxTokens) ?? 8192,
+    compat: isRecord3(value.compat) ? value.compat : void 0,
+    thinkingLevelMap: isRecord3(value.thinkingLevelMap) ? value.thinkingLevelMap : void 0,
+    source: "user"
+  };
+}
+function emptyUserModels() {
+  return { version: 1, models: [] };
+}
+function readUserModels(path) {
+  try {
+    if (!existsSync4(path))
+      return emptyUserModels();
+    let parsed = JSON.parse(readFileSync4(path, "utf-8"));
+    if (!isRecord3(parsed) || !Array.isArray(parsed.models))
+      return emptyUserModels();
+    let models = [];
+    for (let entry of parsed.models) {
+      let model = parseUserEntry(entry);
+      model && models.push(model);
+    }
+    return { version: asFiniteNumber3(parsed.version) ?? 1, models };
+  } catch {
+    return emptyUserModels();
+  }
+}
+function writeUserModels(file, path) {
+  mkdirSync4(dirname4(path), { recursive: !0, mode: 448 }), writeFileSync4(path, `${JSON.stringify({ version: file.version ?? 1, models: file.models }, null, 2)}
+`, "utf-8");
+}
+function evictUserModelsOnOfficial(user, officialKeys) {
+  let hits = new Set(officialKeys), kept = [], evicted = [];
+  for (let model of user.models)
+    hits.has(modelKey(model.provider, model.id)) ? evicted.push(model) : kept.push(model);
+  return { next: { version: user.version, models: kept }, evicted };
+}
+function evictUserModelsByProvider(user, providerId) {
+  let kept = [], evicted = [];
+  for (let model of user.models)
+    model.provider === providerId ? evicted.push(model) : kept.push(model);
+  return { next: { version: user.version, models: kept }, evicted };
+}
+function upsertUserModels(existing, rows) {
+  let byKey = new Map(existing.models.map((model) => [modelKey(model.provider, model.id), model]));
+  for (let row of rows)
+    byKey.set(modelKey(row.provider, row.id), { ...row, source: "user" });
+  return { version: existing.version ?? 1, models: [...byKey.values()] };
+}
+function userEntryToModel(entry) {
+  return {
+    id: entry.id,
+    name: entry.name,
+    api: entry.api,
+    provider: entry.provider,
+    baseUrl: entry.baseUrl,
+    reasoning: entry.reasoning,
+    input: entry.input,
+    cost: entry.cost,
+    contextWindow: entry.contextWindow,
+    maxTokens: entry.maxTokens,
+    compat: entry.compat,
+    thinkingLevelMap: entry.thinkingLevelMap
+  };
+}
+var UserModelsStore = class {
+  path;
+  file;
+  constructor(path) {
+    this.path = path, this.file = path ? readUserModels(path) : emptyUserModels();
+  }
+  list() {
+    return this.file.models;
+  }
+  keys() {
+    return new Set(this.file.models.map((model) => modelKey(model.provider, model.id)));
+  }
+  modelsFor(providerId) {
+    return this.file.models.filter((model) => model.provider === providerId).map(userEntryToModel);
+  }
+  evictOfficial(officialKeys) {
+    let { next, evicted } = evictUserModelsOnOfficial(this.file, officialKeys);
+    return evicted.length > 0 && (this.file = next, this.persist()), evicted;
+  }
+  evictProvider(providerId) {
+    let { next, evicted } = evictUserModelsByProvider(this.file, providerId);
+    return evicted.length > 0 && (this.file = next, this.persist()), evicted;
+  }
+  upsert(rows) {
+    rows.length !== 0 && (this.file = upsertUserModels(this.file, rows), this.persist());
+  }
+  persist() {
+    if (this.path)
+      try {
+        writeUserModels(this.file, this.path);
+      } catch {
+      }
+  }
+};
+
+// packages/coding-agent/dist/core/model-runtime.js
+function mergeHeaders(base, override) {
+  if (!base && !override)
+    return;
+  let merged = { ...base };
+  for (let [name, value] of Object.entries(override ?? {})) {
+    let lowerName = name.toLowerCase();
+    for (let existingName of Object.keys(merged))
+      existingName.toLowerCase() === lowerName && delete merged[existingName];
+    merged[name] = value;
+  }
+  return merged;
+}
+var ModelRuntime = class _ModelRuntime {
+  models;
+  credentials;
+  /** lunr: per-provider subscription-key pools; rotation mirrors the active key into the credential store. */
+  subscriptionManager;
+  defaultBuiltins;
+  builtins = /* @__PURE__ */ new Map();
+  extensionProviders = /* @__PURE__ */ new Map();
+  compositionErrors = /* @__PURE__ */ new Map();
+  modelsPath;
+  allowModelNetwork;
+  config;
+  snapshot = {
+    all: [],
+    available: [],
+    configuredProviders: /* @__PURE__ */ new Set(),
+    storedProviders: /* @__PURE__ */ new Set(),
+    auth: /* @__PURE__ */ new Map()
+  };
+  availabilityRefresh;
+  availabilityError;
+  modelsStore;
+  overlay = new CatalogOverlaySource();
+  userModels;
+  officialCachePath;
+  lastCatalogRefresh = { aborted: !1, errors: /* @__PURE__ */ new Map(), live: [], incomplete: [] };
+  lastOfficial;
+  catalogRefresh;
+  catalogRefreshAllowsNetwork = !1;
+  nextAutomaticRefresh = 0;
+  automaticRefreshIdentity = "";
+  grokHome;
+  constructor(credentials, config, modelsPath, modelsStore, providers, allowModelNetwork, subscriptionManager, catalogDir, grokHome) {
+    this.credentials = credentials, this.config = config, this.modelsPath = modelsPath, this.modelsStore = modelsStore, this.allowModelNetwork = allowModelNetwork, this.subscriptionManager = subscriptionManager, this.userModels = new UserModelsStore(catalogDir ? userModelsPath(catalogDir) : void 0), this.officialCachePath = catalogDir ? officialCatalogCachePath(catalogDir) : void 0, this.grokHome = grokHome, this.defaultBuiltins = new Map(providers.map((provider) => [provider.id, provider]));
+    for (let [providerId, provider] of this.defaultBuiltins)
+      this.builtins.set(providerId, provider);
+    this.models = createModels({ credentials, modelsStore }), this.rebuildProviders();
+  }
+  static async create(options = {}) {
+    let rawStore = options.credentials ?? AuthStorage.create(options.authPath), grokHomeDisabled = options.grokHome === null || options.grokHome === void 0 && options.credentials !== void 0, grokHome = grokHomeDisabled ? void 0 : options.grokHome ?? void 0, baseStore = grokHomeDisabled ? rawStore : wrapXaiGrokCliCredentials(rawStore, { grokHome }), credentials = new RuntimeCredentials(baseStore), subscriptionManager = options.subscriptions ?? (options.credentials && !options.authPath ? SubscriptionManager.inMemory(baseStore) : SubscriptionManager.create(baseStore, options.authPath ? join7(dirname5(options.authPath), "subscriptions.json") : void 0)), modelsPath = options.modelsPath === null ? void 0 : options.modelsPath ?? join7(getAgentDir(), "models.json"), config = await ModelConfig.load(modelsPath), modelsStore = options.modelsStore ?? (modelsPath ? new FileModelsStore(options.modelsStorePath ?? join7(dirname5(modelsPath), "models-store.json")) : new InMemoryCodingAgentModelsStore()), providers = builtinProviderCatalog.builtinProviders(), catalogDir = modelsPath ? dirname5(modelsPath) : options.authPath ? dirname5(options.authPath) : void 0, runtime = new _ModelRuntime(credentials, config, modelsPath, modelsStore, providers, options.allowModelNetwork ?? process.env.PI_OFFLINE === void 0, subscriptionManager, catalogDir, grokHome);
+    return runtime.configureRadiusProviders(), runtime.rebuildProviders(), await runtime.refresh({ allowNetwork: !1 }), runtime;
+  }
+  configureRadiusProviders() {
+    this.builtins.clear();
+    for (let [providerId, provider] of this.defaultBuiltins)
+      this.builtins.set(providerId, provider);
+    for (let providerId of this.config.getProviderIds()) {
+      let config = this.config.getProvider(providerId);
+      config?.oauth !== "radius" || !config.baseUrl || this.builtins.set(providerId, builtinProviderCatalog.radiusProvider({
+        id: providerId,
+        name: config.name ?? providerId,
+        gateway: config.baseUrl.replace(/\/v1\/?$/u, "")
+      }));
+    }
+  }
+  providerIds() {
+    return /* @__PURE__ */ new Set([...this.builtins.keys(), ...this.config.getProviderIds(), ...this.extensionProviders.keys()]);
+  }
+  recomposeProvider(providerId) {
+    let base = this.builtins.get(providerId), extension = this.extensionProviders.get(providerId);
+    if (!base && !this.config.getProvider(providerId) && !extension) {
+      this.models.deleteProvider(providerId), this.compositionErrors.delete(providerId);
+      return;
+    }
+    if (base && !this.config.getProvider(providerId) && !extension) {
+      this.models.setProvider(this.withLocalCatalog(base)), this.compositionErrors.delete(providerId);
+      return;
+    }
+    try {
+      this.models.setProvider(composeModelProvider(providerId, base ? this.withLocalCatalog(base) : void 0, this.config, extension)), this.compositionErrors.delete(providerId);
+    } catch (error) {
+      this.compositionErrors.set(providerId, error instanceof Error ? error.message : String(error)), base ? this.models.setProvider(this.withLocalCatalog(base)) : this.models.deleteProvider(providerId);
+    }
+  }
+  withLocalCatalog(provider) {
+    return withCatalogOverlay(provider, this.overlay);
+  }
+  bakedInModels(providerId) {
+    return [...this.defaultBuiltins.get(providerId)?.getModels() ?? []];
+  }
+  rebuildProviders() {
+    this.models.clearProviders(), this.compositionErrors.clear();
+    for (let providerId of this.providerIds())
+      this.recomposeProvider(providerId);
+    this.updateModelSnapshot();
+  }
+  updateModelSnapshot() {
+    let all = [...this.models.getModels()];
+    this.snapshot = {
+      ...this.snapshot,
+      all,
+      available: all.filter((model) => this.snapshot.configuredProviders.has(model.provider) && this.isCatalogModelAvailable(model))
+    };
+  }
+  isCatalogModelAvailable(model) {
+    return !!this.config.getProvider(model.provider)?.models?.some((row) => row.id === model.id) || !!this.extensionProviders.get(model.provider)?.models?.some((row) => row.id === model.id) || this.overlay.isAvailable(model);
+  }
+  async listStoredProviderIds() {
+    let credentials = await this.credentials.list();
+    return new Set(credentials.map((entry) => entry.providerId));
+  }
+  /** `/model` lists stored creds + models.json/extension keys, never ambient envApiKeyAuth. */
+  configuredProviderIds(storedProviders) {
+    let configured = new Set(storedProviders);
+    for (let provider of this.models.getProviders())
+      configuredRequestAuthStatus(this.config.getProvider(provider.id), this.extensionProviders.get(provider.id))?.configured && configured.add(provider.id);
+    return configured;
+  }
+  userModelsForStoredProviders(storedProviders) {
+    return this.userModels.list().filter((row) => storedProviders.has(row.provider)).map(userEntryToModel);
+  }
+  async runAvailabilityRefresh() {
+    let providers = this.models.getProviders(), [available, checks, storedProviders] = await Promise.all([
+      this.models.getAvailable(),
+      Promise.all(providers.map(async (provider) => [
+        provider.id,
+        await this.models.checkAuth(provider.id)
+      ])),
+      this.listStoredProviderIds()
+    ]), auth = new Map(checks), configuredProviders = this.configuredProviderIds(storedProviders);
+    this.snapshot = {
+      all: [...this.models.getModels()],
+      available: available.filter((model) => configuredProviders.has(model.provider) && this.isCatalogModelAvailable(model)),
+      configuredProviders,
+      storedProviders,
+      auth
+    }, this.availabilityError = void 0;
+  }
+  queueAvailabilityRefresh(after) {
+    let tracked = (after ?? Promise.resolve()).catch(() => {
+    }).then(() => this.runAvailabilityRefresh()).catch((error) => {
+      throw this.availabilityError = error instanceof Error ? error.message : String(error), error;
+    }).finally(() => {
+      this.availabilityRefresh === tracked && (this.availabilityRefresh = void 0);
+    });
+    return this.availabilityRefresh = tracked, tracked;
+  }
+  /** Coalesce concurrent readers onto the pending refresh. */
+  refreshAvailability() {
+    return this.availabilityRefresh ?? this.queueAvailabilityRefresh(void 0);
+  }
+  /** Mutations must not observe an in-flight refresh started before them. */
+  forceRefreshAvailability() {
+    return this.queueAvailabilityRefresh(this.availabilityRefresh);
+  }
+  getProviders() {
+    return this.models.getProviders();
+  }
+  getProvider(providerId) {
+    return this.models.getProvider(providerId);
+  }
+  getModels(providerId) {
+    return this.models.getModels(providerId);
+  }
+  getModel(providerId, modelId) {
+    return this.models.getModel(providerId, modelId);
+  }
+  async checkAuth(providerId) {
+    return this.models.checkAuth(providerId);
+  }
+  async getAvailable(providerId) {
+    if (providerId) {
+      if (this.availabilityRefresh)
+        return await this.availabilityRefresh, this.snapshot.available.filter((model) => model.provider === providerId);
+      try {
+        return (await this.models.getAvailable(providerId)).filter((model) => this.isCatalogModelAvailable(model));
+      } catch (error) {
+        throw this.availabilityError = error instanceof Error ? error.message : String(error), error;
+      }
+    }
+    return await this.refreshAvailability(), this.snapshot.available;
+  }
+  getAvailableSnapshot() {
+    return this.snapshot.available;
+  }
+  getError() {
+    let errors = [], configError = this.config.getError();
+    configError && errors.push(configError);
+    for (let [providerId, error] of this.compositionErrors)
+      errors.push(`Provider "${providerId}": ${error}`);
+    return this.availabilityError && errors.push(`Availability refresh: ${this.availabilityError}`), errors.length > 0 ? errors.join(`
+
+`) : void 0;
+  }
+  getRegisteredProviderConfig(providerId) {
+    return this.extensionProviders.get(providerId);
+  }
+  getRegisteredProviderIds() {
+    return [...this.extensionProviders.keys()];
+  }
+  /** @internal Compatibility fallback for ModelRegistry when provider auth is unconfigured. */
+  getCompatibilityRequestConfig(model) {
+    return resolveCompatibilityRequestConfig(model, this.config.getProvider(model.provider), this.extensionProviders.get(model.provider));
+  }
+  isUsingOAuth(providerId) {
+    return this.snapshot.auth.get(providerId)?.type === "oauth";
+  }
+  hasConfiguredAuth(providerId) {
+    return this.snapshot.configuredProviders.has(providerId);
+  }
+  async getAuth(providerOrModel, overrides = {}) {
+    if (typeof providerOrModel == "string")
+      return this.models.getAuth(providerOrModel, overrides);
+    let resolution = await this.models.getAuth(providerOrModel, overrides);
+    if (!resolution)
+      return;
+    let configuredHeaders2 = resolveConfiguredModelHeaders(providerOrModel, this.config.getProvider(providerOrModel.provider), this.extensionProviders.get(providerOrModel.provider), { ...resolution.env ?? {}, ...overrides.env ?? {} });
+    return {
+      ...resolution,
+      auth: {
+        ...resolution.auth,
+        headers: mergeHeaders(resolution.auth.headers, configuredHeaders2)
+      }
+    };
+  }
+  /** lunr: whether a runtime --api-key override is active for the provider (it shadows auth.json). */
+  hasRuntimeApiKey(providerId) {
+    return this.credentials.hasRuntimeApiKey(providerId);
+  }
+  async setRuntimeApiKey(providerId, apiKey, options) {
+    this.credentials.setRuntimeApiKey(providerId, apiKey);
+    let auth = new Map(this.snapshot.auth).set(providerId, { type: "api_key", source: "runtime API key" }), configuredProviders = new Set(this.snapshot.configuredProviders).add(providerId), storedProviders = new Set(this.snapshot.storedProviders).add(providerId);
+    this.snapshot = {
+      ...this.snapshot,
+      auth,
+      configuredProviders,
+      storedProviders,
+      available: this.snapshot.all.filter((model) => configuredProviders.has(model.provider) && this.isCatalogModelAvailable(model))
+    }, await this.refresh({ allowNetwork: options?.allowNetwork ?? this.allowModelNetwork });
+  }
+  async removeRuntimeApiKey(providerId) {
+    this.credentials.removeRuntimeApiKey(providerId), await this.refresh({ allowNetwork: this.allowModelNetwork });
+  }
+  /** lunr: whether network model-catalog fetches are allowed (offline mode disables them). */
+  isNetworkAllowed() {
+    return this.allowModelNetwork;
+  }
+  listCredentials() {
+    return this.credentials.list();
+  }
+  getProviderAuthStatus(providerId) {
+    if (this.credentials.hasRuntimeApiKey(providerId))
+      return { configured: !0, source: "runtime" };
+    if (this.snapshot.storedProviders.has(providerId))
+      return { configured: !0, source: "stored" };
+    let configured = configuredRequestAuthStatus(this.config.getProvider(providerId), this.extensionProviders.get(providerId));
+    if (configured)
+      return configured;
+    let check = this.snapshot.auth.get(providerId);
+    return check ? { configured: !0, source: "environment", label: check.source } : { configured: !1 };
+  }
+  async prepareRequest(model, options) {
+    let provider = this.models.getProvider(model.provider);
+    if (!provider)
+      throw new ModelsError("provider", `Unknown provider: ${model.provider}`);
+    let resolution = await this.getAuth(model, { apiKey: options?.apiKey, env: options?.env });
+    if (!resolution)
+      throw new ModelsError("auth", `Provider is not configured: ${model.provider}`);
+    let { transformHeaders, ...providerOptions } = options ?? {}, headers = mergeHeaders(resolution.auth.headers, providerOptions.headers);
+    transformHeaders && (headers = await transformHeaders(headers ?? {}));
+    let env = resolution.env || providerOptions.env ? { ...resolution.env ?? {}, ...providerOptions.env ?? {} } : void 0;
+    return {
+      provider,
+      model: resolution.auth.baseUrl ? { ...model, baseUrl: resolution.auth.baseUrl } : model,
+      options: {
+        ...providerOptions,
+        apiKey: providerOptions.apiKey ?? resolution.auth.apiKey,
+        headers,
+        env
+      }
+    };
+  }
+  stream(model, context, options) {
+    return lazyStream2(model, async () => {
+      let prepared = await this.prepareRequest(model, options);
+      return prepared.provider.stream(prepared.model, context, prepared.options);
+    });
+  }
+  complete(model, context, options) {
+    return this.stream(model, context, options).result();
+  }
+  streamSimple(model, context, options) {
+    return lazyStream2(model, async () => {
+      let prepared = await this.prepareRequest(model, options);
+      return prepared.provider.streamSimple(prepared.model, context, prepared.options);
+    });
+  }
+  completeSimple(model, context, options) {
+    return this.streamSimple(model, context, options).result();
+  }
+  async login(providerId, type, interaction) {
+    let credential = await this.models.login(providerId, type, interaction);
+    return clearPlanUsageCache(), await this.refresh({ allowNetwork: this.allowModelNetwork }), credential;
+  }
+  async logout(providerId) {
+    await this.models.logout(providerId), await this.modelsStore.delete(providerId), this.userModels.evictProvider(providerId), this.overlay.setLive(providerId, []), this.recomposeProvider(providerId), clearPlanUsageCache(), await this.refresh({ allowNetwork: this.allowModelNetwork });
+  }
+  /** Copy a live Grok CLI SuperGrok session into lunR `auth.json`. */
+  async importGrokCliXaiAuth() {
+    let grok = readGrokCliXaiOAuth({ grokHome: this.grokHome });
+    if (!grok)
+      return;
+    let stored = await this.credentials.modify("xai", async () => grok);
+    return clearPlanUsageCache(), await this.refresh({ allowNetwork: this.allowModelNetwork }), stored;
+  }
+  async reloadConfig() {
+    this.config = await ModelConfig.load(this.modelsPath), this.configureRadiusProviders(), this.rebuildProviders(), await this.refresh({ allowNetwork: this.allowModelNetwork });
+  }
+  async refresh(options = {}) {
+    let allowNetwork = options.allowNetwork ?? this.allowModelNetwork;
+    if (this.catalogRefresh)
+      return this.catalogRefreshAllowsNetwork || !allowNetwork ? this.catalogRefresh : (await this.catalogRefresh.catch(() => {
+      }), this.refresh({ ...options, allowNetwork }));
+    let run = this.executeCatalogRefresh({ ...options, allowNetwork }).finally(() => {
+      this.catalogRefresh === run && (this.catalogRefresh = void 0, this.catalogRefreshAllowsNetwork = !1);
+    });
+    return this.catalogRefresh = run, this.catalogRefreshAllowsNetwork = allowNetwork, run;
+  }
+  async executeCatalogRefresh(refreshOptions) {
+    let official = await this.refreshOfficialCatalog(refreshOptions.allowNetwork, refreshOptions.signal), live = refreshOptions.allowNetwork ? await this.refreshLiveCatalogs(official ? officialModelKeys(official.catalog) : /* @__PURE__ */ new Set(), refreshOptions.signal) : await this.restoreLiveCatalogs(), result = await this.models.refresh(refreshOptions) ?? {
+      aborted: refreshOptions.signal?.aborted ?? !1,
+      errors: /* @__PURE__ */ new Map()
+    }, errors = new Map(result.errors);
+    for (let [id, error] of Object.entries(official?.errors ?? {}))
+      errors.set(id, new Error(error));
+    for (let entry of live)
+      (entry.status === "error" || entry.status === "timeout") && errors.set(entry.providerId, new Error(entry.error ?? entry.status));
+    this.updateModelSnapshot();
+    try {
+      await this.forceRefreshAvailability();
+    } catch {
+    }
+    let catalogResult = {
+      aborted: result.aborted,
+      errors,
+      official,
+      live,
+      incomplete: live.flatMap((entry) => entry.incomplete)
+    };
+    return this.lastCatalogRefresh = catalogResult, catalogResult;
+  }
+  getLastCatalogRefresh() {
+    return this.lastCatalogRefresh;
+  }
+  /** Called after first paint and by the picker; explicit /refresh always bypasses this gate. */
+  async refreshIfStale(options = {}) {
+    if (!this.allowModelNetwork || options.signal?.aborted)
+      return this.lastCatalogRefresh;
+    if (this.catalogRefresh)
+      return this.refresh({ allowNetwork: !0, signal: options.signal });
+    let providers = [...await this.listStoredProviderIds()].sort(), identity = (await Promise.all(providers.map(async (id) => this.scopeFor(id)))).join(":");
+    if (identity === this.automaticRefreshIdentity && Date.now() < this.nextAutomaticRefresh)
+      return this.lastCatalogRefresh;
+    this.automaticRefreshIdentity = identity, this.nextAutomaticRefresh = Date.now() + 6e4;
+    let result = await this.refresh({ allowNetwork: !0, signal: options.signal });
+    return !result.aborted && !result.errors.size && (this.nextAutomaticRefresh = Date.now() + 36e5), result;
+  }
+  async scopeFor(providerId) {
+    let provider = this.models.getProvider(providerId) ?? this.defaultBuiltins.get(providerId);
+    return catalogCacheScope(providerId, provider?.baseUrl ?? "", await this.credentials.read(providerId));
+  }
+  persistUserModels(rows) {
+    this.userModels.upsert(rows), this.overlay.setUser(this.userModelsForStoredProviders(this.snapshot.storedProviders)), this.updateModelSnapshot();
+  }
+  async refreshOfficialCatalog(allowNetwork, signal) {
+    let storedProviders = await this.listStoredProviderIds(), loaded = preferOfficialCatalog(this.lastOfficial, await loadOfficialCatalog({
+      allowNetwork,
+      cachePath: this.officialCachePath,
+      signal,
+      providerIds: [...storedProviders]
+    }));
+    this.lastOfficial = loaded;
+    let evicted = this.userModels.evictOfficial(officialModelKeys(loaded.catalog)), templateByProvider = /* @__PURE__ */ new Map(), officialModels = loaded.catalog.models.filter((entry) => storedProviders.has(entry.provider)).map((entry) => (templateByProvider.has(entry.provider) || templateByProvider.set(entry.provider, this.bakedInModels(entry.provider)[0]), officialEntryToModel(entry, templateByProvider.get(entry.provider))));
+    return this.overlay.setOfficial(officialModels), this.overlay.setUser(this.userModelsForStoredProviders(storedProviders)), { ...loaded, evictedUserRows: evicted.length };
+  }
+  async restoreLiveCatalogs() {
+    let storedProviders = await this.listStoredProviderIds(), results = [];
+    for (let providerId of LIVE_LIST_PROVIDER_IDS) {
+      let stored = storedProviders.has(providerId) ? await this.modelsStore.read(providerId) : void 0;
+      (!stored?.scope && providerId !== "openai-codex" || stored?.scope === await this.scopeFor(providerId)) && stored?.models ? this.overlay.setLive(providerId, stored.models) : this.overlay.setLive(providerId, []), results.push({
+        providerId,
+        status: "skipped",
+        discoveries: [],
+        added: 0,
+        total: stored?.models.length ?? 0,
+        incomplete: []
+      });
+    }
+    return results;
+  }
+  async refreshLiveCatalogs(officialKeys, signal) {
+    let storedProviders = await this.listStoredProviderIds(), known = knownModelKeys(LIVE_LIST_PROVIDER_IDS.flatMap((id) => this.bakedInModels(id)), officialKeys, this.userModels.keys());
+    return await Promise.all(LIVE_LIST_PROVIDER_IDS.map(async (providerId) => {
+      if (!storedProviders.has(providerId))
+        return this.overlay.setLive(providerId, []), {
+          providerId,
+          status: "skipped",
+          discoveries: [],
+          added: 0,
+          total: 0,
+          incomplete: []
+        };
+      let stored = await this.modelsStore.read(providerId), initialScope = await this.scopeFor(providerId);
+      if (stored?.models && (stored.scope === initialScope || !stored.scope && providerId !== "openai-codex") ? this.overlay.setLive(providerId, stored.models) : this.overlay.setLive(providerId, []), signal?.aborted)
+        return {
+          providerId,
+          status: "skipped",
+          discoveries: [],
+          added: 0,
+          total: stored?.models.length ?? 0,
+          incomplete: [],
+          error: "aborted"
+        };
+      let bakedIn = this.bakedInModels(providerId), baseUrl = (this.models.getProvider(providerId) ?? this.defaultBuiltins.get(providerId))?.baseUrl ?? bakedIn[0]?.baseUrl;
+      if (!baseUrl)
+        return {
+          providerId,
+          status: "skipped",
+          discoveries: [],
+          added: 0,
+          total: 0,
+          incomplete: []
+        };
+      let credential;
+      try {
+        credential = await this.refreshCredentialFor(providerId);
+      } catch (error) {
+        return {
+          providerId,
+          status: "error",
+          discoveries: [],
+          added: 0,
+          total: stored?.models.length ?? 0,
+          incomplete: [],
+          error: error instanceof Error ? error.message : String(error)
+        };
+      }
+      if (!credential)
+        return {
+          providerId,
+          status: "skipped",
+          discoveries: [],
+          added: 0,
+          total: stored?.models.length ?? 0,
+          incomplete: []
+        };
+      let requestScope = catalogCacheScope(providerId, baseUrl, credential), result = await fetchLiveProviderModels({
+        discoveryClientVersion: stored?.scope === requestScope ? stored.discoveryClientVersion : void 0,
+        providerId,
+        baseUrl,
+        bakedIn,
+        credential,
+        knownKeys: known,
+        signal
+      }), accountChanged = await this.scopeFor(providerId) !== requestScope;
+      if (accountChanged && this.overlay.setLive(providerId, []), signal?.aborted || accountChanged)
+        return { ...result, status: "skipped", discoveries: [], incomplete: [] };
+      if (result.status === "ok") {
+        let overlayModels = buildLiveOverlay(bakedIn, result.discoveries);
+        this.overlay.setLive(providerId, overlayModels);
+        try {
+          await this.modelsStore.write(providerId, {
+            models: overlayModels,
+            checkedAt: Date.now(),
+            scope: requestScope,
+            discoveryClientVersion: result.discoveryClientVersion
+          });
+        } catch {
+        }
+      }
+      return result;
+    }));
+  }
+  async refreshCredentialFor(providerId) {
+    let resolved = await this.getAuth(providerId), stored = await this.credentials.read(providerId);
+    if (stored?.type === "oauth")
+      return { ...stored, access: resolved?.auth.apiKey ?? stored.access };
+    if (resolved?.auth.apiKey)
+      return { type: "api_key", key: resolved.auth.apiKey, env: resolved.env };
+    if (stored?.type === "api_key" && stored.key)
+      return stored;
+  }
+  registerProvider(providerId, config) {
+    validateExtensionProvider(providerId, this.builtins.get(providerId), this.config.getProvider(providerId), config);
+    let effective = { ...this.extensionProviders.get(providerId) };
+    for (let [key, value] of Object.entries(config))
+      value !== void 0 && (effective[key] = value);
+    if (this.extensionProviders.set(providerId, effective), this.recomposeProvider(providerId), this.updateModelSnapshot(), this.snapshot.storedProviders.has(providerId) || configuredRequestAuthStatus(this.config.getProvider(providerId), effective)?.configured) {
+      let configuredProviders = new Set(this.snapshot.configuredProviders).add(providerId), auth = new Map(this.snapshot.auth);
+      auth.get(providerId) || auth.set(providerId, {
+        type: effective.oauth && !effective.apiKey ? "oauth" : "api_key",
+        source: "configured provider"
+      }), this.snapshot = {
+        ...this.snapshot,
+        auth,
+        configuredProviders,
+        available: this.snapshot.all.filter((model) => configuredProviders.has(model.provider) && this.isCatalogModelAvailable(model))
+      };
+    }
+    this.refresh({ allowNetwork: !1 });
+  }
+  unregisterProvider(providerId) {
+    this.extensionProviders.delete(providerId), this.recomposeProvider(providerId), this.updateModelSnapshot(), this.refresh({ allowNetwork: !1 });
+  }
+};
+async function refreshModelCandidatesForInit(runtime) {
+  return await runtime.refresh({ allowNetwork: !1 }), runtime.getAvailableSnapshot();
+}
+
+export {
+  AuthStorage,
+  readStoredCredential,
+  formatCatalogRefreshSummary,
+  hasGrokCliXaiAuth,
+  stripJsonComments,
+  isUsageLimitError,
+  isAuthInvalidError,
+  ModelRuntime,
+  refreshModelCandidatesForInit
+};