ompchamber 2.0.2 → 3.0.0

package/src/server/lib/omp/config/provider-seeds.ts

@@ -0,0 +1,176 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Model-entry plumbing for the models.yml writer: the seed shape a provider
+ * listing produces, the YAML entry omp expects for it, and the backfill of
+ * metadata a bare existing entry is missing.
+ *
+ * Split from `./providers.ts` (the provider-level upsert) so each file stays
+ * under the repo's size ceiling; both are one write path.
+ */
+
+import type { Document, YAMLMap } from 'yaml';
+import { sanitizeModelEntry } from '@/server/lib/omp/config/models-validation';
+import { plainOf } from '@/server/lib/omp/config/document';
+import { isRecord } from '@/shared/lib/util/guards';
+import type { ProviderThinkingEffort } from '@/shared/lib/models/provider/dialect';
+
+/** One model entry destined for models.yml (cost numbers are USD per 1M tokens). */
+export interface OmpProviderModelSeed {
+  id: string;
+  name?: string;
+  reasoning?: boolean;
+  imageInput?: boolean;
+  contextWindow?: number;
+  maxTokens?: number;
+  cost?: { input: number; output: number; cacheRead: number; cacheWrite: number };
+  /**
+   * The reasoning ladder this model accepts, lowest first (`thinking.efforts`).
+   *
+   * Only written when the user picks a subset: an EMPTY list is what omp
+   * already assumes for a reasoning model, so writing `efforts: []` would add a
+   * block that changes nothing while claiming to be a configuration.
+   */
+  efforts?: ProviderThinkingEffort[];
+}
+
+/** The model ids already registered under `provider`, array form only. */
+export function knownModelIds(provider: Record<string, unknown> | undefined): Set<string> {
+  if (!Array.isArray(provider?.models)) return new Set();
+  return new Set(
+    provider.models
+      .map((model) => (isRecord(model) && typeof model.id === 'string' ? model.id : ''))
+      .filter(Boolean),
+  );
+}
+
+/** The model entry as omp expects it, omitting anything omp would reject. */
+export function toModelEntry(model: OmpProviderModelSeed): Record<string, unknown> {
+  // omp's `ModelThinkingSchema` requires `mode`; the only ladder the chamber
+  // writes is the effort one, which is what a chat model's `efforts` list means.
+  const efforts = model.efforts && model.efforts.length > 0 ? model.efforts : undefined;
+  return sanitizeModelEntry({
+    id: model.id,
+    ...(model.name ? { name: model.name } : {}),
+    ...(model.reasoning !== undefined ? { reasoning: model.reasoning } : {}),
+    ...(efforts ? { thinking: { mode: 'effort', efforts } } : {}),
+    ...(model.imageInput ? { input: ['text', 'image'] } : { input: ['text'] }),
+    ...(model.contextWindow && model.contextWindow > 0 ? { contextWindow: model.contextWindow } : {}),
+    ...(model.maxTokens && model.maxTokens > 0 ? { maxTokens: model.maxTokens } : {}),
+    ...(model.cost ? { cost: model.cost } : {}),
+  });
+}
+
+/**
+ * Metadata a bare existing entry is missing, taken from the freshly fetched
+ * seed. Values already present are never touched. Writes through the YAML node
+ * so the entry's own comments and key order stay as the user wrote them.
+ */
+export function backfillEntry(doc: Document, entry: YAMLMap, seed: OmpProviderModelSeed): void {
+  if (seed.name && !entry.has('name')) entry.set('name', seed.name);
+  if (seed.reasoning !== undefined && !entry.has('reasoning')) {
+    entry.set('reasoning', seed.reasoning);
+  }
+  const currentInput = plainOf<string[]>(doc, entry.get('input'));
+  if (seed.imageInput && (!Array.isArray(currentInput) || !currentInput.includes('image'))) {
+    entry.set('input', ['text', 'image']);
+  }
+  if (seed.contextWindow && seed.contextWindow > 0 && !plainOf(doc, entry.get('contextWindow'))) {
+    entry.set('contextWindow', seed.contextWindow);
+  }
+  if (seed.maxTokens && seed.maxTokens > 0 && !plainOf(doc, entry.get('maxTokens'))) {
+    entry.set('maxTokens', seed.maxTokens);
+  }
+  if (seed.cost && !entry.has('cost')) {
+    entry.set('cost', seed.cost);
+  }
+}
+
+/**
+ * A model seed built from MANUAL user input (the "Add model" dialog) rather
+ * than a provider listing.
+ *
+ * Numbers arrive as tokens, not as the compact labels a listing produces, so
+ * there is nothing to parse — but the same rules apply: omp rejects the whole
+ * file over a non-positive `contextWindow`/`maxTokens` or a partial `cost`, so
+ * anything not usable is dropped here rather than written and rejected later.
+ */
+export interface ManualModelInput {
+  id: string;
+  name?: string;
+  contextWindow?: number;
+  maxTokens?: number;
+  reasoning?: boolean;
+  imageInput?: boolean;
+  costInput?: number;
+  costOutput?: number;
+  costCacheRead?: number;
+  costCacheWrite?: number;
+  /** Subset of omp's effort ladder this model accepts; empty means "not declared". */
+  efforts?: ProviderThinkingEffort[];
+}
+
+export function manualModelSeed(input: ManualModelInput): OmpProviderModelSeed {
+  const positive = (value: unknown): number | undefined => (
+    typeof value === 'number' && Number.isFinite(value) && value > 0 ? Math.round(value) : undefined
+  );
+  const finite = (value: unknown): number | undefined => (
+    typeof value === 'number' && Number.isFinite(value) && value >= 0 ? value : undefined
+  );
+  const costInput = finite(input.costInput);
+  const costOutput = finite(input.costOutput);
+  // omp requires all four cost fields together, so the two cache rates are
+  // written as 0 when the user left them out — that is "no cached-token
+  // discount", which is what an unlisted rate means.
+  const hasCost = costInput !== undefined && costOutput !== undefined;
+  // A ladder is a capability, so it is only declared for a reasoning model and
+  // only when the user chose a subset; an empty list is omp's own default.
+  const efforts = input.reasoning && input.efforts && input.efforts.length > 0
+    ? [...new Set(input.efforts)]
+    : undefined;
+  return {
+    id: input.id.trim(),
+    ...(input.name?.trim() ? { name: input.name.trim() } : {}),
+    ...(input.reasoning ? { reasoning: true } : {}),
+    ...(efforts ? { efforts } : {}),
+    ...(input.imageInput ? { imageInput: true } : {}),
+    ...(positive(input.contextWindow) ? { contextWindow: positive(input.contextWindow) } : {}),
+    ...(positive(input.maxTokens) ? { maxTokens: positive(input.maxTokens) } : {}),
+    ...(hasCost ? {
+      cost: {
+        input: costInput,
+        output: costOutput,
+        cacheRead: finite(input.costCacheRead) ?? 0,
+        cacheWrite: finite(input.costCacheWrite) ?? 0,
+      },
+    } : {}),
+  };
+}
+
+/**
+ * Existing entries worth backfilling: a bare id whose seed now carries
+ * metadata the entry lacks (context window, price, reasoning, image input).
+ */
+export function backfillableIds(
+  existingModels: unknown,
+  incomingById: Map<string, OmpProviderModelSeed>,
+): string[] {
+  if (!Array.isArray(existingModels)) return [];
+  return existingModels
+    .filter((model): model is Record<string, unknown> => {
+      if (!isRecord(model) || typeof model.id !== 'string') return false;
+      const seed = incomingById.get(model.id);
+      if (!seed) return false;
+      const missingContext = typeof model.contextWindow !== 'number' || !model.contextWindow;
+      return Boolean(
+        (missingContext && (seed.contextWindow || seed.maxTokens))
+        || (!model.cost && seed.cost)
+        || (seed.reasoning !== undefined && model.reasoning === undefined)
+        || (!Array.isArray(model.input) && seed.imageInput),
+      );
+    })
+    .map((model) => String(model.id));
+}

