@kenkaiiii/gg-core 5.90.0 → 5.91.1

package/dist/index.cjs

@@ -40,14 +40,18 @@ __export(index_exports, {
   HIDDEN_PROVIDERS: () => HIDDEN_PROVIDERS,
   LOCAL_API_KEY_PLACEHOLDER: () => LOCAL_API_KEY_PLACEHOLDER,
   LOCAL_AUTH_KEY_PREFIX: () => LOCAL_AUTH_KEY_PREFIX,
+  MINIMAX_CN_BASE_URL: () => MINIMAX_CN_BASE_URL,
+  MINIMAX_GLOBAL_BASE_URL: () => MINIMAX_GLOBAL_BASE_URL,
   MODELS: () => MODELS,
   MOONSHOT_OAUTH_KEY: () => MOONSHOT_OAUTH_KEY,
   NotLoggedInError: () => NotLoggedInError,
+  OPENROUTER_DEFAULT_BASE_URL: () => OPENROUTER_DEFAULT_BASE_URL,
   PLAN_MODE_THINKING_CAP: () => PLAN_MODE_THINKING_CAP,
   SubscriptionUsageError: () => SubscriptionUsageError,
   TelegramBot: () => TelegramBot,
   XAI_OAUTH_KEY: () => XAI_OAUTH_KEY,
   XIAOMI_CREDITS_KEY: () => XIAOMI_CREDITS_KEY,
+  XIAOMI_TOKEN_PLAN_BASE_URLS: () => XIAOMI_TOKEN_PLAN_BASE_URLS,
   authPriorityNote: () => authPriorityNote,
   clampThinkingForPlanMode: () => clampThinkingForPlanMode,
   clearLocalDiscoveryCache: () => clearLocalDiscoveryCache,
@@ -56,6 +60,8 @@ __export(index_exports, {
   createAutoUpdater: () => createAutoUpdater,
   decodeOggOpus: () => decodeOggOpus,
   describeAuthMethods: () => describeAuthMethods,
+  detectMiniMaxBaseUrl: () => detectMiniMaxBaseUrl,
+  detectXiaomiTokenPlanBaseUrl: () => detectXiaomiTokenPlanBaseUrl,
   discoverLocalModels: () => discoverLocalModels,
   downmixToMono: () => downmixToMono,
   dualAuthProvider: () => dualAuthProvider,
@@ -81,6 +87,7 @@ __export(index_exports, {
   getModel: () => getModel,
   getModelsForProvider: () => getModelsForProvider,
   getNextThinkingLevel: () => getNextThinkingLevel,
+  getProviderCatalog: () => getProviderCatalog,
   getSessionId: () => getSessionId,
   getSummaryModel: () => getSummaryModel,
   getSupportedThinkingLevels: () => getSupportedThinkingLevels,
@@ -110,6 +117,7 @@ __export(index_exports, {
   ollamaServedContext: () => ollamaServedContext,
   openLog: () => openLog,
   parseLocalModelId: () => parseLocalModelId,
+  parseOpenRouterCatalog: () => parseOpenRouterCatalog,
   pendingClaudeCodeVersionRefresh: () => import_gg_ai.pendingClaudeCodeVersionRefresh,
   probeEndpoint: () => probeEndpoint,
   providerStorageKeys: () => providerStorageKeys,
@@ -123,6 +131,7 @@ __export(index_exports, {
   registerRuntimeModels: () => registerRuntimeModels,
   resample: () => resample,
   setProgressCallback: () => setProgressCallback,
+  setProviderCatalog: () => setProviderCatalog,
   toModelInfo: () => toModelInfo,
   transcribeVoice: () => transcribeVoice,
   usesOpenAICodexTransport: () => usesOpenAICodexTransport,
@@ -1329,9 +1338,13 @@ async function acquireLock(lockPath) {
           continue;
         }
       } catch {
-        await import_promises.default.unlink(lockPath).catch(() => {
-        });
-        continue;
+        const stat = await import_promises.default.stat(lockPath).catch(() => null);
+        if (!stat) continue;
+        if (Date.now() - stat.mtimeMs > STALE_TIMEOUT_MS) {
+          await import_promises.default.unlink(lockPath).catch(() => {
+          });
+          continue;
+        }
       }
       if (Date.now() - startTime > MAX_WAIT_MS) {
         await import_promises.default.unlink(lockPath).catch(() => {
@@ -1528,6 +1541,90 @@ function isHiddenProvider(provider) {
 
 // src/auth-storage.ts
 var import_gg_ai3 = require("@kenkaiiii/gg-ai");
+
+// src/minimax-region.ts
+var MINIMAX_GLOBAL_BASE_URL = "https://api.minimax.io/anthropic";
+var MINIMAX_CN_BASE_URL = "https://api.minimax.cn/anthropic";
+var REGION_HOSTS = [
+  { host: "https://api.minimax.io", baseUrl: MINIMAX_GLOBAL_BASE_URL },
+  { host: "https://api.minimax.cn", baseUrl: MINIMAX_CN_BASE_URL }
+];
+var KEY_KNOWN_CODES = /* @__PURE__ */ new Set([0, 2062]);
+var KEY_REJECTED_CODES = /* @__PURE__ */ new Set([1004, 2049]);
+async function probeRegion(host, apiKey, fetchImpl, timeoutMs) {
+  const url = apiKey.startsWith("sk-api-") ? `${host}/account/query_balance` : `${host}/v1/token_plan/remains`;
+  let sawRejection = false;
+  const authHeaders2 = [
+    { Authorization: `Bearer ${apiKey}` },
+    { "x-api-key": apiKey }
+  ];
+  for (const auth of authHeaders2) {
+    let res;
+    try {
+      res = await fetchImpl(url, {
+        headers: { ...auth, "Content-Type": "application/json" },
+        signal: AbortSignal.timeout(timeoutMs)
+      });
+    } catch {
+      return "inconclusive";
+    }
+    if (res.status === 401 || res.status === 403) {
+      sawRejection = true;
+      continue;
+    }
+    if (!res.ok) return "inconclusive";
+    let code;
+    try {
+      code = (await res.json()).base_resp?.status_code;
+    } catch {
+      return "inconclusive";
+    }
+    if (typeof code === "number" && KEY_KNOWN_CODES.has(code)) return "authorized";
+    if (typeof code === "number" && KEY_REJECTED_CODES.has(code)) {
+      sawRejection = true;
+      continue;
+    }
+    return "inconclusive";
+  }
+  return sawRejection ? "unauthorized" : "inconclusive";
+}
+async function detectMiniMaxBaseUrl(apiKey, options = {}) {
+  const fetchImpl = options.fetch ?? fetch;
+  const timeoutMs = options.timeoutMs ?? 5e3;
+  const results = await Promise.all(
+    REGION_HOSTS.map((r) => probeRegion(r.host, apiKey, fetchImpl, timeoutMs))
+  );
+  const index = results.indexOf("authorized");
+  return index === -1 ? void 0 : REGION_HOSTS[index].baseUrl;
+}
+
+// src/xiaomi-region.ts
+var XIAOMI_TOKEN_PLAN_BASE_URLS = [
+  "https://token-plan-sgp.xiaomimimo.com/v1",
+  "https://token-plan-ams.xiaomimimo.com/v1",
+  "https://token-plan-cn.xiaomimimo.com/v1"
+];
+async function detectXiaomiTokenPlanBaseUrl(apiKey, options = {}) {
+  const fetchImpl = options.fetch ?? fetch;
+  const timeoutMs = options.timeoutMs ?? 5e3;
+  const accepted = await Promise.all(
+    XIAOMI_TOKEN_PLAN_BASE_URLS.map(async (baseUrl) => {
+      try {
+        const res = await fetchImpl(`${baseUrl}/models`, {
+          headers: { Authorization: `Bearer ${apiKey}` },
+          signal: AbortSignal.timeout(timeoutMs)
+        });
+        return res.ok;
+      } catch {
+        return false;
+      }
+    })
+  );
+  const index = accepted.indexOf(true);
+  return index === -1 ? void 0 : XIAOMI_TOKEN_PLAN_BASE_URLS[index];
+}
+
+// src/auth-storage.ts
 var MOONSHOT_OAUTH_KEY = "moonshot-oauth";
 var XAI_OAUTH_KEY = "xai-oauth";
 var DUAL_AUTH_PROVIDERS = [
@@ -1577,6 +1674,15 @@ function activeBaseUrlEntry(data, provider) {
   }
   return data[provider];
 }
+var MINIMAX_REGION_RETRY_MS = 5 * 60 * 1e3;
+var miniMaxRegionProbes = /* @__PURE__ */ new Map();
+function cachedMiniMaxRegion(apiKey) {
+  const cached = miniMaxRegionProbes.get(apiKey);
+  if (cached && Date.now() - cached.at < MINIMAX_REGION_RETRY_MS) return cached.result;
+  const result = detectMiniMaxBaseUrl(apiKey).catch(() => void 0);
+  miniMaxRegionProbes.set(apiKey, { at: Date.now(), result });
+  return result;
+}
 function readStoredBaseUrlSync(authFile, provider) {
   try {
     const data = JSON.parse((0, import_node_fs3.readFileSync)(authFile, "utf-8"));
@@ -1623,8 +1729,12 @@ var AuthStorage = class {
   snapshotIno = 0;
   /** Per-provider lock to serialize concurrent refresh calls. */
   refreshLocks = /* @__PURE__ */ new Map();
-  constructor(filePath) {
+  detectMiniMaxRegion;
+  detectXiaomiCluster;
+  constructor(filePath, options) {
     this.filePath = filePath ?? getAppPaths().authFile;
+    this.detectMiniMaxRegion = options?.detectMiniMaxBaseUrl ?? cachedMiniMaxRegion;
+    this.detectXiaomiCluster = options?.detectXiaomiTokenPlanBaseUrl ?? detectXiaomiTokenPlanBaseUrl;
   }
   /** Path to the on-disk auth file. Useful for status output. */
   get path() {
@@ -1823,11 +1933,48 @@ var AuthStorage = class {
     await this.ensureFresh();
     return this.data[provider];
   }
+  /**
+   * A MiniMax key saved without an endpoint (every key, until its first use)
+   * gets the endpoint of the region that issued it, saved so the check runs
+   * once. Without this a Mainland China key went to the Global API, got a 401,
+   * and was deleted as invalid.
+   */
+  async withMiniMaxRegion(creds) {
+    const baseUrl = await this.detectMiniMaxRegion(creds.accessToken);
+    if (!baseUrl) return creds;
+    log("INFO", "auth", `MiniMax key belongs to ${baseUrl} \u2014 saved for future requests`);
+    await this.mutateLatest((latest) => {
+      const current = latest["minimax"];
+      if (current?.accessToken === creds.accessToken && !current.baseUrl) {
+        current.baseUrl = baseUrl;
+      }
+    });
+    return { ...creds, baseUrl };
+  }
   async setCredentials(provider, creds) {
     await this.mutateLatest((latest) => {
       latest[provider] = creds;
     });
   }
+  /**
+   * After a 401, move a regional key to the cluster that issued it instead of
+   * treating it as invalid. Only the Xiaomi Token Plan is regional: every key
+   * used to go to Singapore, so Europe and China keys were rejected and deleted.
+   * Returns the new base URL, or undefined when no other cluster accepts the key.
+   */
+  async relocateRegionalApiKey(storageKeys) {
+    const key = await this.pickStorageKey(storageKeys);
+    const creds = key === "xiaomi" ? this.data[key] : void 0;
+    if (!creds) return void 0;
+    const baseUrl = await this.detectXiaomiCluster(creds.accessToken);
+    if (!baseUrl || baseUrl === creds.baseUrl) return void 0;
+    await this.mutateLatest((latest) => {
+      const current = latest["xiaomi"];
+      if (current?.accessToken === creds.accessToken) current.baseUrl = baseUrl;
+    });
+    log("INFO", "auth", `Xiaomi Token Plan key belongs to ${baseUrl} \u2014 saved for future requests`);
+    return baseUrl;
+  }
   // Keeps local-endpoint keys: they're the user's own config, and a 401 there is often a busy gateway.
   async clearRejectedApiKey(storageKey) {
     if (storageKey.startsWith(LOCAL_AUTH_KEY_PREFIX)) return false;
@@ -1947,6 +2094,7 @@ var AuthStorage = class {
       throw new NotLoggedInError(provider);
     }
     if (STATIC_API_KEY_PROVIDERS.has(provider)) {
+      if (provider === "minimax" && !creds.baseUrl) return await this.withMiniMaxRegion(creds);
       return creds;
     }
     if (!opts?.forceRefresh && Date.now() < creds.expiresAt - refreshThresholdMs(creds)) {
@@ -2597,6 +2745,23 @@ var MODELS = [
     maxThinkingLevel: "max"
   },
   // ── MiniMax ────────────────────────────────────────────
+  {
+    // The only text model M Plan / Token Plan keys cover; MiniMax-M3 on those
+    // keys fails with "insufficient balance (1008)". Pay-as-you-go serves both.
+    // Always thinks (`thinking: disabled` 400s; omitted = on) with a real
+    // low→max effort ladder on output_config.effort, API default max.
+    id: "MiniMax-M3.1-Flash",
+    name: "MiniMax M3.1 Flash",
+    provider: "minimax",
+    contextWindow: 1e6,
+    maxOutputTokens: 131072,
+    supportsThinking: true,
+    supportsImages: true,
+    supportsVideo: true,
+    maxVideoBytes: 50 * 1024 * 1024,
+    costTier: "low",
+    maxThinkingLevel: "max"
+  },
   {
     id: "MiniMax-M3",
     name: "MiniMax M3",
@@ -2803,11 +2968,44 @@ function clearRuntimeModels(predicate) {
     if (predicate(model)) runtimeModels.delete(id);
   }
 }
+var providerCatalogs = /* @__PURE__ */ new Map();
+function setProviderCatalog(provider, models) {
+  if (!models) {
+    providerCatalogs.delete(provider);
+    return [];
+  }
+  const installed = /* @__PURE__ */ new Map();
+  for (const model of models) {
+    if (model.provider !== provider) continue;
+    if (MODELS.some((m) => m.id === model.id && m.provider !== provider)) continue;
+    installed.set(model.id, model);
+  }
+  providerCatalogs.set(provider, installed);
+  return [...installed.values()];
+}
+function getProviderCatalog(provider) {
+  const catalog = providerCatalogs.get(provider);
+  return catalog ? [...catalog.values()] : void 0;
+}
 function getAllModels() {
-  return [...MODELS, ...runtimeModels.values()];
+  const synced = [...providerCatalogs.values()].flatMap((c) => [...c.values()]);
+  return [
+    ...MODELS.filter((m) => !providerCatalogs.has(m.provider)),
+    ...synced,
+    ...runtimeModels.values()
+  ];
 }
 function getModel(id) {
-  return MODELS.find((m) => m.id === id) ?? runtimeModels.get(id);
+  const fixed = MODELS.find((m) => m.id === id);
+  if (fixed && !providerCatalogs.has(fixed.provider)) return fixed;
+  return findSynced(id) ?? fixed ?? runtimeModels.get(id);
+}
+function findSynced(id) {
+  for (const catalog of providerCatalogs.values()) {
+    const hit = catalog.get(id);
+    if (hit) return hit;
+  }
+  return void 0;
 }
 function getModelsForProvider(provider) {
   return getAllModels().filter((m) => m.provider === provider);
@@ -2847,7 +3045,7 @@ var DEFAULT_MODEL_IDS = {
   gemini: "gemini-3.1-flash-lite",
   glm: "glm-5.3",
   moonshot: "kimi-k3",
-  minimax: "MiniMax-M3",
+  minimax: "MiniMax-M3.1-Flash",
   deepseek: "deepseek-v4-pro",
   huggingface: "moonshotai/Kimi-K2.7-Code",
   openrouter: "qwen/qwen3.8-max",
@@ -2913,6 +3111,59 @@ function getSummaryModel(provider, currentModelId) {
   return tagged ?? getModel(currentModelId) ?? getDefaultModel(provider);
 }
 
+// src/openrouter-catalog.ts
+var OPENROUTER_DEFAULT_BASE_URL = "https://openrouter.ai/api/v1";
+var EFFORT_LADDER = ["low", "medium", "high", "xhigh", "max"];
+function positiveInt(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value > 0 ? value : void 0;
+}
+function strings(value) {
+  return Array.isArray(value) ? value.filter((v) => typeof v === "string") : [];
+}
+function costTier(prompt) {
+  const perToken = typeof prompt === "string" ? Number(prompt) : NaN;
+  if (!Number.isFinite(perToken) || perToken < 5e-7) return "low";
+  return perToken < 3e-6 ? "medium" : "high";
+}
+function parseOpenRouterCatalog(body) {
+  const data = body?.data;
+  if (!Array.isArray(data)) return { models: [], skipped: 0 };
+  const models = [];
+  let skipped = 0;
+  const seen = /* @__PURE__ */ new Set();
+  for (const raw of data) {
+    const id = typeof raw?.id === "string" ? raw.id.trim() : "";
+    const params = strings(raw?.supported_parameters);
+    const contextWindow = positiveInt(raw?.top_provider?.context_length) ?? positiveInt(raw?.context_length);
+    if (!id || seen.has(id) || !params.includes("tools") || !contextWindow) {
+      skipped++;
+      continue;
+    }
+    seen.add(id);
+    const efforts = strings(raw.reasoning?.supported_efforts);
+    const ladder = EFFORT_LADDER.filter((rung) => efforts.includes(rung));
+    const supportsThinking = ladder.length > 0 || params.includes("reasoning") || params.includes("reasoning_effort");
+    const defaultEffort = raw.reasoning?.default_effort;
+    const maxOutput = positiveInt(raw.top_provider?.max_completion_tokens) ?? Math.min(contextWindow, 16384);
+    models.push({
+      id,
+      name: typeof raw.name === "string" && raw.name.trim() ? raw.name.trim() : id,
+      provider: "openrouter",
+      contextWindow,
+      maxOutputTokens: Math.min(maxOutput, contextWindow),
+      supportsThinking,
+      supportsImages: strings(raw.architecture?.input_modalities).includes("image"),
+      // Video needs a per-transport payload cap the catalog doesn't publish.
+      supportsVideo: false,
+      costTier: costTier(raw.pricing?.prompt),
+      maxThinkingLevel: ladder[ladder.length - 1] ?? "high",
+      ...ladder.length > 0 ? { thinkingLevels: ladder } : {},
+      ...typeof defaultEffort === "string" && ladder.includes(defaultEffort) ? { defaultThinkingLevel: defaultEffort } : {}
+    });
+  }
+  return { models, skipped };
+}
+
 // src/thinking-level.ts
 var OPENAI_GPT_THINKING_LEVELS = ["medium", "high", "xhigh"];
 var OPENAI_GPT_56_THINKING_LEVELS = [
@@ -2941,6 +3192,13 @@ var ANTHROPIC_ADAPTIVE_THINKING_LEVELS = [
 ];
 var MOONSHOT_K3_THINKING_LEVELS = ["low", "high", "max"];
 var GLM_THINKING_LEVELS = ["low", "medium", "high", "xhigh", "max"];
+var MINIMAX_EFFORT_THINKING_LEVELS = [
+  "low",
+  "medium",
+  "high",
+  "xhigh",
+  "max"
+];
 var LOCAL_THINKING_LEVELS = ["low", "medium", "high", "max"];
 function isOpenAIGptModel(provider, model) {
   return provider === "openai" && model.startsWith("gpt-");
@@ -2957,6 +3215,9 @@ function isMoonshotK3Model(provider, model) {
 function isGlmModel(provider) {
   return provider === "glm";
 }
+function isMiniMaxEffortModel(provider, model) {
+  return provider === "minimax" && model.startsWith("MiniMax-M3.1");
+}
 function isAnthropicXhighModel(provider, model) {
   return provider === "anthropic" && /opus-5|opus-4-8|opus-4-7|sonnet-5[-.]5|haiku-5[-.]5/.test(model);
 }
@@ -2970,6 +3231,8 @@ function getSupportedThinkingLevels(provider, model) {
     const maxIndex2 = LOCAL_THINKING_LEVELS.indexOf(info.maxThinkingLevel);
     return maxIndex2 === -1 ? LOCAL_THINKING_LEVELS.slice(0, 3) : LOCAL_THINKING_LEVELS.slice(0, maxIndex2 + 1);
   }
+  const declared = getModel(model)?.thinkingLevels;
+  if (declared && declared.length > 0) return declared;
   const maxLevel = getMaxThinkingLevel(model);
   if (isAnthropicAdaptiveModel(provider, model)) {
     const levels2 = isAnthropicXhighModel(provider, model) ? ANTHROPIC_XHIGH_THINKING_LEVELS : ANTHROPIC_ADAPTIVE_THINKING_LEVELS;
@@ -2989,6 +3252,7 @@ function getSupportedThinkingLevels(provider, model) {
   }
   if (isMoonshotK3Model(provider, model)) return MOONSHOT_K3_THINKING_LEVELS;
   if (provider === "deepseek") return DEEPSEEK_THINKING_LEVELS;
+  if (isMiniMaxEffortModel(provider, model)) return MINIMAX_EFFORT_THINKING_LEVELS;
   if (isGlmModel(provider)) {
     const maxIndex2 = GLM_THINKING_LEVELS.indexOf(maxLevel);
     if (maxIndex2 === -1) return GLM_THINKING_LEVELS;
@@ -3009,7 +3273,7 @@ function isThinkingLevelSupported(provider, model, level) {
 }
 function getNextThinkingLevel(provider, model, current) {
   const supportedLevels = getSupportedThinkingLevels(provider, model);
-  const shouldCycleLevels = isOpenAIGptModel(provider, model) || isAnthropicAdaptiveModel(provider, model) || isSakanaModel(provider) || isXaiModel(provider) || isMoonshotK3Model(provider, model) || isGlmModel(provider) || provider === "deepseek" || // Local servers take a real effort level, not just on/off: Ollama accepts
+  const shouldCycleLevels = isOpenAIGptModel(provider, model) || isAnthropicAdaptiveModel(provider, model) || isSakanaModel(provider) || isXaiModel(provider) || isMoonshotK3Model(provider, model) || isGlmModel(provider) || isMiniMaxEffortModel(provider, model) || provider === "deepseek" || // Local servers take a real effort level, not just on/off: Ollama accepts
   // low/medium/high on `reasoning_effort` (verified against 0.32) and the
   // other OpenAI-compatible servers use the same three. A model that can't
   // reason at all already has no supported levels, so it never gets here.
@@ -3124,7 +3388,9 @@ async function probeEndpoint(endpoint, { timeoutMs = DEFAULT_PROBE_TIMEOUT_MS, s
   const entries = (list.data ?? []).filter(
     (entry) => typeof entry.id === "string" && entry.id.length > 0 && !NON_CHAT_ID_PATTERN.test(entry.id)
   );
-  const models = await enrich(endpoint, entries, { timeoutMs, signal });
+  const enriched = await enrich(endpoint, entries, { timeoutMs, signal });
+  const pinned = contextLength(endpoint.contextLength);
+  const models = pinned === void 0 ? enriched : enriched.map((m) => ({ ...m, contextWindow: pinned, contextWindowKnown: true }));
   log("INFO", "local-models", `Probed ${endpoint.label}`, {
     baseUrl: endpoint.baseUrl,
     models: String(models.length)
@@ -3150,7 +3416,7 @@ async function enrichCustom(endpoint, entries, options) {
   return generic;
 }
 function genericModel(endpoint, entry) {
-  const declared = contextLength(entry.max_model_len) ?? contextLength(entry.context_length);
+  const declared = contextLength(entry.max_model_len) ?? contextLength(entry.context_length) ?? contextLength(entry.meta?.n_ctx);
   return {
     rawId: entry.id,
     endpointId: endpoint.id,
@@ -3330,7 +3596,7 @@ function toModelInfo(model, endpoint) {
 }
 var cache;
 function cacheKey(endpoints) {
-  return endpoints.map((e) => `${e.id}@${e.baseUrl}`).join("|");
+  return endpoints.map((e) => `${e.id}@${e.baseUrl}#${e.contextLength ?? ""}`).join("|");
 }
 async function discoverLocalModels(endpoints = DEFAULT_LOCAL_ENDPOINTS, options = {}) {
   const key = cacheKey(endpoints);
@@ -3451,7 +3717,7 @@ var ALL_AUTH_PROVIDERS = [
   {
     value: "minimax",
     label: "MiniMax",
-    description: "MiniMax M3",
+    description: "MiniMax M3.1 Flash, M3",
     methods: ["apikey"],
     apiKeyLabel: "MiniMax"
   },
@@ -4284,14 +4550,18 @@ function createAutoUpdater(config) {
   HIDDEN_PROVIDERS,
   LOCAL_API_KEY_PLACEHOLDER,
   LOCAL_AUTH_KEY_PREFIX,
+  MINIMAX_CN_BASE_URL,
+  MINIMAX_GLOBAL_BASE_URL,
   MODELS,
   MOONSHOT_OAUTH_KEY,
   NotLoggedInError,
+  OPENROUTER_DEFAULT_BASE_URL,
   PLAN_MODE_THINKING_CAP,
   SubscriptionUsageError,
   TelegramBot,
   XAI_OAUTH_KEY,
   XIAOMI_CREDITS_KEY,
+  XIAOMI_TOKEN_PLAN_BASE_URLS,
   authPriorityNote,
   clampThinkingForPlanMode,
   clearLocalDiscoveryCache,
@@ -4300,6 +4570,8 @@ function createAutoUpdater(config) {
   createAutoUpdater,
   decodeOggOpus,
   describeAuthMethods,
+  detectMiniMaxBaseUrl,
+  detectXiaomiTokenPlanBaseUrl,
   discoverLocalModels,
   downmixToMono,
   dualAuthProvider,
@@ -4325,6 +4597,7 @@ function createAutoUpdater(config) {
   getModel,
   getModelsForProvider,
   getNextThinkingLevel,
+  getProviderCatalog,
   getSessionId,
   getSummaryModel,
   getSupportedThinkingLevels,
@@ -4354,6 +4627,7 @@ function createAutoUpdater(config) {
   ollamaServedContext,
   openLog,
   parseLocalModelId,
+  parseOpenRouterCatalog,
   pendingClaudeCodeVersionRefresh,
   probeEndpoint,
   providerStorageKeys,
@@ -4367,6 +4641,7 @@ function createAutoUpdater(config) {
   registerRuntimeModels,
   resample,
   setProgressCallback,
+  setProviderCatalog,
   toModelInfo,
   transcribeVoice,
   usesOpenAICodexTransport,