@fudrouter/fsrouter 0.6.59 → 0.6.61

package/open-sse/services/usage/grok-cli.js

@@ -1,274 +0,0 @@
-/**
- * Grok CLI / Grok Build usage handler
- *
- * Source of truth: official grok-shell/grok-pager traffic to cli-chat-proxy.grok.com
- *   GET /v1/billing?format=credits
- *   GET /v1/user?include=subscription
- *
- * Observed billing shape (protobuf-json style `{ val: number }`):
- * {
- *   config: {
- *     currentPeriod: { type: "USAGE_PERIOD_TYPE_WEEKLY", start, end },
- *     onDemandCap: { val },
- *     onDemandUsed: { val },
- *     prepaidBalance: { val },
- *     isUnifiedBillingUser: true,
- *     billingPeriodStart, billingPeriodEnd
- *   }
- * }
- *
- * Exhausted free/promo accounts return cap=0/used=0/prepaid=0 and chat 402s with
- * personal-team-blocked:spending-limit. Paid/sub accounts surface non-zero cap
- * or prepaidBalance; richer credit fields are parsed opportunistically if present.
- */
-
-import { proxyAwareFetch } from "../../utils/proxyFetch.js";
-import { U, parseResetTime, toFiniteNumber } from "./shared.js";
-
-const USAGE = U("grok-cli");
-const BILLING_URL = USAGE.url || "https://cli-chat-proxy.grok.com/v1/billing?format=credits";
-const USER_URL = USAGE.userUrl || "https://cli-chat-proxy.grok.com/v1/user?include=subscription";
-
-/** Unwrap protobuf-json `{ val: n }` or plain numbers/strings. */
-function unwrapVal(value, fallback = 0) {
-  if (value == null) return fallback;
-  if (typeof value === "object" && !Array.isArray(value) && "val" in value) {
-    return toFiniteNumber(value.val, fallback);
-  }
-  return toFiniteNumber(value, fallback);
-}
-
-function buildGrokCliHeaders(accessToken, providerSpecificData = {}) {
-  const psd = providerSpecificData || {};
-  const headers = {
-    Authorization: `Bearer ${accessToken}`,
-    Accept: "application/json",
-    "User-Agent": "grok-pager/0.2.93 grok-shell/0.2.93 (linux; x86_64)",
-    "x-xai-token-auth": "xai-grok-cli",
-    "x-grok-client-identifier": "grok-pager",
-    "x-grok-client-version": "0.2.93",
-  };
-  const email = psd.email;
-  const userId = psd.userId || psd.principalId;
-  if (email) headers["x-email"] = email;
-  if (userId) headers["x-userid"] = userId;
-  return headers;
-}
-
-function resolvePlan(user, config) {
-  const tier = typeof user?.subscriptionTier === "string" ? user.subscriptionTier.trim() : "";
-  if (tier) {
-    return tier
-      .replace(/[_-]+/g, " ")
-      .replace(/\b\w/g, (c) => c.toUpperCase());
-  }
-  if (user?.hasGrokCodeAccess === true) return "Grok Code";
-  if (config?.isUnifiedBillingUser === true) return "Grok Build";
-  return "Grok Build";
-}
-
-function makeQuota({ used, total, resetAt, unlimited = false }) {
-  const safeTotal = Math.max(0, toFiniteNumber(total, 0));
-  const safeUsed = Math.max(0, toFiniteNumber(used, 0));
-  // Do NOT set absolute `remaining` — QuotaTable's getRemainingPercentage treats
-  // `remaining` as a 0–100 percentage (same trap as Qoder credits).
-  if (unlimited || safeTotal === 0) {
-    return {
-      used: safeUsed,
-      total: 0,
-      remainingPercentage: unlimited ? 100 : 0,
-      resetAt: resetAt || null,
-      unlimited: true,
-    };
-  }
-  const remaining = Math.max(0, safeTotal - safeUsed);
-  const remainingPercentage = (remaining / safeTotal) * 100;
-  return {
-    used: safeUsed,
-    total: safeTotal,
-    remainingPercentage,
-    resetAt: resetAt || null,
-    unlimited: false,
-  };
-}
-
-/**
- * Map billing JSON → normalized quotas object for the dashboard.
- * Returns { quotas, periodEnd, exhaustedHint } or empty quotas when nothing usable.
- */
-export function parseGrokCliBilling(billing, user = null) {
-  const root = billing && typeof billing === "object" ? billing : {};
-  const config =
-    root.config && typeof root.config === "object" && !Array.isArray(root.config)
-      ? root.config
-      : root;
-
-  const periodEnd =
-    parseResetTime(config.billingPeriodEnd) ||
-    parseResetTime(config.currentPeriod?.end) ||
-    parseResetTime(root.billingPeriodEnd) ||
-    null;
-
-  const quotas = {};
-
-  // Primary: on-demand spending window (subscription / promo credits)
-  const onDemandCap = unwrapVal(config.onDemandCap ?? root.onDemandCap, NaN);
-  const onDemandUsed = unwrapVal(config.onDemandUsed ?? root.onDemandUsed, NaN);
-  if (Number.isFinite(onDemandCap) && onDemandCap > 0) {
-    const used = Number.isFinite(onDemandUsed) ? Math.max(0, onDemandUsed) : 0;
-    quotas["On-demand"] = makeQuota({
-      used,
-      total: onDemandCap,
-      resetAt: periodEnd,
-    });
-  } else if (Number.isFinite(onDemandCap) && onDemandCap === 0 && Number.isFinite(onDemandUsed)) {
-    // Cap 0 is the exhausted free/promo state (chat returns 402 spending-limit).
-    // UI treats total===0 as unlimited, so use a synthetic 1/1 depleted row.
-    quotas["On-demand"] = {
-      used: 1,
-      total: 1,
-      remainingPercentage: 0,
-      resetAt: periodEnd,
-      unlimited: false,
-    };
-  }
-
-  // Prepaid top-up balance (remaining credits; no fixed allotment known)
-  const prepaid = unwrapVal(config.prepaidBalance ?? root.prepaidBalance, NaN);
-  if (Number.isFinite(prepaid) && prepaid > 0) {
-    // Show full bar against the current balance (0 spent of this remaining pot).
-    quotas["Prepaid"] = {
-      used: 0,
-      total: prepaid,
-      remainingPercentage: 100,
-      resetAt: null,
-      unlimited: false,
-    };
-  }
-
-  // Opportunistic richer credit envelopes (future / other account types)
-  const creditBags = [
-    root.credits,
-    root.creditBalance,
-    root.usage,
-    config.credits,
-    config.includedCredits,
-    config.subscriptionCredits,
-  ].filter((bag) => bag && typeof bag === "object" && !Array.isArray(bag));
-
-  for (const bag of creditBags) {
-    const total = unwrapVal(
-      bag.total ?? bag.limit ?? bag.cap ?? bag.allocation ?? bag.amount,
-      NaN,
-    );
-    const used = unwrapVal(bag.used ?? bag.spent ?? bag.consumed, NaN);
-    const remaining = unwrapVal(bag.remaining ?? bag.balance ?? bag.left, NaN);
-    if (Number.isFinite(total) && total > 0) {
-      const resolvedUsed = Number.isFinite(used)
-        ? used
-        : Number.isFinite(remaining)
-          ? Math.max(0, total - remaining)
-          : 0;
-      if (!quotas.Credits) {
-        quotas.Credits = makeQuota({
-          used: resolvedUsed,
-          total,
-          resetAt: parseResetTime(bag.resetAt || bag.resetsAt || bag.end) || periodEnd,
-        });
-      }
-    } else if (Number.isFinite(remaining) && remaining >= 0 && !quotas.Credits) {
-      quotas.Credits = {
-        used: 0,
-        total: remaining > 0 ? remaining : 1,
-        remainingPercentage: remaining > 0 ? 100 : 0,
-        resetAt: periodEnd,
-        unlimited: false,
-      };
-    }
-  }
-
-  // Exhausted when every finite quota bar is at 0% remaining
-  const exhausted =
-    Object.keys(quotas).length > 0 &&
-    Object.values(quotas).every(
-      (q) => q.unlimited !== true && (q.remainingPercentage ?? 100) <= 0,
-    );
-
-  return {
-    plan: resolvePlan(user, config),
-    quotas,
-    periodEnd,
-    exhausted,
-    rawConfig: config,
-  };
-}
-
-/**
- * @param {string} accessToken
- * @param {object|null} providerSpecificData
- * @param {object|null} proxyOptions
- */
-export async function getGrokCliUsage(accessToken, providerSpecificData = null, proxyOptions = null) {
-  if (!accessToken) {
-    return { message: "Grok CLI access token not available." };
-  }
-
-  const headers = buildGrokCliHeaders(accessToken, providerSpecificData);
-
-  try {
-    // Fetch billing + user profile in parallel (same pattern as official CLI startup)
-    const [billingRes, userRes] = await Promise.all([
-      proxyAwareFetch(
-        BILLING_URL,
-        { method: "GET", headers },
-        proxyOptions,
-      ),
-      proxyAwareFetch(
-        USER_URL,
-        { method: "GET", headers },
-        proxyOptions,
-      ).catch(() => null),
-    ]);
-
-    if (billingRes.status === 401 || billingRes.status === 403) {
-      return { message: "Grok CLI authentication expired. Please re-authorize." };
-    }
-
-    if (!billingRes.ok) {
-      const errText = await billingRes.text().catch(() => "");
-      const trimmed = errText ? `: ${errText.slice(0, 200)}` : "";
-      return { message: `Grok CLI billing API error (${billingRes.status})${trimmed}` };
-    }
-
-    const billing = await billingRes.json().catch(() => null);
-    if (!billing || typeof billing !== "object") {
-      return { message: "Grok CLI billing response was not JSON." };
-    }
-
-    let user = null;
-    if (userRes?.ok) {
-      user = await userRes.json().catch(() => null);
-    }
-
-    const parsed = parseGrokCliBilling(billing, user);
-
-    if (!parsed.quotas || Object.keys(parsed.quotas).length === 0) {
-      return {
-        plan: parsed.plan,
-        message:
-          "Grok Build connected, but no credit allotment was returned. Free promo may be exhausted — upgrade at https://grok.com/supergrok or add credits at https://grok.com/?_s=usage.",
-        quotas: {},
-      };
-    }
-
-    // Dashboard hides QuotaTable whenever `message` is set, so only attach a
-    // message when there are no quota rows to render. Depleted accounts keep
-    // the 0% On-demand bar without a blocking message.
-    return {
-      plan: parsed.plan,
-      quotas: parsed.quotas,
-    };
-  } catch (error) {
-    return { message: `Grok CLI usage error: ${error.message}` };
-  }
-}