package/src/server/lib/omp/config/providers.ts

@@ -13,27 +13,48 @@
  * schema before it reaches disk. Reading lives in `./models-config.ts`.
  */
 
-import { isMap, isSeq, type Document, type YAMLMap } from 'yaml';
+import { isMap, isSeq, type YAMLMap } from 'yaml';
 import { getModelsConfigPath } from '@/server/lib/omp/config/models-config';
 import { plainOf, withOmpYamlDocument, OmpConfigError } from '@/server/lib/omp/config/document';
-import { validateModelsDocument, sanitizeModelEntry } from '@/server/lib/omp/config/models-validation';
-import { isRecord } from '@/shared/lib/util/guards';
+import { validateModelsDocument } from '@/server/lib/omp/config/models-validation';
+import {
+  backfillableIds,
+  backfillEntry,
+  knownModelIds,
+  toModelEntry,
+  type OmpProviderModelSeed,
+} from '@/server/lib/omp/config/provider-seeds';
+import { isMaskedApiKey } from '@/shared/lib/models/provider/dialect';
+import type {
+  OmpProviderApi,
+  ProviderAuthMode,
+  ProviderDiscoveryType,
+} from '@/shared/types/settings/provider';
 
-/** One model entry destined for models.yml (cost numbers are USD per 1M tokens). */
-export interface OmpProviderModelSeed {
-  id: string;
-  name?: string;
-  reasoning?: boolean;
-  imageInput?: boolean;
-  contextWindow?: number;
-  maxTokens?: number;
-  cost?: { input: number; output: number; cacheRead: number; cacheWrite: number };
-}
+export type { OmpProviderModelSeed } from '@/server/lib/omp/config/provider-seeds';
 
 export interface OmpProviderUpsertInput {
   baseUrl: string;
   apiKey?: string;
-  api?: 'openai-completions' | 'anthropic-messages' | 'google-generative-ai';
+  api?: OmpProviderApi;
+  /**
+   * omp's auth mode. `none` is what registers a keyless local server: without
+   * it omp demands an `apiKey` and rejects the provider as unconfigured.
+   */
+  auth?: ProviderAuthMode;
+  /**
+   * Let OMP list this provider's models live instead of the chamber writing a
+   * snapshot of ids. A discovery provider is legitimately registered with an
+   * empty `models` array.
+   */
+  discovery?: ProviderDiscoveryType;
+  /**
+   * Register/override the provider WITHOUT writing any model ids — the shape
+   * omp documents as an "override-only provider". Used when the provider is one
+   * omp already bundles (its own catalog supplies the models) or when its
+   * model list is owned by discovery.
+   */
+  overrideOnly?: boolean;
   models: OmpProviderModelSeed[];
 }
 
