tokmon 0.28.2 → 0.28.4

package/dist/chunk-7CH6S7BR.js

@@ -0,0 +1,447 @@
+#!/usr/bin/env node
+import {
+  ConfigUpdateConflictFailure,
+  TOKMON_WS_METHODS,
+  TOKMON_WS_PATH,
+  TokmonRpcGroup
+} from "./chunk-JZSZEHVD.js";
+import {
+  normalizeConfig
+} from "./chunk-HNWEJ6MS.js";
+
+// src/client/daemon-rpc-client.ts
+import { Cause, Context, Duration, Effect, Exit, Fiber, Layer, ManagedRuntime, Schedule, Schema, Stream } from "effect";
+import { RpcClient, RpcSerialization } from "effect/unstable/rpc";
+import { RpcClientError } from "effect/unstable/rpc/RpcClientError";
+import * as Socket from "effect/unstable/socket/Socket";
+var DaemonRpcConnectionError = class extends Error {
+  constructor(message = "daemon RPC connection closed") {
+    super(message);
+    this.name = "DaemonRpcConnectionError";
+  }
+};
+var DaemonRpcRequestTimeoutError = class extends Error {
+  constructor(method, timeoutMs) {
+    super(`${method} timed out after ${timeoutMs}ms`);
+    this.method = method;
+    this.timeoutMs = timeoutMs;
+    this.name = "DaemonRpcRequestTimeoutError";
+  }
+  method;
+  timeoutMs;
+};
+var TokmonRpcClient = class extends Context.Service()(
+  "tokmon/client/DaemonRpcClient/TokmonRpcClient"
+) {
+};
+var dynamicImport = new Function("specifier", "return import(specifier)");
+function makeSignal() {
+  let settled = false;
+  let resolvePromise;
+  const promise = new Promise((resolve) => {
+    resolvePromise = resolve;
+  });
+  return {
+    promise,
+    resolve: (value) => {
+      if (settled) return;
+      settled = true;
+      resolvePromise(value);
+    }
+  };
+}
+function toWsUrl(baseUrl) {
+  const base = typeof window === "undefined" ? void 0 : window.location.origin;
+  const url = new URL(baseUrl, base);
+  if (url.protocol === "http:") url.protocol = "ws:";
+  else if (url.protocol === "https:") url.protocol = "wss:";
+  if (url.protocol !== "ws:" && url.protocol !== "wss:") {
+    throw new Error(`unsupported daemon RPC protocol: ${url.protocol}`);
+  }
+  url.hash = "";
+  url.searchParams.delete("tokmonToken");
+  url.searchParams.delete("wsToken");
+  url.pathname = TOKMON_WS_PATH;
+  return url.toString();
+}
+function shouldUseNodeTransport(transport) {
+  if (transport === "node") return true;
+  if (transport === "browser") return false;
+  return typeof window === "undefined";
+}
+async function socketLayerFor(url, transport, openTimeoutMs) {
+  const socketOptions = { openTimeout: Duration.millis(openTimeoutMs) };
+  if (shouldUseNodeTransport(transport)) {
+    const NodeSocket = await dynamicImport("@effect/platform-node/NodeSocket");
+    return NodeSocket.layerWebSocket(url, socketOptions);
+  }
+  return Socket.layerWebSocket(url, socketOptions).pipe(
+    Layer.provide(Socket.layerWebSocketConstructorGlobal)
+  );
+}
+function normalizeConfigState(state) {
+  return {
+    protocol: {
+      version: state.protocol.version,
+      capabilities: [...state.protocol.capabilities]
+    },
+    config: normalizeConfig(state.config)
+  };
+}
+function normalizeSnapshot(snapshot) {
+  const copyHeadroom = (headroom) => headroom ? {
+    ...headroom,
+    activeAccountIds: [...headroom.activeAccountIds],
+    factors: headroom.factors.map((factor) => ({ ...factor }))
+  } : void 0;
+  const copyRows = (rows) => rows.map((row) => ({
+    ...row,
+    models: [...row.models],
+    breakdown: row.breakdown.map((detail) => ({ ...detail }))
+  }));
+  return {
+    ...snapshot,
+    providers: snapshot.providers.map((provider) => ({
+      ...provider,
+      headroom: copyHeadroom(provider.headroom)
+    })),
+    accounts: snapshot.accounts.map((account) => ({
+      ...account,
+      identity: account.identity ? { ...account.identity } : void 0,
+      quotas: account.quotas?.map((quota) => ({ ...quota })),
+      headroom: copyHeadroom(account.headroom),
+      dashboard: account.dashboard ? {
+        ...account.dashboard,
+        today: { ...account.dashboard.today },
+        week: { ...account.dashboard.week },
+        month: { ...account.dashboard.month },
+        series: [...account.dashboard.series]
+      } : null,
+      table: account.table ? {
+        daily: copyRows(account.table.daily),
+        weekly: copyRows(account.table.weekly),
+        monthly: copyRows(account.table.monthly)
+      } : null,
+      billing: account.billing ? {
+        ...account.billing,
+        metrics: account.billing.metrics.map((metric) => ({
+          ...metric,
+          format: { ...metric.format }
+        })),
+        activity: account.billing.activity ? { ...account.billing.activity, series: [...account.billing.activity.series] } : account.billing.activity,
+        modelSpend: account.billing.modelSpend == null ? account.billing.modelSpend : account.billing.modelSpend.map((spend) => ({ ...spend }))
+      } : null,
+      summaryUpdatedAt: account.summaryUpdatedAt ?? null,
+      billingUpdatedAt: account.billingUpdatedAt ?? null,
+      tableUpdatedAt: account.tableUpdatedAt ?? null
+    })),
+    peak: snapshot.peak ? { ...snapshot.peak } : null
+  };
+}
+function normalizeRequestFailure(error) {
+  if (!error || typeof error !== "object" || error.kind !== "conflict") return error;
+  const state = error.state;
+  if (!state) return error;
+  const normalized = normalizeConfigState(state);
+  if (error instanceof ConfigUpdateConflictFailure) {
+    return new ConfigUpdateConflictFailure({ kind: "conflict", state: normalized });
+  }
+  return { ...error, state: normalized };
+}
+function isSessionFailure(error) {
+  return error instanceof RpcClientError || Schema.isSchemaError(error);
+}
+async function waitForReady(ready, disconnected, timeoutMs) {
+  let timer = null;
+  try {
+    await Promise.race([
+      ready.promise,
+      disconnected.promise.then((error) => Promise.reject(error)),
+      new Promise((_resolve, reject) => {
+        timer = setTimeout(() => reject(new DaemonRpcConnectionError(`daemon RPC connection timed out after ${timeoutMs}ms`)), timeoutMs);
+        timer.unref?.();
+      })
+    ]);
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
+function createDaemonRpcClient(baseUrl, options = {}) {
+  const url = toWsUrl(baseUrl);
+  const requestTimeoutMs = Math.max(1, options.requestTimeoutMs ?? 3e4);
+  const reconnectBaseDelayMs = Math.max(1, options.reconnectBaseDelayMs ?? 250);
+  const subscriptions = /* @__PURE__ */ new Set();
+  let session = null;
+  let sessionPromise = null;
+  let pendingRuntime = null;
+  let supervisorPromise = null;
+  let reconnectTimer = null;
+  let reconnectAttemptsUsed = 0;
+  let hasConnected = false;
+  let closed = false;
+  const reportSubscriberError = (error) => {
+    if (options.onSubscriberError) {
+      try {
+        options.onSubscriberError(error);
+      } catch (reportError) {
+        console.error("[tokmon] daemon RPC subscriber error reporter failed", reportError);
+      }
+      return;
+    }
+    console.error("[tokmon] daemon RPC subscriber failed", error);
+  };
+  const setConn = (state, error) => {
+    try {
+      options.onConn?.(state, error);
+    } catch (callbackError) {
+      reportSubscriberError(callbackError);
+    }
+  };
+  const clearReconnectTimer = () => {
+    if (!reconnectTimer) return;
+    clearTimeout(reconnectTimer);
+    reconnectTimer = null;
+  };
+  const stopSubscriptionFiber = (subscription) => {
+    const fiber = subscription.fiber;
+    subscription.fiber = null;
+    subscription.owner = null;
+    return fiber ? Effect.runPromise(Fiber.interrupt(fiber)).catch(() => {
+    }) : Promise.resolve();
+  };
+  const disposeSubscription = (subscription) => {
+    subscription.active = false;
+    subscriptions.delete(subscription);
+    if (subscription.watchdogTimer) {
+      clearInterval(subscription.watchdogTimer);
+      subscription.watchdogTimer = null;
+    }
+    return stopSubscriptionFiber(subscription);
+  };
+  const scheduleReconnect = () => {
+    if (closed || subscriptions.size === 0 || reconnectTimer || session || sessionPromise) return;
+    if (typeof options.reconnectAttempts === "number" && reconnectAttemptsUsed >= options.reconnectAttempts) return;
+    const delayMs = Math.min(2500, reconnectBaseDelayMs * 1.5 ** reconnectAttemptsUsed);
+    reconnectTimer = setTimeout(() => {
+      reconnectTimer = null;
+      reconnectAttemptsUsed++;
+      connectSubscriptions();
+    }, delayMs);
+    reconnectTimer.unref?.();
+  };
+  const invalidateSession = (active, state, error) => {
+    if (active.invalidated) return;
+    active.invalidated = true;
+    if (session === active) session = null;
+    void active.runtime.dispose().catch(() => {
+    });
+    if (!closed) setConn(state, error);
+    scheduleReconnect();
+  };
+  const makeProtocolLayer = async (ready, disconnected) => {
+    const socketLayer = await socketLayerFor(url, options.transport, requestTimeoutMs);
+    const connectionHooksLayer = Layer.succeed(
+      RpcClient.ConnectionHooks,
+      RpcClient.ConnectionHooks.of({
+        onConnect: Effect.sync(() => {
+          ready.resolve();
+        }),
+        onDisconnect: Effect.sync(() => {
+          disconnected.resolve(new DaemonRpcConnectionError());
+        })
+      })
+    );
+    return Layer.effect(
+      RpcClient.Protocol,
+      RpcClient.makeProtocolSocket({
+        retryPolicy: Schedule.recurs(0),
+        retryTransientErrors: false
+      })
+    ).pipe(
+      Layer.provide(Layer.mergeAll(socketLayer, RpcSerialization.layerJson, connectionHooksLayer))
+    );
+  };
+  const ensureSession = async () => {
+    if (closed) throw new Error("daemon RPC client is closed");
+    if (session) return session;
+    if (sessionPromise) return sessionPromise;
+    setConn(hasConnected ? "reconnecting" : "connecting");
+    const pending = (async () => {
+      let runtime = null;
+      try {
+        const ready = makeSignal();
+        const disconnected = makeSignal();
+        const protocolLayer = await makeProtocolLayer(ready, disconnected);
+        const clientLayer = Layer.effect(
+          TokmonRpcClient,
+          RpcClient.make(TokmonRpcGroup)
+        ).pipe(Layer.provide(protocolLayer));
+        runtime = ManagedRuntime.make(clientLayer);
+        pendingRuntime = runtime;
+        await runtime.runPromise(TokmonRpcClient.asEffect());
+        await waitForReady(ready, disconnected, requestTimeoutMs);
+        if (closed) throw new Error("daemon RPC client is closed");
+        const active = {
+          runtime,
+          disconnected: disconnected.promise,
+          invalidated: false
+        };
+        session = active;
+        pendingRuntime = null;
+        hasConnected = true;
+        reconnectAttemptsUsed = 0;
+        setConn("live");
+        void active.disconnected.then((error) => {
+          invalidateSession(active, "reconnecting", error);
+        });
+        startAllSubscriptions(active);
+        return active;
+      } catch (error) {
+        if (pendingRuntime === runtime) pendingRuntime = null;
+        await runtime?.dispose().catch(() => {
+        });
+        if (!closed) setConn("error", error);
+        throw error;
+      }
+    })();
+    sessionPromise = pending;
+    try {
+      return await pending;
+    } finally {
+      if (sessionPromise === pending) sessionPromise = null;
+    }
+  };
+  const run = async (method, effectFor) => {
+    const active = await ensureSession();
+    try {
+      return await active.runtime.runPromise(
+        TokmonRpcClient.use((client) => effectFor(client)).pipe(
+          Effect.timeoutOrElse({
+            duration: Duration.millis(requestTimeoutMs),
+            orElse: () => Effect.fail(new DaemonRpcRequestTimeoutError(method, requestTimeoutMs))
+          })
+        )
+      );
+    } catch (rawError) {
+      const error = normalizeRequestFailure(rawError);
+      if (!closed && isSessionFailure(error)) invalidateSession(active, "error", error);
+      throw error;
+    }
+  };
+  const startSubscription = (subscription, active) => {
+    if (closed || !subscription.active || subscription.fiber || active.invalidated) return;
+    subscription.lastValueAt = Date.now();
+    subscription.staleAfterMs = options.snapshotStaleFloorMs ?? 9e4;
+    subscription.owner = active;
+    const fiber = active.runtime.runFork(
+      TokmonRpcClient.use(
+        (client) => subscription.streamFor(client).pipe(
+          Stream.runForEach(
+            (value) => Effect.sync(() => {
+              subscription.lastValueAt = Date.now();
+              if (subscription.staleAfterFor) subscription.staleAfterMs = subscription.staleAfterFor(value);
+              try {
+                subscription.onValue(value);
+              } catch (error) {
+                reportSubscriberError(error);
+              }
+            })
+          )
+        )
+      )
+    );
+    subscription.fiber = fiber;
+    fiber.addObserver((exit) => {
+      if (subscription.fiber === fiber) subscription.fiber = null;
+      if (subscription.owner === active) subscription.owner = null;
+      if (closed || !subscription.active || active.invalidated) return;
+      if (Exit.isSuccess(exit)) {
+        invalidateSession(active, "reconnecting");
+      } else {
+        invalidateSession(active, "error", Cause.squash(exit.cause));
+      }
+    });
+  };
+  const startAllSubscriptions = (active) => {
+    for (const subscription of subscriptions) startSubscription(subscription, active);
+  };
+  function connectSubscriptions() {
+    if (closed || subscriptions.size === 0 || supervisorPromise) return;
+    supervisorPromise = ensureSession().then(() => void 0).catch(() => {
+      scheduleReconnect();
+    }).finally(() => {
+      supervisorPromise = null;
+    });
+  }
+  const subscribe = (streamFor, onValue, staleAfterFor) => {
+    if (closed) return () => {
+    };
+    const subscription = {
+      streamFor,
+      onValue,
+      staleAfterFor,
+      active: true,
+      fiber: null,
+      owner: null,
+      watchdogTimer: null,
+      lastValueAt: 0,
+      staleAfterMs: Number.POSITIVE_INFINITY
+    };
+    subscriptions.add(subscription);
+    if (staleAfterFor) {
+      const checkEveryMs = Math.min(5e3, Math.max(10, (options.snapshotStaleFloorMs ?? 9e4) / 2));
+      subscription.watchdogTimer = setInterval(() => {
+        if (!subscription.fiber || !subscription.owner || subscription.lastValueAt === 0) return;
+        if (Date.now() - subscription.lastValueAt <= subscription.staleAfterMs) return;
+        subscription.lastValueAt = Date.now();
+        invalidateSession(subscription.owner, "reconnecting");
+      }, checkEveryMs);
+      subscription.watchdogTimer.unref?.();
+    }
+    if (session) startSubscription(subscription, session);
+    else connectSubscriptions();
+    return () => {
+      void disposeSubscription(subscription);
+      if (subscriptions.size === 0) clearReconnectTimer();
+    };
+  };
+  return {
+    getConfig: () => run(TOKMON_WS_METHODS.getConfig, (client) => client[TOKMON_WS_METHODS.getConfig]({})).then(normalizeConfigState),
+    setConfig: (update) => run(TOKMON_WS_METHODS.setConfig, (client) => client[TOKMON_WS_METHODS.setConfig](update)).then(normalizeConfigState),
+    refresh: (scope = "all") => run(TOKMON_WS_METHODS.refresh, (client) => client[TOKMON_WS_METHODS.refresh]({ scope })),
+    browseFs: (path) => run(TOKMON_WS_METHODS.browseFs, (client) => client[TOKMON_WS_METHODS.browseFs]({ path })),
+    subscribeSnapshot: (onSnapshot) => subscribe(
+      (client) => client[TOKMON_WS_METHODS.snapshot]({}).pipe(Stream.map(normalizeSnapshot)),
+      onSnapshot,
+      (snapshot) => Math.max(options.snapshotStaleFloorMs ?? 9e4, snapshot.intervalMs * 3)
+    ),
+    subscribeConfig: (onConfig) => subscribe(
+      (client) => client[TOKMON_WS_METHODS.config]({}).pipe(Stream.map(normalizeConfigState)),
+      onConfig
+    ),
+    async close() {
+      if (closed) return;
+      closed = true;
+      setConn("closed");
+      clearReconnectTimer();
+      const cleanup = [...subscriptions].map(disposeSubscription);
+      subscriptions.clear();
+      const activeSession = session;
+      session = null;
+      await pendingRuntime?.dispose().catch(() => {
+      });
+      await Promise.all(cleanup);
+      await activeSession?.runtime.dispose().catch(() => {
+      });
+      await sessionPromise?.catch(() => {
+      });
+      pendingRuntime = null;
+      sessionPromise = null;
+      supervisorPromise = null;
+    }
+  };
+}
+
+export {
+  createDaemonRpcClient
+};

package/dist/{chunk-LCAHTRGP.js → chunk-CFKUZCMB.js}

@@ -5,7 +5,7 @@ import {
   envDir,
   expandHome,
   isValidTimezone
-} from "./chunk-HP5UZCXP.js";
+} from "./chunk-HNWEJ6MS.js";
 
 // src/async.ts
 var DEFAULT_TIMEOUT_MS = 3e4;
@@ -20,13 +20,6 @@ function withTimeout(promise, ms = DEFAULT_TIMEOUT_MS) {
   });
 }
 
