pi-myusage 0.1.0

package/src/adapters/anthropic.ts

@@ -0,0 +1,167 @@
+import { windowsSummary, type QuotaWindowMetric } from "../format.ts";
+import { fetchJson, HttpError, safeError, urlOnDomain } from "../http.ts";
+import { snapshot, type Metric, type UsageAdapter, type UsageSnapshot } from "../types.ts";
+
+const OAUTH_USAGE_URL = "https://api.anthropic.com/api/oauth/usage";
+
+interface OAuthWindow {
+  utilization?: number;
+  resets_at?: string;
+}
+
+interface StructuredLimit {
+  kind?: string;
+  percent?: number;
+  resets_at?: string;
+  scope?: { model?: { display_name?: string; id?: string } };
+}
+
+interface OAuthUsageResponse {
+  five_hour?: OAuthWindow | null;
+  seven_day?: OAuthWindow | null;
+  seven_day_sonnet?: OAuthWindow | null;
+  seven_day_opus?: OAuthWindow | null;
+  seven_day_oauth_apps?: OAuthWindow | null;
+  limits?: StructuredLimit[];
+  extra_usage?: {
+    is_enabled?: boolean;
+    monthly_limit?: number | null;
+    used_credits?: number | null;
+    utilization?: number | null;
+  } | null;
+}
+
+type QuotaMetric = Extract<Metric, { kind: "quota-window" }>;
+
+function quotaMetric(id: string, label: string, utilization: unknown, resetAt?: string): QuotaMetric | undefined {
+  if (typeof utilization !== "number" || !Number.isFinite(utilization)) return undefined;
+  const used = Math.max(0, Math.min(100, utilization));
+  const parsedReset = resetAt && Number.isFinite(Date.parse(resetAt)) ? new Date(resetAt).toISOString() : undefined;
+  return {
+    kind: "quota-window",
+    id,
+    label,
+    remainingFraction: (100 - used) / 100,
+    ...(parsedReset ? { resetAt: parsedReset } : {}),
+  };
+}
+
+function parseOAuthMetrics(data: OAuthUsageResponse): Metric[] {
+  const metrics: Metric[] = [];
+  const flat = [
+    quotaMetric("claude-5h", "Claude 5h", data.five_hour?.utilization, data.five_hour?.resets_at),
+    quotaMetric("claude-7d", "Claude 7d", data.seven_day?.utilization, data.seven_day?.resets_at),
+    quotaMetric("claude-7d-sonnet", "Claude 7d Sonnet", data.seven_day_sonnet?.utilization, data.seven_day_sonnet?.resets_at),
+    quotaMetric("claude-7d-opus", "Claude 7d Opus", data.seven_day_opus?.utilization, data.seven_day_opus?.resets_at),
+    quotaMetric("claude-7d-oauth", "Claude 7d OAuth", data.seven_day_oauth_apps?.utilization, data.seven_day_oauth_apps?.resets_at),
+  ].filter((metric): metric is QuotaMetric => Boolean(metric));
+  metrics.push(...flat);
+
+  if (Array.isArray(data.limits)) {
+    for (const [index, limit] of data.limits.entries()) {
+      const kind = (limit.kind ?? "").toLowerCase();
+      const modelName = limit.scope?.model?.display_name || limit.scope?.model?.id;
+      const id = kind === "session"
+        ? "claude-session"
+        : kind === "weekly_all"
+          ? "claude-7d"
+          : `claude-weekly-${modelName?.toLowerCase().replace(/[^a-z0-9]+/g, "-") || index}`;
+      if (metrics.some((metric) => metric.kind === "quota-window" && metric.id === id)) continue;
+      const label = kind === "session"
+        ? "Claude Session"
+        : kind === "weekly_all"
+          ? "Claude 7d"
+          : modelName
+            ? `Claude 7d ${modelName}`
+            : "Claude Weekly";
+      const metric = quotaMetric(id, label, limit.percent, limit.resets_at);
+      if (metric) metrics.push(metric);
+    }
+  }
+
+  const extra = data.extra_usage;
+  if (extra?.is_enabled && typeof extra.utilization === "number") {
+    const metric = quotaMetric("claude-extra-monthly", "Claude Extra Monthly", extra.utilization);
+    if (metric) metrics.push(metric);
+  }
+  if (extra?.is_enabled && typeof extra.monthly_limit === "number" && typeof extra.used_credits === "number") {
+    metrics.push({
+      kind: "usage-limit",
+      id: "claude-extra-credits",
+      label: "Extra usage",
+      used: extra.used_credits,
+      limit: extra.monthly_limit,
+      unit: "credits",
+    });
+  }
+
+  return metrics;
+}
+
+function quotaSummary(metrics: Metric[]): string | undefined {
+  const quotas = metrics.filter((metric): metric is QuotaWindowMetric => metric.kind === "quota-window");
+  const session = quotas.find((metric) => metric.id === "claude-5h" || metric.id === "claude-session");
+  const weekly = quotas.find((metric) => metric.id === "claude-7d")
+    ?? quotas.find((metric) => metric.id.startsWith("claude-7d-") || metric.id.startsWith("claude-weekly-"));
+  return windowsSummary([session, weekly].filter((metric): metric is QuotaWindowMetric => Boolean(metric)));
+}
+
+export const anthropicAdapter: UsageAdapter = {
+  id: "anthropic",
+  label: "Anthropic Claude",
+  canHandle(target) {
+    const pid = target.providerId.toLowerCase();
+    if (pid === "anthropic" || pid === "claude") return true;
+    return urlOnDomain(target.baseUrl, "anthropic.com");
+  },
+  async fetch({ target, signal }): Promise<UsageSnapshot> {
+    try {
+      const token = target.credentials?.apiKey;
+      if (!token) return snapshot(this, target, "unauthorized", { error: "No API key" });
+
+      try {
+        const payload = await fetchJson<OAuthUsageResponse>(
+          OAUTH_USAGE_URL,
+          {
+            headers: {
+              Authorization: `Bearer ${token}`,
+              Accept: "application/json",
+              "anthropic-version": "2023-06-01",
+              "anthropic-beta": "oauth-2025-04-20",
+              "User-Agent": "claude-cli (external, cli)",
+              "x-app": "cli",
+            },
+          },
+          signal,
+        );
+
+        const metrics = parseOAuthMetrics(payload);
+        if (!metrics.length) return snapshot(this, target, "empty");
+        return snapshot(this, target, "ok", {
+          accounts: [{ id: "claude-subscription", label: "Claude Subscription", metrics }],
+          summary: quotaSummary(metrics),
+        });
+      } catch (oauthError) {
+        if (signal.aborted) throw oauthError;
+        const rejected = oauthError instanceof HttpError && (oauthError.status === 401 || oauthError.status === 403);
+        if (!rejected) throw oauthError;
+      }
+
+      return snapshot(this, target, "ok", {
+        accounts: [
+          {
+            id: "claude-api-key",
+            label: "Claude API Account",
+            metrics: [
+              { kind: "status", id: "claude-billing", label: "Billing", value: "API key (pay-as-you-go)" },
+            ],
+          },
+        ],
+        summary: "Claude API key · PAYG",
+      });
+    } catch (error) {
+      if (signal.aborted) return snapshot(this, target, "unavailable", { error: "aborted" });
+      return snapshot(this, target, "unavailable", { error: safeError(error) });
+    }
+  },
+};

