@kairyou/agent-tools 0.4.0 → 0.5.0

package/integrations/usage/lib/cache.mjs

@@ -0,0 +1,110 @@
+// On-disk state under ~/.agent-tools/cache: the last working route per
+// gateway, the latest usage snapshot, and refresh bookkeeping.
+
+import { writeFile, mkdir } from "node:fs/promises";
+import { dirname } from "node:path";
+import {
+  ROUTE_CACHE_PATH,
+  SNAPSHOT_PATH,
+  REFRESH_STATE_PATH,
+  readTextIfExists,
+  debugLog,
+} from "./config.mjs";
+import { usageRouteCacheKey } from "./urls.mjs";
+
+const ROUTE_CACHE_VERSION = 1;
+const SNAPSHOT_VERSION = 1;
+const REFRESH_STATE_VERSION = 1;
+
+export async function readRouteCache() {
+  try {
+    const raw = await readTextIfExists(ROUTE_CACHE_PATH);
+    if (!raw.trim()) return { version: ROUTE_CACHE_VERSION, routes: {} };
+    const parsed = JSON.parse(raw);
+    return {
+      version: ROUTE_CACHE_VERSION,
+      routes: parsed?.routes && typeof parsed.routes === "object" ? parsed.routes : {},
+    };
+  } catch {
+    return { version: ROUTE_CACHE_VERSION, routes: {} };
+  }
+}
+
+export async function rememberUsageRoute(context, route, result) {
+  try {
+    const cache = await readRouteCache();
+    const key = usageRouteCacheKey(context.baseUrl);
+    cache.routes[key] = {
+      route: route.id,
+      path: route.path,
+      source: result.source,
+      updatedAt: new Date().toISOString(),
+    };
+    await mkdir(dirname(ROUTE_CACHE_PATH), { recursive: true });
+    await writeFile(ROUTE_CACHE_PATH, `${JSON.stringify(cache, null, 2)}\n`);
+  } catch (error) {
+    await debugLog({ source: "route-cache", error: error.message });
+  }
+}
+
+async function readSnapshotCache() {
+  try {
+    const raw = await readTextIfExists(SNAPSHOT_PATH);
+    if (!raw.trim()) return { version: SNAPSHOT_VERSION, items: {} };
+    const parsed = JSON.parse(raw);
+    return {
+      version: SNAPSHOT_VERSION,
+      items: parsed?.items && typeof parsed.items === "object" ? parsed.items : {},
+    };
+  } catch {
+    return { version: SNAPSHOT_VERSION, items: {} };
+  }
+}
+
+export async function rememberUsageSnapshot(context, result) {
+  if (!result?.text) return;
+  try {
+    const cache = await readSnapshotCache();
+    const key = usageRouteCacheKey(context.baseUrl);
+    cache.items[key] = {
+      text: result.text,
+      source: result.source,
+      baseUrl: context.baseUrl,
+      updatedAt: new Date().toISOString(),
+    };
+    await mkdir(dirname(SNAPSHOT_PATH), { recursive: true });
+    await writeFile(SNAPSHOT_PATH, `${JSON.stringify(cache, null, 2)}\n`);
+  } catch (error) {
+    await debugLog({ source: "snapshot-cache", error: error.message });
+  }
+}
+
+async function readRefreshState() {
+  try {
+    const raw = await readTextIfExists(REFRESH_STATE_PATH);
+    if (!raw.trim()) return { version: REFRESH_STATE_VERSION, items: {} };
+    const parsed = JSON.parse(raw);
+    return {
+      version: REFRESH_STATE_VERSION,
+      items: parsed?.items && typeof parsed.items === "object" ? parsed.items : {},
+    };
+  } catch {
+    return { version: REFRESH_STATE_VERSION, items: {} };
+  }
+}
+
+export async function rememberRefreshState(context, patch) {
+  try {
+    const state = await readRefreshState();
+    const key = usageRouteCacheKey(context.baseUrl);
+    state.items[key] = {
+      ...(state.items[key] || {}),
+      ...patch,
+      baseUrl: context.baseUrl,
+    };
+    await mkdir(dirname(REFRESH_STATE_PATH), { recursive: true });
+    await writeFile(REFRESH_STATE_PATH, `${JSON.stringify(state, null, 2)}\n`);
+  } catch (error) {
+    await debugLog({ source: "refresh-state", error: error.message });
+  }
+}