package/open-sse/services/usage/kiro.js

@@ -1,188 +0,0 @@
-/**
- * Kiro (AWS CodeWhisperer) usage handler
- */
-
-import { proxyAwareFetch } from "../../utils/proxyFetch.js";
-import { resolveDefaultProfileArn } from "../../config/kiroConstants.js";
-import { U, parseResetTime } from "./shared.js";
-
-/**
- * Kiro (AWS CodeWhisperer) Usage
- */
-function parseKiroQuotaData(data) {
-  const usageList = data.usageBreakdownList || [];
-  const quotaInfo = {};
-  const resetAt = parseResetTime(data.nextDateReset || data.resetDate);
-
-  usageList.forEach((breakdown) => {
-    const resourceType = breakdown.resourceType?.toLowerCase() || "unknown";
-    const used = breakdown.currentUsageWithPrecision || 0;
-    const total = breakdown.usageLimitWithPrecision || 0;
-
-    quotaInfo[resourceType] = {
-      used,
-      total,
-      remaining: total - used,
-      resetAt,
-      unlimited: false,
-    };
-
-    // Add free trial if available
-    if (breakdown.freeTrialInfo) {
-      const freeUsed = breakdown.freeTrialInfo.currentUsageWithPrecision || 0;
-      const freeTotal = breakdown.freeTrialInfo.usageLimitWithPrecision || 0;
-
-      quotaInfo[`${resourceType}_freetrial`] = {
-        used: freeUsed,
-        total: freeTotal,
-        remaining: freeTotal - freeUsed,
-        resetAt: parseResetTime(breakdown.freeTrialInfo.freeTrialExpiry || resetAt),
-        unlimited: false,
-      };
-    }
-  });
-
-  return {
-    plan: data.subscriptionInfo?.subscriptionTitle || "Kiro",
-    quotas: quotaInfo,
-  };
-}
-
-export async function getKiroUsage(accessToken, providerSpecificData, proxyOptions = null) {
-  const authMethod = providerSpecificData?.authMethod || "builder-id";
-  // API-key Kiro connections authenticate the quota API the same way the chat
-  // executor does: a bearer token plus a `tokentype: API_KEY` header so
-  // CodeWhisperer treats it as a long-lived API key rather than an OIDC token.
-  // Without this header the GetUsageLimits call is rejected (401/403).
-  const isApiKey = authMethod === "api_key";
-  const isExternalIdp = authMethod === "external_idp";
-  const apiKeyHeaders = isApiKey ? { tokentype: "API_KEY" } : {};
-  const externalIdpHeaders = isExternalIdp ? { TokenType: "EXTERNAL_IDP" } : {};
-
-  // For api-key auth, never inject the shared default placeholder profileArn —
-  // CodeWhisperer 403s a request whose profileArn isn't owned by the key's
-  // account. Only send a profileArn actually resolved for this connection.
-  const profileArn = isApiKey
-    ? (providerSpecificData?.profileArn || "")
-    : (providerSpecificData?.profileArn || resolveDefaultProfileArn(authMethod));
-
-  const getUsageParams = new URLSearchParams({
-    isEmailRequired: "true",
-    origin: "AI_EDITOR",
-    resourceType: "AGENTIC_REQUEST",
-  });
-
-  // For compatibility, try multiple known Kiro usage endpoints
-  const attempts = [
-    {
-      name: "codewhisperer-get",
-      run: async () => proxyAwareFetch(
-        `${U("kiro").cwHost}${U("kiro").limitsPath}?${getUsageParams.toString()}`,
-        {
-          method: "GET",
-          headers: {
-            "Authorization": `Bearer ${accessToken}`,
-            "Accept": "application/json",
-            "x-amz-user-agent": "aws-sdk-js/1.0.0 KiroIDE",
-            "user-agent": "aws-sdk-js/1.0.0 KiroIDE",
-            ...apiKeyHeaders,
-            ...externalIdpHeaders,
-          },
-        },
-        proxyOptions
-      ),
-    },
-    {
-      name: "codewhisperer-post",
-      run: async () => proxyAwareFetch(U("kiro").cwHost, {
-        method: "POST",
-        headers: {
-          "Authorization": `Bearer ${accessToken}`,
-          "Content-Type": "application/x-amz-json-1.0",
-          "x-amz-target": "AmazonCodeWhispererService.GetUsageLimits",
-          "Accept": "application/json",
-          ...apiKeyHeaders,
-          ...externalIdpHeaders,
-        },
-        body: JSON.stringify({
-          origin: "AI_EDITOR",
-          ...(profileArn ? { profileArn } : {}),
-          resourceType: "AGENTIC_REQUEST",
-        }),
-      }, proxyOptions),
-    },
-    {
-      name: "q-get",
-      run: async () => {
-        const params = new URLSearchParams({
-          origin: "AI_EDITOR",
-          ...(profileArn ? { profileArn } : {}),
-          resourceType: "AGENTIC_REQUEST",
-        });
-        return proxyAwareFetch(`${U("kiro").qHost}${U("kiro").limitsPath}?${params}`, {
-          method: "GET",
-          headers: {
-            "Authorization": `Bearer ${accessToken}`,
-            "Accept": "application/json",
-            ...apiKeyHeaders,
-            ...externalIdpHeaders,
-          },
-        }, proxyOptions);
-      },
-    },
-  ];
-
-  let sawAuthError = false;
-  const errors = [];
-
-  for (const attempt of attempts) {
-    try {
-      const response = await attempt.run();
-      if (!response.ok) {
-        const errorText = await response.text().catch(() => "");
-        if (response.status === 401 || response.status === 403) {
-          sawAuthError = true;
-        }
-        errors.push(`${attempt.name}:${response.status}${errorText ? `:${errorText}` : ""}`);
-        continue;
-      }
-
-      const data = await response.json();
-      return parseKiroQuotaData(data);
-    } catch (error) {
-      errors.push(`${attempt.name}:${error.message}`);
-    }
-  }
-
-  if (sawAuthError && authMethod === "idc") {
-    return {
-      message: "Kiro quota API is unavailable for the current AWS IAM Identity Center session. Chat may still work. If this persists after renewing your session, reconnect Kiro.",
-      quotas: {},
-    };
-  }
-
-  // Social auth (Google/GitHub) - these use a different token format that may not work with AWS CodeWhisperer quota APIs
-  if (sawAuthError && (authMethod === "google" || authMethod === "github")) {
-    return {
-      message: "Kiro quota API authentication expired. Chat may still work.",
-      quotas: {},
-    };
-  }
-
-  if (sawAuthError) {
-    return {
-      message: "Kiro quota API rejected the current token. Chat may still work.",
-      quotas: {},
-    };
-  }
-
-  const fallbackMessage =
-    errors.length > 0
-      ? `Unable to fetch Kiro usage right now. (${errors[errors.length - 1]})`
-      : "Unable to fetch Kiro usage right now.";
-
-  return {
-    message: fallbackMessage,
-    quotas: {},
-  };
-}

