@kenkaiiii/gg-core 5.90.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,
@@ -1528,6 +1533,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 +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"));
@@ -1623,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() {
@@ -1823,11 +1925,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 +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)) {
@@ -2597,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",
@@ -2847,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",
@@ -2941,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-");
@@ -2957,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);
 }
@@ -2989,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;
@@ -3009,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.
@@ -3451,7 +3619,7 @@ var ALL_AUTH_PROVIDERS = [
   {
     value: "minimax",
     label: "MiniMax",
-    description: "MiniMax M3",
+    description: "MiniMax M3.1 Flash, M3",
     methods: ["apikey"],
     apiKeyLabel: "MiniMax"
   },
@@ -4284,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,
@@ -4292,6 +4462,7 @@ function createAutoUpdater(config) {
   TelegramBot,
   XAI_OAUTH_KEY,
   XIAOMI_CREDITS_KEY,
+  XIAOMI_TOKEN_PLAN_BASE_URLS,
   authPriorityNote,
   clampThinkingForPlanMode,
   clearLocalDiscoveryCache,
@@ -4300,6 +4471,8 @@ function createAutoUpdater(config) {
   createAutoUpdater,
   decodeOggOpus,
   describeAuthMethods,
+  detectMiniMaxBaseUrl,
+  detectXiaomiTokenPlanBaseUrl,
   discoverLocalModels,
   downmixToMono,
   dualAuthProvider,