@kenkaiiii/gg-core 5.89.0 → 5.91.0

package/dist/index.cjs

@@ -40,6 +40,8 @@ __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,
@@ -48,6 +50,7 @@ __export(index_exports, {
   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 +59,8 @@ __export(index_exports, {
   createAutoUpdater: () => createAutoUpdater,
   decodeOggOpus: () => decodeOggOpus,
   describeAuthMethods: () => describeAuthMethods,
+  detectMiniMaxBaseUrl: () => detectMiniMaxBaseUrl,
+  detectXiaomiTokenPlanBaseUrl: () => detectXiaomiTokenPlanBaseUrl,
   discoverLocalModels: () => discoverLocalModels,
   downmixToMono: () => downmixToMono,
   dualAuthProvider: () => dualAuthProvider,
@@ -99,6 +104,7 @@ __export(index_exports, {
   kimiCodeBaseUrl: () => kimiCodeBaseUrl,
   kimiCodingHeaders: () => kimiCodingHeaders,
   localAuthStorageKey: () => localAuthStorageKey,
+  localModelShortName: () => localModelShortName,
   log: () => log,
   loginAnthropic: () => loginAnthropic,
   loginGemini: () => loginGemini,
@@ -106,6 +112,7 @@ __export(index_exports, {
   loginOpenAI: () => loginOpenAI,
   loginXai: () => loginXai,
   oauthStorageKey: () => oauthStorageKey,
+  ollamaServedContext: () => ollamaServedContext,
   openLog: () => openLog,
   parseLocalModelId: () => parseLocalModelId,
   pendingClaudeCodeVersionRefresh: () => import_gg_ai.pendingClaudeCodeVersionRefresh,
@@ -1524,6 +1531,91 @@ function isHiddenProvider(provider) {
   return HIDDEN_PROVIDERS.includes(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";
@@ -1574,6 +1666,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"));
@@ -1620,8 +1721,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() {
@@ -1683,7 +1788,7 @@ var AuthStorage = class {
    */
   async setLocalEndpoint(endpointId, baseUrl, apiKey) {
     await this.setCredentials(`${LOCAL_AUTH_KEY_PREFIX}${endpointId}`, {
-      accessToken: apiKey && apiKey.length > 0 ? apiKey : "local",
+      accessToken: apiKey && apiKey.length > 0 ? apiKey : import_gg_ai3.LOCAL_NO_API_KEY,
       refreshToken: "",
       expiresAt: Date.now() + LOCAL_CREDENTIAL_LIFETIME_MS,
       baseUrl
@@ -1820,11 +1925,54 @@ 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;
+    await this.clearCredentials(storageKey);
+    return true;
+  }
   async clearCredentials(provider) {
     await this.mutateLatest((latest) => {
       delete latest[provider];
@@ -1938,6 +2086,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)) {
@@ -2588,6 +2737,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",
@@ -2838,7 +3004,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",
@@ -2932,6 +3098,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-");
@@ -2948,6 +3121,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);
 }
@@ -2980,6 +3156,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;
@@ -3000,7 +3177,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.
@@ -3028,11 +3205,12 @@ function clampThinkingForPlanMode(level) {
 }
 
 // src/local-models.ts
+var import_gg_ai4 = require("@kenkaiiii/gg-ai");
 var DEFAULT_LOCAL_ENDPOINTS = [
   { id: "ollama", label: "Ollama", baseUrl: "http://127.0.0.1:11434/v1", kind: "ollama" }
 ];
 var FALLBACK_CONTEXT_WINDOW = 4096;
-var LOCAL_API_KEY_PLACEHOLDER = "local";
+var LOCAL_API_KEY_PLACEHOLDER = import_gg_ai4.LOCAL_NO_API_KEY;
 var DEFAULT_PROBE_TIMEOUT_MS = 1200;
 var ENRICH_CONCURRENCY = 6;
 var CACHE_TTL_MS = 3e4;
@@ -3048,6 +3226,9 @@ function parseLocalModelId(id) {
   if (slash <= 0 || slash === rest.length - 1) return void 0;
   return { endpointId: rest.slice(0, slash), rawId: rest.slice(slash + 1) };
 }
+function localModelShortName(rawId) {
+  return rawId.slice(rawId.lastIndexOf("/") + 1) || rawId;
+}
 function isLocalModelId(id) {
   return parseLocalModelId(id) !== void 0;
 }
@@ -3058,8 +3239,9 @@ function endpointRoot(baseUrl) {
   return baseUrl.replace(/\/+$/, "").replace(/\/v1$/, "");
 }
 function authHeaders(endpoint) {
+  const key = (0, import_gg_ai4.localBearerKey)(endpoint.apiKey);
   return {
-    Authorization: `Bearer ${endpoint.apiKey ?? LOCAL_API_KEY_PLACEHOLDER}`,
+    ...key ? { Authorization: `Bearer ${key}` } : {},
     Accept: "application/json"
   };
 }
@@ -3121,10 +3303,22 @@ async function enrich(endpoint, entries, options) {
   if (endpoint.kind === "lmstudio") return enrichLmStudio(endpoint, entries, options);
   if (endpoint.kind === "ollama") return enrichOllama(endpoint, entries, options);
   if (endpoint.kind === "llamacpp") return enrichLlamaCpp(endpoint, entries, options);
+  if (endpoint.kind === "custom") return enrichCustom(endpoint, entries, options);
   return entries.map((entry) => genericModel(endpoint, entry));
 }
+async function enrichCustom(endpoint, entries, options) {
+  const generic = entries.map((entry) => genericModel(endpoint, entry));
+  if (generic.every((model) => model.contextWindowKnown)) return generic;
+  const root = endpointRoot(endpoint.baseUrl);
+  const props = await fetchJson(`${root}/props`, endpoint, options);
+  const nCtx = contextLength(props?.default_generation_settings?.n_ctx);
+  if (nCtx !== void 0) return llamaCppModels(endpoint, entries, nCtx);
+  const lmStudio = await fetchJson(`${root}/api/v1/models`, endpoint, options);
+  if (Array.isArray(lmStudio?.models)) return enrichLmStudio(endpoint, entries, options, lmStudio);
+  return generic;
+}
 function genericModel(endpoint, entry) {
-  const declared = contextLength(entry.max_model_len);
+  const declared = contextLength(entry.max_model_len) ?? contextLength(entry.context_length);
   return {
     rawId: entry.id,
     endpointId: endpoint.id,
@@ -3151,9 +3345,7 @@ async function enrichOllama(endpoint, entries, options) {
     });
     const caps = Array.isArray(show?.capabilities) ? show.capabilities : [];
     if (caps.includes("embedding") && !caps.includes("completion")) return void 0;
-    const ctx = contextLength(
-      runningModels.find((model) => model?.name === entry.id || model?.model === entry.id)?.context_length
-    );
+    const ctx = runningContext(runningModels, entry.id) ?? modelfileNumCtx(show?.parameters);
     return {
       rawId: entry.id,
       endpointId: endpoint.id,
@@ -3168,12 +3360,41 @@ async function enrichOllama(endpoint, entries, options) {
   });
   return enriched.filter((model) => model !== void 0);
 }
+function runningContext(models, rawId) {
+  return contextLength(
+    models.find((model) => model?.name === rawId || model?.model === rawId)?.context_length
+  );
+}
+function modelfileNumCtx(parameters) {
+  const match = /^num_ctx\s+(\d+)\s*$/m.exec(parameters ?? "");
+  return match ? contextLength(Number(match[1])) : void 0;
+}
+async function ollamaServedContext(endpoint, rawId, {
+  load = false,
+  timeoutMs = 12e4,
+  signal
+} = {}) {
+  const root = endpointRoot(endpoint.baseUrl);
+  if (load) {
+    await fetchJson(`${root}/api/generate`, endpoint, {
+      timeoutMs,
+      signal,
+      method: "POST",
+      body: { model: rawId }
+    });
+  }
+  const running = await fetchJson(`${root}/api/ps`, endpoint, {
+    timeoutMs: DEFAULT_PROBE_TIMEOUT_MS,
+    signal
+  });
+  return runningContext(Array.isArray(running?.models) ? running.models : [], rawId);
+}
 function contextLength(value) {
   return typeof value === "number" && Number.isSafeInteger(value) && value > 0 ? value : void 0;
 }
-async function enrichLmStudio(endpoint, entries, options) {
+async function enrichLmStudio(endpoint, entries, options, fetched) {
   const root = endpointRoot(endpoint.baseUrl);
-  const detail = await fetchJson(`${root}/api/v1/models`, endpoint, options);
+  const detail = fetched ?? await fetchJson(`${root}/api/v1/models`, endpoint, options);
   const byId = /* @__PURE__ */ new Map();
   if (Array.isArray(detail?.models)) {
     for (const model of detail.models) {
@@ -3231,12 +3452,17 @@ async function enrichLlamaCpp(endpoint, entries, options) {
     endpoint,
     options
   );
-  const nCtx = contextLength(props?.default_generation_settings?.n_ctx);
-  const known = nCtx !== void 0;
+  return llamaCppModels(
+    endpoint,
+    entries,
+    contextLength(props?.default_generation_settings?.n_ctx)
+  );
+}
+function llamaCppModels(endpoint, entries, nCtx) {
   return entries.map((entry) => ({
     ...genericModel(endpoint, entry),
-    contextWindow: known ? nCtx : FALLBACK_CONTEXT_WINDOW,
-    contextWindowKnown: known
+    contextWindow: nCtx ?? FALLBACK_CONTEXT_WINDOW,
+    contextWindowKnown: nCtx !== void 0
   }));
 }
 async function mapLimited(items, limit, fn) {
@@ -3393,7 +3619,7 @@ var ALL_AUTH_PROVIDERS = [
   {
     value: "minimax",
     label: "MiniMax",
-    description: "MiniMax M3",
+    description: "MiniMax M3.1 Flash, M3",
     methods: ["apikey"],
     apiKeyLabel: "MiniMax"
   },
@@ -4226,6 +4452,8 @@ 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,
@@ -4234,6 +4462,7 @@ function createAutoUpdater(config) {
   TelegramBot,
   XAI_OAUTH_KEY,
   XIAOMI_CREDITS_KEY,
+  XIAOMI_TOKEN_PLAN_BASE_URLS,
   authPriorityNote,
   clampThinkingForPlanMode,
   clearLocalDiscoveryCache,
@@ -4242,6 +4471,8 @@ function createAutoUpdater(config) {
   createAutoUpdater,
   decodeOggOpus,
   describeAuthMethods,
+  detectMiniMaxBaseUrl,
+  detectXiaomiTokenPlanBaseUrl,
   discoverLocalModels,
   downmixToMono,
   dualAuthProvider,
@@ -4285,6 +4516,7 @@ function createAutoUpdater(config) {
   kimiCodeBaseUrl,
   kimiCodingHeaders,
   localAuthStorageKey,
+  localModelShortName,
   log,
   loginAnthropic,
   loginGemini,
@@ -4292,6 +4524,7 @@ function createAutoUpdater(config) {
   loginOpenAI,
   loginXai,
   oauthStorageKey,
+  ollamaServedContext,
   openLog,
   parseLocalModelId,
   pendingClaudeCodeVersionRefresh,