@kenkaiiii/gg-core 5.89.0 → 5.91.0

package/dist/{chunk-5ZYOOESD.js → chunk-M53JVW2V.js}

@@ -1374,6 +1374,91 @@ function isHiddenProvider(provider) {
   return HIDDEN_PROVIDERS.includes(provider);
 }
 
+// src/auth-storage.ts
+import { LOCAL_NO_API_KEY } from "@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 authHeaders = [
+    { Authorization: `Bearer ${apiKey}` },
+    { "x-api-key": apiKey }
+  ];
+  for (const auth of authHeaders) {
+    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";
@@ -1424,6 +1509,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(readFileSync2(authFile, "utf-8"));
@@ -1470,8 +1564,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() {
@@ -1533,7 +1631,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 : LOCAL_NO_API_KEY,
       refreshToken: "",
       expiresAt: Date.now() + LOCAL_CREDENTIAL_LIFETIME_MS,
       baseUrl
@@ -1670,11 +1768,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];
@@ -1788,6 +1929,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)) {
@@ -2438,6 +2580,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",
@@ -2688,7 +2847,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",
@@ -2784,6 +2943,11 @@ export {
   closeLogger,
   HIDDEN_PROVIDERS,
   isHiddenProvider,
+  MINIMAX_GLOBAL_BASE_URL,
+  MINIMAX_CN_BASE_URL,
+  detectMiniMaxBaseUrl,
+  XIAOMI_TOKEN_PLAN_BASE_URLS,
+  detectXiaomiTokenPlanBaseUrl,
   MOONSHOT_OAUTH_KEY,
   XAI_OAUTH_KEY,
   dualAuthProvider,
@@ -2818,4 +2982,4 @@ export {
   getDefaultThinkingLevel,
   getSummaryModel
 };
-//# sourceMappingURL=chunk-5ZYOOESD.js.map
+//# sourceMappingURL=chunk-M53JVW2V.js.map