package/integrations/usage/lib/config.mjs

@@ -0,0 +1,99 @@
+// Paths, constants, config.jsonc access, and debug logging shared by the
+// usage runtime modules.
+
+import { readFile, writeFile, mkdir } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { homedir } from "node:os";
+import { parse as parseJsonc } from "jsonc-parser";
+
+export const CODEX_HOME = process.env.CODEX_HOME || join(homedir(), ".codex");
+export const AGENT_TOOLS_HOME = process.env.AGENT_TOOLS_HOME || join(homedir(), ".agent-tools");
+export const AUTH_PATH = join(CODEX_HOME, "auth.json");
+export const CODEX_CONFIG_PATH = join(CODEX_HOME, "config.toml");
+export const AGENT_CONFIG_PATH = join(AGENT_TOOLS_HOME, "config.jsonc");
+export const DEBUG_PATH = join(AGENT_TOOLS_HOME, "logs", "usage-debug.log");
+export const ROUTE_CACHE_PATH = join(AGENT_TOOLS_HOME, "cache", "usage-routes.json");
+export const SNAPSHOT_PATH = join(AGENT_TOOLS_HOME, "cache", "usage-snapshot.json");
+export const REFRESH_STATE_PATH = join(AGENT_TOOLS_HOME, "cache", "usage-refresh-state.json");
+export const DEFAULT_USAGE_DAYS = 30;
+export const MAX_USAGE_DAYS = 90;
+export const DEFAULT_NEW_API_QUOTA_SCALE = 500000;
+
+export async function readJson(path) {
+  return JSON.parse(await readFile(path, "utf8"));
+}
+
+export async function readTextIfExists(path) {
+  if (!existsSync(path)) return "";
+  return readFile(path, "utf8");
+}
+
+let agentConfigCache;
+export async function agentConfig() {
+  if (agentConfigCache) return agentConfigCache;
+  try {
+    const raw = await readTextIfExists(AGENT_CONFIG_PATH);
+    if (!raw.trim()) {
+      agentConfigCache = {};
+      return agentConfigCache;
+    }
+    const errors = [];
+    const parsed = parseJsonc(raw.replace(/^\uFEFF/, ""), errors, { allowTrailingComma: true });
+    agentConfigCache = (errors.length === 0 && parsed?.providerUsage) || {};
+  } catch {
+    agentConfigCache = {};
+  }
+  return agentConfigCache;
+}
+
+export async function debugLog(event) {
+  const config = await agentConfig();
+  if (process.env.PROVIDER_USAGE_DEBUG !== "1" && config.debug !== true) return;
+  await mkdir(dirname(DEBUG_PATH), { recursive: true });
+  const line = JSON.stringify({
+    at: new Date().toISOString(),
+    ...event,
+  });
+  await writeFile(DEBUG_PATH, `${line}\n`, { flag: "a" });
+}
+
+export async function providerUsageDays() {
+  const config = await agentConfig();
+  const value = Number(process.env.PROVIDER_USAGE_DAYS || config.days || DEFAULT_USAGE_DAYS);
+  if (!Number.isInteger(value) || value <= 0 || value > MAX_USAGE_DAYS) return DEFAULT_USAGE_DAYS;
+  return value;
+}
+
+export async function usagePreset() {
+  const config = await agentConfig();
+  return String(process.env.PROVIDER_USAGE_PRESET || config.preset || "auto").toLowerCase();
+}
+
+export async function panelUserId() {
+  const config = await agentConfig();
+  const raw = process.env.PROVIDER_USAGE_USER_ID || config.userId || "";
+  const parsed = Number.parseInt(String(raw), 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : null;
+}
+
+export async function panelUserHeaders() {
+  const userId = await panelUserId();
+  if (!userId) return {};
+  const value = String(userId);
+  return {
+    "New-API-User": value,
+    "Veloera-User": value,
+    "voapi-user": value,
+    "User-id": value,
+    "X-User-Id": value,
+    "Rix-Api-User": value,
+    "neo-api-user": value,
+  };
+}
+
+export async function newApiQuotaScale() {
+  const config = await agentConfig();
+  const scale = Number(config.newApiQuotaScale || DEFAULT_NEW_API_QUOTA_SCALE);
+  return Number.isFinite(scale) && scale > 0 ? scale : 0;
+}

package/integrations/usage/lib/context.mjs

@@ -0,0 +1,138 @@
+// Discovers the active relay endpoint and credentials for each agent.
+
+import { existsSync } from "node:fs";
+import {
+  AUTH_PATH,
+  CODEX_CONFIG_PATH,
+  readJson,
+  readTextIfExists,
+} from "./config.mjs";
+
+function stripInlineComment(value) {
+  let inSingle = false;
+  let inDouble = false;
+  for (let i = 0; i < value.length; i += 1) {
+    const char = value[i];
+    const prev = value[i - 1];
+    if (char === "'" && !inDouble) inSingle = !inSingle;
+    if (char === '"' && !inSingle && prev !== "\\") inDouble = !inDouble;
+    if (char === "#" && !inSingle && !inDouble) return value.slice(0, i).trim();
+  }
+  return value.trim();
+}
+
+function parseTomlLite(source) {
+  const root = {};
+  let current = root;
+  for (const rawLine of source.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith("#")) continue;
+
+    const table = line.match(/^\[([^\]]+)\]$/);
+    if (table) {
+      current = root;
+      for (const part of table[1].split(".")) {
+        const key = part.replace(/^['"]|['"]$/g, "");
+        current[key] ||= {};
+        current = current[key];
+      }
+      continue;
+    }
+
+    const eq = line.indexOf("=");
+    if (eq === -1) continue;
+    const key = line.slice(0, eq).trim();
+    const rawValue = stripInlineComment(line.slice(eq + 1));
+    current[key] = parseTomlValue(rawValue);
+  }
+  return root;
+}
+
+function parseTomlValue(value) {
+  if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
+    return value.slice(1, -1);
+  }
+  if (value === "true") return true;
+  if (value === "false") return false;
+  return value;
+}
+
+function activeProvider(config) {
+  const providerName = config.model_provider || "openai";
+  const provider = config.model_providers?.[providerName] || {};
+  return { providerName, provider };
+}
+
+function apiKeyFor(auth, provider) {
+  if (process.env.PROVIDER_USAGE_API_KEY) return process.env.PROVIDER_USAGE_API_KEY;
+  if (process.env.SUB2API_API_KEY) return process.env.SUB2API_API_KEY;
+  if (provider.env_key && process.env[provider.env_key]) return process.env[provider.env_key];
+  if (auth.OPENAI_API_KEY) return auth.OPENAI_API_KEY;
+  if (process.env.OPENAI_API_KEY) return process.env.OPENAI_API_KEY;
+  return "";
+}
+
+function apiKeyForClaude() {
+  return (
+    process.env.PROVIDER_USAGE_API_KEY ||
+    process.env.ANTHROPIC_AUTH_TOKEN ||
+    process.env.ANTHROPIC_API_KEY ||
+    ""
+  );
+}
+
+function providerLabel(providerName, provider) {
+  return String(provider.name || providerName || "API").toUpperCase();
+}
+
+async function contextForCodex() {
+  const auth = existsSync(AUTH_PATH) ? await readJson(AUTH_PATH) : {};
+  const codexConfig = parseTomlLite(await readTextIfExists(CODEX_CONFIG_PATH));
+  const { providerName, provider } = activeProvider(codexConfig);
+  const baseUrl =
+    process.env.PROVIDER_USAGE_BASE_URL ||
+    process.env.SUB2API_BASE_URL ||
+    process.env.OPENAI_BASE_URL ||
+    provider.base_url ||
+    "";
+  const key = apiKeyFor(auth, provider);
+  return {
+    providerName,
+    provider,
+    baseUrl,
+    key,
+    label: providerLabel(providerName, provider),
+  };
+}
+
+function contextForClaude() {
+  const baseUrl =
+    process.env.PROVIDER_USAGE_BASE_URL ||
+    process.env.ANTHROPIC_BASE_URL ||
+    "";
+  return {
+    providerName: "claude",
+    provider: { name: "Claude" },
+    baseUrl,
+    key: apiKeyForClaude(),
+    label: "Claude",
+  };
+}
+
+export async function usageContext(agent) {
+  return agent === "claude" ? contextForClaude() : await contextForCodex();
+}
+
+export function normalizeUsageContext(input) {
+  const providerName = String(input?.providerName || "provider");
+  const provider = input?.provider && typeof input.provider === "object"
+    ? input.provider
+    : { name: providerName };
+  return {
+    providerName,
+    provider,
+    baseUrl: String(input?.baseUrl || ""),
+    key: String(input?.key || ""),
+    label: String(input?.label || provider.name || providerName),
+  };
+}