package/open-sse/services/usage/minimax.js

@@ -1,234 +0,0 @@
-/**
- * MiniMax usage handler
- */
-
-import { proxyAwareFetch } from "../../utils/proxyFetch.js";
-import { U, parseResetTime } from "./shared.js";
-
-// MiniMax usage endpoints (try in order, fallback on transient errors)
-const MINIMAX_USAGE_URLS = {
-  minimax: U("minimax").urls,
-  "minimax-cn": U("minimax-cn").urls,
-};
-
-// ── MiniMax helpers ──────────────────────────────────────────────────────
-function getMiniMaxField(model, snakeKey, camelKey) {
-  if (!model || typeof model !== "object") return null;
-  return model[snakeKey] ?? model[camelKey] ?? null;
-}
-
-function getMiniMaxModelName(model) {
-  return String(getMiniMaxField(model, "model_name", "modelName") || "").trim();
-}
-
-function formatMiniMaxQuotaName(model) {
-  const rawName = getMiniMaxModelName(model);
-  if (!rawName) return "MiniMax";
-
-  // M3+ shared quota pool: MiniMax reports M-series as a single wildcard
-  // bucket ("MiniMax-M*"). Newer responses rename it to plain "general".
-  // Render both as a friendly series label rather than leaking the
-  // asterisk or the vague "general" word to the UI.
-  if (rawName === "MiniMax-M*" || rawName === "general") return "M-series";
-
-  return rawName
-    .replace(/[_-]+/g, " ")
-    .replace(/\s+/g, " ")
-    .trim()
-    .replace(/\b\w/g, (ch) => ch.toUpperCase())
-    .replace(/\bTo\b/g, "to")
-    .replace(/\bTts\b/g, "TTS")
-    .replace(/\bHd\b/g, "HD");
-}
-
-function getMiniMaxProvidedPercent(model, snakeKey, camelKey) {
-  if (!model || typeof model !== "object") return null;
-  const raw = model[snakeKey] ?? model[camelKey];
-  if (raw === null || raw === undefined) return null;
-  const num = Number(raw);
-  if (!Number.isFinite(num)) return null;
-  return Math.max(0, Math.min(100, num));
-}
-
-function getMiniMaxSessionTotal(model) {
-  return Math.max(0, Number(getMiniMaxField(model, "current_interval_total_count", "currentIntervalTotalCount")) || 0);
-}
-
-function getMiniMaxWeeklyTotal(model) {
-  return Math.max(0, Number(getMiniMaxField(model, "current_weekly_total_count", "currentWeeklyTotalCount")) || 0);
-}
-
-function hasMiniMaxQuota(model) {
-  // Old format has real count totals; M3-era M-series buckets ship percent-only
-  // (count fields are 0) so accept those too.
-  if (getMiniMaxSessionTotal(model) > 0 || getMiniMaxWeeklyTotal(model) > 0) return true;
-  if (getMiniMaxProvidedPercent(model, "current_interval_remaining_percent", "currentIntervalRemainingPercent") !== null) return true;
-  if (getMiniMaxProvidedPercent(model, "current_weekly_remaining_percent", "currentWeeklyRemainingPercent") !== null) return true;
-  return false;
-}
-
-function getMiniMaxResetAt(model, capturedAtMs, remainsSnake, remainsCamel, endSnake, endCamel) {
-  const remainsMs = Number(getMiniMaxField(model, remainsSnake, remainsCamel)) || 0;
-  if (remainsMs > 0) return new Date(capturedAtMs + remainsMs).toISOString();
-  return parseResetTime(getMiniMaxField(model, endSnake, endCamel));
-}
-
-function buildMiniMaxQuota(total, count, resetAt, countMeansRemaining, providedPercent = null) {
-  const safeTotal = Math.max(0, total);
-  const used = countMeansRemaining ? Math.max(safeTotal - count, 0) : Math.min(Math.max(0, count), safeTotal);
-  const remaining = Math.max(safeTotal - used, 0);
-  // M-series buckets ship percent-only (count = 0). Prefer the upstream value
-  // when present, otherwise fall back to the computed percentage. When the
-  // quota is unbounded (no count) and no upstream percent is available, surface
-  // the percent anyway as long as it is defined.
-  const remainingPercentage = providedPercentage(providedPercent, remaining, safeTotal);
-  return {
-    used,
-    total: safeTotal,
-    remaining,
-    remainingPercentage,
-    resetAt,
-    unlimited: false,
-  };
-}
-
-function providedPercentage(provided, remaining, total) {
-  if (provided !== null && provided !== undefined && Number.isFinite(provided)) {
-    return Math.max(0, Math.min(100, provided));
-  }
-  return total > 0 ? Math.max(0, Math.min(100, (remaining / total) * 100)) : 0;
-}
-
-function addMiniMaxQuota(quotas, key, model, getTotal, countSnake, countCamel, percentSnake, percentCamel, resetArgs, countMeansRemaining) {
-  const total = getTotal(model);
-  const providedPercent = getMiniMaxProvidedPercent(model, percentSnake, percentCamel);
-  if (total <= 0 && providedPercent === null) return;
-
-  const count = Math.max(0, Number(getMiniMaxField(model, countSnake, countCamel)) || 0);
-  let effectiveTotal = total;
-  let effectiveCount = count;
-  if (total <= 0) {
-    // M-series bucket: API only ships *_remaining_percent (count = 0). Normalize
-    // to total=100. The downstream buildMiniMaxQuota treats the count as
-    // "used" or "remaining" depending on countMeansRemaining, so the synthetic
-    // count has to match that semantic — otherwise the UI flips the percentage.
-    effectiveTotal = 100;
-    const pct = providedPercent;
-    effectiveCount = countMeansRemaining
-      ? Math.round(effectiveTotal * (pct / 100))
-      : Math.round(effectiveTotal * (1 - pct / 100));
-  }
-  quotas[key] = buildMiniMaxQuota(
-    effectiveTotal,
-    effectiveCount,
-    getMiniMaxResetAt(model, ...resetArgs),
-    countMeansRemaining,
-    providedPercent
-  );
-}
-
-/**
- * MiniMax Token Plan / Coding Plan usage
- */
-export async function getMiniMaxUsage(apiKey, provider, proxyOptions = null) {
-  if (!apiKey) {
-    return { message: "MiniMax API key not available." };
-  }
-
-  const usageUrls = MINIMAX_USAGE_URLS[provider] || [];
-  let lastErrorMessage = "";
-
-  for (let index = 0; index < usageUrls.length; index += 1) {
-    const usageUrl = usageUrls[index];
-    const canFallback = index < usageUrls.length - 1;
-
-    try {
-      const response = await proxyAwareFetch(usageUrl, {
-        method: "GET",
-        headers: {
-          Authorization: `Bearer ${apiKey}`,
-          Accept: "application/json",
-          "Content-Type": "application/json",
-        },
-      }, proxyOptions);
-
-      const rawText = await response.text();
-      let payload = {};
-      if (rawText) {
-        try { payload = JSON.parse(rawText); } catch { payload = {}; }
-      }
-
-      const baseResp = (payload?.base_resp ?? payload?.baseResp) || {};
-      const apiStatusCode = Number(baseResp.status_code ?? baseResp.statusCode) || 0;
-      const apiStatusMessage = String(baseResp.status_msg ?? baseResp.statusMsg ?? "").trim();
-      const combined = `${apiStatusMessage} ${rawText}`.trim();
-      const authLike = /token plan|coding plan|invalid api key|invalid key|unauthorized|inactive/i;
-
-      if (response.status === 401 || response.status === 403 || apiStatusCode === 1004 || authLike.test(combined)) {
-        return { message: "MiniMax API key invalid or inactive. Use an active Token/Coding Plan key." };
-      }
-
-      if (!response.ok) {
-        lastErrorMessage = `MiniMax usage endpoint error (${response.status})`;
-        if ((response.status === 404 || response.status === 405 || response.status >= 500) && canFallback) continue;
-        return { message: `MiniMax connected. ${lastErrorMessage}` };
-      }
-
-      if (apiStatusCode !== 0) {
-        return { message: `MiniMax connected. ${apiStatusMessage || "Upstream quota API error"}` };
-      }
-
-      const modelRemains = payload?.model_remains ?? payload?.modelRemains;
-      const allModels = Array.isArray(modelRemains) ? modelRemains : [];
-      const quotaModels = allModels.filter(hasMiniMaxQuota);
-
-      if (quotaModels.length === 0) {
-        return { message: "MiniMax connected. No quota data was returned." };
-      }
-
-      const capturedAtMs = Date.now();
-      const countMeansRemaining = usageUrl.includes("/coding_plan/remains");
-      const quotas = {};
-
-      for (const model of quotaModels) {
-        const displayName = formatMiniMaxQuotaName(model);
-        addMiniMaxQuota(
-          quotas,
-          `${displayName} (5h)`,
-          model,
-          getMiniMaxSessionTotal,
-          "current_interval_usage_count",
-          "currentIntervalUsageCount",
-          "current_interval_remaining_percent",
-          "currentIntervalRemainingPercent",
-          [capturedAtMs, "remains_time", "remainsTime", "end_time", "endTime"],
-          countMeansRemaining
-        );
-
-        addMiniMaxQuota(
-          quotas,
-          `${displayName} (7d)`,
-          model,
-          getMiniMaxWeeklyTotal,
-          "current_weekly_usage_count",
-          "currentWeeklyUsageCount",
-          "current_weekly_remaining_percent",
-          "currentWeeklyRemainingPercent",
-          [capturedAtMs, "weekly_remains_time", "weeklyRemainsTime", "weekly_end_time", "weeklyEndTime"],
-          countMeansRemaining
-        );
-      }
-
-      if (Object.keys(quotas).length === 0) {
-        return { message: "MiniMax connected. Unable to extract quota usage." };
-      }
-
-      return { quotas };
-    } catch (error) {
-      lastErrorMessage = error.message;
-      if (!canFallback) break;
-    }
-  }
-
-  return { message: lastErrorMessage ? `MiniMax connected. Unable to fetch usage: ${lastErrorMessage}` : "MiniMax connected. Unable to fetch usage." };
-}