package/src/adapters/baseten.ts

@@ -0,0 +1,97 @@
+import { fetchJson, HttpError, safeError, urlOnDomain } from "../http.ts";
+import { snapshot, type UsageAdapter, type UsageSnapshot } from "../types.ts";
+
+const USAGE_URL = "https://api.baseten.co/v1/billing/usage_summary";
+
+interface UsageSummaryResponse {
+  model_apis_usage?: {
+    total?: string | number;
+    credits_used?: string | number;
+    subtotal?: string | number;
+  };
+}
+
+function amount(value: string | number | undefined): number | undefined {
+  const n = typeof value === "number" ? value : typeof value === "string" && value.trim() !== "" ? Number(value) : NaN;
+  return Number.isFinite(n) && n >= 0 ? n : undefined;
+}
+
+export const basetenAdapter: UsageAdapter = {
+  id: "baseten",
+  label: "Baseten",
+  canHandle(target) {
+    if (target.providerId.toLowerCase() === "baseten") return true;
+    return urlOnDomain(target.baseUrl, "baseten.co");
+  },
+  async fetch({ target, signal }): Promise<UsageSnapshot> {
+    try {
+      const apiKey = target.credentials?.apiKey;
+      if (!apiKey) return snapshot(this, target, "unauthorized", { error: "No API key" });
+
+      const end = new Date();
+      const start = new Date(end.getTime() - 30 * 86_400_000);
+      const payload = await fetchJson<UsageSummaryResponse>(
+        `${USAGE_URL}?start_date=${start.toISOString()}&end_date=${end.toISOString()}`,
+        { headers: { Authorization: `Bearer ${apiKey}`, Accept: "application/json" } },
+        signal,
+      );
+
+      const usage = payload.model_apis_usage;
+      if (!usage) return snapshot(this, target, "empty", { error: "No Model APIs usage returned" });
+      const total = amount(usage.total);
+      const credits = amount(usage.credits_used);
+      const subtotal = amount(usage.subtotal);
+      if (total === undefined && credits === undefined && subtotal === undefined) {
+        return snapshot(this, target, "empty", { error: "No usage amounts returned" });
+      }
+
+      const metrics = [
+        ...(total !== undefined && subtotal !== undefined
+          ? [
+              {
+                kind: "usage-limit" as const,
+                id: "baseten-model-apis",
+                label: "Model APIs (30d)",
+                used: subtotal,
+                limit: total,
+                unit: "USD",
+                detail:
+                  credits !== undefined
+                    ? `net after ${credits.toFixed(2)} credits · gross ${total.toFixed(2)}`
+                    : `gross ${total.toFixed(2)}`,
+              },
+            ]
+          : []),
+        ...(credits !== undefined && (total === undefined || subtotal === undefined)
+          ? [
+              {
+                kind: "status" as const,
+                id: "baseten-credits",
+                label: "Credits used (30d)",
+                value: `$${credits.toFixed(2)}`,
+              },
+            ]
+          : []),
+      ];
+      if (!metrics.length) {
+        metrics.push({
+          kind: "status",
+          id: "baseten-model-apis",
+          label: "Model APIs (30d)",
+          value: `$${(total ?? subtotal ?? 0).toFixed(2)}`,
+        });
+      }
+      const spend = subtotal ?? total ?? 0;
+      return snapshot(this, target, "ok", {
+        accounts: [{ id: "baseten-org", label: "Baseten (org)", metrics }],
+        summary: `$${spend.toFixed(2)} spend (30d) · Baseten`,
+      });
+    } catch (error) {
+      if (signal.aborted) return snapshot(this, target, "unavailable", { error: "aborted" });
+      if (error instanceof HttpError && (error.status === 401 || error.status === 403)) {
+        return snapshot(this, target, "unauthorized", { error: `HTTP ${error.status}` });
+      }
+      return snapshot(this, target, "unavailable", { error: safeError(error) });
+    }
+  },
+};

