n9router 0.4.43 → 0.4.45

package/app/open-sse/services/usage/google.js

@@ -0,0 +1,279 @@
+/**
+ * Google usage handlers (Gemini CLI + Antigravity)
+ */
+
+import { CLIENT_METADATA, getPlatformUserAgent } from "../../config/appConstants.js";
+import { ANTIGRAVITY_OAUTH_CLIENT } from "../../providers/shared.js";
+import { U, parseResetTime, normalizeCloudCodeProjectId, fetchWithTimeout } from "./shared.js";
+
+// Antigravity API config (from Quotio) — urls from registry, oauth client + dynamic UA kept here
+const ANTIGRAVITY_CONFIG = {
+  ...U("antigravity"),
+  ...ANTIGRAVITY_OAUTH_CLIENT,
+  userAgent: getPlatformUserAgent(),
+};
+
+/**
+ * Gemini CLI Usage — fetch per-model quota via Cloud Code Assist API.
+ * Uses retrieveUserQuota (same endpoint as `gemini /stats`) returning
+ * per-model buckets with remainingFraction + resetTime.
+ */
+export async function getGeminiUsage(accessToken, providerSpecificData, proxyOptions = null) {
+  if (!accessToken) {
+    return { plan: "Free", message: "Gemini CLI access token not available." };
+  }
+
+  try {
+    // Resolve project id: prefer connection-stored id, else loadCodeAssist lookup.
+    // #1271: OAuth save stores projectId on the connection, not providerSpecificData.
+    let projectId = normalizeCloudCodeProjectId(providerSpecificData?.projectId);
+    let plan = "Free";
+
+    if (!projectId) {
+      const subInfo = await getGeminiSubscriptionInfo(accessToken, proxyOptions);
+      projectId = normalizeCloudCodeProjectId(subInfo?.cloudaicompanionProject);
+      plan = subInfo?.currentTier?.name || plan;
+    }
+
+    if (!projectId) {
+      return {
+        plan,
+        message: "Gemini CLI project ID not available. Reconnect Gemini CLI, or configure a Google Cloud project with Gemini Code Assist access before checking quota.",
+      };
+    }
+
+    const response = await fetchWithTimeout(
+      U("gemini-cli").quotaUrl,
+      {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${accessToken}`,
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify({ project: projectId }),
+      },
+      10000,
+      proxyOptions
+    );
+
+    if (!response.ok) {
+      return { plan, message: `Gemini CLI quota error (${response.status}).` };
+    }
+
+    const data = await response.json();
+    const quotas = {};
+
+    if (Array.isArray(data.buckets)) {
+      for (const bucket of data.buckets) {
+        if (!bucket.modelId || bucket.remainingFraction == null) continue;
+
+        const remainingFraction = Number(bucket.remainingFraction) || 0;
+        const total = 1000; // Normalized base, matches antigravity convention
+        const remaining = Math.round(total * remainingFraction);
+        const used = Math.max(0, total - remaining);
+
+        quotas[bucket.modelId] = {
+          used,
+          total,
+          resetAt: parseResetTime(bucket.resetTime),
+          remainingPercentage: remainingFraction * 100,
+          unlimited: false,
+        };
+      }
+    }
+
+    return { plan, quotas };
+  } catch (error) {
+    return { message: `Gemini CLI error: ${error.message}` };
+  }
+}
+
+/**
+ * Get Gemini CLI subscription info via loadCodeAssist
+ */
+async function getGeminiSubscriptionInfo(accessToken, proxyOptions = null) {
+  try {
+    const response = await fetchWithTimeout(
+      U("gemini-cli").loadCodeAssistUrl,
+      {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${accessToken}`,
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify({ metadata: CLIENT_METADATA }),
+      },
+      10000,
+      proxyOptions
+    );
+    if (!response.ok) return null;
+    return await response.json();
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Antigravity Usage - Fetch quota from Google Cloud Code API
+ */
+export async function getAntigravityUsage(accessToken, providerSpecificData, proxyOptions = null) {
+  try {
+    // Fetch subscription info once — reuse for both projectId and plan
+    const subscriptionInfo = await getAntigravitySubscriptionInfo(accessToken, proxyOptions);
+    const projectId = subscriptionInfo?.cloudaicompanionProject || null;
+
+    const requestOptions = {
+      method: "POST",
+      headers: {
+        "Authorization": `Bearer ${accessToken}`,
+        "User-Agent": ANTIGRAVITY_CONFIG.userAgent,
+        "Content-Type": "application/json",
+        "X-Client-Name": "antigravity",
+        "X-Client-Version": "1.107.0",
+        "x-request-source": "local", // MITM bypass
+      },
+      body: JSON.stringify({
+        ...(projectId ? { project: projectId } : {})
+      }),
+    };
+    let response = await fetchWithTimeout(
+      ANTIGRAVITY_CONFIG.quotaApiUrl,
+      requestOptions,
+      10000,
+      proxyOptions,
+    );
+
+    // Some Antigravity accounts reject quota requests carrying the project id
+    // even though loadCodeAssist returned it. Retry once without the project.
+    if (response.status === 403 && projectId) {
+      response = await fetchWithTimeout(
+        ANTIGRAVITY_CONFIG.quotaApiUrl,
+        { ...requestOptions, body: JSON.stringify({}) },
+        10000,
+        proxyOptions,
+      );
+    }
+
+    if (response.status === 403) {
+      return {
+        plan: subscriptionInfo?.subscriptionTier || "Unknown",
+        message: "Antigravity quota API access forbidden. Chat may still work.",
+        isForbidden: true,
+        quotas: {}
+      };
+    }
+
+    if (response.status === 401) {
+      return {
+        plan: subscriptionInfo?.subscriptionTier || "Unknown",
+        message: "Antigravity quota API authentication expired. Chat may still work.",
+        isExpired: true,
+        quotas: {}
+      };
+    }
+
+    if (!response.ok) {
+      throw new Error(`Antigravity API error: ${response.status}`);
+    }
+
+    const data = await response.json();
+    const quotas = {};
+
+    // Parse model quotas (inspired by vscode-antigravity-cockpit)
+    if (data.models) {
+      for (const [modelKey, info] of Object.entries(data.models)) {
+        // Skip models without quota info
+        if (!info.quotaInfo) {
+          continue;
+        }
+
+        const matchesTarget =
+          modelKey === "claude-opus-4-6-thinking" ||
+          modelKey === "claude-sonnet-4-6" ||
+          modelKey.startsWith("gemini-3.1-pro-") ||
+          modelKey === "gemini-3.1-pro" ||
+          modelKey.startsWith("gemini-3.5-") ||
+          modelKey === "gemini-3.5" ||
+          modelKey === "gemini-3-flash-agent";
+
+        if (info.isInternal || !matchesTarget) {
+          continue;
+        }
+
+        const remainingFraction = info.quotaInfo.remainingFraction || 0;
+        const remainingPercentage = remainingFraction * 100;
+
+        // Convert percentage to used/total for UI compatibility
+        const total = 1000; // Normalized base
+        const remaining = Math.round(total * remainingFraction);
+        const used = total - remaining;
+
+        // Use modelKey as key (matches PROVIDER_MODELS id)
+        quotas[modelKey] = {
+          used,
+          total,
+          resetAt: parseResetTime(info.quotaInfo.resetTime),
+          remainingPercentage,
+          unlimited: false,
+          displayName: info.displayName || modelKey,
+        };
+      }
+    }
+
+    return {
+      plan: subscriptionInfo?.subscriptionTier || "Unknown",
+      quotas,
+      subscriptionInfo,
+    };
+  } catch (error) {
+    console.error("[Antigravity Usage] Error:", error.message, error.cause);
+    return { message: `Antigravity error: ${error.message}` };
+  }
+}
+
+/**
+ * Get Antigravity subscription info
+ */
+async function getAntigravitySubscriptionInfo(accessToken, proxyOptions = null) {
+  try {
+    const response = await fetchWithTimeout(ANTIGRAVITY_CONFIG.loadProjectApiUrl, {
+      method: "POST",
+      headers: {
+        "Authorization": `Bearer ${accessToken}`,
+        "User-Agent": ANTIGRAVITY_CONFIG.userAgent,
+        "Content-Type": "application/json",
+        "x-request-source": "local", // MITM bypass
+      },
+      body: JSON.stringify({ metadata: CLIENT_METADATA, mode: 1 }),
+    }, 10000, proxyOptions);
+
+    if (!response.ok) return null;
+    const data = await response.json();
+    const paidTier = data.paidTier;
+    const currentTier = data.currentTier;
+    const allowedTiers = data.allowedTiers;
+    const ineligibleTiers = data.ineligibleTiers;
+    const isIneligible = Array.isArray(ineligibleTiers) && ineligibleTiers.length > 0;
+
+    let subscriptionTier = paidTier?.name || paidTier?.id || null;
+    if (!subscriptionTier) {
+      if (!isIneligible) {
+        subscriptionTier = currentTier?.name || currentTier?.id || null;
+      } else if (Array.isArray(allowedTiers)) {
+        const defaultTier = allowedTiers.find((tier) => tier.isDefault === true);
+        const nameOrId = defaultTier?.name || defaultTier?.id;
+        if (nameOrId) subscriptionTier = `${nameOrId} (Restricted)`;
+      }
+    }
+
+    if (!subscriptionTier && currentTier && !isIneligible) {
+      subscriptionTier = "Free";
+    }
+
+    data.subscriptionTier = subscriptionTier;
+    return data;
+  } catch (error) {
+    console.error("[Antigravity Subscription] Error:", error.message);
+    return null;
+  }
+}

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

@@ -0,0 +1,188 @@
+/**
+ * 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/app/open-sse/services/usage/minimax.js

@@ -0,0 +1,234 @@
+/**
+ * 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." };
+}