-// src/providers/usage-core.ts
-import { readFileSync, readdirSync } from "fs";
-import { readdir as readdir2 } from "fs/promises";
-import { dirname, join as join2, relative } from "path";
-import { createHash as createHash2 } from "crypto";
-import { fileURLToPath } from "url";
-
 // src/tz.ts
 function systemTimezone() {
   try {
@@ -120,14 +113,17 @@ function startOfWeek(ts, tz) {
   const offset = p.weekday === 0 ? 6 : p.weekday - 1;
   return instantFromTz(p.y, p.m, p.d - offset, 0, 0, 0, tz);
 }
-function monthsAgoStart(ts, months, tz) {
-  const p = tzParts(ts, tz);
-  return instantFromTz(p.y, p.m - months, 1, 0, 0, 0, tz);
-}
 function weekKey(ts, tz) {
   return dayKey(startOfWeek(ts, tz), tz);
 }
 
+// src/providers/usage-core.ts
+import { readFileSync, readdirSync } from "fs";
+import { readdir as readdir2 } from "fs/promises";
+import { dirname, join as join2, relative } from "path";
+import { createHash as createHash2 } from "crypto";
+import { fileURLToPath } from "url";
+
 // src/providers/_shared/metric.ts
 var finite = (value, fallback = 0) => typeof value === "number" && Number.isFinite(value) ? value : fallback;
 var finiteNumber = (value) => typeof value === "number" && Number.isFinite(value);
@@ -395,7 +391,7 @@ async function mapLimit(items, limit, fn) {
 }
 
 // src/providers/usage-core.ts
-var SPARK_DAYS = 14;
+var SPARK_DAYS = 30;
 var DAY_MS = 864e5;
 var PRUNE_AGE_MS = 230 * DAY_MS;
 var stores = /* @__PURE__ */ new Map();
@@ -560,8 +556,8 @@ function dashboardSince(tz) {
   const now = Date.now();
   return Math.min(startOfMonth(now, tz), startOfWeek(now, tz), now - SPARK_DAYS * DAY_MS);
 }
-function tableSince(tz) {
-  return monthsAgoStart(Date.now(), 6, tz);
+function tableSince(_tz) {
+  return 0;
 }
 function cleanEntry(e) {
   return {
@@ -596,6 +592,7 @@ function summarize(entries, tz) {
   const byDay = /* @__PURE__ */ new Map();
   let oldestToday = now;
   let hadToday = false;
+  let lastActivityAt = null;
   const add = (s, e) => {
     s.cost += e.cost;
     s.tokens += e.input + e.output + e.cacheCreate + e.cacheRead;
@@ -605,6 +602,9 @@ function summarize(entries, tz) {
   };
   for (const raw of entries) {
     const e = cleanEntry(raw);
+    if (e.ts > 0 && (lastActivityAt === null || e.ts > lastActivityAt)) {
+      lastActivityAt = Math.floor(e.ts);
+    }
     if (e.ts >= monthStart) add(month, e);
     if (e.ts >= weekStart) add(week, e);
     if (e.ts >= todayStart) {
@@ -619,7 +619,7 @@ function summarize(entries, tz) {
   const rawBurnRate = hadToday ? today.cost / hrs : 0;
   const burnRate = Number.isFinite(rawBurnRate) ? rawBurnRate : 0;
   const series = lastDayKeys(now, tz, SPARK_DAYS).map((k) => byDay.get(k) ?? 0);
-  return { today, week, month, burnRate, series };
+  return { today, week, month, burnRate, series, lastActivityAt };
 }
 function groupBy(entries, keyFn) {
   const groups = /* @__PURE__ */ new Map();
@@ -747,7 +747,10 @@ function formatCurrency(value, opts = {}) {
   const abs = Math.abs(value);
   if (abs >= 1e5) return `${sign}$${(value / 1e3).toFixed(0)}k`;
   if (abs >= 1e4) return `${sign}$${(value / 1e3).toFixed(1)}k`;
-  if (abs >= 1) return `${sign}$${value.toFixed(2)}`;
+  if (abs >= 1) {
+    const polarity = value < 0 ? "-" : "";
+    return `${sign}${polarity}$${abs.toLocaleString("en-US", { minimumFractionDigits: 2, maximumFractionDigits: 2 })}`;
+  }
   if (abs >= 0.01) return `${sign}$${value.toFixed(3)}`;
   if (abs === 0) return "$0.00";
   return `${sign}$${value.toFixed(4)}`;
@@ -784,17 +787,22 @@ function formatShortDate(label, opts = {}) {
   const day = Number(match[3]);
   return `${MONTHS[Number(match[2]) - 1]} ${opts.padDay ? day.toString().padStart(2, " ") : day}`;
 }
+function resetParts(diffMs) {
+  if (!Number.isFinite(diffMs) || diffMs <= 0) return null;
+  const totalMinutes = Math.max(1, Math.ceil(diffMs / 6e4));
+  return {
+    days: Math.floor(totalMinutes / (24 * 60)),
+    hours: Math.floor(totalMinutes % (24 * 60) / 60),
+    minutes: totalMinutes % 60,
+    totalMinutes
+  };
+}
 function formatResetIn(iso, now = Date.now()) {
-  const diff = new Date(iso).getTime() - now;
-  if (!Number.isFinite(diff) || diff <= 0) return "now";
-  const minutes = Math.round(diff / 6e4);
-  if (minutes < 60) return `${minutes}m`;
-  const hours = Math.floor(minutes / 60);
-  const mins = minutes % 60;
-  if (hours < 24) return `${hours}h ${mins}m`;
-  const days = Math.floor(hours / 24);
-  const hrs = hours % 24;
-  return `${days}d ${hrs}h`;
+  const parts = resetParts(new Date(iso).getTime() - now);
+  if (!parts) return "now";
+  if (parts.days > 0) return `${parts.days}d ${parts.hours}h`;
+  if (parts.hours > 0) return `${parts.hours}h ${parts.minutes}m`;
+  return `${parts.minutes}m`;
 }
 function formatResetAt(iso, display, now = Date.now(), tz) {
   const timestamp = Date.parse(iso);
@@ -1269,7 +1277,19 @@ function limitMetric(entry, primary) {
   if (used === void 0) return null;
   const label = limitLabel(o);
   if (!label) return null;
-  return percentMetric(label, used, resetFrom(o.resets_at), primary);
+  const scope = recordValue(o.scope);
+  const model = recordValue(scope?.model);
+  const modelId = nonEmptyString(model?.id);
+  const kind = nonEmptyString(o.kind)?.toLowerCase() ?? "";
+  const scopedModel = kind === "weekly_scoped" || kind.startsWith("weekly_model");
+  const role = kind === "session" || nonEmptyString(o.group)?.toLowerCase() === "session" ? "session" : kind === "weekly_all" ? "weekly" : modelId || scopedModel ? "model" : "other";
+  return {
+    ...percentMetric(label, used, resetFrom(o.resets_at), primary),
+    key: modelId ? `model:${modelId}` : kind || label.toLowerCase(),
+    role,
+    modelId: modelId ?? (scopedModel ? label.toLowerCase().replace(/\s+/g, "-") : null),
+    active: boolValue(o.is_active)
+  };
 }
 function limitMetrics(limits) {
   if (!Array.isArray(limits)) return [];
@@ -1296,7 +1316,12 @@ function topLevelUsageMetrics(data) {
     const window = recordValue(value);
     if (!window || numberValue(window.utilization) === void 0) continue;
     const metric = usageMetric(usageLabelFromKey(key), window, key === "five_hour" ? true : void 0);
-    if (metric) metrics.push(metric);
+    if (metric) metrics.push({
+      ...metric,
+      key,
+      role: key === "five_hour" ? "session" : key === "seven_day" ? "weekly" : key.startsWith("seven_day_") ? "model" : "other",
+      modelId: key.startsWith("seven_day_") ? key.slice("seven_day_".length) : null
+    });
   }
   return metrics;
 }
@@ -1339,6 +1364,8 @@ async function claudeBilling(account) {
       if (usedCredits !== void 0 && (usedCredits > 0 || monthlyLimit !== void 0 && monthlyLimit > 0)) {
         const scale = decimalScale(data.extra_usage?.decimal_places);
         metrics.push({
+          key: "extra_usage",
+          role: "unbounded",
           label: "Extra",
           used: finite(usedCredits) / scale,
           limit: monthlyLimit !== void 0 && monthlyLimit > 0 ? monthlyLimit / scale : null,