package/src/adapters/cline.ts

@@ -0,0 +1,135 @@
+import { windowsSummary, type QuotaWindowMetric } from "../format.ts";
+import { fetchJson, HttpError, safeError, urlOnDomain } from "../http.ts";
+import { snapshot, type Metric, type UsageAdapter, type UsageSnapshot } from "../types.ts";
+
+const ORIGIN = "https://api.cline.bot";
+
+interface Envelope<T> {
+  success?: boolean;
+  error?: string;
+  data?: T;
+}
+
+interface MeResponse {
+  id?: string | number;
+  email?: string;
+  name?: string;
+}
+
+interface UsageLimitItem {
+  type?: string;
+  percentUsed?: number;
+  resetsAt?: string;
+}
+
+interface UsageLimitsResponse {
+  limits?: UsageLimitItem[];
+}
+
+interface BalanceResponse {
+  balance?: number;
+}
+
+const MICRO_USD = 1_000_000;
+
+async function clineGet<T>(path: string, apiKey: string, signal: AbortSignal): Promise<T | undefined> {
+  const payload = await fetchJson<Envelope<T>>(
+    `${ORIGIN}${path}`,
+    { headers: { Authorization: `Bearer ${apiKey}`, Accept: "application/json" } },
+    signal,
+  );
+  if (typeof payload.error === "string" && payload.error) throw new Error(payload.error);
+  return payload.data;
+}
+
+function normalizeReset(raw: string | undefined): string | undefined {
+  if (!raw || Number.isNaN(Date.parse(raw))) return undefined;
+  return new Date(raw).toISOString();
+}
+
+function parseWindows(data: UsageLimitsResponse | undefined): Metric[] {
+  if (!data || !Array.isArray(data.limits)) return [];
+  const metrics: Metric[] = [];
+  for (const limit of data.limits) {
+    if (typeof limit.percentUsed !== "number" || !Number.isFinite(limit.percentUsed)) continue;
+    const type = (limit.type ?? "").toLowerCase();
+    const label =
+      type === "five_hour" ? "Cline 5h"
+      : type === "weekly" ? "Cline Weekly"
+      : type === "monthly" ? "Cline Monthly"
+      : `Cline ${limit.type ?? "limit"}`;
+    const used = Math.min(100, Math.max(0, limit.percentUsed));
+    const resetAt = normalizeReset(limit.resetsAt);
+    metrics.push({
+      kind: "quota-window",
+      id: `cline-${type || metrics.length}`,
+      label,
+      remainingFraction: Math.max(0, (100 - used) / 100),
+      ...(resetAt ? { resetAt } : {}),
+    });
+  }
+  return metrics;
+}
+
+export const clineAdapter: UsageAdapter = {
+  id: "cline",
+  label: "Cline",
+  canHandle(target) {
+    if (target.providerId.toLowerCase() === "cline") return true;
+    return urlOnDomain(target.baseUrl, "cline.bot");
+  },
+  async fetch({ target, signal }): Promise<UsageSnapshot> {
+    try {
+      const apiKey = target.credentials?.apiKey;
+      if (!apiKey) return snapshot(this, target, "unauthorized", { error: "No API key" });
+
+      const [me, plan] = await Promise.all([
+        clineGet<MeResponse>("/api/v1/users/me", apiKey, signal),
+        clineGet<unknown>("/api/v1/users/me/plan", apiKey, signal),
+      ]);
+      const userId = me?.id;
+
+      const metrics: Metric[] = [];
+      const [limits, balance] = await Promise.all([
+        plan !== null && plan !== undefined
+          ? clineGet<UsageLimitsResponse>("/api/v1/users/me/plan/usage-limits", apiKey, signal)
+          : undefined,
+        userId !== undefined
+          ? clineGet<BalanceResponse>(`/api/v1/users/${userId}/balance`, apiKey, signal)
+          : undefined,
+      ]);
+      if (limits) metrics.push(...parseWindows(limits));
+
+      let balanceAmount: number | undefined;
+      if (typeof balance?.balance === "number" && Number.isFinite(balance.balance)) {
+        balanceAmount = balance.balance / MICRO_USD;
+        metrics.push({
+          kind: "balance",
+          id: "cline-balance",
+          label: "Balance",
+          amount: balanceAmount,
+          currency: "USD",
+        });
+      }
+
+      if (!metrics.length) {
+        return snapshot(this, target, "empty", {
+          error: plan === null || plan === undefined ? "No ClinePass plan" : "No usage or balance data",
+        });
+      }
+
+      const windows = metrics.filter((m): m is QuotaWindowMetric => m.kind === "quota-window");
+      const summary = windowsSummary(windows) ?? `$${(balanceAmount ?? 0).toFixed(2)} · Cline`;
+      return snapshot(this, target, "ok", {
+        accounts: [{ id: "cline-account", label: "Cline", metrics }],
+        summary,
+      });
+    } catch (error) {
+      if (signal.aborted) return snapshot(this, target, "unavailable", { error: "aborted" });
+      if (error instanceof HttpError && (error.status === 401 || error.status === 403)) {
+        return snapshot(this, target, "unauthorized", { error: `HTTP ${error.status}` });
+      }
+      return snapshot(this, target, "unavailable", { error: safeError(error) });
+    }
+  },
+};

