zevairouter 1.0.43 → 1.0.44

package/cli/app/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zevairouter",
-  "version": "1.0.43",
+  "version": "1.0.44",
   "description": "ZevaiRouter - AI Router with provider automation, multi-account workflows, and quota tracking",
   "bin": {
     "zevai": "./cli/cli.js"

package/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zevairouter-cli",
-  "version": "1.0.43",
+  "version": "1.0.44",
   "description": "ZevaiRouter CLI - Start and manage ZevaiRouter server",
   "bin": {
     "zevai": "./cli.js"

package/open-sse/services/usage.js

@@ -131,6 +131,15 @@ export async function getUsageForProvider(connection, proxyOptions = null) {
       return await getMiniMaxUsage(apiKey, provider, proxyOptions);
     case "grok-cli":
       return await getGrokCliUsage(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}` };
   }
@@ -1976,3 +1985,303 @@ export async function getGrokCliUsage(accessToken, providerSpecificData = null,
     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,
+      },
+    },
+  };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zevairouter",
-  "version": "1.0.43",
+  "version": "1.0.44",
   "description": "ZevaiRouter - AI Router with provider automation, multi-account workflows, and quota tracking",
   "bin": {
     "zevai": "./cli/cli.js"

package/src/app/api/providers/[id]/models/route.js

@@ -252,6 +252,44 @@ const PROVIDER_MODELS_CONFIG = {
       };
     }
   },
+  cline: {
+    customResolver: async (connection) => {
+      // Cline catalog is the full Cline gateway list (not just cline-pass/*)
+      const result = await resolveClinepassModels({
+        accessToken: connection.accessToken,
+        apiKey: connection.apiKey,
+      });
+      // resolveClinepassModels filters to cline-pass/* — for Cline use OpenAI models endpoint via probe fallback
+      const token = connection.apiKey || connection.accessToken;
+      if (!token) {
+        return { models: getModelsByProviderId("cline") };
+      }
+      try {
+        const { buildClineHeaders } = await import("@/shared/utils/clineAuth");
+        const res = await fetch("https://api.cline.bot/api/v1/models", {
+          headers: buildClineHeaders(token, { Accept: "application/json" }),
+        });
+        if (res.ok) {
+          const json = await res.json();
+          const raw = Array.isArray(json) ? json : json?.data;
+          if (Array.isArray(raw) && raw.length) {
+            return {
+              models: raw
+                .filter((m) => typeof m?.id === "string")
+                .map((m) => ({ id: m.id, name: m.name || m.id })),
+            };
+          }
+        }
+      } catch {
+        /* fall through */
+      }
+      if (result?.models?.length) return { models: result.models };
+      return {
+        models: getModelsByProviderId("cline"),
+        warning: "Cline returned no live models; falling back to static catalog.",
+      };
+    }
+  },
   github: {
     customResolver: async (connection) => {
       const result = await resolveCopilotModels({

package/src/app/api/v1/models/route.js

@@ -54,6 +54,26 @@ const LIVE_MODEL_RESOLVERS = {
     });
     return result?.models?.length ? { models: result.models } : null;
   },
+  cline: async (conn) => {
+    const token = conn.apiKey || conn.accessToken;
+    if (!token) return null;
+    try {
+      const { buildClineHeaders } = await import("@/shared/utils/clineAuth");
+      const res = await fetch("https://api.cline.bot/api/v1/models", {
+        headers: buildClineHeaders(token, { Accept: "application/json" }),
+      });
+      if (!res.ok) return null;
+      const json = await res.json();
+      const raw = Array.isArray(json) ? json : json?.data;
+      if (!Array.isArray(raw) || raw.length === 0) return null;
+      const models = raw
+        .filter((m) => typeof m?.id === "string")
+        .map((m) => ({ id: m.id, name: m.name || m.id }));
+      return models.length ? { models } : null;
+    } catch {
+      return null;
+    }
+  },
   github: async (conn) => {
     const result = await resolveCopilotModels({
       accessToken: conn.accessToken,

package/src/shared/constants/providers.js

@@ -426,6 +426,12 @@ export const USAGE_SUPPORTED_PROVIDERS = [
   "iflow",
   // Wave 2: Grok CLI / Grok Build billing
   "grok-cli",
+  // Multi-account quota expansion
+  "xai",
+  "cline",
+  "clinepass",
+  "kimchi",
+  "cursor",
 ];
 
 // Subset that uses apikey auth (still surfaced on quota page)
@@ -436,4 +442,6 @@ export const USAGE_APIKEY_PROVIDERS = [
   "minimax-cn",
   "codebuddy",
   "codebuddy-cn",
+  "xai",
+  "clinepass",
 ];