@@ -46,75 +67,30 @@ export interface OmpProviderUpsertResult {
   reason?: string;
 }
 
-/** Masks a stored credential echoed back by the UI; not a value to persist. */
-const MASKED_KEY_PATTERN = /•{3,}/;
-
-/** True when `value` is a credential the UI masked rather than a real key. */
-export function isMaskedApiKey(value: unknown): boolean {
-  return typeof value === 'string' && MASKED_KEY_PATTERN.test(value);
-}
-
-/** The model ids already registered under `provider`, array form only. */
-function knownModelIds(provider: Record<string, unknown> | undefined): Set<string> {
-  if (!Array.isArray(provider?.models)) return new Set();
-  return new Set(
-    provider.models
-      .map((model) => (isRecord(model) && typeof model.id === 'string' ? model.id : ''))
-      .filter(Boolean),
-  );
-}
-
-/** The model entry as omp expects it, omitting anything omp would reject. */
-function toModelEntry(model: OmpProviderModelSeed): Record<string, unknown> {
-  return sanitizeModelEntry({
-    id: model.id,
-    ...(model.name ? { name: model.name } : {}),
-    ...(model.reasoning !== undefined ? { reasoning: model.reasoning } : {}),
-    ...(model.imageInput ? { input: ['text', 'image'] } : { input: ['text'] }),
-    ...(model.contextWindow && model.contextWindow > 0 ? { contextWindow: model.contextWindow } : {}),
-    ...(model.maxTokens && model.maxTokens > 0 ? { maxTokens: model.maxTokens } : {}),
-    ...(model.cost ? { cost: model.cost } : {}),
-  });
-}
-
-/**
- * Metadata a bare existing entry is missing, taken from the freshly fetched
- * seed. Values already present are never touched. Writes through the YAML node
- * so the entry's own comments and key order stay as the user wrote them.
- */
-function backfillEntry(doc: Document, entry: YAMLMap, seed: OmpProviderModelSeed): void {
-  if (seed.name && !entry.has('name')) entry.set('name', seed.name);
-  if (seed.reasoning !== undefined && !entry.has('reasoning')) {
-    entry.set('reasoning', seed.reasoning);
-  }
-  const currentInput = plainOf<string[]>(doc, entry.get('input'));
-  if (seed.imageInput && (!Array.isArray(currentInput) || !currentInput.includes('image'))) {
-    entry.set('input', ['text', 'image']);
-  }
-  if (seed.contextWindow && seed.contextWindow > 0 && !plainOf(doc, entry.get('contextWindow'))) {
-    entry.set('contextWindow', seed.contextWindow);
-  }
-  if (seed.maxTokens && seed.maxTokens > 0 && !plainOf(doc, entry.get('maxTokens'))) {
-    entry.set('maxTokens', seed.maxTokens);
-  }
-  if (seed.cost && !entry.has('cost')) {
-    entry.set('cost', seed.cost);
-  }
-}
-
 /**
  * Add-only upsert of a provider (and its models) into the native omp
  * models.yml — the agent's own registry, where per-model cost feeds usage
- * tracking. Existing provider fields (apiKey, baseUrl) and existing model
+ * tracking. Existing provider fields (apiKey, baseUrl, api) and existing model
  * entries are never modified; only models whose id is not yet registered are
- * appended. Merges preserve unrelated keys, comments and formatting (document
- * model), and the write is atomic and mode-preserving.
+ * appended, and only fields the entry is MISSING are filled. Merges preserve
+ * unrelated keys, comments and formatting (document model), and the write is
+ * atomic and mode-preserving.
+ *
+ * Three provider shapes are written here, and omp's rules differ for each:
+ *
+ * - **full** (`models` non-empty): `baseUrl` plus an `apiKey` unless
+ *   `auth: none`/`oauth`.
+ * - **discovery** (`discovery` set): a shell omp lists models from itself. The
+ *   model list stays empty — writing ids as well would freeze a snapshot omp
+ *   would then serve alongside its live discovery.
+ * - **override** (`overrideOnly`, or an empty model list for a provider omp
+ *   already bundles): keep omp's own catalog models and only change the
+ *   endpoint. A provider with neither models nor any config field is rejected
+ *   by omp, so one of `baseUrl`/`apiKey`/`auth: none`/`discovery` must be set.
  *
- * Provider creation requires an apiKey — omp rejects models-cfg providers
- * without one unless auth is "none" or "oauth"; existing providers keep
- * whatever credential they already have. The finished document is validated
- * against omp's own rules before the write: a schema violation anywhere in the
- * file makes omp disable every custom provider at once.
+ * The finished document is validated against omp's own rules before the write:
+ * a schema violation anywhere in the file makes omp disable every custom
+ * provider at once.
  */
 export async function upsertOmpProviderModels(
   slug: string,
@@ -144,11 +120,18 @@ export async function upsertOmpProviderModels(
         + 'Fix that entry before adding models; omp currently disables every custom provider because of it.',
       );
     }
