feat(usage): add Kimi and DeepSeek usage handlers

Wire /v1/usages for Kimi (OAuth + API key) and balance API for DeepSeek,
flag both providers with usage/usageApikey, and normalize their quotas
in the dashboard ProviderLimits parser.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

open-sse/services/usage.js

@@ -12,6 +12,8 @@ import { getKiroUsage } from "./usage/kiro.js";
 import { getMiniMaxUsage } from "./usage/minimax.js";
 import { getCodeBuddyCnUsage } from "./usage/codebuddy-cn.js";
 import { getGrokCliUsage } from "./usage/grok-cli.js";
+import { getKimiUsage } from "./usage/kimi.js";
+import { getDeepseekUsage } from "./usage/deepseek.js";
 import {
   getQwenUsage,
   getIflowUsage,
@@ -45,6 +47,8 @@ const USAGE_HANDLERS = {
   "vercel-ai-gateway": (c) => getVercelAiGatewayUsage(c.apiKey, c.proxyOptions),
   "codebuddy-cn": (c) => getCodeBuddyCnUsage(c.accessToken, c.apiKey, c.providerSpecificData, c.proxyOptions),
   "grok-cli": (c) => getGrokCliUsage(c.accessToken, c.providerSpecificData, c.proxyOptions),
+  kimi: (c) => getKimiUsage(c.accessToken, c.apiKey, c.proxyOptions, c.providerSpecificData),
+  deepseek: (c) => getDeepseekUsage(c.apiKey, c.proxyOptions),
 };
 
 export async function getUsageForProvider(connection, proxyOptions = null) {

open-sse/services/usage/deepseek.js

@@ -0,0 +1,112 @@
+/**
+ * DeepSeek usage — GET https://api.deepseek.com/user/balance
+ * Auth: Bearer <apiKey>
+ */
+
+import { proxyAwareFetch } from "../../utils/proxyFetch.js";
+import { toFiniteNumber } from "./shared.js";
+
+const BALANCE_URL = "https://api.deepseek.com/user/balance";
+
+function parseBalanceInfos(data) {
+  const list = Array.isArray(data?.balance_infos) ? data.balance_infos : [];
+  const results = [];
+  for (const item of list) {
+    if (!item || typeof item !== "object") continue;
+    const currency =
+      typeof item.currency === "string" ? item.currency.toUpperCase() : "";
+    if (!currency) continue;
+    const totalBalance = toFiniteNumber(
+      item.total_balance ?? item.totalBalance,
+      0,
+    );
+    results.push({
+      currency,
+      totalBalance,
+      grantedBalance: toFiniteNumber(
+        item.granted_balance ?? item.grantedBalance,
+        0,
+      ),
+      toppedUpBalance: toFiniteNumber(
+        item.topped_up_balance ?? item.toppedUpBalance,
+        0,
+      ),
+    });
+  }
+  return results;
+}
+
+/**
+ * @param {string|null|undefined} apiKey
+ * @param {object|null} proxyOptions
+ */
+export async function getDeepseekUsage(apiKey = null, proxyOptions = null) {
+  if (!apiKey || typeof apiKey !== "string" || !apiKey.trim()) {
+    return { message: "DeepSeek API key not available. Add a key to view usage." };
+  }
+
+  try {
+    const response = await proxyAwareFetch(
+      BALANCE_URL,
+      {
+        method: "GET",
+        headers: {
+          Authorization: `Bearer ${apiKey.trim()}`,
+          "Content-Type": "application/json",
+          Accept: "application/json",
+        },
+      },
+      proxyOptions,
+    );
+
+    if (response.status === 401 || response.status === 403) {
+      return {
+        plan: "DeepSeek",
+        message: "DeepSeek authentication failed. Check the API key.",
+      };
+    }
+
+    if (!response.ok) {
+      const errText = await response.text().catch(() => "");
+      return {
+        plan: "DeepSeek",
+        message: `DeepSeek balance API error (${response.status})${errText ? `: ${errText.slice(0, 120)}` : ""}`,
+      };
+    }
+
+    const data = await response.json().catch(() => null);
+    if (!data || typeof data !== "object") {
+      return { message: "DeepSeek balance response was not JSON." };
+    }
+
+    const balances = parseBalanceInfos(data);
+    if (balances.length === 0) {
+      return {
+        plan: "DeepSeek",
+        message: "DeepSeek connected. No balance data returned.",
+      };
+    }
+
+    const isAvailable = data.is_available === true || data.isAvailable === true;
+    const quotas = {};
+    for (const b of balances) {
+      const total = Math.max(0, b.totalBalance);
+      // Credit pot: show full remaining against current balance; never set absolute
+      // `remaining` — QuotaTable treats it as a 0–100 percentage.
+      quotas[`Balance (${b.currency})`] = {
+        used: 0,
+        total,
+        remainingPercentage: total > 0 ? 100 : 0,
+        resetAt: null,
+        unlimited: total > 0,
+      };
+    }
+
+    return {
+      plan: isAvailable ? "DeepSeek" : "DeepSeek (Insufficient Balance)",
+      quotas,
+    };
+  } catch (error) {
+    return { message: `DeepSeek error: ${error.message}` };
+  }
+}

open-sse/services/usage/kimi.js

@@ -0,0 +1,211 @@
+/**
+ * Kimi Coding usage — GET /v1/usages
+ *
+ * Dual auth (single provider id `kimi`):
+ *   - apiKey present → x-api-key only (platform / coding API key)
+ *   - else accessToken → Bearer + X-Msh-* (device-code OAuth; OmniRoute parity)
+ *
+ * Note: chat messages use combined x-api-key; /usages OAuth is Bearer.
+ * 403 permission_denied is NOT auth-expired — account lacks usage feature / sub.
+ */
+
+import { proxyAwareFetch } from "../../utils/proxyFetch.js";
+import { parseResetTime, toFiniteNumber } from "./shared.js";
+import { buildKimiHeaders } from "../../config/appConstants.js";
+
+const USAGE_URL = "https://api.kimi.com/coding/v1/usages";
+
+const PLAN_LEVELS = {
+  LEVEL_BASIC: "Moderato",
+  LEVEL_INTERMEDIATE: "Allegretto",
+  LEVEL_ADVANCED: "Allegro",
+  LEVEL_STANDARD: "Vivace",
+};
+
+function getKimiPlanName(level) {
+  if (!level) return "";
+  const key = String(level);
+  if (PLAN_LEVELS[key]) return PLAN_LEVELS[key];
+  return key.replace(/^LEVEL_/, "").toLowerCase();
+}
+
+/** Best-effort extract human message from Kimi error JSON (403 body is Connect-RPC-ish). */
+export function formatKimiUsageError(status, responseText) {
+  let parsed = null;
+  try {
+    parsed = JSON.parse(responseText || "");
+  } catch {
+    /* plain text */
+  }
+
+  const detail0 = Array.isArray(parsed?.details) ? parsed.details[0] : null;
+  const debug = detail0?.debug || parsed?.debug || null;
+  const reason = debug?.reason || parsed?.reason || "";
+  const localized =
+    debug?.localizedMessage?.message ||
+    detail0?.localizedMessage?.message ||
+    parsed?.message ||
+    "";
+
+  if (status === 401) {
+    return "Kimi authentication expired. Please re-authorize.";
+  }
+
+  // Live OAuth token without Kimi Code usage entitlement returns 403
+  // REASON_FEATURE_NO_PERMISSION — not an expired session.
+  if (
+    status === 403 &&
+    (reason === "REASON_FEATURE_NO_PERMISSION" ||
+      /permission_denied|do not have permission|subscribe/i.test(
+        `${parsed?.code || ""} ${localized} ${responseText || ""}`,
+      ))
+  ) {
+    return (
+      localized ||
+      "Kimi connected, but this account has no permission to view usage. Subscribe to Kimi Code to access quota."
+    );
+  }
+
+  const snippet = (localized || responseText || "").slice(0, 100);
+  return snippet
+    ? `Kimi Coding connected. API Error ${status}: ${snippet}`
+    : `Kimi Coding connected. API Error ${status}`;
+}
+
+function makeQuota({ used, total, remaining, resetAt }) {
+  const safeTotal = Math.max(0, toFiniteNumber(total, 0));
+  const safeUsed = Math.max(0, toFiniteNumber(used, 0));
+  // Prefer provider remaining when present; never set absolute `remaining`
+  // on the quota object — QuotaTable treats it as a 0–100 percentage.
+  let remainingPct;
+  if (safeTotal > 0 && remaining != null && Number.isFinite(Number(remaining))) {
+    remainingPct = (Math.max(0, Number(remaining)) / safeTotal) * 100;
+  } else if (safeTotal > 0) {
+    remainingPct = (Math.max(0, safeTotal - safeUsed) / safeTotal) * 100;
+  } else {
+    remainingPct = 0;
+  }
+  return {
+    used: safeUsed,
+    total: safeTotal,
+    remainingPercentage: remainingPct,
+    resetAt: resetAt || null,
+    unlimited: false,
+  };
+}
+
+/**
+ * @param {string|null|undefined} accessToken
+ * @param {string|null|undefined} apiKey
+ * @param {object|null} proxyOptions
+ * @param {object|null} providerSpecificData
+ */
+export async function getKimiUsage(
+  accessToken = null,
+  apiKey = null,
+  proxyOptions = null,
+  providerSpecificData = null,
+) {
+  const useApiKey = typeof apiKey === "string" && apiKey.length > 0;
+  const useOAuth = !useApiKey && typeof accessToken === "string" && accessToken.length > 0;
+
+  if (!useApiKey && !useOAuth) {
+    return { message: "Kimi access token or API key not available." };
+  }
+
+  const authHeaders = useApiKey
+    ? { "x-api-key": apiKey }
+    : {
+        Authorization: `Bearer ${accessToken}`,
+        ...buildKimiHeaders(providerSpecificData?.deviceId),
+      };
+
+  try {
+    const response = await proxyAwareFetch(
+      USAGE_URL,
+      {
+        method: "GET",
+        headers: {
+          ...authHeaders,
+          "Content-Type": "application/json",
+          Accept: "application/json",
+        },
+      },
+      proxyOptions,
+    );
+
+    const responseText = await response.text().catch(() => "");
+
+    if (!response.ok) {
+      return {
+        plan: "Kimi Coding",
+        message: formatKimiUsageError(response.status, responseText),
+      };
+    }
+
+    let data;
+    try {
+      data = JSON.parse(responseText || "{}");
+    } catch {
+      return {
+        plan: "Kimi Coding",
+        message: "Kimi Coding connected. Invalid JSON response from API.",
+      };
+    }
+
+    const quotas = {};
+    const usageObj = data?.usage && typeof data.usage === "object" ? data.usage : {};
+    const usageLimit = toFiniteNumber(usageObj.limit ?? usageObj.Limit, 0);
+    const usageUsed = toFiniteNumber(usageObj.used ?? usageObj.Used, 0);
+    const usageRemainingRaw = usageObj.remaining ?? usageObj.Remaining;
+    const usageRemaining =
+      usageRemainingRaw != null && usageRemainingRaw !== ""
+        ? toFiniteNumber(usageRemainingRaw, NaN)
+        : NaN;
+    const usageResetTime =
+      usageObj.resetTime || usageObj.ResetTime || usageObj.reset_at || usageObj.resetAt;
+
+    if (usageLimit > 0) {
+      quotas.Weekly = makeQuota({
+        used: usageUsed,
+        total: usageLimit,
+        remaining: Number.isFinite(usageRemaining) ? usageRemaining : null,
+        resetAt: parseResetTime(usageResetTime),
+      });
+    }
+
+    const limitsArray = Array.isArray(data?.limits) ? data.limits : [];
+    for (const item of limitsArray) {
+      if (!item || typeof item !== "object") continue;
+      const detail = item.detail && typeof item.detail === "object" ? item.detail : {};
+      const limit = toFiniteNumber(detail.limit ?? detail.Limit, 0);
+      const remaining = toFiniteNumber(detail.remaining ?? detail.Remaining, NaN);
+      const resetTime = detail.resetTime || detail.reset_at || detail.resetAt;
+      if (limit > 0) {
+        const rem = Number.isFinite(remaining) ? remaining : Math.max(0, limit);
+        quotas.Ratelimit = makeQuota({
+          used: Math.max(0, limit - rem),
+          total: limit,
+          remaining: rem,
+          resetAt: parseResetTime(resetTime),
+        });
+      }
+    }
+
+    const membershipLevel = data?.user?.membership?.level;
+    const planName = getKimiPlanName(membershipLevel) || "Kimi Coding";
+
+    if (Object.keys(quotas).length > 0) {
+      return { plan: planName, quotas };
+    }
+
+    return {
+      plan: planName,
+      message: "Kimi Coding connected. Usage tracked per request.",
+    };
+  } catch (error) {
+    return {
+      message: `Kimi Coding connected. Unable to fetch usage: ${error.message}`,
+    };
+  }
+}