package/src/adapters/cliproxy.ts

@@ -0,0 +1,69 @@
+import { fetchJson, safeError, urlOrigin, urlOnDomain } from "../http.ts";
+import { snapshot, type Metric, type UsageAdapter, type UsageSnapshot } from "../types.ts";
+
+interface ApiUser {
+  name?: string;
+  requests?: number;
+  expires?: string;
+}
+
+function isLocal(url: string | undefined): boolean {
+  return urlOnDomain(url, "localhost") || urlOnDomain(url, "127.0.0.1");
+}
+
+export const cliproxyAdapter: UsageAdapter = {
+  id: "cliproxyapi",
+  label: "CLIProxyAPI",
+  canHandle(target) {
+    if (!target.providerId.toLowerCase().includes("cliproxy")) return false;
+    return !target.baseUrl || isLocal(target.baseUrl);
+  },
+  async fetch({ target, signal }): Promise<UsageSnapshot> {
+    try {
+      const origin = urlOrigin(target.baseUrl);
+      const statusOnly = (): UsageSnapshot =>
+        snapshot(this, target, "ok", {
+          accounts: [
+            {
+              id: "cliproxy-local",
+              label: "CLIProxyAPI",
+              metrics: [{ kind: "status", id: "cliproxy-proxy", label: "Proxy", value: `configured ${origin ?? "local"}` }],
+            },
+          ],
+          summary: "CLIProxy · local proxy",
+        });
+
+      const mgmtKey = process.env.CLIPROXY_MANAGEMENT_KEY;
+      if (!mgmtKey || !origin) return statusOnly();
+
+      let users: ApiUser[];
+      try {
+        users = await fetchJson<ApiUser[]>(
+          `${origin}/v0/management/api-users`,
+          { headers: { Authorization: `Bearer ${mgmtKey}`, Accept: "application/json" } },
+          signal,
+        );
+      } catch {
+        if (signal.aborted) return snapshot(this, target, "unavailable", { error: "aborted" });
+        return statusOnly();
+      }
+      if (!Array.isArray(users)) return statusOnly();
+
+      const metrics: Metric[] = users.slice(0, 5).map((user, index) => ({
+        kind: "status",
+        id: `cliproxy-${user.name ?? index}`,
+        label: user.name ?? `user ${index + 1}`,
+        value: `${typeof user.requests === "number" ? user.requests : 0} requests`,
+        ...(user.expires ? { detail: `expires ${user.expires}` } : {}),
+      }));
+      if (!metrics.length) return statusOnly();
+      return snapshot(this, target, "ok", {
+        accounts: [{ id: "cliproxy-local", label: "CLIProxyAPI", metrics }],
+        summary: `CLIProxy · ${users.length} api users`,
+      });
+    } catch (error) {
+      if (signal.aborted) return snapshot(this, target, "unavailable", { error: "aborted" });
+      return snapshot(this, target, "unavailable", { error: safeError(error) });
+    }
+  },
+};