+    // omp demands an `apiKey` only when a provider carries MODELS: an
+    // override-only entry (baseUrl/discovery/auth) is valid without one, which
+    // is how a proxy override for a bundled provider keeps using `/login`
+    // credentials, and how a keyless local server is declared.
+    const overrideOnly = input.overrideOnly === true || input.discovery !== undefined;
+    const writesModels = !overrideOnly && input.models.length > 0;
+    const keyless = input.auth === 'none' || input.auth === 'oauth';
     const known = knownModelIds(existing);
     const incomingById = new Map(input.models.map((model) => [model.id, model]));
     const additions = input.models.filter((model) => model.id && !known.has(model.id));
 
-    if (!existing && !input.apiKey) {
+    if (!existing && writesModels && !input.apiKey && !keyless) {
       return {
         result: {
           written: false,
@@ -164,7 +147,7 @@ export async function upsertOmpProviderModels(
     // writer is the last gate before a file omp will authenticate with — a
     // masked placeholder persisted here would look like a configured provider
     // that cannot authenticate.
-    if (!existing && isMaskedApiKey(input.apiKey)) {
+    if (!existing && writesModels && isMaskedApiKey(input.apiKey)) {
       return {
         result: {
           written: false,
@@ -179,22 +162,21 @@ export async function upsertOmpProviderModels(
 
     // Existing entries with bare ids (no context, no capabilities) get the
     // fetched metadata filled in — values already present are never touched.
-    const backfillIds = (Array.isArray(existing?.models) ? existing.models : [])
-      .filter((model): model is Record<string, unknown> => {
-        if (!isRecord(model) || typeof model.id !== 'string') return false;
-        const seed = incomingById.get(model.id);
-        if (!seed) return false;
-        const missingContext = typeof model.contextWindow !== 'number' || !model.contextWindow;
-        return Boolean(
-          (missingContext && (seed.contextWindow || seed.maxTokens))
-          || (!model.cost && seed.cost)
-          || (seed.reasoning !== undefined && model.reasoning === undefined)
-          || (!Array.isArray(model.input) && seed.imageInput),
-        );
-      })
-      .map((model) => String(model.id));
+    // A discovery provider keeps its empty list: omp owns those models.
+    const backfillIds = overrideOnly ? [] : backfillableIds(existing?.models, incomingById);
 
-    if (additions.length === 0 && backfillIds.length === 0) {
+    // A provider the user re-saves without any new model and without a dialect
+    // change has nothing to write — reporting `written: true` there would claim
+    // a file edit that never happened. A provider that does NOT exist yet is
+    // always a change: the entry itself is the write, which is the whole point
+    // of a discovery or override registration that carries no model ids.
+    const providerChanged = !existing || Boolean(
+      (input.api && !existing.api)
+      || (input.auth && input.auth !== 'apiKey' && !existing.auth)
+      || (input.discovery && !existing.discovery),
+    );
+
+    if (additions.length === 0 && backfillIds.length === 0 && !providerChanged) {
       return {
         result: {
           written: false,
@@ -213,16 +195,28 @@ export async function upsertOmpProviderModels(
     if (!existing) {
       doc.setIn(['providers', slug], doc.createNode({
         baseUrl: input.baseUrl,
-        apiKey: input.apiKey,
+        // `auth: none` makes an apiKey optional, so a keyless shell omits it
+        // rather than writing an empty string omp rejects.
+        ...(input.apiKey ? { apiKey: input.apiKey } : {}),
         // omp disables every custom provider when a models-carrying provider
         // lacks "api" (provider or model level) — always set one.
         api: input.api ?? 'openai-completions',
+        ...(input.auth && input.auth !== 'apiKey' ? { auth: input.auth } : {}),
+        ...(input.discovery ? { discovery: { type: input.discovery } } : {}),
         models: [],
       }));
-    } else if (!existing.api) {
-      // Existing provider without an api: adding models without one would make
-      // the whole models.yml fail omp validation, so fill it.
-      doc.setIn(['providers', slug, 'api'], input.api ?? 'openai-completions');
+    } else {
+      // Add-only: a field the entry already carries belongs to the user, and
+      // rewriting it would discard a credential or endpoint they pinned.
+      if (!existing.api) {
+        doc.setIn(['providers', slug, 'api'], input.api ?? 'openai-completions');
+      }
+      if (input.auth && input.auth !== 'apiKey' && !existing.auth) {
+        doc.setIn(['providers', slug, 'auth'], input.auth);
+      }
+      if (input.discovery && !existing.discovery) {
+        doc.setIn(['providers', slug, 'discovery'], doc.createNode({ type: input.discovery }));
+      }
     }
 
     // `addIn` on a missing key creates a MAP, not a sequence — exactly the

package/src/server/lib/omp/core/auth-credentials.ts

@@ -85,3 +85,48 @@ export async function readOmpProviderApiKey(slug: string): Promise<string | null
   if (fromYml) return fromYml;
   return readAgentDbApiKey(slug);
 }
+
+/**
+ * Slugs holding a live (non-disabled) credential in omp's agent.db. Used to
+ * decide which providers a usage surface may list — a provider with no
+ * credential must not be shown at all. Returns slugs only, never key material.
+ */
+export async function listAgentDbCredentialSlugs(): Promise<string[]> {
+  const dbPath = join(getAgentDir(), 'agent.db');
+  if (!(await Bun.file(dbPath).exists())) return [];
+  let db: Database | null = null;
+  try {
+    db = new Database(dbPath, { readonly: true });
+    const rows = db
+      .query<{ provider: string }, []>(
+        `SELECT DISTINCT provider FROM ${AUTH_CREDENTIALS_TABLE} WHERE disabled_cause IS NULL`,
+      )
+      .all();
+    return rows
+      .map((row) => (typeof row.provider === 'string' ? row.provider.trim().toLowerCase() : ''))
+      .filter(Boolean);
+  } catch {
+    return []; // no-excuse-ok: catch — best-effort read of an external store
+  } finally {
+    db?.close();
+  }
+}
+
+/** Slugs carrying an `apiKey` in models.yml. Returns slugs only. */
+export async function listModelsYmlCredentialSlugs(): Promise<string[]> {
+  const path = await getModelsConfigPath();
+  if (!(await Bun.file(path).exists())) return [];
+  try {
+    const data = Bun.YAML.parse(await Bun.file(path).text());
+    if (!isRecord(data) || !isRecord(data.providers)) return [];
+    const slugs: string[] = [];
+    for (const [slug, value] of Object.entries(data.providers)) {
+      if (!isRecord(value)) continue;
+      const key = typeof value.apiKey === 'string' ? value.apiKey.trim() : '';
+      if (key.length > 0) slugs.push(slug.trim().toLowerCase());
+    }
+    return slugs;
+  } catch {
+    return []; // no-excuse-ok: catch — a malformed models.yml is a soft miss
+  }
+}

package/src/server/lib/omp/session/{usage.ts → usage/aggregate.ts}

@@ -15,7 +15,7 @@ import fs from 'fs';
 import { join } from 'path';
 import { getSessionsDir } from '@/server/lib/omp/core/paths';
 import { parseJsonlLenient } from '@/shared/lib/omp/session/jsonl';
-import type { BreakdownRow, CadenceType, ChartSeriesPoint, TimeRangeType, TokenUsageMetricSet } from '@/shared/types';
+import type { TimeRangeType } from '@/shared/types';
 import type { OmpMessageEntry } from '@/shared/types/omp/session';
 
 export type UsageWindow =
@@ -179,120 +179,3 @@ export async function aggregateUsage(window: UsageWindow): Promise<UsageAggregat
   cache.set(key, { at: Date.now(), data });
   return data;
 }
-
-const fmtInt = (value: number): string => value.toLocaleString('en-US');
-const fmtUsd = (value: number): string => `$${value.toFixed(2)}`;
-
-const MONTH_LABELS = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'] as const;
-
-function dayLabel(dayKey: string): string {
-  const date = new Date(`${dayKey}T00:00:00`);
-  return Number.isNaN(date.getTime()) ? dayKey : `${MONTH_LABELS[date.getMonth()]} ${date.getDate()}`;
-}
-
-function bucketKey(dayKey: string, cadence: CadenceType): string {
-  if (cadence === 'monthly') return dayKey.slice(0, 7);
-  if (cadence === 'weekly') {
-    const date = new Date(`${dayKey}T00:00:00`);
-    if (Number.isNaN(date.getTime())) return dayKey;
-    const monday = new Date(date);
-    const shift = (date.getDay() + 6) % 7;
-    monday.setDate(date.getDate() - shift);
-    return monday.toISOString().slice(0, 10);
-  }
-  return dayKey;
-}
-
-function labelForBucket(key: string, cadence: CadenceType): string {
-  if (cadence === 'monthly') {
-    const [year, month] = key.split('-');
-    const monthIndex = Number(month) - 1;
-    const label = MONTH_LABELS[monthIndex] ?? key;
-    return year && Number(year) !== new Date().getFullYear() ? `${label} ${year}` : label;
-  }
-  return dayLabel(key);
-}
-
-/** Shape the per-day aggregate into an ordered chart series for the cadence:
- * weekly buckets align to Monday, monthly to YYYY-MM, and the series is
- * truncated to the last 60 buckets so the SVG path stays readable. */
-export function buildChartSeries(a: UsageAggregate, cadence: CadenceType): ChartSeriesPoint[] {
-  const buckets = new Map<string, { cost: number; tokens: number }>();
-  for (const [dayKey, v] of a.byDay) {
-    const key = bucketKey(dayKey, cadence);
-    const current = buckets.get(key) ?? { cost: 0, tokens: 0 };
-    current.cost += v.cost;
-    current.tokens += v.tokens;
-    buckets.set(key, current);
-  }
-  return [...buckets.entries()]
-    .sort(([aKey], [bKey]) => (aKey < bKey ? -1 : aKey > bKey ? 1 : 0))
-    .slice(-60)
-    .map(([key, v]) => ({ label: labelForBucket(key, cadence), cost: v.cost, tokens: v.tokens }));
-}
-
-export function toMetricSet(a: UsageAggregate, cadence: CadenceType = 'daily'): TokenUsageMetricSet {
-  const observedInput = a.inputTokens + a.cacheReadTokens;
-  const cachedPercent = observedInput > 0 ? ((a.cacheReadTokens / observedInput) * 100).toFixed(1) : '0.0';
-  const unit = cadence === 'weekly' ? 'week' : cadence === 'monthly' ? 'month' : 'day';
-  return {
-    rawCost: fmtUsd(a.costTotal),
-    processedTokens: fmtInt(a.inputTokens + a.outputTokens + a.cacheReadTokens + a.cacheWriteTokens),
-    activeRate: `${a.activeDays.size} active ${unit}${a.activeDays.size === 1 ? '' : 's'}`,
-    cachedInput: fmtInt(a.cacheReadTokens),
-    cachedPercent: `${cachedPercent}% of observed input`,
-    uncachedInput: fmtInt(a.inputTokens),
-    outputTokens: fmtInt(a.outputTokens),
-    reasoning: `includes ${fmtInt(a.reasoningTokens)} reasoning`,
-    cacheSavings: fmtUsd(a.costCacheRead),
-    scannedTranscripts: a.scannedTranscripts,
-    usageRecords: a.usageRecords,
-  };
-}
-
-const BREAKDOWN_DOT_COLORS = [
-  'bg-[var(--theme-ink)]',
-  'bg-[var(--theme-ink)]/70',
-  'bg-[var(--theme-ink)]/50',
-  'bg-[var(--theme-ink)]/35',
-  'bg-[var(--theme-ink)]/20',
-] as const;
-
-/** Build breakdown rows (model/day/project) from the aggregate; the `day` tab
- * is bucketed by the cadence (day/week/month) so it stays consistent with the chart. */
-export function toBreakdownRows(
-  a: UsageAggregate,
-  tab: 'model' | 'day' | 'project',
-  cadence: CadenceType = 'daily',
-): BreakdownRow[] {
-  if (tab === 'day' && cadence !== 'daily') {
-    const buckets = new Map<string, { tokens: number; cost: number }>();
-    for (const [dayKey, v] of a.byDay) {
-      const key = bucketKey(dayKey, cadence);
-      const current = buckets.get(key) ?? { tokens: 0, cost: 0 };
-      current.tokens += v.tokens;
-      current.cost += v.cost;
-      buckets.set(key, current);
-    }
-    const merged: UsageAggregate = { ...a, byDay: buckets };
-    return toBreakdownRows(merged, 'day', 'daily');
-  }
-  const source = tab === 'model' ? a.byModel : tab === 'day' ? a.byDay : a.byProject;
-  return [...source.entries()]
-    .map(([name, v]) => ({
-      name: tab === 'day' ? labelForBucket(name, cadence) : name,
-      tokens: v.tokens,
-      cost: v.cost,
-      sharePercent: a.costTotal > 0 ? Math.round((v.cost / a.costTotal) * 100) : 0,
-    }))
-    .sort((x, y) => y.cost - x.cost)
-    .slice(0, 12)
-    .map((row, index) => ({
-      name: row.name,
-      tokens: fmtInt(row.tokens),
-      cost: fmtUsd(row.cost),
-      share: `${row.sharePercent}%`,
-      sharePercent: row.sharePercent,
-      dotColorClass: BREAKDOWN_DOT_COLORS[index % BREAKDOWN_DOT_COLORS.length],
-    }));
-}