zevairouter 1.0.154 → 1.0.156

package/open-sse/services/usage.js

@@ -1,2415 +0,0 @@
-/**
- * Usage Fetcher - Get usage data from provider APIs
- */
-
-import { CLIENT_METADATA, getPlatformUserAgent } from "../config/appConstants.js";
-import { proxyAwareFetch } from "../utils/proxyFetch.js";
-
-// GitHub API config
-const GITHUB_CONFIG = {
-  apiVersion: "2022-11-28",
-  userAgent: "GitHubCopilotChat/0.26.7",
-};
-
-// GLM quota endpoints (region-aware)
-const GLM_QUOTA_URLS = {
-  international: "https://api.z.ai/api/monitor/usage/quota/limit",
-  china: "https://open.bigmodel.cn/api/monitor/usage/quota/limit",
-};
-
-// MiniMax usage endpoints (try in order, fallback on transient errors)
-const MINIMAX_USAGE_URLS = {
-  minimax: [
-    "https://www.minimax.io/v1/token_plan/remains",
-    "https://api.minimax.io/v1/api/openplatform/coding_plan/remains",
-  ],
-  "minimax-cn": [
-    "https://www.minimaxi.com/v1/api/openplatform/coding_plan/remains",
-    "https://api.minimaxi.com/v1/api/openplatform/coding_plan/remains",
-  ],
-};
-
-// Antigravity API config (from Quotio)
-const ANTIGRAVITY_CONFIG = {
-  // Multiple upstream domains — Google routes free/paid accounts differently and
-  // some hosts 403 where others 200. Try in order until one answers (ported from
-  // OmniRoute antigravityUpstream.ts).
-  quotaApiHosts: [
-    "https://daily-cloudcode-pa.googleapis.com",
-    "https://cloudcode-pa.googleapis.com",
-    "https://daily-cloudcode-pa.sandbox.googleapis.com",
-  ],
-  fetchAvailableModelsPath: "/v1internal:fetchAvailableModels",
-  retrieveUserQuotaPath: "/v1internal:retrieveUserQuota",
-  loadProjectApiUrl: "https://cloudcode-pa.googleapis.com/v1internal:loadCodeAssist",
-  tokenUrl: "https://oauth2.googleapis.com/token",
-  clientId: "1071006060591-tmhssin2h21lcre235vtolojh4g403ep.apps.googleusercontent.com",
-  clientSecret: "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",
-  userAgent: getPlatformUserAgent(),
-};
-
-// Codex (OpenAI) API config
-const CODEX_CONFIG = {
-  usageUrl: "https://chatgpt.com/backend-api/wham/usage",
-};
-
-// Claude API config
-const CLAUDE_CONFIG = {
-  oauthUsageUrl: "https://api.anthropic.com/api/oauth/usage",
-  usageUrl: "https://api.anthropic.com/v1/organizations/{org_id}/usage",
-  settingsUrl: "https://api.anthropic.com/v1/settings",
-  apiVersion: "2023-06-01",
-};
-
-const CODEBUDDY_CONFIG = {
-  usageUrlPath: "/v2/billing/meter/get-user-resource",
-  productCode: "p_tcaca",
-  packageCodes: {
-    free: "TCACA_code_001_PqouKr6QWV",
-    proMon: "TCACA_code_002_AkiJS3ZHF5",
-    gift: "TCACA_code_006_DbXS0lrypC",
-    activity: "TCACA_code_007_nzdH5h4Nl0",
-    proYear: "TCACA_code_003_FAnt7lcmRT",
-    freeMon: "TCACA_code_008_cfWoLwvjU4",
-    extra: "TCACA_code_009_0XmEQc2xOf",
-  },
-};
-
-// Build the billing/meter endpoint for the given provider-specific data.
-// Global edition uses www.codebuddy.ai; the China edition (codebuddy-cn)
-// is served from www.codebuddy.cn. The stored domain takes precedence;
-// otherwise the provider id determines the default domain.
-function getCodeBuddyUsageUrl(providerSpecificData = {}, provider = "codebuddy") {
-  const defaultDomain = provider === "codebuddy-cn" ? "www.codebuddy.cn" : "www.codebuddy.ai";
-  const domain = providerSpecificData?.domain || providerSpecificData?.rawAuth?.domain || defaultDomain;
-  return `https://${domain}${CODEBUDDY_CONFIG.usageUrlPath}`;
-}
-
-/**
- * Get usage data for a provider connection
- * @param {Object} connection - Provider connection with accessToken
- * @returns {Object} Usage data with quotas
- */
-export async function getUsageForProvider(connection, proxyOptions = null) {
-  const { provider, accessToken, apiKey, providerSpecificData, projectId } = connection;
-  const providerDataWithProjectId = {
-    ...(providerSpecificData || {}),
-    ...(projectId ? { projectId } : {}),
-  };
-
-  switch (provider) {
-    case "github":
-      return await getGitHubUsage(accessToken, providerSpecificData, proxyOptions);
-    case "gemini-cli":
-      return await getGeminiUsage(accessToken, providerDataWithProjectId, proxyOptions);
-    case "antigravity":
-      return await getAntigravityUsage(accessToken, providerDataWithProjectId, proxyOptions);
-    case "claude":
-      return await getClaudeUsage(accessToken, proxyOptions);
-    case "codex":
-      return await getCodexUsage(accessToken, proxyOptions);
-    case "kiro":
-      return await getKiroUsage(accessToken, providerSpecificData, proxyOptions);
-    case "codebuddy":
-    case "codebuddy-cn":
-      return await getCodeBuddyUsage(accessToken, providerSpecificData, proxyOptions, apiKey, provider);
-    case "qoder":
-      return await getQoderUsage(accessToken, proxyOptions);
-    case "autoclaw":
-      return await getAutoclawUsage(accessToken, proxyOptions, connection);
-    case "qwen":
-      return await getQwenUsage(accessToken, providerSpecificData);
-    case "iflow":
-      return await getIflowUsage(accessToken);
-    case "ollama":
-      return await getOllamaUsage(accessToken);
-    case "glm":
-    case "glm-cn":
-      return await getGlmUsage(apiKey, provider, proxyOptions);
-    case "minimax":
-    case "minimax-cn":
-      return await getMiniMaxUsage(apiKey, provider, proxyOptions);
-    case "grok-cli":
-      return await getGrokCliUsage(accessToken, providerSpecificData, proxyOptions);
-    case "cloudflare-ai":
-      return await getCloudflareAiUsage(apiKey || accessToken, providerSpecificData, proxyOptions);
-    case "xai":
-      return await getXaiUsage(accessToken || apiKey, providerSpecificData, proxyOptions);
-    case "cline":
-    case "clinepass":
-      return await getClineUsage(accessToken || apiKey, provider, proxyOptions);
-    case "kimchi":
-      return await getKimchiUsage(accessToken || apiKey, providerSpecificData, proxyOptions);
-    case "cursor":
-      return await getCursorUsage(accessToken, providerSpecificData);
-    default:
-      return { message: `Usage API not implemented for ${provider}` };
-  }
-}
-
-async function fetchCodeBuddyUid(accessToken, providerSpecificData = {}, proxyOptions = null, provider = "codebuddy") {
-  const cachedUid = providerSpecificData?.uid || providerSpecificData?.rawAuth?.uid;
-  if (cachedUid) return { uid: cachedUid, enterpriseId: providerSpecificData?.enterpriseId || null };
-
-  const defaultDomain = provider === "codebuddy-cn" ? "www.codebuddy.cn" : "www.codebuddy.ai";
-  const domain = providerSpecificData?.domain || providerSpecificData?.rawAuth?.domain || defaultDomain;
-  try {
-    const response = await proxyAwareFetch(`https://${domain}/v2/plugin/accounts`, {
-      method: "GET",
-      headers: {
-        Authorization: `Bearer ${accessToken}`,
-        Accept: "application/json",
-        "X-Domain": domain,
-      },
-    }, proxyOptions);
-
-    if (!response.ok) return { uid: null, enterpriseId: null };
-
-    const body = await response.json();
-    const accounts = body?.data?.accounts || [];
-    const account = accounts.find((a) => a.lastLogin) || accounts[0] || {};
-    return {
-      uid: account.uid || null,
-      enterpriseId: account.enterpriseId || null,
-    };
-  } catch {
-    return { uid: null, enterpriseId: null };
-  }
-}
-
-async function getCodeBuddyUsage(accessToken, providerSpecificData = {}, proxyOptions = null, apiKey = null, provider = "codebuddy") {
-  // Prefer the IDE OAuth token; fall back to the API key (chat key) when no
-  // OAuth token is stored. The billing/meter endpoint on both the global (.ai)
-  // and China (.cn) editions accepts the API key via Authorization: Bearer +
-  // X-Api-Key, so even zevairouter-generated chat keys are tried. If the
-  // endpoint rejects the key (401/403) we fall back to the local-router
-  // tracking message instead of throwing.
-  const isGeneratedKey = providerSpecificData?.authMode === "generated-api-key";
-  const effectiveToken = accessToken || apiKey;
-  const authMode = accessToken ? "oauth" : apiKey ? "api-key" : null;
-
-  if (!effectiveToken) {
-    return {
-      plan: "CodeBuddy",
-      message: "CodeBuddy upstream quota is unavailable because no valid IDE OAuth token or API key is stored.",
-      quotas: {},
-      trackingMode: "unavailable",
-    };
-  }
-
-  // Local-router fallback message used when an API-key (chat key) connection
-  // cannot read upstream quota — e.g. a generated key the upstream rejects.
-  const chatKeyFallback = {
-    plan: "CodeBuddy",
-    message: "CodeBuddy chat key active. Upstream quota is unavailable without a valid IDE OAuth token; use ZevaiRouter Usage for local request and token tracking.",
-    quotas: {},
-    authMode: isGeneratedKey ? "generated-api-key" : "api-key",
-    trackingMode: "local-router",
-  };
-
-  try {
-    const { uid, enterpriseId } = await fetchCodeBuddyUid(effectiveToken, providerSpecificData, proxyOptions, provider);
-
-    const response = await proxyAwareFetch(getCodeBuddyUsageUrl(providerSpecificData, provider), {
-      method: "POST",
-      headers: buildCodeBuddyUsageHeaders(effectiveToken, providerSpecificData, uid, enterpriseId, apiKey),
-      body: JSON.stringify(buildCodeBuddyUsageBody()),
-    }, proxyOptions);
-
-    const rawText = await response.text();
-    let payload = null;
-    try {
-      payload = rawText ? JSON.parse(rawText) : null;
-    } catch {
-      payload = null;
-    }
-
-    if (response.status === 401 || response.status === 403) {
-      // OAuth token rejected — surface explicitly (callers may force-refresh & retry).
-      if (authMode === "oauth") {
-        return {
-          plan: "CodeBuddy",
-          message: `CodeBuddy IDE OAuth token was rejected (${response.status}). Upstream quota is unavailable; use ZevaiRouter Usage for local request and token tracking.`,
-          quotas: {},
-          authMode: "oauth-rejected",
-          trackingMode: "local-router",
-        };
-      }
-      // API key (chat key) rejected — fall back to local-router tracking.
-      return chatKeyFallback;
-    }
-
-    if (!response.ok) {
-      return {
-        plan: "CodeBuddy",
-        message: `CodeBuddy quota endpoint returned ${response.status}.`,
-        quotas: {},
-      };
-    }
-
-    return {
-      ...parseCodeBuddyUsage(payload),
-      authMode,
-    };
-  } catch (error) {
-    return { plan: "CodeBuddy", message: `CodeBuddy connected. Unable to fetch quota: ${error.message}`, quotas: {} };
-  }
-}
-
-/**
- * Parse reset date/time to ISO string
- * Handles multiple formats: Unix timestamp (ms), ISO date string, etc.
- */
-function parseResetTime(resetValue) {
-  if (!resetValue) return null;
-
-  try {
-    // If it's already a Date object
-    if (resetValue instanceof Date) {
-      return resetValue.toISOString();
-    }
-
-    // Unix timestamps from provider APIs may be seconds or milliseconds.
-    if (typeof resetValue === 'number') {
-      return new Date(resetValue < 1e12 ? resetValue * 1000 : resetValue).toISOString();
-    }
-
-    // If it's a numeric string, treat it like a Unix timestamp too.
-    if (typeof resetValue === 'string') {
-      if (/^\d+$/.test(resetValue)) {
-        const timestamp = Number(resetValue);
-        return new Date(timestamp < 1e12 ? timestamp * 1000 : timestamp).toISOString();
-      }
-      return new Date(resetValue).toISOString();
-    }
-
-    return null;
-  } catch (error) {
-    console.warn(`Failed to parse reset time: ${resetValue}`, error);
-    return null;
-  }
-}
-
-function formatCodeBuddyDate(date) {
-  const pad = (value) => String(value).padStart(2, "0");
-  return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())} ${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())}`;
-}
-
-function buildCodeBuddyUsageBody() {
-  const now = new Date();
-  const rangeEnd = new Date(now);
-  rangeEnd.setFullYear(rangeEnd.getFullYear() + 101);
-
-  return {
-    PageNumber: 1,
-    PageSize: 200,
-    ProductCode: CODEBUDDY_CONFIG.productCode,
-    Status: [0, 3],
-    PackageCodes: Object.values(CODEBUDDY_CONFIG.packageCodes),
-    PackageEndTimeRangeBegin: formatCodeBuddyDate(now),
-    PackageEndTimeRangeEnd: formatCodeBuddyDate(rangeEnd),
-  };
-}
-
-function buildCodeBuddyUsageHeaders(accessToken, providerSpecificData = {}, uid = null, enterpriseId = null, apiKey = null) {
-  const domain = providerSpecificData?.domain || providerSpecificData?.rawAuth?.domain || "www.codebuddy.ai";
-
-  const headers = {
-    Authorization: `Bearer ${accessToken}`,
-    Accept: "application/json, text/plain, */*",
-    "Accept-Language": "zh-CN,zh;q=0.9",
-    "Content-Type": "application/json",
-    "X-Domain": domain,
-  };
-
-  // When authenticating with an API key (chat key) instead of an IDE OAuth
-  // token, also send the key via X-Api-Key — the billing/meter endpoint on
-  // both the global (.ai) and China (.cn) editions accepts this header.
-  if (apiKey) {
-    headers["X-Api-Key"] = apiKey;
-  }
-
-  if (uid) {
-    headers["X-User-Id"] = uid;
-  }
-  if (enterpriseId) {
-    headers["X-Enterprise-Id"] = enterpriseId;
-    headers["X-Tenant-Id"] = enterpriseId;
-  }
-
-  return headers;
-}
-
-function parseCodeBuddyUsage(payload) {
-  const data = payload?.data?.Response?.Data || payload?.Response?.Data || payload?.data || payload || {};
-  const accounts = Array.isArray(data?.Accounts)
-    ? data.Accounts
-    : Array.isArray(data?.accounts)
-      ? data.accounts
-      : [];
-
-  if (accounts.length === 0) {
-    return {
-      plan: "CodeBuddy",
-      message: "CodeBuddy connected. No quota records were returned.",
-      quotas: {},
-    };
-  }
-
-  // Split refill packs (monthly cycle resets) vs one-shot bonus packs so the UI
-  // does not imply bonus credits replenish every month (ported from zevairouter).
-  const REFILL_GAP_MS = 2 * 24 * 60 * 60 * 1000;
-  const cycleEndMs = (acc) => {
-    const r = parseResetTime(acc.CycleEndTime);
-    return r ? new Date(r).getTime() : Number.POSITIVE_INFINITY;
-  };
-  const isRefill = (acc) => {
-    const ce = cycleEndMs(acc);
-    const de = Number(acc.DeductionEndTime);
-    return Number.isFinite(ce) && Number.isFinite(de) && de - ce > REFILL_GAP_MS;
-  };
-  const byExpiry = (a, b) => cycleEndMs(a) - cycleEndMs(b);
-
-  const refills = accounts.filter(isRefill).sort(byExpiry);
-  const bonuses = accounts.filter((a) => !isRefill(a)).sort(byExpiry);
-
-  const quotas = {};
-  let hasProPackage = false;
-
-  const addQuota = (label, account, { recurring }) => {
-    const quota = getCodeBuddyQuotaValues(account, { useCycle: recurring });
-    if (!quota) return;
-    if (account.PackageCode === CODEBUDDY_CONFIG.packageCodes.proMon
-      || account.PackageCode === CODEBUDDY_CONFIG.packageCodes.proYear) {
-      hasProPackage = true;
-    }
-    if (!quotas[label]) {
-      quotas[label] = {
-        used: 0,
-        total: 0,
-        remaining: 0,
-        resetAt: null,
-        unit: "credits",
-        unlimited: false,
-        recurring,
-      };
-    }
-    quotas[label].used += quota.used;
-    quotas[label].total += quota.total;
-    quotas[label].remaining += quota.remaining;
-    quotas[label].resetAt = getEarlierReset(quotas[label].resetAt, quota.resetAt);
-    quotas[label].recurring = quotas[label].recurring && recurring;
-  };
-
-  // Aggregate ALL refill packs into one Monthly row and ALL bonus packs into one
-  // Bonus row — Tencent often returns many small gift packages (10–20 rows) for a
-  // single account, which flooded the dashboard as Bonus Pack 1..N.
-  for (const account of refills) {
-    addQuota("Monthly Credits", account, { recurring: true });
-  }
-  for (const account of bonuses) {
-    addQuota("Bonus Credits", account, { recurring: false });
-  }
-  if (bonuses.length > 0 && quotas["Bonus Credits"]) {
-    quotas["Bonus Credits"].packCount = bonuses.length;
-  }
-
-  // Fallback: if classification produced nothing, keep old package-label merge.
-  if (Object.keys(quotas).length === 0) {
-    for (const account of accounts) {
-      if (!account || typeof account !== "object") continue;
-      const label = getCodeBuddyQuotaLabel(account.PackageCode) || "Other Credits";
-      const recurring = label !== "Activity Credits" && label !== "Gift Credits";
-      addQuota(recurring ? "Monthly Credits" : "Bonus Credits", account, { recurring });
-    }
-  }
-
-  if (Object.keys(quotas).length === 0) {
-    return {
-      plan: hasProPackage ? "Pro" : "Free",
-      message: "CodeBuddy connected. Unable to extract quota values.",
-      quotas: {},
-    };
-  }
-
-  for (const quota of Object.values(quotas)) {
-    quota.remainingPercentage = quota.total > 0
-      ? Math.max(0, Math.min(100, (quota.remaining / quota.total) * 100))
-      : 0;
-  }
-
-  const plan = hasProPackage ? "Pro" : "Free";
-  return {
-    plan,
-    // packCount stays on Bonus Credits for UI/detail if needed; no noisy top-level message
-    quotas,
-  };
-}
-
-function getCodeBuddyQuotaLabel(packageCode) {
-  const codes = CODEBUDDY_CONFIG.packageCodes;
-  switch (packageCode) {
-    case codes.free:
-    case codes.freeMon:
-    case codes.proMon:
-    case codes.proYear:
-      return "Monthly Credits";
-    case codes.gift:
-      return "Gift Credits";
-    case codes.extra:
-      return "Extra Credits";
-    case codes.activity:
-      return "Activity Credits";
-    default:
-      return packageCode ? "Other Credits" : null;
-  }
-}
-
-function getCodeBuddyQuotaValues(account, { useCycle = true } = {}) {
-  // Refill packs: Cycle* fields = current period. Bonus packs: plain Capacity* = lifetime one-shot.
-  const total = useCycle
-    ? firstFiniteNumber(
-      account.CycleCapacitySizePrecise,
-      account.CycleCapacitySize,
-      account.CapacitySizePrecise,
-      account.CapacitySize,
-    )
-    : firstFiniteNumber(
-      account.CapacitySizePrecise,
-      account.CapacitySize,
-      account.CycleCapacitySizePrecise,
-      account.CycleCapacitySize,
-    );
-  const remaining = useCycle
-    ? firstFiniteNumber(
-      account.CycleCapacityRemainPrecise,
-      account.CapacityRemainPrecise,
-      account.CapacityRemain,
-    )
-    : firstFiniteNumber(
-      account.CapacityRemainPrecise,
-      account.CapacityRemain,
-      account.CycleCapacityRemainPrecise,
-    );
-  const used = firstFiniteNumber(
-    account.CapacityUsedPrecise,
-    account.CapacityUsed,
-    total !== null && remaining !== null ? Math.max(0, total - remaining) : null,
-  );
-
-  if (total === null && remaining === null && used === null) return null;
-
-  const safeTotal = Math.max(0, total ?? ((used ?? 0) + (remaining ?? 0)));
-  const safeRemaining = Math.max(0, remaining ?? Math.max(0, safeTotal - (used ?? 0)));
-  const safeUsed = Math.max(0, used ?? Math.max(0, safeTotal - safeRemaining));
-
-  return {
-    total: safeTotal,
-    remaining: safeRemaining,
-    used: safeUsed,
-    resetAt: parseResetTime(account.CycleEndTime || account.DeductionEndTime || account.ExpiredTime),
-  };
-}
-
-function firstFiniteNumber(...values) {
-  for (const value of values) {
-    if (value === null || value === undefined || value === "") continue;
-    const number = Number(value);
-    if (Number.isFinite(number)) return number;
-  }
-  return null;
-}
-
-function getEarlierReset(current, next) {
-  if (!current) return next || null;
-  if (!next) return current;
-  return new Date(next).getTime() < new Date(current).getTime() ? next : current;
-}
-
-/**
- * GitHub Copilot Usage
- * Uses GitHub accessToken (not copilotToken) to call copilot_internal/user API
- */
-async function getGitHubUsage(accessToken, providerSpecificData, proxyOptions = null) {
-  try {
-    if (!accessToken) {
-      throw new Error("No GitHub access token available. Please re-authorize the connection.");
-    }
-
-    // copilot_internal/user API requires GitHub OAuth token, not copilotToken
-    const response = await proxyAwareFetch("https://api.github.com/copilot_internal/user", {
-      headers: {
-        "Authorization": `token ${accessToken}`,
-        "Accept": "application/json",
-        "X-GitHub-Api-Version": GITHUB_CONFIG.apiVersion,
-        "User-Agent": GITHUB_CONFIG.userAgent,
-        "Editor-Version": "vscode/1.100.0",
-        "Editor-Plugin-Version": "copilot-chat/0.26.7",
-      },
-    }, proxyOptions);
-
-    if (!response.ok) {
-      const error = await response.text();
-      throw new Error(`GitHub API error: ${error}`);
-    }
-
-    const data = await response.json();
-
-    // Handle different response formats (paid vs free)
-    if (data.quota_snapshots) {
-      // Paid plan format
-      const snapshots = data.quota_snapshots;
-      const resetAt = parseResetTime(data.quota_reset_date);
-
-      return {
-        plan: data.copilot_plan,
-        resetDate: data.quota_reset_date,
-        quotas: {
-          chat: { ...formatGitHubQuotaSnapshot(snapshots.chat), resetAt },
-          completions: { ...formatGitHubQuotaSnapshot(snapshots.completions), resetAt },
-          premium_interactions: { ...formatGitHubQuotaSnapshot(snapshots.premium_interactions), resetAt },
-        },
-      };
-    } else if (data.monthly_quotas || data.limited_user_quotas) {
-      // Free/limited plan format
-      const monthlyQuotas = data.monthly_quotas || {};
-      const usedQuotas = data.limited_user_quotas || {};
-      const resetAt = parseResetTime(data.limited_user_reset_date);
-
-      return {
-        plan: data.copilot_plan || data.access_type_sku,
-        resetDate: data.limited_user_reset_date,
-        quotas: {
-          chat: {
-            used: usedQuotas.chat || 0,
-            total: monthlyQuotas.chat || 0,
-            unlimited: false,
-            resetAt,
-          },
-          completions: {
-            used: usedQuotas.completions || 0,
-            total: monthlyQuotas.completions || 0,
-            unlimited: false,
-            resetAt,
-          },
-        },
-      };
-    }
-
-    return { message: "GitHub Copilot connected. Unable to parse quota data." };
-  } catch (error) {
-    throw new Error(`Failed to fetch GitHub usage: ${error.message}`);
-  }
-}
-
-function formatGitHubQuotaSnapshot(quota) {
-  if (!quota) return { used: 0, total: 0, unlimited: true };
-
-  return {
-    used: quota.entitlement - quota.remaining,
-    total: quota.entitlement,
-    remaining: quota.remaining,
-    unlimited: quota.unlimited || false,
-  };
-}
-
-/**
- * Gemini CLI Usage \u2014 fetch per-model quota via Cloud Code Assist API.
- * Uses retrieveUserQuota (same endpoint as `gemini /stats`) returning
- * per-model buckets with remainingFraction + resetTime.
- */
-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 controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), 10000);
-    let response;
-    try {
-      response = await proxyAwareFetch(
-        "https://cloudcode-pa.googleapis.com/v1internal:retrieveUserQuota",
-        {
-          method: "POST",
-          headers: {
-            Authorization: `Bearer ${accessToken}`,
-            "Content-Type": "application/json",
-          },
-          body: JSON.stringify({ project: projectId }),
-          signal: controller.signal,
-        },
-        proxyOptions
-      );
-    } finally {
-      clearTimeout(timeoutId);
-    }
-
-    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}` };
-  }
-}
-
-function normalizeCloudCodeProjectId(project) {
-  if (typeof project === "string") return project.trim() || null;
-  if (project && typeof project === "object" && typeof project.id === "string") {
-    return project.id.trim() || null;
-  }
-  return null;
-}
-
-/**
- * Get Gemini CLI subscription info via loadCodeAssist
- */
-async function getGeminiSubscriptionInfo(accessToken, proxyOptions = null) {
-  const controller = new AbortController();
-  const timeoutId = setTimeout(() => controller.abort(), 10000);
-  try {
-    const response = await proxyAwareFetch(
-      "https://cloudcode-pa.googleapis.com/v1internal:loadCodeAssist",
-      {
-        method: "POST",
-        headers: {
-          Authorization: `Bearer ${accessToken}`,
-          "Content-Type": "application/json",
-        },
-        body: JSON.stringify({
-          metadata: CLIENT_METADATA,
-        }),
-        signal: controller.signal,
-      },
-      proxyOptions
-    );
-    if (!response.ok) return null;
-    return await response.json();
-  } catch {
-    return null;
-  } finally {
-    clearTimeout(timeoutId);
-  }
-}
-
-/**
- * POST to the first Antigravity host that answers (2xx/401/403). Returns
- * { response, host } or throws if every host is unreachable.
- */
-async function antigravityQuotaFetch(path, accessToken, bodyObj, proxyOptions) {
-  let lastError = null;
-  for (const host of ANTIGRAVITY_CONFIG.quotaApiHosts) {
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), 10000);
-    try {
-      const response = await proxyAwareFetch(`${host}${path}`, {
-        method: "POST",
-        headers: {
-          "Authorization": `Bearer ${accessToken}`,
-          "User-Agent": ANTIGRAVITY_CONFIG.userAgent,
-          "Content-Type": "application/json",
-          "x-request-source": "local", // MITM bypass
-        },
-        body: JSON.stringify(bodyObj || {}),
-        signal: controller.signal,
-      }, proxyOptions);
-      // A definitive answer (ok, or auth/permission verdict) ends the loop; only
-      // transient upstream errors (5xx / network) fall through to the next host.
-      if (response.ok || response.status === 401 || response.status === 403) {
-        return { response, host };
-      }
-      lastError = new Error(`Antigravity API error: ${response.status}`);
-    } catch (error) {
-      lastError = error;
-    } finally {
-      clearTimeout(timeoutId);
-    }
-  }
-  if (lastError) throw lastError;
-  throw new Error("Antigravity API unavailable");
-}
-
-/**
- * Antigravity Usage - Fetch quota from Google Cloud Code API.
- *
- * Two upstream sources are merged:
- *   - fetchAvailableModels: catalog + per-model quotaInfo (can be stale/full).
- *   - retrieveUserQuota:    per-model consumption buckets (source of truth).
- * retrieveUserQuota wins when it reports a model, matching OmniRoute behaviour.
- */
-async function getAntigravityUsage(accessToken, providerSpecificData, proxyOptions = null) {
-  try {
-    // Prefer the projectId stored on the connection; use loadCodeAssist for tier metadata
-    // and as the project fallback.
-    const savedProjectId = normalizeCloudCodeProjectId(providerSpecificData?.projectId);
-    const subscriptionInfo = await getAntigravitySubscriptionInfo(accessToken, proxyOptions);
-    const projectId = savedProjectId
-      || normalizeCloudCodeProjectId(subscriptionInfo?.cloudaicompanionProject);
-
-    // fetchAvailableModels (catalog) \u2014 required. retrieveUserQuota (live) \u2014 best effort.
-    let modelsResp;
-    try {
-      modelsResp = await antigravityQuotaFetch(
-        ANTIGRAVITY_CONFIG.fetchAvailableModelsPath,
-        accessToken,
-        projectId ? { project: projectId } : {},
-        proxyOptions
-      );
-    } catch (error) {
-      return { message: `Antigravity quota unavailable: ${error.message}. Chat may still work.` };
-    }
-
-    const response = modelsResp.response;
-
-    if (response.status === 401) {
-      // Distinguish a dead account (refresh token revoked/deleted) from a merely
-      // stale access token, so the dashboard can tell the user which is which.
-      const deadReason = await getAntigravityAccountDeadReason(providerSpecificData, proxyOptions);
-      if (deadReason) {
-        return { accountDead: true, message: `Antigravity account ${deadReason}. Reconnect won't help \u2014 recreate the account.`, quotas: {} };
-      }
-      return { message: "Antigravity quota API authentication expired. Chat may still work.", quotas: {} };
-    }
-
-    if (response.status === 403) {
-      return { message: "Antigravity quota API access forbidden (tier may not expose quota). Chat may still work.", quotas: {} };
-    }
-
-    if (!response.ok) {
-      throw new Error(`Antigravity API error: ${response.status}`);
-    }
-
-    const data = await response.json();
-
-    // Live consumption buckets keyed by modelId (source of truth).
-    // retrieveUserQuota works with or without a project — send the project when
-    // we have one, otherwise an empty body (Google resolves the default project).
-    const liveBuckets = new Map();
-    try {
-      const quotaResp = await antigravityQuotaFetch(
-        ANTIGRAVITY_CONFIG.retrieveUserQuotaPath,
-        accessToken,
-        projectId ? { project: projectId } : {},
-        proxyOptions
-      );
-      if (quotaResp.response.ok) {
-        const quotaData = await quotaResp.response.json();
-        if (Array.isArray(quotaData.buckets)) {
-          for (const bucket of quotaData.buckets) {
-            const id = String(bucket.modelId || "").trim();
-            if (id) liveBuckets.set(id, bucket);
-          }
-        }
-      }
-    } catch {
-      // Non-fatal: fall back to catalog-only quotaInfo.
-    }
-
-    const quotas = {};
-    if (data.models) {
-      const importantModels = [
-        'gemini-3.6-flash-high',
-        'gemini-3.6-flash-medium',
-        'gemini-3.6-flash-low',
-        'gemini-3-flash-agent',
-        'gemini-3.5-flash-low',
-        'gemini-3.5-flash-extra-low',
-        'gemini-pro-agent',
-        'gemini-3.1-pro-low',
-        'claude-sonnet-4-6',
-        'claude-opus-4-6-thinking',
-        'gpt-oss-120b-medium',
-        'gemini-3-flash',
-      ];
-
-      for (const [modelKey, info] of Object.entries(data.models)) {
-        if (info.isInternal || !importantModels.includes(modelKey)) continue;
-
-        // retrieveUserQuota bucket wins over the (possibly stale) catalog quotaInfo.
-        const live = liveBuckets.get(modelKey);
-        const quotaSource = live || info.quotaInfo;
-        if (!quotaSource) continue;
-
-        const remainingFraction = Number(quotaSource.remainingFraction) || 0;
-        const remainingPercentage = remainingFraction * 100;
-        const total = 1000; // Normalized base
-        const remaining = Math.round(total * remainingFraction);
-        const used = Math.max(0, total - remaining);
-
-        quotas[modelKey] = {
-          used,
-          total,
-          resetAt: parseResetTime(quotaSource.resetTime),
-          remainingPercentage,
-          unlimited: false,
-          displayName: info.displayName || modelKey,
-          quotaSource: live ? "retrieveUserQuota" : "fetchAvailableModels",
-        };
-      }
-    }
-
-    return {
-      plan: subscriptionInfo?.currentTier?.name || "Unknown",
-      quotas,
-      subscriptionInfo,
-    };
-  } catch (error) {
-    console.error("[Antigravity Usage] Error:", error.message, error.cause);
-    return { message: `Antigravity error: ${error.message}` };
-  }
-}
-
-/**
- * Probe whether an Antigravity account is permanently dead (refresh token
- * revoked / account deleted). Returns a short reason string, or null if the
- * account looks alive (or we can't tell). Used to turn a misleading
- * "authentication expired" into an actionable "account deleted" verdict.
- */
-async function getAntigravityAccountDeadReason(providerSpecificData, proxyOptions = null) {
-  const refreshToken = providerSpecificData?.refreshToken;
-  if (!refreshToken) return null;
-  try {
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), 10000);
-    let response;
-    try {
-      response = await proxyAwareFetch(ANTIGRAVITY_CONFIG.tokenUrl, {
-        method: "POST",
-        headers: { "Content-Type": "application/x-www-form-urlencoded" },
-        body: new URLSearchParams({
-          client_id: ANTIGRAVITY_CONFIG.clientId,
-          client_secret: ANTIGRAVITY_CONFIG.clientSecret,
-          refresh_token: refreshToken,
-          grant_type: "refresh_token",
-        }),
-        signal: controller.signal,
-      }, proxyOptions);
-    } finally {
-      clearTimeout(timeoutId);
-    }
-    if (response.ok) return null; // refresh works \u2192 account alive, token just stale
-    const body = await response.json().catch(() => ({}));
-    if (body.error === "invalid_grant") {
-      const desc = (body.error_description || "").toLowerCase();
-      if (desc.includes("deleted")) return "has been deleted";
-      if (desc.includes("disabled") || desc.includes("suspend")) return "is disabled/suspended";
-      return "authorization was revoked";
-    }
-    return null;
-  } catch {
-    return null;
-  }
-}
-
-/**
- * Get Antigravity project ID from subscription info
- */
-async function getAntigravityProjectId(accessToken) {
-  try {
-    const info = await getAntigravitySubscriptionInfo(accessToken);
-    return info?.cloudaicompanionProject || null;
-  } catch {
-    return null;
-  }
-}
-
-/**
- * Get Antigravity subscription info
- */
-async function getAntigravitySubscriptionInfo(accessToken, proxyOptions = null) {
-  const controller = new AbortController();
-  const timeoutId = setTimeout(() => controller.abort(), 10000); // 10s timeout
-  try {
-    const response = await proxyAwareFetch(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 }),
-      signal: controller.signal,
-    }, proxyOptions);
-
-    if (!response.ok) return null;
-    return await response.json();
-  } catch (error) {
-    console.error("[Antigravity Subscription] Error:", error.message);
-    return null;
-  } finally {
-    clearTimeout(timeoutId);
-  }
-}
-
-/**
- * Claude Usage - Primary: OAuth endpoint, Fallback: legacy settings/org endpoint
- */
-async function getClaudeUsage(accessToken, proxyOptions = null) {
-  try {
-    // Primary: OAuth usage endpoint (Claude Code consumer OAuth tokens)
-    const oauthResponse = await proxyAwareFetch(CLAUDE_CONFIG.oauthUsageUrl, {
-      method: "GET",
-      headers: {
-        "Authorization": `Bearer ${accessToken}`,
-        "anthropic-beta": "oauth-2025-04-20",
-        "anthropic-version": CLAUDE_CONFIG.apiVersion,
-      },
-    }, proxyOptions);
-
-    if (oauthResponse.ok) {
-      const data = await oauthResponse.json();
-      const quotas = {};
-
-      // utilization = % USED (e.g. 87 means 87% used, 13% remaining)
-      const hasUtilization = (window) =>
-        window && typeof window === "object" && typeof window.utilization === "number";
-
-      const createQuotaObject = (window) => {
-        const used = window.utilization;
-        const remaining = Math.max(0, 100 - used);
-        return {
-          used,
-          total: 100,
-          remaining,
-          remainingPercentage: remaining,
-          resetAt: parseResetTime(window.resets_at),
-          unlimited: false,
-        };
-      };
-
-      if (hasUtilization(data.five_hour)) {
-        quotas["session (5h)"] = createQuotaObject(data.five_hour);
-      }
-
-      if (hasUtilization(data.seven_day)) {
-        quotas["weekly (7d)"] = createQuotaObject(data.seven_day);
-      }
-
-      // Parse model-specific weekly windows (e.g. seven_day_sonnet, seven_day_opus)
-      for (const [key, value] of Object.entries(data)) {
-        if (key.startsWith("seven_day_") && key !== "seven_day" && hasUtilization(value)) {
-          const modelName = key.replace("seven_day_", "");
-          quotas[`weekly ${modelName} (7d)`] = createQuotaObject(value);
-        }
-      }
-
-      return {
-        plan: "Claude Code",
-        extraUsage: data.extra_usage ?? null,
-        quotas,
-      };
-    }
-
-    // Fallback: legacy settings + org usage endpoint
-    console.warn(`[Claude Usage] OAuth endpoint returned ${oauthResponse.status}, falling back to legacy`);
-    return await getClaudeUsageLegacy(accessToken, proxyOptions);
-  } catch (error) {
-    return { message: `Claude connected. Unable to fetch usage: ${error.message}` };
-  }
-}
-
-/**
- * Legacy Claude usage for API key / org admin users
- */
-async function getClaudeUsageLegacy(accessToken, proxyOptions = null) {
-  try {
-    const settingsResponse = await proxyAwareFetch(CLAUDE_CONFIG.settingsUrl, {
-      method: "GET",
-      headers: {
-        "Authorization": `Bearer ${accessToken}`,
-        "anthropic-version": CLAUDE_CONFIG.apiVersion,
-      },
-    }, proxyOptions);
-
-    if (settingsResponse.ok) {
-      const settings = await settingsResponse.json();
-
-      if (settings.organization_id) {
-        const usageResponse = await proxyAwareFetch(
-          CLAUDE_CONFIG.usageUrl.replace("{org_id}", settings.organization_id),
-          {
-            method: "GET",
-            headers: {
-              "Authorization": `Bearer ${accessToken}`,
-              "anthropic-version": CLAUDE_CONFIG.apiVersion,
-            },
-          },
-          proxyOptions
-        );
-
-        if (usageResponse.ok) {
-          const usage = await usageResponse.json();
-          return {
-            plan: settings.plan || "Unknown",
-            organization: settings.organization_name,
-            quotas: usage,
-          };
-        }
-      }
-
-      return {
-        plan: settings.plan || "Unknown",
-        organization: settings.organization_name,
-        message: "Claude connected. Usage details require admin access.",
-      };
-    }
-
-    return { message: "Claude connected. Usage API requires admin permissions." };
-  } catch (error) {
-    return { message: `Claude connected. Unable to fetch usage: ${error.message}` };
-  }
-}
-
-/**
- * Codex (OpenAI) Usage - Fetch from ChatGPT backend API
- */
-function toFiniteNumber(value, fallback = 0) {
-  if (typeof value === "number" && Number.isFinite(value)) return value;
-  if (typeof value === "string" && value.trim()) {
-    const parsed = Number(value);
-    if (Number.isFinite(parsed)) return parsed;
-  }
-  return fallback;
-}
-
-function getCodexRateLimitBody(snapshot) {
-  if (!snapshot || typeof snapshot !== "object" || Array.isArray(snapshot)) return null;
-  return snapshot.rate_limit && typeof snapshot.rate_limit === "object"
-    ? snapshot.rate_limit
-    : snapshot;
-}
-
-function formatCodexWindow(window) {
-  const used = Math.max(0, Math.min(100, toFiniteNumber(window?.used_percent ?? window?.percent_used, 0)));
-  return {
-    used,
-    total: 100,
-    remaining: Math.max(0, 100 - used),
-    resetAt: parseResetTime(window?.reset_at ?? window?.resets_at ?? window?.resetAt ?? null),
-    unlimited: false,
-  };
-}
-
-function appendCodexQuotaWindows(quotas, prefix, snapshot) {
-  const rateLimit = getCodexRateLimitBody(snapshot);
-  if (!rateLimit) return false;
-
-  const primary = rateLimit.primary_window || rateLimit.primary || snapshot.primary_window || snapshot.primary;
-  const secondary = rateLimit.secondary_window || rateLimit.secondary || snapshot.secondary_window || snapshot.secondary;
-  let added = false;
-
-  if (primary) {
-    quotas[prefix ? `${prefix}_session` : "session"] = formatCodexWindow(primary);
-    added = true;
-  }
-  if (secondary) {
-    quotas[prefix ? `${prefix}_weekly` : "weekly"] = formatCodexWindow(secondary);
-    added = true;
-  }
-
-  return added;
-}
-
-function getCodexReviewRateLimit(data) {
-  if (data.code_review_rate_limit || data.review_rate_limit) {
-    return data.code_review_rate_limit || data.review_rate_limit;
-  }
-
-  const byLimitId = data.rate_limits_by_limit_id;
-  if (byLimitId && typeof byLimitId === "object" && !Array.isArray(byLimitId)) {
-    return byLimitId.code_review || byLimitId.codex_review || byLimitId.review || null;
-  }
-
-  const additional = Array.isArray(data.additional_rate_limits) ? data.additional_rate_limits : [];
-  return additional.find((entry) => {
-    const id = String(entry?.limit_name || entry?.metered_feature || entry?.id || "").toLowerCase();
-    return id === "code_review" || id === "codex_review" || id === "review" || id.includes("review");
-  }) || null;
-}
-
-async function getCodexUsage(accessToken, proxyOptions = null) {
-  try {
-    const response = await proxyAwareFetch(CODEX_CONFIG.usageUrl, {
-      method: "GET",
-      headers: {
-        "Authorization": `Bearer ${accessToken}`,
-        "Accept": "application/json",
-      },
-    }, proxyOptions);
-
-    if (!response.ok) {
-      return { message: `Codex connected. Usage API temporarily unavailable (${response.status}).` };
-    }
-
-    const data = await response.json();
-    const normalRateLimit = data.rate_limit || data.rate_limits || data.rate_limits_by_limit_id?.codex || {};
-    const reviewRateLimit = getCodexReviewRateLimit(data);
-    const quotas = {};
-
-    appendCodexQuotaWindows(quotas, "", normalRateLimit);
-    appendCodexQuotaWindows(quotas, "review", reviewRateLimit);
-
-    return {
-      plan: data.plan_type || data.summary?.plan || "unknown",
-      limitReached: getCodexRateLimitBody(normalRateLimit)?.limit_reached || false,
-      reviewLimitReached: getCodexRateLimitBody(reviewRateLimit)?.limit_reached || false,
-      quotas,
-    };
-  } catch (error) {
-    throw new Error(`Failed to fetch Codex usage: ${error.message}`);
-  }
-}
-
-/**
- * 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,
-  };
-}
-
-async function getKiroUsage(accessToken, providerSpecificData, proxyOptions = null) {
-  // Default profileArn fallback
-  const DEFAULT_PROFILE_ARN = "arn:aws:codewhisperer:us-east-1:638616132270:profile/AAAACCCCXXXX";
-  const profileArn = providerSpecificData?.profileArn || DEFAULT_PROFILE_ARN;
-  const authMethod = providerSpecificData?.authMethod || "builder-id";
-
-  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(
-        `https://codewhisperer.us-east-1.amazonaws.com/getUsageLimits?${getUsageParams.toString()}`,
-        {
-          method: "GET",
-          headers: {
-            "Authorization": `Bearer ${accessToken}`,
-            "Accept": "application/json",
-            "x-amz-user-agent": "aws-sdk-js/1.0.0 KiroIDE-1.0.138",
-            "user-agent": "aws-sdk-js/1.0.0 KiroIDE-1.0.138",
-          },
-        },
-        proxyOptions
-      ),
-    },
-    {
-      name: "codewhisperer-post",
-      run: async () => proxyAwareFetch("https://codewhisperer.us-east-1.amazonaws.com", {
-        method: "POST",
-        headers: {
-          "Authorization": `Bearer ${accessToken}`,
-          "Content-Type": "application/x-amz-json-1.0",
-          "x-amz-target": "AmazonCodeWhispererService.GetUsageLimits",
-          "Accept": "application/json",
-        },
-        body: JSON.stringify({
-          origin: "AI_EDITOR",
-          profileArn,
-          resourceType: "AGENTIC_REQUEST",
-        }),
-      }, proxyOptions),
-    },
-    {
-      name: "q-get",
-      run: async () => {
-        const params = new URLSearchParams({
-          origin: "AI_EDITOR",
-          profileArn,
-          resourceType: "AGENTIC_REQUEST",
-        });
-        return proxyAwareFetch(`https://q.us-east-1.amazonaws.com/getUsageLimits?${params}`, {
-          method: "GET",
-          headers: {
-            "Authorization": `Bearer ${accessToken}`,
-            "Accept": "application/json",
-          },
-        }, 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: {},
-  };
-}
-
-/**
- * Qwen Usage
- */
-async function getQwenUsage(accessToken, providerSpecificData) {
-  try {
-    const resourceUrl = providerSpecificData?.resourceUrl;
-    if (!resourceUrl) {
-      return { message: "Qwen connected. No resource URL available." };
-    }
-
-    // Qwen may have usage endpoint at resource URL
-    return { message: "Qwen connected. Usage tracked per request." };
-  } catch (error) {
-    return { message: "Unable to fetch Qwen usage." };
-  }
-}
-
-/**
- * iFlow Usage
- */
-async function getIflowUsage(accessToken) {
-  try {
-    // iFlow may have usage endpoint
-    return { message: "iFlow connected. Usage tracked per request." };
-  } catch (error) {
-    return { message: "Unable to fetch iFlow usage." };
-  }
-}
-
-/**
- * Ollama Cloud Usage
- * Ollama Cloud uses an API key from ollama.com/settings/keys
- * and has no public usage API \u2014 free tier has light usage limits (resets every 5h & 7d).
- * This returns an informational message with the plan details.
- */
-async function getOllamaUsage(accessToken, providerSpecificData) {
-  try {
-    // Ollama Cloud does not expose a public quota/usage API.
-    // The provider is configured as noAuth with a notice explaining limits.
-    // We return a graceful message so the UI shows a friendly state instead of an error.
-    const plan = providerSpecificData?.plan || "Free";
-    return {
-      plan,
-      message: "Ollama Cloud uses a free tier with light usage limits (resets every 5h & 7d). For detailed usage tracking, visit ollama.com/settings/keys.",
-      quotas: [],
-    };
-  } catch (error) {
-    return { message: "Unable to fetch Ollama Cloud usage." };
-  }
-}
-
-/**
- * GLM Coding Plan usage (international + China regions)
- */
-async function getGlmUsage(apiKey, provider, proxyOptions = null) {
-  if (!apiKey) {
-    return { message: "GLM API key not available." };
-  }
-
-  const region = provider === "glm-cn" ? "china" : "international";
-  const quotaUrl = GLM_QUOTA_URLS[region];
-
-  try {
-    const response = await proxyAwareFetch(quotaUrl, {
-      headers: {
-        Authorization: `Bearer ${apiKey}`,
-        Accept: "application/json",
-      },
-    }, proxyOptions);
-
-    if (!response.ok) {
-      if (response.status === 401) {
-        return { message: "GLM API key invalid or expired." };
-      }
-      return { message: `GLM quota API error (${response.status}).` };
-    }
-
-    const json = await response.json();
-    const data = json?.data && typeof json.data === "object" ? json.data : {};
-    const limits = Array.isArray(data.limits) ? data.limits : [];
-    const quotas = {};
-
-    for (const limit of limits) {
-      if (!limit || limit.type !== "TOKENS_LIMIT") continue;
-      const usedPercent = Number(limit.percentage) || 0;
-      const resetMs = Number(limit.nextResetTime) || 0;
-      const remaining = Math.max(0, 100 - usedPercent);
-
-      quotas["session"] = {
-        used: usedPercent,
-        total: 100,
-        remaining,
-        remainingPercentage: remaining,
-        resetAt: resetMs > 0 ? new Date(resetMs).toISOString() : null,
-        unlimited: false,
-      };
-    }
-
-    const levelRaw = typeof data.level === "string" ? data.level : "";
-    const plan = levelRaw
-      ? levelRaw.charAt(0).toUpperCase() + levelRaw.slice(1).toLowerCase()
-      : "Unknown";
-
-    return { plan, quotas };
-  } catch (error) {
-    return { message: `GLM error: ${error.message}` };
-  }
-}
-
-// \u2500\u2500 MiniMax helpers \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
-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 \u2014 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
- */
-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." };
-}
-
-async function getQoderUsage(accessToken, proxyOptions = null) {
-  if (!accessToken) {
-    return { message: "Qoder usage unavailable: no access token" };
-  }
-  try {
-    const response = await proxyAwareFetch(
-      "https://openapi.qoder.sh/api/v2/quota/usage",
-      {
-        method: "GET",
-        headers: {
-          Authorization: `Bearer ${accessToken}`,
-          Accept: "application/json",
-        },
-      },
-      proxyOptions,
-    );
-    if (!response.ok) {
-      return { message: `Qoder connected. Usage fetch returned ${response.status}.` };
-    }
-    const body = await response.json().catch(() => null);
-    if (!body) {
-      return { message: "Qoder connected. Usage response was not JSON." };
-    }
-    // Quota records live under `quotas`; scalar metadata
-    // (totalUsagePercentage, isQuotaExceeded, expiresAt) are surfaced as
-    // siblings so the dashboard parser doesn't try to render them as rows.
-    const userQuota = body.userQuota || {};
-    const orgQuota = body.orgResourcePackage || {};
-    // Qoder publishes a single absolute reset timestamp (`expiresAt` in ms);
-    // surface it on every quota record as ISO so the table can render
-    // "resets at" alongside used/total.
-    const expiresAtMs = Number.isFinite(Number(body.expiresAt)) && Number(body.expiresAt) > 0
-      ? Number(body.expiresAt)
-      : null;
-    const resetAt = expiresAtMs ? new Date(expiresAtMs).toISOString() : null;
-    const quotas = {
-      user: {
-        total: Number(userQuota.total) || 0,
-        used: Number(userQuota.used) || 0,
-        remaining: Number(userQuota.remaining) || 0,
-        unit: userQuota.unit || "credits",
-        resetAt,
-      },
-      organization: {
-        total: Number(orgQuota.total) || 0,
-        used: Number(orgQuota.used) || 0,
-        remaining: Number(orgQuota.remaining) || 0,
-        unit: orgQuota.unit || "credits",
-        resetAt,
-      },
-    };
-    return {
-      quotas,
-      totalUsagePercentage: Number(body.totalUsagePercentage) || 0,
-      isQuotaExceeded: !!body.isQuotaExceeded,
-      expiresAt: expiresAtMs,
-    };
-  } catch (error) {
-    return { message: `Qoder connected. Unable to fetch usage: ${error.message}` };
-  }
-}
-
-async function getAutoclawUsage(accessToken, proxyOptions = null, connection = null) {
-  if (!accessToken) {
-    return { message: "AutoClaw usage unavailable: no access token" };
-  }
-  try {
-    const { AUTOCLAW_WALLET_ENDPOINT, buildAutoClawWalletHeaders } = await import("../../src/lib/autoclaw/constants.js");
-    const response = await proxyAwareFetch(
-      AUTOCLAW_WALLET_ENDPOINT,
-      { method: "GET", headers: buildAutoClawWalletHeaders(accessToken) },
-      proxyOptions,
-    );
-    if (!response.ok) {
-      return { message: `AutoClaw connected. Usage fetch returned ${response.status}.` };
-    }
-    const body = await response.json().catch(() => null);
-    if (!body || body.code !== 0) {
-      return { message: "AutoClaw connected. Unable to read balance." };
-    }
-    const total = Number(body.data?.total_balance);
-    const remaining = Number.isFinite(total) ? total : 0;
-
-    // AutoClaw's wallet only returns the CURRENT balance, not how much was spent.
-    // To show real consumption, track the highest balance ever seen (baseline)
-    // in the cached snapshot: used = baseline - remaining. Baseline grows if the
-    // account is topped up.
-    let baseline = remaining;
-    try {
-      if (connection?.id) {
-        const { getQuotaSnapshot } = await import("@/lib/localDb.js");
-        const prev = await getQuotaSnapshot(connection.id);
-        const prevBaseline = Number(prev?.usage?.quotas?.points?.total) || 0;
-        const prevRemaining = Number(prev?.usage?.quotas?.points?.remaining);
-        // Baseline = max(prev baseline, current remaining). If balance jumped
-        // above the old baseline (top-up), adopt the new higher value.
-        baseline = Math.max(prevBaseline, remaining, Number.isFinite(prevRemaining) ? prevRemaining : 0);
-      }
-    } catch { /* first run / no snapshot */ }
-
-    const used = Math.max(0, baseline - remaining);
-    const pct = baseline > 0 ? Math.round((remaining / baseline) * 100) : 0;
-    return {
-      quotas: {
-        points: {
-          total: baseline,
-          used,
-          remaining,
-          unit: "points",
-          resetAt: null,
-        },
-      },
-      totalUsagePercentage: baseline > 0 ? Math.round((used / baseline) * 100) : 0,
-      isQuotaExceeded: remaining <= 0,
-    };
-  } catch (error) {
-    return { message: `AutoClaw connected. Unable to fetch balance: ${error.message}` };
-  }
-}
-
-// ─── Cloudflare Workers AI ──────────────────────────────────────────────────
-
-/**
- * Cloudflare does not expose remaining free-tier "neurons" via a public API.
- * Verify the token + account and surface a clear "Workers AI free tier" row so
- * the quota page is not blank for cloudflare-ai connections.
- */
-export async function getCloudflareAiUsage(apiKey, providerSpecificData = null, proxyOptions = null) {
-  const token = String(apiKey || "").trim();
-  const accountId = String(providerSpecificData?.accountId || "").trim();
-  if (!token) {
-    return { message: "Cloudflare API token not available." };
-  }
-  if (!accountId) {
-    return { message: "Cloudflare account ID missing. Re-import or edit the connection." };
-  }
-
-  try {
-    const verifyRes = await proxyAwareFetch(
-      "https://api.cloudflare.com/client/v4/user/tokens/verify",
-      {
-        method: "GET",
-        headers: {
-          Authorization: `Bearer ${token}`,
-          Accept: "application/json",
-        },
-      },
-      proxyOptions,
-    );
-
-    if (verifyRes.status === 401 || verifyRes.status === 403) {
-      return { message: "Cloudflare API token invalid or expired. Re-import the account." };
-    }
-
-    if (!verifyRes.ok) {
-      const errText = await verifyRes.text().catch(() => "");
-      return {
-        message: `Cloudflare token verify failed (${verifyRes.status})${errText ? `: ${errText.slice(0, 160)}` : ""}`,
-      };
-    }
-
-    const verifyBody = await verifyRes.json().catch(() => null);
-    const status = verifyBody?.result?.status || (verifyBody?.success ? "active" : "unknown");
-
-    // Bulk-harvested tokens are often scoped to Workers AI only — they may 403
-    // on GET /accounts/{id}. Do not treat that as dead; verify is enough.
-    let accountName = providerSpecificData?.accountName || "";
-    try {
-      const acctRes = await proxyAwareFetch(
-        `https://api.cloudflare.com/client/v4/accounts/${encodeURIComponent(accountId)}`,
-        {
-          method: "GET",
-          headers: {
-            Authorization: `Bearer ${token}`,
-            Accept: "application/json",
-          },
-        },
-        proxyOptions,
-      );
-      if (acctRes?.ok) {
-        const acctBody = await acctRes.json().catch(() => null);
-        accountName = acctBody?.result?.name || accountName;
-      }
-    } catch {
-      /* optional */
-    }
-
-    const shortId = accountId.length > 10 ? `${accountId.slice(0, 8)}…` : accountId;
-    return {
-      plan: accountName
-        ? `Workers AI · ${accountName}`
-        : `Workers AI · ${shortId}`,
-      quotas: {
-        "Workers AI": {
-          used: 0,
-          total: 0,
-          remainingPercentage: 100,
-          resetAt: null,
-          unlimited: true,
-        },
-      },
-      message:
-        status && status !== "active"
-          ? `Token status: ${status}. Cloudflare does not publish remaining free-tier neurons via API.`
-          : "Token valid. CF does not expose remaining free-tier neurons via API — model rate limits still apply.",
-    };
-  } catch (error) {
-    return { message: `Cloudflare usage error: ${error.message}` };
-  }
-}
-
-// ─── Grok CLI / Grok Build usage (cli-chat-proxy.grok.com) ─────────────────
-
-function unwrapGrokCliVal(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 buildGrokCliUsageHeaders(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 resolveGrokCliPlan(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 makeGrokCliQuota({ used, total, resetAt, unlimited = false }) {
-  const safeTotal = Math.max(0, toFiniteNumber(total, 0));
-  const safeUsed = Math.max(0, toFiniteNumber(used, 0));
-  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,
-  };
-}
-
-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 = {};
-
-  // On-demand spending budget (USD-style). Cap 0 means "not enabled", NOT exhausted.
-  // Old code faked used=1/total=1 → remainingPercentage 0 while chat still worked.
-  const onDemandCap = unwrapGrokCliVal(config.onDemandCap ?? root.onDemandCap, NaN);
-  const onDemandUsed = unwrapGrokCliVal(config.onDemandUsed ?? root.onDemandUsed, NaN);
-  if (Number.isFinite(onDemandCap) && onDemandCap > 0) {
-    const used = Number.isFinite(onDemandUsed) ? Math.max(0, onDemandUsed) : 0;
-    quotas["On-demand"] = makeGrokCliQuota({
-      used,
-      total: onDemandCap,
-      resetAt: periodEnd,
-    });
-  }
-
-  // Non-credits billing payload also exposes monthlyLimit/used
-  const monthlyLimit = unwrapGrokCliVal(config.monthlyLimit ?? root.monthlyLimit, NaN);
-  const monthlyUsed = unwrapGrokCliVal(config.used ?? root.used, NaN);
-  if (Number.isFinite(monthlyLimit) && monthlyLimit > 0) {
-    quotas["Monthly"] = makeGrokCliQuota({
-      used: Number.isFinite(monthlyUsed) ? Math.max(0, monthlyUsed) : 0,
-      total: monthlyLimit,
-      resetAt: periodEnd,
-    });
-  }
-
-  const prepaid = unwrapGrokCliVal(config.prepaidBalance ?? root.prepaidBalance, NaN);
-  if (Number.isFinite(prepaid) && prepaid > 0) {
-    quotas["Prepaid"] = {
-      used: 0,
-      total: prepaid,
-      remainingPercentage: 100,
-      resetAt: null,
-      unlimited: false,
-    };
-  }
-
-  // Subscription / Grok Code included access: API often returns all dollar caps as 0
-  // while hasGrokCodeAccess / isUnifiedBillingUser is true and chat still works.
-  const hasIncludedAccess =
-    user?.hasGrokCodeAccess === true || config?.isUnifiedBillingUser === true;
-
-  // Always surface Grok Code / included access when the account still has it —
-  // even if On-demand/Prepaid rows also exist. Previously we only added this
-  // when quotas was empty, so free Grok Code looked like "no quota data".
-  if (hasIncludedAccess) {
-    quotas["Grok Code"] = {
-      used: 0,
-      total: 0,
-      remainingPercentage: 100,
-      resetAt: periodEnd,
-      unlimited: true,
-    };
-  }
-
-  // Soft fallback when billing returns nothing usable (no caps, no access flags).
-  if (Object.keys(quotas).length === 0) {
-    quotas["Included"] = {
-      used: 0,
-      total: 0,
-      remainingPercentage: 100,
-      resetAt: periodEnd,
-      unlimited: true,
-    };
-  }
-
-  return {
-    plan: resolveGrokCliPlan(user, config),
-    quotas,
-    periodEnd,
-  };
-}
-
-/**
- * Grok CLI / Grok Build usage from cli-chat-proxy billing + user endpoints.
- */
-export async function getGrokCliUsage(accessToken, providerSpecificData = null, proxyOptions = null) {
-  if (!accessToken) {
-    return { message: "Grok CLI access token not available." };
-  }
-
-  const headers = buildGrokCliUsageHeaders(accessToken, providerSpecificData);
-  const BILLING_URL = "https://cli-chat-proxy.grok.com/v1/billing?format=credits";
-  const USER_URL = "https://cli-chat-proxy.grok.com/v1/user?include=subscription";
-
-  try {
-    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: {},
-      };
-    }
-
-    return {
-      plan: parsed.plan,
-      quotas: parsed.quotas,
-    };
-  } catch (error) {
-    return { message: `Grok CLI usage error: ${error.message}` };
-  }
-}
-
-// ─── Shared: dig credit-like fields from arbitrary JSON ─────────────────────
-
-function digCreditFields(obj, depth = 0, path = "") {
-  if (!obj || typeof obj !== "object" || depth > 4) return null;
-  const candidates = [];
-  const keys = Object.entries(obj);
-  for (const [k, v] of keys) {
-    const lk = k.toLowerCase();
-    if (v && typeof v === "object" && !Array.isArray(v)) {
-      const nested = digCreditFields(v, depth + 1, path ? `${path}.${k}` : k);
-      if (nested) candidates.push(nested);
-      continue;
-    }
-    if (typeof v !== "number" && typeof v !== "string") continue;
-    const n = toFiniteNumber(v, NaN);
-    if (!Number.isFinite(n)) continue;
-    if (/(remaining|balance|credit|quota|limit|allowance|cap|used|spent|consumed)/i.test(lk)) {
-      candidates.push({ key: path ? `${path}.${k}` : k, name: k, value: n, kind: lk });
-    }
-  }
-  if (!candidates.length) return null;
-  // Prefer explicit remaining/balance pairs
-  return candidates;
-}
-
-function buildQuotaFromCreditFields(fields) {
-  if (!fields?.length) return null;
-  const by = (re) => fields.find((f) => re.test(f.kind) || re.test(f.name));
-  const remaining = by(/remaining|balance|credit(?!s_used)/i);
-  const total = by(/limit|cap|allowance|total|quota(?!_used)/i);
-  const used = by(/used|spent|consumed/i);
-  if (total && Number(total.value) > 0) {
-    const u = used
-      ? Math.max(0, Number(used.value))
-      : remaining
-        ? Math.max(0, Number(total.value) - Number(remaining.value))
-        : 0;
-    const rem = Math.max(0, Number(total.value) - u);
-    return {
-      used: u,
-      total: Number(total.value),
-      remainingPercentage: (rem / Number(total.value)) * 100,
-      resetAt: null,
-      unlimited: false,
-    };
-  }
-  if (remaining && Number(remaining.value) >= 0) {
-    const bal = Number(remaining.value);
-    return {
-      used: 0,
-      total: bal > 0 ? bal : 1,
-      remainingPercentage: bal > 0 ? 100 : 0,
-      resetAt: null,
-      unlimited: false,
-    };
-  }
-  return null;
-}
-
-// ─── Cline / ClinePass ──────────────────────────────────────────────────────
-
-export async function getClineUsage(accessToken, provider = "cline", proxyOptions = null) {
-  if (!accessToken) return { message: "Cline access token not available." };
-  try {
-    // Dynamic import avoids circular deps with package.json in browser bundles
-    const { buildClineHeaders } = await import("../../src/shared/utils/clineAuth.js");
-    const headers = buildClineHeaders(accessToken, { Accept: "application/json" });
-    const res = await proxyAwareFetch("https://api.cline.bot/api/v1/users/me", {
-      method: "GET",
-      headers,
-    }, proxyOptions);
-
-    if (res.status === 401 || res.status === 403) {
-      return { message: "Cline authentication expired. Please re-authorize." };
-    }
-    if (!res.ok) {
-      return { message: `Cline user API error (${res.status})` };
-    }
-
-    const data = await res.json().catch(() => null);
-    if (!data || typeof data !== "object") {
-      return { message: "Cline user response was not JSON." };
-    }
-
-    // Cline wraps payload in { data: {...} } sometimes
-    const user = data.data && typeof data.data === "object" ? data.data : data;
-    const email = user.email || user.user?.email || null;
-    const plan =
-      user.plan ||
-      user.subscription?.plan ||
-      user.subscription?.name ||
-      user.organization?.plan ||
-      user.organizations?.[0]?.plan ||
-      (provider === "clinepass" ? "ClinePass" : "Cline") ;
-
-    const fields = digCreditFields(user) || [];
-    const quota = buildQuotaFromCreditFields(fields);
-    const quotas = {};
-    if (quota) quotas.Credits = quota;
-
-    // Organization seats / orgs count as informational quota rows when no credits
-    const orgs = user.organizations || user.organization;
-    if (!Object.keys(quotas).length && orgs) {
-      quotas.Account = {
-        used: 0,
-        total: 0,
-        remainingPercentage: 100,
-        resetAt: null,
-        unlimited: true,
-      };
-    }
-
-    if (!Object.keys(quotas).length) {
-      return {
-        plan: typeof plan === "string" ? plan : "Cline",
-        email,
-        message: "Cline connected. No credit allotment was returned by the account API.",
-        quotas: {},
-      };
-    }
-
-    return {
-      plan: typeof plan === "string" ? plan : "Cline",
-      email,
-      quotas,
-    };
-  } catch (error) {
-    return { message: `Cline usage error: ${error.message}` };
-  }
-}
-
-// ─── Kimchi ─────────────────────────────────────────────────────────────────
-
-export async function getKimchiUsage(accessToken, providerSpecificData = null, proxyOptions = null) {
-  if (!accessToken) return { message: "Kimchi access token not available." };
-  try {
-    const url = "https://app.kimchi.dev/api/v1/me";
-    const res = await proxyAwareFetch(url, {
-      method: "GET",
-      headers: {
-        Accept: "application/json",
-        Authorization: `Bearer ${accessToken}`,
-        "User-Agent": "kimchi/0.1.50",
-      },
-    }, proxyOptions);
-
-    if (res.status === 401 || res.status === 403) {
-      return { message: "Kimchi authentication expired. Please re-authorize." };
-    }
-    if (!res.ok) {
-      return { message: `Kimchi user API error (${res.status})` };
-    }
-
-    const user = await res.json().catch(() => null);
-    if (!user || typeof user !== "object") {
-      return { message: "Kimchi user response was not JSON." };
-    }
-
-    const email = user.email || providerSpecificData?.username || null;
-    const plan = user.plan || user.tier || user.subscription?.name || "Kimchi";
-    const fields = digCreditFields(user) || [];
-    const quota = buildQuotaFromCreditFields(fields);
-    const quotas = {};
-    if (quota) quotas.Credits = quota;
-    else {
-      quotas.Account = {
-        used: 0,
-        total: 0,
-        remainingPercentage: 100,
-        resetAt: null,
-        unlimited: true,
-      };
-    }
-
-    return {
-      plan: typeof plan === "string" ? plan : "Kimchi",
-      email,
-      quotas,
-    };
-  } catch (error) {
-    return { message: `Kimchi usage error: ${error.message}` };
-  }
-}
-
-// ─── xAI (API key or OAuth → api.x.ai) ──────────────────────────────────────
-
-export async function getXaiUsage(token, providerSpecificData = null, proxyOptions = null) {
-  if (!token) return { message: "xAI token not available." };
-  try {
-    const headers = {
-      Authorization: `Bearer ${token}`,
-      Accept: "application/json",
-    };
-
-    // Prefer management-style key probe when available; fall back to models list.
-    const probes = [
-      "https://api.x.ai/v1/api-key",
-      "https://api.x.ai/v1/models",
-    ];
-
-    let lastStatus = 0;
-    let body = null;
-    let okUrl = null;
-    for (const url of probes) {
-      const res = await proxyAwareFetch(url, { method: "GET", headers }, proxyOptions);
-      lastStatus = res.status;
-      if (res.status === 401 || res.status === 403) {
-        return { message: "xAI authentication expired. Please re-authorize or update the API key." };
-      }
-      if (res.ok) {
-        body = await res.json().catch(() => null);
-        okUrl = url;
-        break;
-      }
-    }
-
-    if (!body) {
-      return { message: `xAI API error (${lastStatus || "unknown"})` };
-    }
-
-    const fields = digCreditFields(body) || [];
-    const quota = buildQuotaFromCreditFields(fields);
-    const quotas = {};
-    if (quota) {
-      quotas.Credits = quota;
-    } else {
-      // Connected / healthy without numeric allotment
-      const modelCount = Array.isArray(body?.data) ? body.data.length : 0;
-      quotas.API = {
-        used: 0,
-        total: 0,
-        remainingPercentage: 100,
-        resetAt: null,
-        unlimited: true,
-      };
-      if (modelCount > 0) {
-        // informational only via plan string
-      }
-    }
-
-    const email = providerSpecificData?.email || null;
-    const plan =
-      body.name ||
-      body.api_key_name ||
-      body.team?.name ||
-      (okUrl?.includes("api-key") ? "xAI API Key" : "xAI");
-
-    return {
-      plan: typeof plan === "string" ? plan : "xAI",
-      email,
-      quotas,
-    };
-  } catch (error) {
-    return { message: `xAI usage error: ${error.message}` };
-  }
-}
-
-// ─── Cursor (session token — no public quota API) ───────────────────────────
-
-export async function getCursorUsage(accessToken, providerSpecificData = null) {
-  if (!accessToken) return { message: "Cursor access token not available." };
-
-  // Cursor uses a long-lived session JWT; there is no stable public quota endpoint.
-  // Surface connection health + any plan hints from stored providerSpecificData / JWT claims.
-  let plan = providerSpecificData?.plan || providerSpecificData?.membershipType || "Cursor";
-  let email = providerSpecificData?.email || null;
-
-  try {
-    const parts = String(accessToken).split(".");
-    if (parts.length === 3) {
-      const b64 = parts[1].replace(/-/g, "+").replace(/_/g, "/");
-      const padded = b64 + "=".repeat((4 - (b64.length % 4)) % 4);
-      const payload = JSON.parse(Buffer.from(padded, "base64").toString("utf8"));
-      email = email || payload.email || payload.preferred_username || null;
-      plan =
-        payload.plan ||
-        payload.subscription ||
-        payload.membershipType ||
-        payload.tier ||
-        plan;
-    }
-  } catch {
-    /* ignore JWT decode errors */
-  }
-
-  return {
-    plan: typeof plan === "string" ? plan : "Cursor",
-    email,
-    quotas: {
-      Session: {
-        used: 0,
-        total: 0,
-        remainingPercentage: 100,
-        resetAt: null,
-        unlimited: true,
-      },
-    },
-  };
-}