package/src/adapters/deepseek.ts

@@ -0,0 +1,76 @@
+import { fetchJson, HttpError, safeError, urlOrigin } from "../http.ts";
+import { snapshot, type UsageAdapter, type UsageSnapshot } from "../types.ts";
+
+const BALANCE_URL = "https://api.deepseek.com/user/balance";
+
+interface BalanceResponse {
+  is_available?: boolean;
+  balance_infos?: Array<{
+    currency?: string;
+    total_balance?: string;
+    granted_balance?: string;
+    topped_up_balance?: string;
+  }>;
+}
+
+export const deepseekAdapter: UsageAdapter = {
+  id: "deepseek",
+  label: "DeepSeek",
+  canHandle(target) {
+    if (target.providerId.toLowerCase() === "deepseek") return true;
+    return urlOrigin(target.baseUrl) === "https://api.deepseek.com";
+  },
+  async fetch({ target, signal }): Promise<UsageSnapshot> {
+    try {
+      const creds = target.credentials;
+      const apiKey = creds?.apiKey;
+      if (!apiKey) return snapshot(this, target, "unauthorized", { error: "No API key" });
+
+      const payload = await fetchJson<BalanceResponse>(
+        BALANCE_URL,
+        { headers: { Authorization: `Bearer ${apiKey}`, Accept: "application/json" } },
+        signal,
+      );
+
+      const accounts = (payload.balance_infos ?? []).map((info, index) => ({
+        id: `deepseek-${info.currency ?? index}`,
+        label: info.currency === "CNY" ? "Account (CNY)" : `Account (${info.currency ?? "?"})`,
+        metrics: [
+          ...(info.total_balance !== undefined
+            ? [
+                {
+                  kind: "balance" as const,
+                  id: "total",
+                  label: "Balance",
+                  amount: Number(info.total_balance) || 0,
+                  currency: info.currency ?? "CNY",
+                  detail:
+                    info.granted_balance !== undefined || info.topped_up_balance !== undefined
+                      ? `granted ${info.granted_balance ?? "0"} · topped up ${info.topped_up_balance ?? "0"}`
+                      : undefined,
+                },
+              ]
+            : []),
+          ...(payload.is_available === false
+            ? [{ kind: "status" as const, id: "availability", label: "Status", value: "insufficient balance" }]
+            : []),
+        ],
+      }));
+      if (!accounts.length) return snapshot(this, target, "empty");
+      const primary = accounts[0].metrics[0];
+      return snapshot(this, target, "ok", {
+        accounts,
+        summary:
+          primary?.kind === "balance"
+            ? `${primary.currency === "CNY" ? "¥" : "$"}${primary.amount.toFixed(2)} · DeepSeek`
+            : undefined,
+      });
+    } catch (error) {
+      if (signal.aborted) return snapshot(this, target, "unavailable", { error: "aborted" });
+      if (error instanceof HttpError && (error.status === 401 || error.status === 403)) {
+        return snapshot(this, target, "unauthorized", { error: `HTTP ${error.status}` });
+      }
+      return snapshot(this, target, "unavailable", { error: safeError(error) });
+    }
+  },
+};

