n9router 0.4.43 → 0.4.45

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

@@ -2,61 +2,49 @@
  * 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 = {
-  quotaApiUrl: "https://cloudcode-pa.googleapis.com/v1internal:fetchAvailableModels",
-  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",
-};
+import { getGitHubUsage } from "./usage/github.js";
+import { getGeminiUsage, getAntigravityUsage } from "./usage/google.js";
+import { getClaudeUsage } from "./usage/claude.js";
+import { getCodexUsage, consumeCodexRateLimitResetCredit, getCodexRateLimitResetCredits } from "./usage/codex.js";
+
+export { consumeCodexRateLimitResetCredit, getCodexRateLimitResetCredits };
+import { getKiroUsage } from "./usage/kiro.js";
+import { getMiniMaxUsage } from "./usage/minimax.js";
+import { getCodeBuddyCnUsage } from "./usage/codebuddy-cn.js";
+import {
+  getQwenUsage,
+  getIflowUsage,
+  getOllamaUsage,
+  getGlmUsage,
+  getVercelAiGatewayUsage,
+  getQoderUsage,
+} from "./usage/misc.js";
 
 /**
  * Get usage data for a provider connection
  * @param {Object} connection - Provider connection with accessToken
  * @returns {Object} Usage data with quotas
  */
+// provider → usage handler (ctx carries every arg each handler needs)
+const USAGE_HANDLERS = {
+  github: (c) => getGitHubUsage(c.accessToken, c.providerSpecificData, c.proxyOptions),
+  "gemini-cli": (c) => getGeminiUsage(c.accessToken, c.providerDataWithProjectId, c.proxyOptions),
+  antigravity: (c) => getAntigravityUsage(c.accessToken, c.providerSpecificData, c.proxyOptions),
+  claude: (c) => getClaudeUsage(c.accessToken, c.proxyOptions),
+  codex: (c) => getCodexUsage(c.accessToken, c.proxyOptions),
+  kiro: (c) => getKiroUsage(c.accessToken, c.providerSpecificData, c.proxyOptions),
+  qoder: (c) => getQoderUsage(c.accessToken, c.proxyOptions),
+  qwen: (c) => getQwenUsage(c.accessToken, c.providerSpecificData),
+  iflow: (c) => getIflowUsage(c.accessToken),
+  ollama: (c) => getOllamaUsage(c.accessToken),
+  glm: (c) => getGlmUsage(c.apiKey, c.provider, c.proxyOptions),
+  "glm-cn": (c) => getGlmUsage(c.apiKey, c.provider, c.proxyOptions),
+  minimax: (c) => getMiniMaxUsage(c.apiKey, c.provider, c.proxyOptions),
+  "minimax-cn": (c) => getMiniMaxUsage(c.apiKey, c.provider, c.proxyOptions),
+  "vercel-ai-gateway": (c) => getVercelAiGatewayUsage(c.apiKey, c.proxyOptions),
+  "codebuddy-cn": (c) => getCodeBuddyCnUsage(c.accessToken, c.apiKey, c.providerSpecificData, c.proxyOptions),
+};
+
 export async function getUsageForProvider(connection, proxyOptions = null) {
   const { provider, accessToken, apiKey, providerSpecificData, projectId } = connection;
   const providerDataWithProjectId = {
@@ -64,1250 +52,7 @@ export async function getUsageForProvider(connection, proxyOptions = null) {
     ...(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, providerSpecificData, proxyOptions);
-    case "claude":
-      return await getClaudeUsage(accessToken, proxyOptions);
-    case "codex":
-      return await getCodexUsage(accessToken, proxyOptions);
-    case "kiro":
-      return await getKiroUsage(accessToken, providerSpecificData, proxyOptions);
-    case "qoder":
-      return await getQoderUsage(accessToken, proxyOptions);
-    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);
-    default:
-      return { message: `Usage API not implemented for ${provider}` };
-  }
-}
-
-/**
- * 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;
-  }
-}
-
-/**
- * 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 — 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);
-  }
-}
-
-/**
- * Antigravity Usage - Fetch quota from Google Cloud Code API
- */
-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 subscriptionTier = subscriptionInfo?.subscriptionTier || "Unknown";
-
-    const endpoints = [
-      "https://daily-cloudcode-pa.sandbox.googleapis.com/v1internal:fetchAvailableModels",
-      "https://daily-cloudcode-pa.googleapis.com/v1internal:fetchAvailableModels",
-      "https://cloudcode-pa.googleapis.com/v1internal:fetchAvailableModels"
-    ];
-
-    let response = null;
-    let responseData = null;
-    let fetchError = null;
-
-    for (const url of endpoints) {
-      const controller = new AbortController();
-      const timeoutId = setTimeout(() => controller.abort(), 10000);
-
-      let payload = projectId ? { project: projectId } : {};
-
-      try {
-        let res = await proxyAwareFetch(url, {
-          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",
-          },
-          body: JSON.stringify(payload),
-          signal: controller.signal,
-        }, proxyOptions);
-
-        // 403 Forbidden check: if payload has project, retry without project ID on the SAME endpoint
-        if (res.status === 403 && payload.project) {
-          console.warn(`[Antigravity Quota] 403 Forbidden with project ID on ${url}, retrying without project ID...`);
-          res = await proxyAwareFetch(url, {
-            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",
-            },
-            body: JSON.stringify({}),
-            signal: controller.signal,
-          }, proxyOptions);
-        }
-
-        if (res.status === 403) {
-          return {
-            plan: subscriptionTier,
-            message: "Antigravity quota API access forbidden.",
-            isForbidden: true,
-            quotas: {}
-          };
-        }
-
-        if (res.status === 401) {
-          return {
-            plan: subscriptionTier,
-            message: "Antigravity quota API authentication expired.",
-            isExpired: true,
-            quotas: {}
-          };
-        }
-
-        if (res.ok) {
-          response = res;
-          responseData = await res.json();
-          break; // Succeeded! Break the endpoints loop
-        } else {
-          const errText = await res.text();
-          fetchError = new Error(`HTTP ${res.status}: ${errText}`);
-        }
-      } catch (err) {
-        fetchError = err;
-      } finally {
-        clearTimeout(timeoutId);
-      }
-    }
-
-    if (!response || !responseData) {
-      throw fetchError || new Error("Failed to fetch antigravity quota from all endpoints");
-    }
-
-    const quotas = {};
-    if (responseData.models) {
-      // Like Antigravity-Manager, accept any model whose key starts with gemini, claude, gpt, image, or imagen
-      for (const [modelKey, info] of Object.entries(responseData.models)) {
-        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 (!matchesTarget) {
-          continue;
-        }
-
-        const remainingFraction = info.quotaInfo.remainingFraction != null ? info.quotaInfo.remainingFraction : 0;
-        const remainingPercentage = remainingFraction * 100;
-        const total = 1000;
-        const remaining = Math.round(total * remainingFraction);
-        const used = total - remaining;
-
-        quotas[modelKey] = {
-          used,
-          total,
-          resetAt: parseResetTime(info.quotaInfo.resetTime),
-          remainingPercentage,
-          unlimited: false,
-          displayName: info.displayName || modelKey,
-        };
-      }
-    }
-
-    return {
-      plan: subscriptionTier,
-      quotas,
-      subscriptionInfo,
-    };
-  } catch (error) {
-    console.error("[Antigravity Usage] Error:", error.message);
-    return { message: `Antigravity error: ${error.message}` };
-  }
-}
-
-/**
- * Get Antigravity project ID from subscription info
- */
-async function getAntigravityProjectId(accessToken) {
-  try {
-    const info = await getAntigravitySubscriptionInfo(accessToken);
-    return info?.cloudaicompanionProject || null;
-  } catch {
-    return null;
-  }
-}
-
-/**
- * Check whether a tier string contains a recognizable keyword (ultra/pro/plus/free).
- * Used to detect free accounts where currentTier.name is a generic label like "Antigravity".
- */
-function isTierNormalizeable(value) {
-  if (!value) return false;
-  const lower = String(value).toLowerCase();
-  return lower.includes("ultra") || lower.includes("pro") || lower.includes("plus") || lower.includes("free") || lower.includes("restricted");
-}
-
-/**
- * Get Antigravity subscription info
- */
-async function getAntigravitySubscriptionInfo(accessToken, proxyOptions = null) {
-  const urls = [
-    "https://daily-cloudcode-pa.sandbox.googleapis.com/v1internal:loadCodeAssist",
-    "https://daily-cloudcode-pa.googleapis.com/v1internal:loadCodeAssist",
-    "https://cloudcode-pa.googleapis.com/v1internal:loadCodeAssist"
-  ];
-
-  for (const url of urls) {
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), 10000);
-    try {
-      const response = await proxyAwareFetch(url, {
-        method: "POST",
-        headers: {
-          "Authorization": `Bearer ${accessToken}`,
-          "User-Agent": ANTIGRAVITY_CONFIG.userAgent,
-          "Content-Type": "application/json",
-          "x-request-source": "local",
-        },
-        body: JSON.stringify({ metadata: CLIENT_METADATA, mode: 1 }),
-        signal: controller.signal,
-      }, proxyOptions);
-
-      if (response.ok) {
-        const data = await response.json();
-        const paidTier = data.paidTier;
-        const currentTier = data.currentTier;
-        const allowedTiers = data.allowedTiers;
-        const ineligibleTiers = data.ineligibleTiers;
-
-        let subscriptionTier = (paidTier?.name || paidTier?.id) || null;
-        const isIneligible = Array.isArray(ineligibleTiers) && ineligibleTiers.length > 0;
-
-        if (!subscriptionTier) {
-          if (!isIneligible) {
-            subscriptionTier = (currentTier?.name || currentTier?.id) || null;
-          } else {
-            if (Array.isArray(allowedTiers)) {
-              const defaultTier = allowedTiers.find(t => t.isDefault === true);
-              if (defaultTier) {
-                const nameOrId = defaultTier.name || defaultTier.id;
-                if (nameOrId) {
-                  subscriptionTier = `${nameOrId} (Restricted)`;
-                }
-              }
-            }
-          }
-        }
-
-        // If subscriptionTier resolved to a value that doesn't map to a known tier
-        // (e.g. free accounts return currentTier.name="Antigravity" which is unrecognized),
-        // fall back to currentTier.id (free accounts have id="free-tier") or force "Free".
-        // This mirrors Antigravity-Manager's catch-all: anything not "ultra"/"pro" → FREE.
-        if (subscriptionTier && !isTierNormalizeable(subscriptionTier)) {
-          const idFallback = currentTier?.id;
-          if (idFallback && isTierNormalizeable(idFallback)) {
-            subscriptionTier = idFallback; // e.g. "free-tier" → will normalize to "Free"
-          } else if (!paidTier) {
-            // No paid tier and name didn't normalize → treat as Free (catch-all like Antigravity-Manager)
-            subscriptionTier = "Free";
-          }
-        }
-
-        // If still no tier resolved but we have currentTier info → Free
-        if (!subscriptionTier && currentTier && !isIneligible) {
-          subscriptionTier = "Free";
-        }
-        
-        data.subscriptionTier = subscriptionTier;
-        return data;
-      }
-    } catch (error) {
-      console.error(`[Antigravity Subscription] Error fetching from ${url}:`, error.message);
-    } finally {
-      clearTimeout(timeoutId);
-    }
-  }
-  return null;
-}
-
-/**
- * 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",
-            "user-agent": "aws-sdk-js/1.0.0 KiroIDE",
-          },
-        },
-        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 — 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}` };
-  }
-}
-
-// ── 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";
-
-  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 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) {
-  return getMiniMaxSessionTotal(model) > 0 || getMiniMaxWeeklyTotal(model) > 0;
-}
-
-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) {
-  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);
-  return {
-    used,
-    total: safeTotal,
-    remaining,
-    remainingPercentage: safeTotal > 0 ? Math.max(0, Math.min(100, (remaining / safeTotal) * 100)) : 0,
-    resetAt,
-    unlimited: false,
-  };
-}
-
-function addMiniMaxQuota(quotas, key, model, getTotal, countSnake, countCamel, resetArgs, countMeansRemaining) {
-  const total = getTotal(model);
-  if (total <= 0) return;
-
-  const count = Math.max(0, Number(getMiniMaxField(model, countSnake, countCamel)) || 0);
-  quotas[key] = buildMiniMaxQuota(
-    total,
-    count,
-    getMiniMaxResetAt(model, ...resetArgs),
-    countMeansRemaining
-  );
-}
-
-/**
- * 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",
-          [capturedAtMs, "remains_time", "remainsTime", "end_time", "endTime"],
-          countMeansRemaining
-        );
-
-        addMiniMaxQuota(
-          quotas,
-          `${displayName} (7d)`,
-          model,
-          getMiniMaxWeeklyTotal,
-          "current_weekly_usage_count",
-          "currentWeeklyUsageCount",
-          [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}` };
-  }
+  const handler = USAGE_HANDLERS[provider];
+  if (!handler) return { message: `Usage API not implemented for ${provider}` };
+  return await handler({ provider, accessToken, apiKey, providerSpecificData, providerDataWithProjectId, proxyOptions });
 }