@narumitw/pi-usage 0.52.3 → 0.54.0

package/dist/index.ts

@@ -550,6 +550,219 @@ function asNonnegativeNumber(value) {
   return number === void 0 || number < 0 ? void 0 : number;
 }
 
+// src/providers/kimi-coding.ts
+var FIVE_HOUR_WINDOW_MINUTES = 300;
+var DAILY_WINDOW_MINUTES = 1440;
+var WEEKLY_WINDOW_MINUTES = 10080;
+var FIXED_POINT_UNITS_PER_CENT = 1e6;
+function normalizeKimiCodingUsagePayload(payload, capturedAt) {
+  const root = asObject3(payload);
+  if (!root) throw new Error("Kimi Coding usage response was not an object.");
+  const candidates = [];
+  let omittedWindow = false;
+  const summary = parseUsageRow(root.usage, WEEKLY_WINDOW_MINUTES, "Weekly window");
+  if (summary) candidates.push(summary);
+  else if (root.usage !== void 0) omittedWindow = true;
+  if (Array.isArray(root.limits)) {
+    for (const raw of root.limits) {
+      const item = asObject3(raw);
+      const windowMinutes = parseWindowMinutes(item?.window);
+      const label = sanitizedLabel(item?.name);
+      const bucket = windowMinutes === void 0 ? void 0 : parseUsageRow(item?.detail, windowMinutes, label ?? defaultWindowLabel(windowMinutes));
+      if (bucket) candidates.push(bucket);
+      else omittedWindow = true;
+    }
+  } else if (root.limits !== void 0) {
+    omittedWindow = true;
+  }
+  const buckets = [];
+  const byWindow = /* @__PURE__ */ new Map();
+  for (const bucket of candidates) {
+    const windowMinutes = bucket.windowMinutes;
+    byWindow.set(windowMinutes, [...byWindow.get(windowMinutes) ?? [], bucket]);
+  }
+  for (const rows of byWindow.values()) {
+    if (rows.length === 1) buckets.push(rows[0]);
+    else omittedWindow = true;
+  }
+  buckets.sort((left, right) => (left.windowMinutes ?? 0) - (right.windowMinutes ?? 0));
+  const metrics = parseBoosterWallet(root.boosterWallet);
+  if (buckets.length === 0 && metrics.length === 0) {
+    throw new Error("Kimi Coding usage endpoint returned no displayable usage data.");
+  }
+  return {
+    providerId: "kimi-coding",
+    providerName: "Kimi For Coding",
+    capturedAt,
+    source: "kimi-managed-usage",
+    semantics: { kind: "consumer-subscription", label: "Kimi Coding Plan usage" },
+    buckets,
+    metrics,
+    ...omittedWindow ? { notes: ["Unsupported, malformed, or duplicate plan windows were unavailable."] } : {}
+  };
+}
+function parseUsageRow(value, windowMinutes, label) {
+  const row = asObject3(value);
+  if (!row) return void 0;
+  const used = asNonnegativeInteger2(row.used);
+  const limit = asNonnegativeInteger2(row.limit);
+  if (used === void 0 || limit === void 0 || limit === 0) return void 0;
+  const resetsAt = asIsoEpochSeconds(row.resetTime);
+  return {
+    id: windowId(windowMinutes),
+    label,
+    used,
+    remaining: Math.max(0, limit - used),
+    limit,
+    unit: "count",
+    windowMinutes,
+    ...resetsAt !== void 0 ? { resetsAt } : {}
+  };
+}
+function parseWindowMinutes(value) {
+  const window = asObject3(value);
+  if (!window) return void 0;
+  const duration = asPositiveInteger(window.duration);
+  if (duration === void 0) return void 0;
+  const multiplier = window.timeUnit === "TIME_UNIT_MINUTE" ? 1 : window.timeUnit === "TIME_UNIT_HOUR" ? 60 : window.timeUnit === "TIME_UNIT_DAY" ? 1440 : window.timeUnit === "TIME_UNIT_WEEK" ? 10080 : void 0;
+  if (multiplier === void 0) return void 0;
+  const minutes = duration * multiplier;
+  return Number.isSafeInteger(minutes) ? minutes : void 0;
+}
+function parseBoosterWallet(value) {
+  const wallet = asObject3(value);
+  const balance = asObject3(wallet?.balance);
+  if (!wallet || !balance || balance.type !== "BOOSTER") return [];
+  const totalRaw = asPositiveInteger(balance.amount);
+  if (totalRaw === void 0) return [];
+  const leftRaw = asNonnegativeInteger2(balance.amountLeft) ?? 0;
+  const monthlyLimit = parseMoney(wallet.monthlyChargeLimit);
+  const monthlyUsed = parseMoney(wallet.monthlyUsed);
+  const currencies = new Set(
+    [monthlyLimit?.currency, monthlyUsed?.currency].filter(
+      (currency2) => currency2 !== void 0
+    )
+  );
+  if (currencies.size !== 1) return [];
+  const currency = currencies.values().next().value;
+  if (!currency) return [];
+  const total = fixedPointToMajor(totalRaw);
+  const left = fixedPointToMajor(leftRaw);
+  if (total === void 0 || left === void 0) return [];
+  const metrics = [
+    { id: "booster-balance", label: "Balance", value: left, unit: "currency", currency },
+    { id: "booster-total", label: "Total balance", value: total, unit: "currency", currency }
+  ];
+  if (monthlyUsed) {
+    metrics.push({
+      id: "booster-monthly-used",
+      label: "Used this month",
+      value: monthlyUsed.cents / 100,
+      unit: "currency",
+      currency
+    });
+  }
+  if (wallet.monthlyChargeLimitEnabled === false) {
+    metrics.push({
+      id: "booster-monthly-limit",
+      label: "Monthly limit",
+      value: "unlimited",
+      unit: "currency",
+      currency
+    });
+  } else if (wallet.monthlyChargeLimitEnabled === true && monthlyLimit) {
+    metrics.push({
+      id: "booster-monthly-limit",
+      label: "Monthly limit",
+      value: monthlyLimit.cents / 100,
+      unit: "currency",
+      currency
+    });
+  }
+  return metrics;
+}
+function parseMoney(value) {
+  const money = asObject3(value);
+  if (!money) return void 0;
+  const cents = asNonnegativeInteger2(money.priceInCents);
+  if (cents === void 0) return void 0;
+  const currency = asCurrency(money.currency);
+  if (!currency) return void 0;
+  return { cents, currency };
+}
+function fixedPointToMajor(value) {
+  const cents = value / FIXED_POINT_UNITS_PER_CENT;
+  const roundedCents = cents > 0 && cents < 1 ? 1 : Math.round(cents);
+  const major = roundedCents / 100;
+  return Number.isSafeInteger(roundedCents) && Number.isFinite(major) ? major : void 0;
+}
+function asObject3(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  return value;
+}
+function asNonnegativeInteger2(value) {
+  if (typeof value === "string" && !/^\d+$/u.test(value)) return void 0;
+  const number = typeof value === "string" ? Number(value) : value;
+  if (typeof number !== "number" || !Number.isSafeInteger(number) || number < 0) return void 0;
+  return number;
+}
+function asPositiveInteger(value) {
+  const number = asNonnegativeInteger2(value);
+  return number !== void 0 && number > 0 ? number : void 0;
+}
+function asIsoEpochSeconds(value) {
+  if (typeof value !== "string") return void 0;
+  const match = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})(?:\.\d+)?(?:Z|([+-])(\d{2}):(\d{2}))$/u.exec(
+    value
+  );
+  if (!match) return void 0;
+  const [
+    ,
+    yearText,
+    monthText,
+    dayText,
+    hourText,
+    minuteText,
+    secondText,
+    ,
+    offsetHour,
+    offsetMinute
+  ] = match;
+  const year = Number(yearText);
+  const month = Number(monthText);
+  const day = Number(dayText);
+  const hour = Number(hourText);
+  const minute = Number(minuteText);
+  const second = Number(secondText);
+  if (month < 1 || month > 12 || day < 1 || day > new Date(Date.UTC(year, month, 0)).getUTCDate() || hour > 23 || minute > 59 || second > 59 || offsetHour !== void 0 && Number(offsetHour) > 23 || offsetMinute !== void 0 && Number(offsetMinute) > 59) {
+    return void 0;
+  }
+  const millis = Date.parse(value);
+  return Number.isFinite(millis) && millis >= 0 ? Math.floor(millis / 1e3) : void 0;
+}
+function sanitizedLabel(value) {
+  if (typeof value !== "string") return void 0;
+  return sanitizeDisplayText(value, 80) || void 0;
+}
+function asCurrency(value) {
+  if (typeof value !== "string") return void 0;
+  const currency = sanitizeDisplayText(value, 3).toUpperCase();
+  return /^[A-Z]{3}$/u.test(currency) ? currency : void 0;
+}
+function windowId(minutes) {
+  if (minutes === FIVE_HOUR_WINDOW_MINUTES) return "five-hour";
+  if (minutes === DAILY_WINDOW_MINUTES) return "daily";
+  if (minutes === WEEKLY_WINDOW_MINUTES) return "weekly";
+  return `window-${minutes}-minutes`;
+}
+function defaultWindowLabel(minutes) {
+  if (minutes === WEEKLY_WINDOW_MINUTES) return "Weekly window";
+  if (minutes % 10080 === 0) return `${minutes / 10080}w window`;
+  if (minutes % 1440 === 0) return `${minutes / 1440}d window`;
+  if (minutes % 60 === 0) return `${minutes / 60}h window`;
+  return `${minutes}m window`;
+}
+
 // src/providers/opencode-zen.ts
 var ZEN_WINDOWS = [
   { key: "rolling", label: "Rolling" },
@@ -557,12 +770,12 @@ var ZEN_WINDOWS = [
   { key: "monthly", label: "Monthly" }
 ];
 function normalizeOpenCodeZenPayload(payload, capturedAt) {
-  const usage = asObject3(payload.usage);
+  const usage = asObject4(payload.usage);
   if (!usage) throw new Error("OpenCode Zen usage response was not an object.");
   const buckets = [];
   const notes = [];
   for (const window of ZEN_WINDOWS) {
-    const raw = asObject3(usage[window.key]);
+    const raw = asObject4(usage[window.key]);
     if (!raw) continue;
     const status = asString3(raw.status);
     if (status !== "ok" && status !== "rate-limited") {
@@ -599,7 +812,7 @@ function normalizeOpenCodeZenPayload(payload, capturedAt) {
     ...notes.length > 0 ? { notes } : {}
   };
 }
-function asObject3(value) {
+function asObject4(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
   return value;
 }
@@ -623,7 +836,7 @@ function clampPercent2(value) {
 
 // src/providers/openrouter.ts
 function normalizeOpenRouterKeyPayload(payload, capturedAt) {
-  const data = asObject4(payload.data);
+  const data = asObject5(payload.data);
   if (!data) throw new Error("OpenRouter key response data was not an object.");
   const limit = asNonnegativeNumber3(data.limit);
   const remaining = asNonnegativeNumber3(data.limit_remaining);
@@ -669,7 +882,7 @@ function addUsageMetric(metrics, id, label, value) {
   if (amount === void 0) return;
   metrics.push({ id, label, value: amount, unit: "usd" });
 }
-function asObject4(value) {
+function asObject5(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
   return value;
 }
@@ -682,11 +895,294 @@ function asNonnegativeNumber3(value) {
   return value;
 }
 
+// src/providers/xai.ts
+var MAX_SAFE_CENTS = Number.MAX_SAFE_INTEGER;
+function normalizeXaiBillingPayload(payload, subscriptionTier, capturedAt) {
+  const configValue = payload.config;
+  if (configValue !== null && configValue !== void 0 && !isRecord2(configValue)) {
+    throw new Error("xAI billing response config was not an object or null.");
+  }
+  const config = isRecord2(configValue) ? configValue : void 0;
+  const buckets = [];
+  const metrics = [];
+  const notes = [];
+  if (config) {
+    const period = normalizePeriod(
+      config.currentPeriod,
+      config.billingPeriodStart,
+      config.billingPeriodEnd
+    );
+    const preferredPercent = optionalPercent(config.creditUsagePercent, "creditUsagePercent");
+    if (preferredPercent !== void 0) {
+      buckets.push({
+        id: "included-allowance",
+        label: "Included allowance",
+        used: preferredPercent,
+        remaining: 100 - preferredPercent,
+        unit: "percent",
+        ...period
+      });
+    } else {
+      const limit = optionalUsd(config.monthlyLimit, "monthlyLimit");
+      const used = optionalUsd(config.used, "used");
+      if (limit !== void 0 || used !== void 0) {
+        buckets.push({
+          id: "included-allowance",
+          label: "Included allowance",
+          ...limit !== void 0 ? { limit } : {},
+          ...used !== void 0 ? { used } : {},
+          ...limit !== void 0 && used !== void 0 ? { remaining: limit - used } : {},
+          unit: "usd",
+          ...period
+        });
+      } else if (period.period || period.resetsAt !== void 0) {
+        buckets.push({
+          id: "included-allowance",
+          label: "Included allowance",
+          unit: "percent",
+          ...period
+        });
+      }
+    }
+    const onDemandCap = optionalUsd(config.onDemandCap, "onDemandCap");
+    const onDemandUsed = optionalUsd(config.onDemandUsed, "onDemandUsed");
+    if (onDemandCap !== void 0 || onDemandUsed !== void 0) {
+      buckets.push({
+        id: "on-demand",
+        label: "On-demand usage",
+        ...onDemandCap !== void 0 ? { limit: onDemandCap } : {},
+        ...onDemandUsed !== void 0 ? { used: onDemandUsed } : {},
+        ...onDemandCap !== void 0 && onDemandUsed !== void 0 ? { remaining: onDemandCap - onDemandUsed } : {},
+        unit: "usd"
+      });
+    }
+    const prepaidBalance = optionalUsd(config.prepaidBalance, "prepaidBalance");
+    if (prepaidBalance !== void 0) {
+      metrics.push({
+        id: "prepaid-balance",
+        label: "Prepaid balance",
+        value: prepaidBalance,
+        unit: "usd"
+      });
+    }
+  }
+  const tier = optionalTier(subscriptionTier);
+  if (tier) metrics.push({ id: "subscription-tier", label: "Plan tier", value: tier });
+  if (!config) notes.push("No xAI consumer billing configuration is available for this account.");
+  else if (buckets.length === 0 && metrics.length === 0) {
+    notes.push("The xAI consumer billing response contained no displayable usage fields.");
+  }
+  return {
+    providerId: "xai",
+    providerName: "xAI",
+    capturedAt,
+    source: "cli-chat-proxy.grok.com consumer billing",
+    semantics: {
+      kind: "consumer-subscription",
+      label: "xAI consumer subscription usage"
+    },
+    buckets,
+    metrics,
+    ...notes.length > 0 ? { notes } : {}
+  };
+}
+function normalizePeriod(currentPeriod, legacyStart, legacyEnd) {
+  if (currentPeriod !== void 0 && currentPeriod !== null && !isRecord2(currentPeriod)) {
+    throw new Error("xAI billing currentPeriod was not an object or null.");
+  }
+  if (isRecord2(currentPeriod)) {
+    const type = optionalString(currentPeriod.type, "currentPeriod.type");
+    const start2 = optionalTimestamp(currentPeriod.start, "currentPeriod.start");
+    const end2 = optionalTimestamp(currentPeriod.end, "currentPeriod.end");
+    return {
+      ...periodLabel(type, start2) ? { period: periodLabel(type, start2) } : {},
+      ...end2 !== void 0 ? { resetsAt: end2 } : {}
+    };
+  }
+  const start = optionalTimestamp(legacyStart, "billingPeriodStart");
+  const end = optionalTimestamp(legacyEnd, "billingPeriodEnd");
+  return {
+    ...start !== void 0 ? { period: "Monthly" } : {},
+    ...end !== void 0 ? { resetsAt: end } : {}
+  };
+}
+function periodLabel(type, start) {
+  if (type === "USAGE_PERIOD_TYPE_WEEKLY") return "Weekly";
+  if (type === "USAGE_PERIOD_TYPE_MONTHLY") return "Monthly";
+  if (type)
+    return sanitizeDisplayText(type.replace(/^USAGE_PERIOD_TYPE_/u, "").replaceAll("_", " "), 40);
+  return start === void 0 ? void 0 : "Current period";
+}
+function optionalUsd(value, field) {
+  if (value === void 0 || value === null) return void 0;
+  if (!isRecord2(value)) throw new Error(`xAI billing ${field} was not a cent wrapper.`);
+  const cents = value.val === void 0 ? 0 : value.val;
+  if (!Number.isSafeInteger(cents) || Math.abs(cents) > MAX_SAFE_CENTS) {
+    throw new Error(`xAI billing ${field}.val was not a safe signed integer.`);
+  }
+  return cents / 100;
+}
+function optionalPercent(value, field) {
+  if (value === void 0 || value === null) return void 0;
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0 || value > 100) {
+    throw new Error(`xAI billing ${field} was outside 0\u2013100.`);
+  }
+  return value;
+}
+function optionalTimestamp(value, field) {
+  if (value === void 0 || value === null) return void 0;
+  if (typeof value !== "string" || value.length > 80) {
+    throw new Error(`xAI billing ${field} was not a bounded timestamp.`);
+  }
+  const milliseconds = Date.parse(value);
+  if (!Number.isFinite(milliseconds)) throw new Error(`xAI billing ${field} was invalid.`);
+  return Math.floor(milliseconds / 1e3);
+}
+function optionalString(value, field) {
+  if (value === void 0 || value === null) return void 0;
+  if (typeof value !== "string" || value.length > 80) {
+    throw new Error(`xAI billing ${field} was not a bounded string.`);
+  }
+  return value;
+}
+function optionalTier(value) {
+  if (value === void 0 || value === null) return void 0;
+  if (typeof value !== "string" || value.length > 160) {
+    throw new Error("xAI subscription tier was not a bounded string or null.");
+  }
+  return sanitizeDisplayText(value, 80) || void 0;
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/providers/zai.ts
+var FIVE_HOUR_WINDOW_MINUTES2 = 300;
+var WEEKLY_WINDOW_MINUTES2 = 10080;
+function normalizeZaiQuotaPayload(providerId, providerName, payload, capturedAt) {
+  const data = asObject6(payload.data);
+  if (!data) throw new Error("Z.AI quota response data was not an object.");
+  const limits = Array.isArray(data.limits) ? data.limits : [];
+  const buckets = [];
+  const metrics = [];
+  for (const raw of limits) {
+    const limit = asObject6(raw);
+    if (!limit) continue;
+    const type = asString5(limit.type);
+    const unit = asNonnegativeNumber4(limit.unit);
+    const isPlanUsage = type === "TOKENS_LIMIT" || type === "CREDIT_LIMIT";
+    if (type === "TIME_LIMIT") {
+      addCountBucket(buckets, limit, "mcp-monthly", "MCP monthly allowance");
+      addUsageDetailMetrics(metrics, limit.usageDetails);
+    } else if (isPlanUsage && unit === 3) {
+      addPercentBucket(buckets, limit, "five-hour", "5h window", FIVE_HOUR_WINDOW_MINUTES2);
+    } else if (isPlanUsage && unit === 6) {
+      const used = asNonnegativeNumber4(limit.currentValue);
+      const quota = asNonnegativeNumber4(limit.usage);
+      if (used !== void 0 && quota !== void 0) {
+        addCountBucket(buckets, limit, "weekly", "Weekly window", WEEKLY_WINDOW_MINUTES2);
+      } else {
+        addPercentBucket(buckets, limit, "weekly", "Weekly window", WEEKLY_WINDOW_MINUTES2);
+      }
+    }
+  }
+  if (buckets.length === 0) {
+    throw new Error("Z.AI quota endpoint returned no displayable usage data.");
+  }
+  const notes = [];
+  const level = asString5(data.level);
+  if (level) notes.push(`Plan: ${level}`);
+  return {
+    providerId,
+    providerName,
+    capturedAt,
+    source: "zai-quota",
+    semantics: { kind: "consumer-subscription", label: "GLM Coding Plan usage" },
+    buckets,
+    metrics,
+    ...notes.length > 0 ? { notes } : {}
+  };
+}
+function addPercentBucket(buckets, limit, id, label, windowMinutes) {
+  const used = asNonnegativeNumber4(limit.percentage);
+  if (used === void 0) return;
+  const percent = clampPercent3(used);
+  const resetsAt = asEpochSeconds2(limit.nextResetTime);
+  buckets.push({
+    id,
+    label,
+    used: percent,
+    remaining: 100 - percent,
+    limit: 100,
+    unit: "percent",
+    windowMinutes,
+    ...resetsAt !== void 0 ? { resetsAt } : {}
+  });
+}
+function addCountBucket(buckets, limit, id, label, windowMinutes) {
+  const used = asNonnegativeNumber4(limit.currentValue);
+  const quota = asNonnegativeNumber4(limit.usage);
+  if (used === void 0 || quota === void 0) return;
+  const resetsAt = asEpochSeconds2(limit.nextResetTime);
+  buckets.push({
+    id,
+    label,
+    used,
+    remaining: Math.max(0, quota - used),
+    limit: quota,
+    unit: "count",
+    ...windowMinutes !== void 0 ? { windowMinutes } : {},
+    ...resetsAt !== void 0 ? { resetsAt } : {}
+  });
+}
+function addUsageDetailMetrics(metrics, value) {
+  if (!Array.isArray(value)) return;
+  for (const raw of value) {
+    const detail = asObject6(raw);
+    if (!detail) continue;
+    const label = asString5(detail.modelCode);
+    const usage = asNonnegativeNumber4(detail.usage);
+    if (!label || usage === void 0) continue;
+    metrics.push({ id: `mcp-${kebabCase(label)}`, label, value: usage, unit: "count" });
+  }
+}
+function asObject6(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  return value;
+}
+function asString5(value) {
+  if (typeof value !== "string") return void 0;
+  return sanitizeDisplayText(value, 80) || void 0;
+}
+function asNonnegativeNumber4(value) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0) return void 0;
+  return value;
+}
+function asEpochSeconds2(value) {
+  const millis = asNonnegativeNumber4(value);
+  if (millis === void 0) return void 0;
+  return Math.floor(millis / 1e3);
+}
+function kebabCase(label) {
+  return label.toLowerCase().replace(/[^a-z0-9]+/gu, "-").replace(/^-+|-+$/gu, "") || "tool";
+}
+function clampPercent3(value) {
+  return Math.min(100, Math.max(0, value));
+}
+
 // src/query.ts
 var CODEX_USAGE_URL = "https://chatgpt.com/backend-api/wham/usage";
 var GITHUB_COPILOT_USAGE_URL = "https://api.github.com/copilot_internal/user";
 var OPENROUTER_KEY_URL = "https://openrouter.ai/api/v1/key";
 var OPENCODE_GO_USAGE_URL = "https://opencode.ai/zen/go/v1/usage";
+var KIMI_CODING_USAGE_URL = "https://api.kimi.com/coding/v1/usages";
+var XAI_USER_URL = "https://cli-chat-proxy.grok.com/v1/user?include=subscription";
+var XAI_BILLING_URL = "https://cli-chat-proxy.grok.com/v1/billing?format=credits";
+var XAI_CLIENT_HEADERS = Object.freeze({
+  "X-XAI-Token-Auth": "xai-grok-cli",
+  "x-grok-client-version": "1.0.10",
+  "x-grok-client-mode": "interactive"
+});
 var MAX_SUCCESS_BODY_BYTES = 64 * 1024;
 var MAX_ERROR_BODY_BYTES = 4 * 1024;
 var AUTH_FINGERPRINT_SALT = randomBytes(32);
@@ -756,10 +1252,110 @@ var SUPPORTED_ADAPTERS = [
       );
       return normalizeOpenCodeZenPayload(payload, Date.now());
     }
+  },
+  {
+    id: "kimi-coding",
+    displayName: "Kimi For Coding",
+    semantics: { kind: "consumer-subscription", label: "Kimi Coding Plan usage" },
+    async query(auth, signal, timeoutMs) {
+      const payload = await fetchProviderJson(
+        KIMI_CODING_USAGE_URL,
+        auth,
+        signal,
+        timeoutMs,
+        "Kimi Coding usage endpoint",
+        { redirect: "error" }
+      );
+      return normalizeKimiCodingUsagePayload(payload, Date.now());
+    }
+  },
+  {
+    id: "zai",
+    displayName: "Z.AI",
+    semantics: { kind: "consumer-subscription", label: "GLM Coding Plan usage" },
+    publishesStatusline: false,
+    async query(auth, signal, timeoutMs) {
+      const payload = await fetchProviderJson(
+        zaiMonitorUrl(auth.model.baseUrl),
+        zaiMonitorAuth(auth),
+        signal,
+        timeoutMs,
+        "Z.AI quota endpoint"
+      );
+      return normalizeZaiQuotaPayload("zai", "Z.AI", payload, Date.now());
+    }
+  },
+  {
+    id: "zai-coding-cn",
+    displayName: "Z.AI Coding CN",
+    semantics: { kind: "consumer-subscription", label: "GLM Coding Plan usage" },
+    publishesStatusline: false,
+    async query(auth, signal, timeoutMs) {
+      const payload = await fetchProviderJson(
+        zaiMonitorUrl(auth.model.baseUrl),
+        zaiMonitorAuth(auth),
+        signal,
+        timeoutMs,
+        "Z.AI Coding CN quota endpoint"
+      );
+      return normalizeZaiQuotaPayload(
+        "zai-coding-cn",
+        "Z.AI Coding CN",
+        payload,
+        Date.now()
+      );
+    }
   }
 ];
-function adapterForProvider(providerId) {
-  return SUPPORTED_ADAPTERS.find((adapter) => adapter.id === providerId);
+var XAI_ADAPTER = {
+  id: "xai",
+  displayName: "xAI",
+  semantics: {
+    kind: "consumer-subscription",
+    label: "xAI consumer subscription usage"
+  },
+  publishesStatusline: false,
+  async query(auth, signal, timeoutMs, guard) {
+    if (!guard) throw new Error("xAI usage requires request-boundary revalidation.");
+    const startedAt = Date.now();
+    const clientAuth = {
+      ...auth,
+      headers: { ...auth.headers, ...XAI_CLIENT_HEADERS }
+    };
+    await guard();
+    const userPayload = await fetchProviderJson(
+      XAI_USER_URL,
+      clientAuth,
+      signal,
+      remainingTimeout(timeoutMs, startedAt),
+      "xAI consumer identity endpoint",
+      { redirect: "error", userAgent: false }
+    );
+    await guard();
+    const userId = validatedXaiUserId(userPayload.userId);
+    const billingAuth = {
+      ...clientAuth,
+      headers: { ...clientAuth.headers, "x-userid": userId },
+      secrets: [...clientAuth.secrets, userId]
+    };
+    await guard();
+    const billingPayload = await fetchProviderJson(
+      XAI_BILLING_URL,
+      billingAuth,
+      signal,
+      remainingTimeout(timeoutMs, startedAt),
+      "xAI consumer billing endpoint",
+      { redirect: "error", userAgent: false }
+    );
+    await guard();
+    return normalizeXaiBillingPayload(billingPayload, userPayload.subscriptionTier, Date.now());
+  }
+};
+function usageAdapters(xaiUsage = true) {
+  return xaiUsage ? [...SUPPORTED_ADAPTERS, XAI_ADAPTER] : SUPPORTED_ADAPTERS;
+}
+function adapterForProvider(providerId, xaiUsage = true) {
+  return usageAdapters(xaiUsage).find((adapter) => adapter.id === providerId);
 }
 function isStaleExtensionContextError(error) {
   return error instanceof Error && error.message.includes("This extension ctx is stale after session replacement or reload");
@@ -805,6 +1401,11 @@ async function resolveUsageAuth(ctx, adapter, salt = AUTH_FINGERPRINT_SALT, cred
       offered.offeredCount === 0
     );
   }
+  if (adapter.id === "xai") {
+    const offered = candidateReader ? candidateReader(ctx, adapter.id) : fallbackOAuthCredentialCandidates(adapter.id, credentialReader);
+    if (!offered.ok) throw new Error("xAI OAuth credential discovery failed closed.");
+    return resolveXaiUsageAuth(auth, model, salt, offered.candidates);
+  }
   const authorization = authorizationFrom(auth);
   if (!authorization) return void 0;
   const headers = { Authorization: authorization };
@@ -819,9 +1420,9 @@ async function resolveUsageAuth(ctx, adapter, salt = AUTH_FINGERPRINT_SALT, cred
     model
   };
 }
-async function queryProviderUsage(adapter, auth, signal, timeoutMs) {
+async function queryProviderUsage(adapter, auth, signal, timeoutMs, guard) {
   try {
-    return await adapter.query(auth, signal, timeoutMs);
+    return await adapter.query(auth, signal, timeoutMs, guard);
   } catch (error) {
     if (isStaleExtensionContextError(error) || isAbortError(error)) throw error;
     throw new Error(redactUsageError(errorMessage(error), auth.secrets));
@@ -861,7 +1462,9 @@ async function fetchProviderJson(url, auth, signal, timeoutMs, description, requ
   }, timeoutMs);
   try {
     const headers = { ...auth.headers };
-    if (!hasHeader(headers, "User-Agent")) headers["User-Agent"] = "pi-usage";
+    if (request.userAgent !== false && !hasHeader(headers, "User-Agent")) {
+      headers["User-Agent"] = "pi-usage";
+    }
     if (request.body && !hasHeader(headers, "Content-Type")) {
       headers["Content-Type"] = "application/json";
     }
@@ -869,15 +1472,18 @@ async function fetchProviderJson(url, auth, signal, timeoutMs, description, requ
       method: request.method ?? "GET",
       headers,
       ...request.body ? { body: JSON.stringify(request.body) } : {},
+      ...request.redirect ? { redirect: request.redirect } : {},
       signal: controller.signal
     });
+    if (response.redirected) throw new Error(`${description} refused a redirected response.`);
     if (controller.signal.aborted)
       throw Object.assign(new Error("Usage query aborted."), { name: "AbortError" });
     const text = await readBoundedResponse(
       response,
       response.ok ? MAX_SUCCESS_BODY_BYTES : MAX_ERROR_BODY_BYTES,
       !response.ok,
-      description
+      description,
+      controller.signal
     );
     if (controller.signal.aborted)
       throw Object.assign(new Error("Usage query aborted."), { name: "AbortError" });
@@ -908,12 +1514,15 @@ async function fetchProviderJson(url, auth, signal, timeoutMs, description, requ
     signal.removeEventListener("abort", abortFromCaller);
   }
 }
-async function readBoundedResponse(response, maxBytes, truncateOverflow, description) {
+async function readBoundedResponse(response, maxBytes, truncateOverflow, description, signal) {
   if (!response.body) return "";
   const reader = response.body.getReader();
   const chunks = [];
   let total = 0;
   let truncated = false;
+  const abort = () => void reader.cancel().catch(() => void 0);
+  if (signal.aborted) abort();
+  else signal.addEventListener("abort", abort, { once: true });
   try {
     while (true) {
       const { done, value } = await reader.read();
@@ -930,6 +1539,7 @@ async function readBoundedResponse(response, maxBytes, truncateOverflow, descrip
       total += value.byteLength;
     }
   } finally {
+    signal.removeEventListener("abort", abort);
     reader.releaseLock();
   }
   if (truncated && !truncateOverflow) {
@@ -944,6 +1554,59 @@ async function readBoundedResponse(response, maxBytes, truncateOverflow, descrip
   const text = new TextDecoder().decode(body);
   return truncated ? `${text}\u2026` : text;
 }
+function resolveXaiUsageAuth(auth, model, salt, candidates) {
+  const resolvedAccess = bearerToken(headerValue(auth.headers, "Authorization")) ?? auth.apiKey;
+  if (!resolvedAccess) throw new Error("xAI runtime authentication was incomplete.");
+  let sawOAuth = false;
+  let sawMatchingAccess = false;
+  let sawIncompleteMatch = false;
+  const matches = [];
+  for (const candidate of candidates) {
+    try {
+      const credential = asObject7(candidate);
+      if (credential?.type !== "oauth") continue;
+      sawOAuth = true;
+      if (credential.access !== resolvedAccess) continue;
+      sawMatchingAccess = true;
+      if (typeof credential.access !== "string" || !credential.access || typeof credential.refresh !== "string" || !credential.refresh || typeof credential.expires !== "number" || !Number.isFinite(credential.expires)) {
+        sawIncompleteMatch = true;
+        continue;
+      }
+      matches.push({ access: credential.access, refresh: credential.refresh });
+    } catch {
+    }
+  }
+  if (sawIncompleteMatch) throw new Error("The matching xAI OAuth credential was incomplete.");
+  if (matches.length > 1) {
+    throw new Error("Multiple OAuth credentials match the active xAI runtime account.");
+  }
+  const match = matches[0];
+  if (!match) {
+    if (!sawOAuth) {
+      throw new Error(
+        "xAI consumer usage requires the OAuth subscription account configured through Pi /login; XAI_API_KEY users can review API spend at console.x.ai."
+      );
+    }
+    if (sawMatchingAccess) throw new Error("The matching xAI OAuth credential was incomplete.");
+    throw new Error("The active xAI runtime account does not match Pi's stored OAuth account.");
+  }
+  const authorization = `Bearer ${match.access}`;
+  const headers = { Authorization: authorization };
+  return {
+    apiKey: match.access,
+    headers,
+    fingerprint: fingerprintResolvedAuth({ headers }, salt),
+    secrets: [
+      match.access,
+      match.refresh,
+      resolvedAccess,
+      auth.apiKey,
+      headerValue(auth.headers, "Authorization"),
+      authorization
+    ].filter((value) => Boolean(value)),
+    model
+  };
+}
 function resolveGitHubCopilotUsageAuth(auth, model, salt, candidates, standaloneFallback) {
   const resolvedAccess = bearerToken(headerValue(auth.headers, "Authorization")) ?? auth.apiKey;
   if (!resolvedAccess) throw new Error("GitHub Copilot OAuth credentials were incomplete.");
@@ -954,7 +1617,7 @@ function resolveGitHubCopilotUsageAuth(auth, model, salt, candidates, standalone
   const matches = /* @__PURE__ */ new Map();
   for (const candidate of candidates) {
     try {
-      const credential = asObject5(candidate);
+      const credential = asObject7(candidate);
       if (credential?.type !== "oauth") continue;
       sawOAuth = true;
       const storedAccess2 = typeof credential.access === "string" && credential.access ? credential.access : void 0;
@@ -1016,7 +1679,7 @@ function bearerToken(authorization) {
   const match = /^Bearer\s+(.+)$/iu.exec(authorization ?? "");
   return match?.[1];
 }
-function asObject5(value) {
+function asObject7(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
   return value;
 }
@@ -1037,6 +1700,10 @@ function hasOfficialUrlOrigin(value, providerId) {
     if (providerId === "openai-codex") return url.origin === "https://chatgpt.com";
     if (providerId === "openrouter") return url.origin === "https://openrouter.ai";
     if (providerId === "opencode-go") return url.origin === "https://opencode.ai";
+    if (providerId === "kimi-coding") return url.origin === "https://api.kimi.com";
+    if (providerId === "xai") return url.origin === "https://api.x.ai";
+    if (providerId === "zai") return url.origin === "https://api.z.ai";
+    if (providerId === "zai-coding-cn") return url.origin === "https://open.bigmodel.cn";
     if (providerId === "github-copilot") {
       return url.protocol === "https:" && /^api\.[a-z0-9-]+\.githubcopilot\.com$/u.test(url.hostname);
     }
@@ -1054,6 +1721,28 @@ function headerValue(headers, name) {
 function hasHeader(headers, name) {
   return Object.keys(headers).some((key) => key.toLowerCase() === name.toLowerCase());
 }
+function validatedXaiUserId(value) {
+  if (typeof value !== "string" || !/^[A-Za-z0-9._~-]{1,128}$/u.test(value)) {
+    throw new Error("xAI consumer identity returned an unsafe canonical user ID.");
+  }
+  return value;
+}
+function remainingTimeout(timeoutMs, startedAt) {
+  const remaining = timeoutMs - (Date.now() - startedAt);
+  if (remaining <= 0) throw new Error("Timed out while fetching xAI consumer usage.");
+  return remaining;
+}
+function zaiMonitorUrl(baseUrl) {
+  const base = baseUrl?.trim();
+  if (!base) throw new Error("Z.AI model base URL is unavailable.");
+  return `${new URL(base).origin}/api/monitor/usage/quota/limit`;
+}
+function zaiMonitorAuth(auth) {
+  const authorization = headerValue(auth.headers, "Authorization");
+  const token = authorization === void 0 ? void 0 : bearerToken(authorization) ?? authorization;
+  if (token === void 0 || token === authorization) return auth;
+  return { ...auth, headers: { ...auth.headers, Authorization: token } };
+}
 function isAbortError(error) {
   return error instanceof Error && error.name === "AbortError";
 }
@@ -1196,7 +1885,7 @@ function normalizeCodexResetCreditsPayload(payload) {
   if (rawCredits !== void 0 && !Array.isArray(rawCredits)) {
     throw new Error("Codex reset credits response returned invalid credits.");
   }
-  const options = (rawCredits ?? []).map(asObject6).filter((credit) => Boolean(credit)).filter((credit) => credit.status === "available" && credit.reset_type === "codex_rate_limits").map(normalizeResetOption).sort(
+  const options = (rawCredits ?? []).map(asObject8).filter((credit) => Boolean(credit)).filter((credit) => credit.status === "available" && credit.reset_type === "codex_rate_limits").map(normalizeResetOption).sort(
     (left, right) => (left.expiresAt ?? Number.MAX_SAFE_INTEGER) - (right.expiresAt ?? Number.MAX_SAFE_INTEGER)
   ).slice(0, Math.min(availableCount, MAX_RESET_OPTIONS));
   if (availableCount > 0 && options.length === 0) {
@@ -1211,7 +1900,7 @@ function selectCodexResetCredential(candidates, resolvedAccess, resolvedAccountI
   const matches = /* @__PURE__ */ new Map();
   for (const candidate of candidates) {
     try {
-      const credential = asObject6(candidate);
+      const credential = asObject8(candidate);
       if (credential?.type !== "oauth") continue;
       sawOAuth = true;
       const storedAccess = asNonemptyString(credential.access);
@@ -1250,7 +1939,7 @@ function codexAccountIdFromAccessToken(access) {
     const parts = access.split(".");
     if (parts.length !== 3 || !parts[1]) return void 0;
     const payload = JSON.parse(Buffer.from(parts[1], "base64url").toString("utf8"));
-    const claims = asObject6(asObject6(payload)?.["https://api.openai.com/auth"]);
+    const claims = asObject8(asObject8(payload)?.["https://api.openai.com/auth"]);
     return validHeaderValue(claims?.chatgpt_account_id);
   } catch {
     return void 0;
@@ -1282,7 +1971,7 @@ function normalizeResetOption(credit) {
 function isCodexResetOutcomeCode(value) {
   return value === "reset" || value === "nothing_to_reset" || value === "no_credit" || value === "already_redeemed";
 }
-function asObject6(value) {
+function asObject8(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
   return value;
 }
@@ -1330,7 +2019,11 @@ function formatUsageReport(report, displayState) {
   else if (report.providerId === "github-copilot") formatGitHubCopilotReport(lines, report);
   else if (report.providerId === "openrouter") formatOpenRouterReport(lines, report);
   else if (report.providerId === "opencode-go") formatOpenCodeZenReport(lines, report);
-  else formatGenericReport(lines, report);
+  else if (report.providerId === "kimi-coding") formatKimiCodingReport(lines, report);
+  else if (report.providerId === "xai") formatXaiReport(lines, report);
+  else if (report.providerId === "zai" || report.providerId === "zai-coding-cn") {
+    formatZaiReport(lines, report);
+  } else formatGenericReport(lines, report);
   if (report.notes) {
     for (const note of report.notes) lines.push(note);
   }
@@ -1346,6 +2039,7 @@ function formatUsageStatusline(report, model) {
     if (typeof total?.value === "number") return `openrouter ${formatUsd(total.value)} used`;
   }
   if (report.providerId === "opencode-go") return formatOpenCodeZenStatusline(report);
+  if (report.providerId === "kimi-coding") return formatKimiCodingStatusline(report);
   return void 0;
 }
 function formatProviderStates(states) {
@@ -1417,7 +2111,7 @@ function compactGitHubCopilotQuotaKind(bucket) {
 }
 function percentRemaining(bucket) {
   if (!bucket.limit || bucket.remaining === void 0) return 0;
-  return Math.round(clampPercent3(bucket.remaining / bucket.limit * 100));
+  return Math.round(clampPercent4(bucket.remaining / bucket.limit * 100));
 }
 function formatOpenRouterReport(lines, report) {
   const limit = report.buckets.find((bucket) => bucket.id === "key-limit");
@@ -1444,10 +2138,114 @@ function formatOpenCodeZenStatusline(report) {
   for (const bucket of report.buckets) {
     if (bucket.used === void 0) continue;
     const compact = bucket.id === "rolling" ? "r" : bucket.id === "weekly" ? "w" : "m";
-    parts.push(`${clampPercent3(bucket.used).toFixed(0)}% ${compact}`);
+    parts.push(`${clampPercent4(bucket.used).toFixed(0)}% ${compact}`);
+  }
+  return parts.length > 1 ? parts.join(" ") : void 0;
+}
+function formatKimiCodingReport(lines, report) {
+  for (const bucket of report.buckets) {
+    const reset = bucket.resetsAt ? ` (resets ${formatReset(bucket.resetsAt)})` : "";
+    if (bucket.used === void 0 || bucket.limit === void 0) {
+      lines.push(`${`${bucket.label}:`.padEnd(VALUE_COLUMN)}unavailable${reset}`);
+      continue;
+    }
+    lines.push(
+      `${`${bucket.label}:`.padEnd(VALUE_COLUMN)}${bucket.used} of ${bucket.limit} used \xB7 ${percentRemaining(bucket)}% left${reset}`
+    );
+  }
+  const balance = report.metrics.find((metric) => metric.id === "booster-balance");
+  const total = report.metrics.find((metric) => metric.id === "booster-total");
+  const monthlyUsed = report.metrics.find((metric) => metric.id === "booster-monthly-used");
+  const monthlyLimit = report.metrics.find((metric) => metric.id === "booster-monthly-limit");
+  if (!balance && !monthlyUsed && !monthlyLimit) return;
+  lines.push("", "Extra usage wallet:");
+  if (balance) {
+    const totalSuffix = total ? ` of ${formatCurrencyMetric(total)}` : "";
+    lines.push(`${"Balance:".padEnd(VALUE_COLUMN)}${formatCurrencyMetric(balance)}${totalSuffix}`);
+  }
+  if (monthlyUsed) {
+    lines.push(`${"Used this month:".padEnd(VALUE_COLUMN)}${formatCurrencyMetric(monthlyUsed)}`);
+  }
+  if (monthlyLimit) {
+    lines.push(`${"Monthly limit:".padEnd(VALUE_COLUMN)}${formatCurrencyMetric(monthlyLimit)}`);
+  }
+}
+function formatKimiCodingStatusline(report) {
+  const fiveHour = report.buckets.find((bucket) => bucket.id === "five-hour");
+  const weekly = report.buckets.find((bucket) => bucket.id === "weekly");
+  const subWindow = fiveHour ?? report.buckets.find((bucket) => bucket.id !== "weekly");
+  const selected = [subWindow, weekly].filter(
+    (bucket, index, buckets) => bucket !== void 0 && buckets.indexOf(bucket) === index
+  );
+  const parts = ["kimi"];
+  for (const bucket of selected) {
+    if (!bucket.limit || bucket.remaining === void 0) continue;
+    const fallback = bucket.id === "weekly" ? "weekly" : "5h";
+    parts.push(
+      `${percentRemaining(bucket)}% ${formatWindowLabel(bucket.windowMinutes, fallback, true)}`
+    );
   }
   return parts.length > 1 ? parts.join(" ") : void 0;
 }
+function formatCurrencyMetric(metric) {
+  if (typeof metric.value !== "number") return String(metric.value);
+  if (!metric.currency) return "unavailable";
+  if (metric.currency === "USD") return `$${metric.value.toFixed(2)}`;
+  if (metric.currency === "CNY") return `\xA5${metric.value.toFixed(2)}`;
+  return `${metric.value.toFixed(2)} ${metric.currency}`;
+}
+function formatXaiReport(lines, report) {
+  const included = report.buckets.find((bucket) => bucket.id === "included-allowance");
+  if (included) {
+    let value = "unavailable";
+    if (included.unit === "percent" && included.used !== void 0) {
+      value = `${included.used}% used`;
+      if (included.remaining !== void 0) value += ` \xB7 ${included.remaining}% left`;
+    } else if (included.used !== void 0) {
+      value = `${formatUsd(included.used)} used`;
+      if (included.limit !== void 0) value += ` of ${formatUsd(included.limit)}`;
+    } else if (included.limit !== void 0) {
+      value = `usage unavailable \xB7 ${formatUsd(included.limit)} limit`;
+    }
+    const period = included.period ? ` \xB7 ${included.period}` : "";
+    const reset = included.resetsAt ? ` (resets ${formatReset(included.resetsAt)})` : "";
+    lines.push(`${"Included allowance:".padEnd(VALUE_COLUMN)}${value}${period}${reset}`);
+  }
+  const onDemand = report.buckets.find((bucket) => bucket.id === "on-demand");
+  if (onDemand) {
+    let value = onDemand.used === void 0 ? "usage unavailable" : `${formatUsd(onDemand.used)} used`;
+    if (onDemand.limit !== void 0) value += ` of ${formatUsd(onDemand.limit)} cap`;
+    lines.push(`${"On-demand usage:".padEnd(VALUE_COLUMN)}${value}`);
+  }
+  for (const metric of report.metrics) {
+    lines.push(
+      `${`${metric.label}:`.padEnd(VALUE_COLUMN)}${formatMetricValue(metric.value, metric.unit)}`
+    );
+  }
+}
+function formatZaiReport(lines, report) {
+  for (const bucket of report.buckets) {
+    const reset = bucket.resetsAt ? ` (resets ${formatReset(bucket.resetsAt)})` : "";
+    let value = "unavailable";
+    if (bucket.unit === "percent" && bucket.used !== void 0) {
+      value = `${bucket.used}% used`;
+      if (bucket.remaining !== void 0) value += ` \xB7 ${bucket.remaining}% left`;
+    } else if (bucket.used !== void 0 && bucket.limit !== void 0) {
+      value = `${bucket.used} of ${bucket.limit} used`;
+      if (bucket.remaining !== void 0) value += ` \xB7 ${bucket.remaining} left`;
+    } else if (bucket.used !== void 0) {
+      value = `${bucket.used} used`;
+    } else if (bucket.remaining !== void 0) {
+      value = `${bucket.remaining} left`;
+    }
+    lines.push(`${`${bucket.label}:`.padEnd(VALUE_COLUMN)}${value}${reset}`);
+  }
+  for (const metric of report.metrics) {
+    lines.push(
+      `${`${metric.label}:`.padEnd(VALUE_COLUMN)}${formatMetricValue(metric.value, metric.unit)}`
+    );
+  }
+}
 function formatGenericReport(lines, report) {
   for (const bucket of report.buckets) {
     lines.push(
@@ -1472,7 +2270,7 @@ function formatCodexStatusline(report, model) {
     if (bucket.remaining === void 0) continue;
     const fallback = bucket.id.endsWith(":secondary") ? "weekly" : "5h";
     parts.push(
-      `${clampPercent3(bucket.remaining).toFixed(0)}% ${formatWindowLabel(bucket.windowMinutes, fallback, true)}`
+      `${clampPercent4(bucket.remaining).toFixed(0)}% ${formatWindowLabel(bucket.windowMinutes, fallback, true)}`
     );
   }
   return parts.length > 1 ? parts.join(" ") : formatCodexCreditsStatus(report);
@@ -1539,7 +2337,7 @@ function compactLimitLabel(label) {
   return (suffix || normalized).toLowerCase().replace(/\s+/g, " ");
 }
 function formatPercentBucket(bucket) {
-  const remaining = clampPercent3(bucket.remaining ?? 0);
+  const remaining = clampPercent4(bucket.remaining ?? 0);
   const filled = Math.round(remaining / 100 * BAR_SEGMENTS);
   const reset = bucket.resetsAt ? ` (resets ${formatReset(bucket.resetsAt)})` : "";
   return `[${"\u2588".repeat(filled)}${"\u2591".repeat(BAR_SEGMENTS - filled)}] ${remaining.toFixed(0)}% left${reset}`;
@@ -1572,7 +2370,7 @@ function formatReset(epochSeconds) {
 function capitalize(value) {
   return `${value[0]?.toUpperCase() ?? ""}${value.slice(1)}`;
 }
-function clampPercent3(value) {
+function clampPercent4(value) {
   return Math.min(100, Math.max(0, value));
 }
 
@@ -1585,18 +2383,23 @@ import { getAgentDir } from "@earendil-works/pi-coding-agent";
 var USAGE_SETTINGS_FILE = "pi-usage.json";
 var MAX_USAGE_SETTINGS_BYTES = 64 * 1024;
 var DEFAULT_USAGE_SETTINGS = Object.freeze({
-  codexFastMode: false
+  codexFastMode: false,
+  xaiUsage: true
 });
 function usageSettingsPath() {
   return join(getAgentDir(), USAGE_SETTINGS_FILE);
 }
 function normalizeUsageSettings(value) {
-  if (!isRecord2(value)) return void 0;
+  if (!isRecord3(value)) return void 0;
   if (Object.hasOwn(value, "codexFastMode") && typeof value.codexFastMode !== "boolean") {
     return void 0;
   }
+  if (Object.hasOwn(value, "xaiUsage") && typeof value.xaiUsage !== "boolean") {
+    return void 0;
+  }
   return {
-    codexFastMode: typeof value.codexFastMode === "boolean" ? value.codexFastMode : DEFAULT_USAGE_SETTINGS.codexFastMode
+    codexFastMode: typeof value.codexFastMode === "boolean" ? value.codexFastMode : DEFAULT_USAGE_SETTINGS.codexFastMode,
+    xaiUsage: typeof value.xaiUsage === "boolean" ? value.xaiUsage : DEFAULT_USAGE_SETTINGS.xaiUsage
   };
 }
 async function loadUsageSettings(path = usageSettingsPath(), signal) {
@@ -1618,7 +2421,7 @@ async function loadUsageSettings(path = usageSettingsPath(), signal) {
     throwIfAborted(signal);
     const document = JSON.parse(text);
     const settings = normalizeUsageSettings(document);
-    if (!settings || !isRecord2(document)) throw new Error("invalid settings shape");
+    if (!settings || !isRecord3(document)) throw new Error("invalid settings shape");
     return { kind: "loaded", path, settings, document };
   } catch (error) {
     if (signal?.aborted) throw error;
@@ -1713,7 +2516,7 @@ async function chmodPrivate(path) {
 function throwIfAborted(signal) {
   if (signal?.aborted) throw new DOMException("Settings operation aborted", "AbortError");
 }
-function isRecord2(value) {
+function isRecord3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function isNodeError(error) {
@@ -1822,7 +2625,7 @@ function registerCodexFastMode(pi, settingsRuntime, refreshStatus) {
     const key = activeRequestKey(ctx);
     if (key && ctx.model) {
       pendingFastRequests.set(key, {
-        fastRequested: isRecord3(rewritten) && rewritten.service_tier === "priority",
+        fastRequested: isRecord4(rewritten) && rewritten.service_tier === "priority",
         model: ctx.model
       });
     }
@@ -1862,7 +2665,7 @@ function activeRequestKey(ctx) {
   return model ? `${ctx.sessionManager.getSessionId()}:${model.provider}/${model.id}` : void 0;
 }
 function consumeFastRequest(ctx, message, pending) {
-  if (!isRecord3(message) || message.role !== "assistant") return NO_FAST_REQUEST;
+  if (!isRecord4(message) || message.role !== "assistant") return NO_FAST_REQUEST;
   const key = messageRequestKey(ctx, message);
   if (!key) return NO_FAST_REQUEST;
   const request = pending.get(key);
@@ -1873,7 +2676,7 @@ function messageRequestKey(ctx, message) {
   if (typeof message.provider !== "string" || typeof message.model !== "string") return void 0;
   return `${ctx.sessionManager.getSessionId()}:${message.provider}/${message.model}`;
 }
-function isRecord3(value) {
+function isRecord4(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function isAbortError2(error) {
@@ -1881,8 +2684,8 @@ function isAbortError2(error) {
 }
 
 // src/usage-helpers.ts
-function configuredAdapters(ctx) {
-  return SUPPORTED_ADAPTERS.filter(
+function configuredAdapters(ctx, xaiUsage = true) {
+  return usageAdapters(xaiUsage).filter(
     (adapter) => adapter.id === ctx.model?.provider || providerIsConfigured(ctx, adapter.id)
   );
 }
@@ -1912,6 +2715,118 @@ function isTimeoutError(error) {
   return error instanceof Error && error.name === "TimeoutError";
 }
 
+// src/usage-settings-ui.ts
+import {
+  getSettingsListTheme
+} from "@earendil-works/pi-coding-agent";
+import {
+  Container,
+  Key,
+  matchesKey,
+  SettingsList,
+  Text
+} from "@earendil-works/pi-tui";
+var OFF = "Off";
+var ON = "On";
+async function showUsageSettings(ctx, settingsRuntime, parentSignal, isCurrent, onApplied) {
+  if (ctx.mode !== "tui") {
+    if (ctx.hasUI) ctx.ui.notify(`Edit settings manually: ${settingsRuntime.get().path}`, "info");
+    return false;
+  }
+  if (parentSignal.aborted || !isCurrent()) return false;
+  return ctx.ui.custom((tui, theme, _keybindings, done) => {
+    const localController = new AbortController();
+    const signal = AbortSignal.any([parentSignal, localController.signal]);
+    let changed = false;
+    let closing = false;
+    let saveQueue = Promise.resolve();
+    const state = settingsRuntime.get();
+    const items = [
+      {
+        id: "codexFastMode",
+        label: "Codex Fast mode",
+        description: "Use faster Codex routing at increased plan allowance consumption.",
+        currentValue: state.settings.codexFastMode ? ON : OFF,
+        values: [OFF, ON]
+      },
+      {
+        id: "xaiUsage",
+        label: "xAI usage",
+        description: "Report OAuth subscription allowance and credits.",
+        currentValue: state.kind !== "invalid" && state.settings.xaiUsage ? ON : OFF,
+        values: [OFF, ON]
+      }
+    ];
+    const container = new Container();
+    container.addChild(new Text(theme.fg("accent", theme.bold("pi-usage Settings")), 1, 1));
+    let settingsList;
+    const cancel = () => {
+      if (closing) return;
+      closing = true;
+      localController.abort();
+      done(changed);
+    };
+    settingsList = new SettingsList(
+      items,
+      items.length + 2,
+      getSettingsListTheme(),
+      (id, value) => {
+        if (closing || signal.aborted || !isCurrent()) return;
+        const settingId = id;
+        const requested = value !== OFF;
+        saveQueue = saveQueue.then(async () => {
+          const previous = settingsRuntime.get().settings[settingId];
+          if (settingsRuntime.get().kind === "invalid") {
+            const effectivePrevious = settingId === "xaiUsage" ? false : previous;
+            settingsList.updateValue(id, displayValue(settingId, effectivePrevious));
+            if (!signal.aborted && isCurrent()) {
+              ctx.ui.notify("Repair pi-usage.json and reload before changing settings.", "error");
+              tui.requestRender();
+            }
+            return;
+          }
+          try {
+            await settingsRuntime.update({ [settingId]: requested }, signal);
+          } catch (error) {
+            if (signal.aborted || !isCurrent()) return;
+            settingsList.updateValue(id, displayValue(settingId, previous));
+            ctx.ui.notify(`Could not save pi-usage.json: ${errorMessage(error)}`, "error");
+            tui.requestRender();
+            return;
+          }
+          if (previous !== requested) {
+            changed = true;
+            onApplied(settingId, previous, requested);
+          }
+          if (signal.aborted || !isCurrent()) return;
+          settingsList.updateValue(id, displayValue(settingId, requested));
+          tui.requestRender();
+        });
+      },
+      cancel
+    );
+    container.addChild(settingsList);
+    parentSignal.addEventListener("abort", cancel, { once: true });
+    return {
+      render: (width) => container.render(width),
+      invalidate: () => container.invalidate(),
+      handleInput(data) {
+        if (closing) return;
+        if (matchesKey(data, Key.ctrl("c"))) cancel();
+        else settingsList.handleInput(data);
+        tui.requestRender();
+      },
+      dispose() {
+        localController.abort();
+        parentSignal.removeEventListener("abort", cancel);
+      }
+    };
+  });
+}
+function displayValue(_id, enabled) {
+  return enabled ? ON : OFF;
+}
+
 // src/usage.ts
 var CACHE_TTL_MS = 5 * 60 * 1e3;
 var DEFAULT_TIMEOUT_MS = 15e3;
@@ -1923,6 +2838,7 @@ var REFRESH_CURRENT = "Refresh current usage";
 var VIEW_ANOTHER = "View another configured provider\u2026";
 var VIEW_ALL = "View all configured providers\u2026";
 var CLOSE = "Close";
+var SETTINGS = "Settings";
 var REDEEM_CODEX_RESET = "Redeem usage limit reset\u2026";
 function usageExtension(pi, dependencies = {}) {
   const credentialReader = dependencies.credentialReader;
@@ -1937,9 +2853,16 @@ function usageExtension(pi, dependencies = {}) {
   let activeCurrentIdentity;
   let sessionActive = false;
   let statusGeneration = 0;
+  let sessionGeneration = 0;
+  let xaiSettingsGeneration = 0;
   let statusRefreshTimer;
   let statusController;
   let fastRuntime;
+  const xaiUsageEnabled = () => {
+    const state = settingsRuntime.get();
+    return state.kind !== "invalid" && state.settings.xaiUsage;
+  };
+  const activeAdapterForProvider = (providerId) => adapterForProvider(providerId, xaiUsageEnabled());
   const clearStatusTimer = () => {
     if (statusRefreshTimer) clearTimeout(statusRefreshTimer);
     statusRefreshTimer = void 0;
@@ -1971,6 +2894,11 @@ function usageExtension(pi, dependencies = {}) {
     statusRefreshTimer.unref?.();
   };
   const publishStatus = (ctx, outcome, model, shouldSchedule) => {
+    if (activeAdapterForProvider(model.provider)?.publishesStatusline === false) {
+      clearStatusTimer();
+      safeSetStatus(ctx, void 0);
+      return;
+    }
     if (outcome.state.status === "unsupported") {
       clearStatusTimer();
       safeSetStatus(ctx, void 0);
@@ -2012,6 +2940,10 @@ function usageExtension(pi, dependencies = {}) {
   };
   const queryAdapterState = async (ctx, adapter, displayState, force, signal) => {
     const startedAt = Date.now();
+    const expectedSessionGeneration = sessionGeneration;
+    const expectedXaiSettingsGeneration = xaiSettingsGeneration;
+    const expectedSessionId = ctx.sessionManager.getSessionId();
+    const expectedModelIdentity = modelIdentity(ctx.model);
     let auth;
     try {
       auth = await awaitWithDeadline(
@@ -2035,6 +2967,9 @@ function usageExtension(pi, dependencies = {}) {
         }
       };
     }
+    if (adapter.id === "xai" && (expectedSessionGeneration !== sessionGeneration || expectedXaiSettingsGeneration !== xaiSettingsGeneration || !xaiUsageEnabled() || ctx.sessionManager.getSessionId() !== expectedSessionId || modelIdentity(ctx.model) !== expectedModelIdentity)) {
+      throw abortError();
+    }
     if (!auth) {
       if (displayState === "current") {
         transitionCurrentIdentity(`${adapter.id}:unavailable`, adapter.id);
@@ -2086,7 +3021,22 @@ function usageExtension(pi, dependencies = {}) {
     setBoundedMap(latestQueries, failureKey, queryId, MAX_ACCOUNT_STATES);
     try {
       const remainingMs = Math.max(1, DEFAULT_TIMEOUT_MS - (Date.now() - startedAt));
-      const report = await queryProviderUsage(adapter, auth, signal, remainingMs);
+      const guard = adapter.id === "xai" ? async () => {
+        if (signal.aborted || expectedSessionGeneration !== sessionGeneration || expectedXaiSettingsGeneration !== xaiSettingsGeneration || !xaiUsageEnabled() || ctx.sessionManager.getSessionId() !== expectedSessionId || modelIdentity(ctx.model) !== expectedModelIdentity) {
+          throw abortError();
+        }
+        const revalidated = await awaitWithDeadline(
+          resolveUsageAuth(ctx, adapter, void 0, credentialReader, credentialCandidates),
+          signal,
+          Math.max(1, DEFAULT_TIMEOUT_MS - (Date.now() - startedAt)),
+          "revalidating xAI runtime auth"
+        );
+        if (signal.aborted || expectedSessionGeneration !== sessionGeneration || expectedXaiSettingsGeneration !== xaiSettingsGeneration || !xaiUsageEnabled() || ctx.sessionManager.getSessionId() !== expectedSessionId || modelIdentity(ctx.model) !== expectedModelIdentity || revalidated?.fingerprint !== auth.fingerprint) {
+          throw abortError();
+        }
+      } : void 0;
+      const report = await queryProviderUsage(adapter, auth, signal, remainingMs, guard);
+      if (guard) await guard();
       if (latestQueries.get(failureKey) === queryId) {
         cache.set(adapter.id, auth.fingerprint, report);
         failureBackoff.delete(failureKey);
@@ -2129,7 +3079,7 @@ function usageExtension(pi, dependencies = {}) {
     }
   };
   const queryCurrentState = async (ctx, model, force, signal) => {
-    const adapter = adapterForProvider(model?.provider);
+    const adapter = activeAdapterForProvider(model?.provider);
     if (!adapter) {
       const providerId = model?.provider ?? "none";
       transitionCurrentIdentity(`unsupported:${providerId}`, providerId);
@@ -2139,20 +3089,24 @@ function usageExtension(pi, dependencies = {}) {
           providerName: providerDisplayName(ctx, providerId),
           displayState: "current",
           status: "unsupported",
-          message: model ? `Usage reporting is not supported for ${providerDisplayName(ctx, providerId)}.` : "No model is selected."
+          message: providerId === "xai" && !xaiUsageEnabled() ? "xAI usage is disabled. Open Settings to enable it." : model ? `Usage reporting is not supported for ${providerDisplayName(ctx, providerId)}.` : "No model is selected."
         }
       };
     }
     return queryAdapterState(ctx, adapter, "current", force, signal);
   };
   const refreshCurrentStatus = async (ctx, model, force) => {
-    const adapter = adapterForProvider(model?.provider);
+    const adapter = activeAdapterForProvider(model?.provider);
     if (!adapter || !model) {
       const providerId = model?.provider ?? "none";
       transitionCurrentIdentity(`unsupported:${providerId}`, providerId);
       clearStatus(ctx);
       return;
     }
+    if (adapter.publishesStatusline === false) {
+      clearStatus(ctx);
+      return;
+    }
     statusGeneration += 1;
     const generation = statusGeneration;
     statusController?.abort();
@@ -2205,7 +3159,7 @@ function usageExtension(pi, dependencies = {}) {
     if (generation !== statusGeneration || modelIdentity(ctx.model) !== modelIdentity(model)) {
       return false;
     }
-    const adapter = adapterForProvider(model?.provider);
+    const adapter = activeAdapterForProvider(model?.provider);
     if (outcome.authState === "unavailable") {
       if (!adapter) return false;
       try {
@@ -2300,6 +3254,7 @@ function usageExtension(pi, dependencies = {}) {
               lines: [...formatProviderStates(visibleStates).split("\n"), ...fastLines],
               items: [
                 { id: "refresh", label: REFRESH_CURRENT, action: "refresh" },
+                { id: "settings", label: SETTINGS, action: "settings" },
                 ...fastAvailability.kind === "available" ? [
                   {
                     id: "toggle-fast",
@@ -2328,7 +3283,7 @@ function usageExtension(pi, dependencies = {}) {
           providers: () => ({
             kind: "actions",
             title: "Select a configured provider",
-            items: configuredAdapters(ctx).filter((adapter) => adapter.id !== ctx.model?.provider).map((adapter) => ({
+            items: configuredAdapters(ctx, xaiUsageEnabled()).filter((adapter) => adapter.id !== ctx.model?.provider).map((adapter) => ({
               id: adapter.id,
               label: adapter.displayName,
               action: "provider"
@@ -2392,6 +3347,37 @@ function usageExtension(pi, dependencies = {}) {
           })
         },
         actions: {
+          settings: async () => {
+            await showUsageSettings(
+              ctx,
+              settingsRuntime,
+              controller.signal,
+              () => statusGeneration === menuGeneration && !controller.signal.aborted,
+              (id, _previous, next) => {
+                if (id !== "xaiUsage") return;
+                xaiSettingsGeneration += 1;
+                invalidateProviderState("xai");
+                if (!next) {
+                  for (const active of activeControllers) {
+                    if (active !== controller) active.abort();
+                  }
+                }
+              }
+            );
+            fastState = settingsRuntime.get();
+            const revalidated = await queryStableCurrent(
+              ctx,
+              false,
+              controller,
+              "Applying usage settings\u2026"
+            );
+            if (!revalidated) return { kind: "stay" };
+            stableCurrent = revalidated;
+            current = revalidated.outcome;
+            visibleStates = [current.state];
+            publishStableCurrent(ctx, revalidated);
+            return { kind: "stay" };
+          },
           "toggle-fast": async () => {
             const availability = fastRuntime.availability(ctx.model);
             if (availability.kind !== "available" || fastState.kind === "invalid") {
@@ -2560,7 +3546,7 @@ function usageExtension(pi, dependencies = {}) {
             return { kind: "stay" };
           },
           another: async () => {
-            const others = configuredAdapters(ctx).filter(
+            const others = configuredAdapters(ctx, xaiUsageEnabled()).filter(
               (adapter) => adapter.id !== ctx.model?.provider
             );
             if (others.length === 0) {
@@ -2570,7 +3556,7 @@ function usageExtension(pi, dependencies = {}) {
             return { kind: "to", screen: "providers" };
           },
           provider: async ({ itemId }) => {
-            const adapter = configuredAdapters(ctx).find(
+            const adapter = configuredAdapters(ctx, xaiUsageEnabled()).find(
               (candidate) => candidate.id === itemId && candidate.id !== ctx.model?.provider
             );
             if (!adapter) return { kind: "back" };
@@ -2596,7 +3582,7 @@ function usageExtension(pi, dependencies = {}) {
             return { kind: "back" };
           },
           all: async () => {
-            const adapters = configuredAdapters(ctx);
+            const adapters = configuredAdapters(ctx, xaiUsageEnabled());
             const currentProviderId = ctx.model?.provider;
             const settled = await runMenuOperation(
               ctx,
@@ -2675,6 +3661,8 @@ function usageExtension(pi, dependencies = {}) {
     }
   });
   pi.on("session_start", (_event, ctx) => {
+    sessionGeneration += 1;
+    xaiSettingsGeneration += 1;
     statusGeneration += 1;
     clearStatusTimer();
     for (const controller of activeControllers) controller.abort();
@@ -2694,6 +3682,8 @@ function usageExtension(pi, dependencies = {}) {
   });
   pi.on("session_shutdown", (_event, ctx) => {
     sessionActive = false;
+    sessionGeneration += 1;
+    xaiSettingsGeneration += 1;
     statusGeneration += 1;
     clearStatusTimer();
     for (const controller of activeControllers) controller.abort();
@@ -2718,6 +3708,7 @@ export {
   DEFAULT_USAGE_SETTINGS,
   SUPPORTED_ADAPTERS,
   UsageCache,
+  XAI_ADAPTER,
   abortError,
   adapterForProvider,
   awaitWithDeadline,
@@ -2740,9 +3731,12 @@ export {
   normalizeCodexBackendPayload,
   normalizeCodexResetCreditsPayload,
   normalizeGitHubCopilotUsagePayload,
+  normalizeKimiCodingUsagePayload,
   normalizeOpenCodeZenPayload,
   normalizeOpenRouterKeyPayload,
   normalizeUsageSettings,
+  normalizeXaiBillingPayload,
+  normalizeZaiQuotaPayload,
   providerIsConfigured,
   queryProviderUsage,
   redactUsageError,
@@ -2751,6 +3745,7 @@ export {
   rewriteCodexFastPayload,
   runWithConcurrency,
   sanitizeDisplayText,
+  usageAdapters,
   usageSettingsPath
 };
 //# sourceMappingURL=index.ts.map