package/src/adapters/fireworks.ts

@@ -0,0 +1,105 @@
+import { fetchJson, HttpError, safeError, urlOnDomain } from "../http.ts";
+import { snapshot, type Metric, type UsageAdapter, type UsageSnapshot } from "../types.ts";
+
+const ORIGIN = "https://api.fireworks.ai";
+const WINDOW_DAYS = 30;
+
+interface AccountsResponse {
+  accounts?: Array<{ name?: string }>;
+}
+
+interface LineItem {
+  series?: string;
+  totalCost?: { currencyCode?: string; units?: string | number; nanos?: string | number };
+}
+
+interface BillingSummaryResponse {
+  lineItems?: LineItem[];
+}
+
+const SERIES_LABELS: Record<string, string> = {
+  serverless: "Serverless",
+  dedicated: "Dedicated",
+  training: "Training",
+  other: "Other",
+};
+
+function money(cost: LineItem["totalCost"]): { currency: string; amount: number } | undefined {
+  if (!cost?.currencyCode) return undefined;
+  const units = Number(cost.units ?? 0);
+  const nanos = Number(cost.nanos ?? 0);
+  if (!Number.isFinite(units) || !Number.isFinite(nanos)) return undefined;
+  return { currency: cost.currencyCode, amount: Math.round((units + nanos / 1e9) * 100) / 100 };
+}
+
+export const fireworksAdapter: UsageAdapter = {
+  id: "fireworks",
+  label: "Fireworks",
+  canHandle(target) {
+    if (target.providerId.toLowerCase() === "fireworks") return true;
+    return urlOnDomain(target.baseUrl, "fireworks.ai");
+  },
+  async fetch({ target, signal }): Promise<UsageSnapshot> {
+    try {
+      const apiKey = target.credentials?.apiKey;
+      if (!apiKey) return snapshot(this, target, "unauthorized", { error: "No API key" });
+      const headers = { Authorization: `Bearer ${apiKey}`, Accept: "application/json" };
+
+      const accountsPayload = await fetchJson<AccountsResponse>(`${ORIGIN}/v1/accounts`, { headers }, signal);
+      const first = accountsPayload.accounts?.[0]?.name?.match(/^accounts\/([^/]+)$/)?.[1];
+      if (!first) return snapshot(this, target, "empty", { error: "No accounts returned" });
+
+      const dayMs = 86_400_000;
+      const day = (t: number) => new Date(t).toISOString().slice(0, 10);
+      const now = Date.now();
+      const url =
+        `${ORIGIN}/v1/accounts/${first}/billing/summary` +
+        `?startTime=${day(now - (WINDOW_DAYS - 1) * dayMs)}T00:00:00Z&endTime=${day(now + dayMs)}T00:00:00Z`;
+      const summary = await fetchJson<BillingSummaryResponse>(url, { headers }, signal);
+
+      const totals = new Map<string, Map<string, number>>();
+      for (const item of summary.lineItems ?? []) {
+        const m = money(item.totalCost);
+        if (!m) continue;
+        const series = item.series === "SERVERLESS" ? "serverless"
+          : item.series === "DEDICATED_DEPLOYMENT" ? "dedicated"
+          : item.series === "TRAINING" ? "training"
+          : "other";
+        const bySeries = totals.get(m.currency) ?? new Map<string, number>();
+        bySeries.set(series, Math.round(((bySeries.get(series) ?? 0) + m.amount) * 100) / 100);
+        totals.set(m.currency, bySeries);
+      }
+
+      const metrics: Metric[] = [];
+      let primaryValue = "";
+      for (const [currency, bySeries] of totals) {
+        const total = Math.round([...bySeries.values()].reduce((a, b) => a + b, 0) * 100) / 100;
+        const detail = Object.entries(bySeries)
+          .map(([series, v]) => `${SERIES_LABELS[series] ?? series} ${v.toFixed(2)}`)
+          .join(" · ");
+        const value = `${currency === "USD" ? "$" : ""}${total.toFixed(2)}${currency === "USD" ? "" : ` ${currency}`}`;
+        if (!primaryValue) primaryValue = value;
+        metrics.push({
+          kind: "status",
+          id: `fireworks-${currency.toLowerCase()}`,
+          label: "Spend (30d)",
+          value,
+          detail: detail || undefined,
+        });
+      }
+      if (!metrics.length) {
+        return snapshot(this, target, "empty", { error: "No rated line items for the last 30 days" });
+      }
+      return snapshot(this, target, "ok", {
+        accounts: [{ id: `fireworks-${first}`, label: `Fireworks (${first})`, metrics }],
+        summary: `${primaryValue} spend (30d) · Fireworks`,
+      });
+    } catch (error) {
+      if (signal.aborted) return snapshot(this, target, "unavailable", { error: "aborted" });
+      if (error instanceof HttpError && (error.status === 401 || error.status === 403)) {
+        return snapshot(this, target, "unauthorized", { error: `HTTP ${error.status}` });
+      }
+      return snapshot(this, target, "unavailable", { error: safeError(error) });
+    }
+  },
+};