package/integrations/usage/lib/format.mjs

@@ -0,0 +1,265 @@
+// Turns gateway payloads into the compact one-line usage message.
+
+import { newApiQuotaScale, providerUsageDays, DEFAULT_NEW_API_QUOTA_SCALE } from "./config.mjs";
+
+export function pickNumber(obj, keys) {
+  for (const key of keys) {
+    const value = obj?.[key];
+    if (typeof value === "number" && Number.isFinite(value)) return value;
+    if (typeof value === "string" && value.trim() && Number.isFinite(Number(value))) return Number(value);
+  }
+  return undefined;
+}
+
+export function formatMoney(value) {
+  return `$${value.toFixed(value >= 100 ? 0 : 1)}`;
+}
+
+function formatMaybeMoney(value, unit = "USD") {
+  if (unit === "USD" || unit === "$") return formatMoney(value);
+  return `${value.toLocaleString("en-US", { maximumFractionDigits: 1 })} ${unit}`;
+}
+
+function usageParts() {
+  return ["API"];
+}
+
+async function formatNewApiQuota(value) {
+  const scale = await newApiQuotaScale();
+  if (Number.isFinite(scale) && scale > 0) return formatMoney(value / scale);
+  return value.toLocaleString("en-US", { maximumFractionDigits: 0 });
+}
+
+export function usageRoot(data) {
+  return data?.data && typeof data.data === "object" ? data.data : data;
+}
+
+function shortDate(value) {
+  if (!value) return "";
+  const match = String(value).match(/^(\d{4})-(\d{2})-(\d{2})/);
+  return match ? `${match[2]}-${match[3]}` : "";
+}
+
+function hasSubscriptionLimits(root) {
+  const sub = root?.subscription || {};
+  return [
+    "daily_limit_usd",
+    "weekly_limit_usd",
+    "monthly_limit_usd",
+    "daily_usage_usd",
+    "weekly_usage_usd",
+    "monthly_usage_usd",
+  ].some((key) => pickNumber(sub, [key]) !== undefined);
+}
+
+function isQuotaLimitedUsage(root) {
+  return root?.mode === "quota_limited" || root?.quota;
+}
+
+function isSubscriptionUsage(root) {
+  return hasSubscriptionLimits(root) || (root?.mode === "unrestricted" && root?.subscription);
+}
+
+function isWalletUsage(root) {
+  const planName = String(root?.planName || "");
+  return (
+    (root?.mode === "unrestricted" && !isSubscriptionUsage(root)) ||
+    planName.includes("钱包") ||
+    planName.toLowerCase().includes("wallet") ||
+    (pickNumber(root, ["balance"]) !== undefined && !hasSubscriptionLimits(root))
+  );
+}
+
+export function hasV1UsageFields(root) {
+  return (
+    hasSubscriptionLimits(root) ||
+    pickNumber(root, [
+      "balance",
+      "remaining",
+      "remain",
+      "available",
+      "hard_limit_usd",
+      "hard_limit",
+      "total_granted",
+      "quota",
+      "total_usage",
+      "used",
+      "usage",
+    ]) !== undefined ||
+    pickNumber(root?.quota, ["limit", "quota", "used", "quota_used", "remaining"]) !== undefined ||
+    pickNumber(root?.usage?.today, ["actual_cost", "cost"]) !== undefined ||
+    (Array.isArray(root?.daily_usage) && root.daily_usage.length > 0)
+  );
+}
+
+export async function formatQuota(label, data) {
+  const root = usageRoot(data);
+  const unit = root?.unit || "USD";
+  const remaining = pickNumber(root, ["remaining"]);
+  const hardLimit = pickNumber(root, ["hard_limit_usd", "hard_limit", "total_granted", "quota"]);
+  const used = pickNumber(root, ["total_usage", "used", "usage"]);
+  const balance = pickNumber(root, ["balance", "remaining", "remain", "available"]);
+
+  if (isQuotaLimitedUsage(root)) return formatQuotaLimitedLine(label, root);
+  if (isSubscriptionUsage(root)) return formatUsageLine(label, root);
+  if (isWalletUsage(root)) return await formatWalletLine(label, root);
+  if (remaining !== undefined) return formatUsageLine(label, root);
+  if (balance !== undefined) return `API | balance ${formatMaybeMoney(balance, unit)}`;
+  if (hardLimit !== undefined && used !== undefined) {
+    return `API | remaining ${formatMaybeMoney(Math.max(0, hardLimit - used), unit)}`;
+  }
+  if (hardLimit !== undefined) return `API | total ${formatMaybeMoney(hardLimit, unit)}`;
+
+  const keys = Object.keys(root || {}).slice(0, 4).join(", ");
+  return keys ? `API | received (${keys})` : `API | checked ${unit}`;
+}
+
+export async function formatNewApiTokenLine(label, data) {
+  const root = usageRoot(data);
+  const unlimited = root?.unlimited_quota === true || root?.unlimitedQuota === true;
+  const quota = pickNumber(root, ["quota", "limit", "total_quota", "totalQuota"]);
+  const used = pickNumber(root, ["used_quota", "usedQuota", "used"]);
+  let remaining = pickNumber(root, ["remain_quota", "remainQuota", "remaining", "balance"]);
+  if (remaining === undefined && quota !== undefined && used !== undefined) {
+    remaining = Math.max(0, quota - used);
+  }
+
+  if (!unlimited && quota === undefined && used === undefined && remaining === undefined) {
+    throw new Error("NewAPI token usage payload has no quota fields");
+  }
+
+  const parts = usageParts();
+  if (unlimited) parts.push("unlimited");
+  if (remaining !== undefined) parts.push(`balance ${await formatNewApiQuota(remaining)}`);
+  if (used !== undefined && quota !== undefined) {
+    parts.push(`used ${await formatNewApiQuota(used)}/${await formatNewApiQuota(quota)}`);
+  } else if (used !== undefined) {
+    parts.push(`used ${await formatNewApiQuota(used)}`);
+  }
+  return parts.join(" | ");
+}
+
+export function formatOpenRouterLine(label, data) {
+  const root = usageRoot(data);
+  const limit = pickNumber(root, ["limit", "limit_remaining", "total_credits"]);
+  const remaining = pickNumber(root, ["limit_remaining", "remaining_credits"]);
+  const used = pickNumber(root, ["usage", "total_usage", "spend"]);
+  const reset = root?.limit_reset || root?.reset_at ? shortDate(root.limit_reset || root.reset_at) : "";
+  const parts = usageParts();
+
+  if (remaining !== undefined) parts.push(`balance ${formatMoney(remaining)}`);
+  if (used !== undefined && limit !== undefined && limit !== remaining) {
+    parts.push(`used ${formatMoney(used)}/${formatMoney(limit)}`);
+  } else if (used !== undefined) {
+    parts.push(`used ${formatMoney(used)}`);
+  }
+  if (reset) parts.push(`Reset ${reset}`);
+
+  if (parts.length === 1) throw new Error("OpenRouter payload has no usage fields");
+  return parts.join(" | ");
+}
+
+export function panelQuotaScale(kind) {
+  return kind === "veloera" ? 1000000 : DEFAULT_NEW_API_QUOTA_SCALE;
+}
+
+export function panelQuotaLooksRemaining(kind) {
+  return ["new-api", "anyrouter", "agentrouter", "done-hub", "donehub"].includes(kind);
+}
+
+export async function formatPanelUserSelfLine(label, data, kind) {
+  const root = usageRoot(data);
+  const scale = panelQuotaScale(kind);
+  const quota = pickNumber(root, ["quota"]);
+  const used = pickNumber(root, ["used_quota", "usedQuota"]);
+  const todayIncome = pickNumber(root, ["today_income", "todayIncome"]);
+  const todayUsed = pickNumber(root, ["today_quota_consumption", "todayQuotaConsumption"]);
+
+  if (quota === undefined && used === undefined) {
+    throw new Error("panel /api/user/self payload has no quota fields");
+  }
+
+  const quotaUsd = quota === undefined ? undefined : quota / scale;
+  const usedUsd = used === undefined ? undefined : used / scale;
+  const remainingUsd = panelQuotaLooksRemaining(kind)
+    ? quotaUsd
+    : (quotaUsd === undefined || usedUsd === undefined ? quotaUsd : Math.max(0, quotaUsd - usedUsd));
+  const totalUsd = panelQuotaLooksRemaining(kind)
+    ? (quotaUsd === undefined || usedUsd === undefined ? quotaUsd : quotaUsd + usedUsd)
+    : quotaUsd;
+
+  const parts = usageParts();
+  if (remainingUsd !== undefined) parts.push(`balance ${formatMoney(remainingUsd)}`);
+  if (usedUsd !== undefined && totalUsd !== undefined) {
+    parts.push(`used ${formatMoney(usedUsd)}/${formatMoney(totalUsd)}`);
+  } else if (usedUsd !== undefined) {
+    parts.push(`used ${formatMoney(usedUsd)}`);
+  }
+  if (todayUsed !== undefined) parts.push(`today ${formatMoney(todayUsed / scale)}`);
+  if (todayIncome !== undefined) parts.push(`income ${formatMoney(todayIncome / scale)}`);
+  return parts.join(" | ");
+}
+
+function formatQuotaLimitedLine(label, root) {
+  const quota = root?.quota || {};
+  const limit = pickNumber(quota, ["limit", "quota"]);
+  const used = pickNumber(quota, ["used", "quota_used"]);
+  const remaining = pickNumber(quota, ["remaining"]) ?? pickNumber(root, ["remaining"]);
+  const parts = usageParts();
+
+  if (limit !== undefined && used !== undefined) {
+    parts.push(`Q ${formatMoney(used)}/${formatMoney(limit)}`);
+  } else if (remaining !== undefined) {
+    parts.push(`remaining ${formatMoney(remaining)}`);
+  }
+
+  if (Array.isArray(root?.rate_limits) && root.rate_limits.length > 0) {
+    const rateParts = root.rate_limits
+      .map((entry) => {
+        const window = entry?.window;
+        const rateLimit = pickNumber(entry, ["limit"]);
+        const rateUsed = pickNumber(entry, ["used"]);
+        return window && rateLimit !== undefined && rateUsed !== undefined
+          ? `${window} ${formatMoney(rateUsed)}/${formatMoney(rateLimit)}`
+          : "";
+      })
+      .filter(Boolean);
+    if (rateParts.length > 0) parts.push(rateParts.join(", "));
+  }
+
+  return parts.join(" | ");
+}
+
+async function formatWalletLine(label, root) {
+  const balance = pickNumber(root, ["balance", "remaining", "remain", "available"]);
+  const todayCost = pickNumber(root?.usage?.today, ["actual_cost", "cost"]);
+  const recentUsage = Array.isArray(root?.daily_usage)
+    ? root.daily_usage.reduce((sum, day) => sum + (pickNumber(day, ["actual_cost", "cost"]) || 0), 0)
+    : undefined;
+
+  const parts = usageParts();
+  if (balance !== undefined) parts.push(`balance ${formatMoney(balance)}`);
+  if (todayCost !== undefined) parts.push(`today ${formatMoney(todayCost)}`);
+  if (recentUsage !== undefined && root.daily_usage.length > 0) {
+    parts.push(`${await providerUsageDays()}d ${formatMoney(recentUsage)}`);
+  }
+  return parts.join(" | ");
+}
+
+function formatUsageLine(label, root) {
+  const sub = root?.subscription || {};
+  const dailyLimit = pickNumber(sub, ["daily_limit_usd"]);
+  const dailyUsage = pickNumber(sub, ["daily_usage_usd"]);
+  const weeklyLimit = pickNumber(sub, ["weekly_limit_usd"]);
+  const weeklyUsage = pickNumber(sub, ["weekly_usage_usd"]);
+  const monthlyLimit = pickNumber(sub, ["monthly_limit_usd"]);
+  const monthlyUsage = pickNumber(sub, ["monthly_usage_usd"]);
+  const expires = shortDate(sub.expires_at);
+
+  const parts = usageParts();
+  if (dailyLimit > 0 && dailyUsage !== undefined) parts.push(`D ${formatMoney(dailyUsage)}/${formatMoney(dailyLimit)}`);
+  if (weeklyLimit > 0 && weeklyUsage !== undefined) parts.push(`W ${formatMoney(weeklyUsage)}/${formatMoney(weeklyLimit)}`);
+  if (monthlyLimit > 0 && monthlyUsage !== undefined) parts.push(`M ${formatMoney(monthlyUsage)}/${formatMoney(monthlyLimit)}`);
+  if (expires) parts.push(`Exp ${expires}`);
+  return parts.join(" | ");
+}