ompchamber 2.0.2 → 3.1.0

package/src/server/routes/settings/provider-models.ts

@@ -1,26 +1,43 @@
 import { json } from '@/server/lib/remix-compat';
 import type { ActionFunctionArgs } from '@/server/lib/remix-compat';
 import { isMockMode } from '@/server/mock.server';
-import { findCatalogModel, loadModelsDevCatalog } from '@/shared/lib/models/catalog';
-import { extractModels } from '@/shared/lib/models/remote-list';
 import { upsertOmpProviderModels } from '@/server/lib/omp/config/providers';
 import { invalidateModelsCaches } from '@/shared/lib/models/server-cache';
+import {
+  enrichFromCatalog,
+  fetchRemoteModels,
+  toOmpSeed,
+} from '@/server/lib/models/provider-listing.server';
+import {
+  inferProviderApi,
+  isOmpProviderApi,
+  isProviderAuthMode,
+  isProviderDiscoveryType,
+} from '@/shared/lib/models/provider/dialect';
 import type { ProviderModel } from '@/shared/types';
 
 /**
- * POST /api/settings/provider-models — lists models from an OpenAI-compatible
- * provider endpoint for the providers settings auto-fetch. Body:
- * { baseUrl: string, apiKey?: string, providerSlug?: string,
- *   persistToOmp?: boolean } → { ok, models, omp? } | { ok: false, error }.
- * Tries Bearer auth, then Anthropic x-api-key, then Gemini ?key= — the first
- * style returning a recognizable list wins. Models missing metadata (context,
- * capabilities, price) are enriched from the models.dev catalog. With
- * persistToOmp the enriched models are also registered into the native omp
- * models.yml (add-only) so the agent's usage tracking knows their prices.
+ * POST /api/settings/provider-models — lists models from a provider endpoint
+ * for the providers settings auto-fetch, and optionally registers the provider
+ * in omp's own models.yml. Body:
+ * { baseUrl: string, apiKey?: string, providerSlug?: string, persistToOmp?: boolean,
+ *   api?: OmpProviderApi, auth?: ProviderAuthMode, discovery?: ProviderDiscoveryType,
+ *   registerOnly?: boolean } → { ok, models, omp? } | { ok: false, error }.
+ *
+ * `api` picks the dialect, which decides both the auth header the listing probe
+ * sends and the `api` written to models.yml; when it is omitted the endpoint is
+ * classified by URL and the probe tries the three common auth styles. Models
+ * missing metadata (context, capabilities, price) are enriched from the
+ * models.dev catalog. The probe itself lives in
+ * `@/server/lib/models/provider-listing.server`.
+ *
+ * `discovery` and `registerOnly` skip the listing entirely: the first registers
+ * a provider OMP will list itself, the second registers an endpoint override
+ * for a provider omp already bundles. Both are legitimate with an empty model
+ * list — writing ids there would freeze a snapshot omp would then serve
+ * alongside its own listing.
  */
 
-const FETCH_TIMEOUT_MS = 15_000;
-const ANTHROPIC_VERSION = '2023-06-01';
 const MASKED_KEY_PATTERN = /•{3,}/;
 
 const MOCK_REMOTE_MODELS: ProviderModel[] = [
@@ -51,187 +68,6 @@ const MOCK_REMOTE_MODELS: ProviderModel[] = [
   },
 ];
 
-interface FetchAttempt {
-  models: ProviderModel[] | null;
-  error: string;
-}
-
-async function attemptStyle(
-  label: string,
-  url: string,
-  headers: Record<string, string>,
-): Promise<FetchAttempt> {
-  const response = await fetch(url, { headers, signal: AbortSignal.timeout(FETCH_TIMEOUT_MS) });
-  let payload: unknown = null;
-  try {
-    payload = await response.json();
-  } catch {
-    // Non-JSON body (HTML error page, empty body) — payload stays null and is
-    // reported below as an unrecognized response format.
-  }
-  if (response.status < 200 || response.status >= 300) {
-    return { models: null, error: `${label}: HTTP ${response.status}` };
-  }
-  const models = extractModels(payload);
-  if (!models) return { models: null, error: `${label}: unrecognized response format` };
-  return { models, error: '' };
-}
-
-/**
- * Try the common listing styles in order: OpenAI-compatible Bearer auth,
- * Anthropic x-api-key, then Gemini ?key=. The first style that returns a
- * recognizable model list wins; otherwise the collected errors are reported.
- */
-async function fetchRemoteModels(baseUrl: string, apiKey?: string): Promise<FetchAttempt> {
-  const base = baseUrl.replace(/\/+$/, '');
-  const attempts: Array<{ label: string; url: string; headers: Record<string, string> }> = [
-    {
-      label: 'OpenAI-compatible',
-      url: `${base}/models`,
-      headers: apiKey ? { Authorization: `Bearer ${apiKey}` } : {},
-    },
-  ];
-  if (apiKey) {
-    attempts.push({
-      label: 'Anthropic',
-      url: `${base}/models`,
-      headers: { 'x-api-key': apiKey, 'anthropic-version': ANTHROPIC_VERSION },
-    });
-    attempts.push({
-      label: 'Gemini',
-      url: `${base}/models?key=${encodeURIComponent(apiKey)}`,
-      headers: {},
-    });
-  }
-
-  const errors: string[] = [];
-  for (const attempt of attempts) {
-    try {
-      const result = await attemptStyle(attempt.label, attempt.url, attempt.headers);
-      if (result.models) return result;
-      errors.push(result.error);
-    } catch (error) {
-      // Network-level failure (DNS, refused, timeout) applies to every auth
-      // style — no point retrying the same host with different headers.
-      const message = error instanceof Error ? error.message : 'request failed';
-      errors.push(`${attempt.label}: ${message}`);
-      break;
-    }
-  }
-  return {
-    models: null,
-    error: errors.length > 0 ? `Failed to fetch models — ${errors.join(' · ')}` : 'Failed to fetch models',
-  };
-}
-
-/**
- * omp's `api` for a custom provider, inferred from its endpoint. omp accepts
- * eleven `api` values and there is no way to ask a gateway which one it speaks,
- * so the chamber only claims the two dialects it can recognise by URL; every
- * other endpoint gets the OpenAI-compatible default, which is what the
- * model-listing probe already assumes. A gateway that speaks something else
- * (Azure, Bedrock, Vertex, …) needs its `api` set by hand in models.yml.
- */
-function inferProviderApi(baseUrl: string): 'openai-completions' | 'anthropic-messages' | 'google-generative-ai' {
-  if (/anthropic\./i.test(baseUrl)) return 'anthropic-messages';
-  if (/generativelanguage\.googleapis\.com/i.test(baseUrl)) return 'google-generative-ai';
-  return 'openai-completions';
-}
-
-/**
- * omp's models.yml schema requires all four cost fields when cost is present,
- * so a price is only seeded when both sides are known; missing ones default
- * to 0. Context/output labels ("128K ctx · 16K out") parse back to tokens.
- * Cache prices come from the catalog and are kept when known — dropping them
- * makes every cached turn look free in omp's usage accounting.
- */
-function toOmpSeed(model: ProviderModel): {
-  id: string;
-  name?: string;
-  reasoning?: boolean;
-  imageInput?: boolean;
-  contextWindow?: number;
-  maxTokens?: number;
-  cost?: { input: number; output: number; cacheRead: number; cacheWrite: number };
-} {
-  const parseTokens = (label: string, suffix: string): number | undefined => {
-    const match = label.match(new RegExp(`(\\d+(?:\\.\\d+)?)([KM])? ${suffix}`));
-    if (!match) return undefined;
-    const value = Number.parseFloat(match[1]);
-    if (!Number.isFinite(value) || value <= 0) return undefined;
-    const multiplier = match[2] === 'M' ? 1_000_000 : 1000;
-    return Math.round(value * multiplier);
-  };
-  const contextWindow = parseTokens(model.contextWindow, 'ctx');
-  const outTokens = parseTokens(model.contextWindow, 'out');
-  // omp rejects the whole file on a non-finite number, so a price has to be a
-  // real finite value before it may be written at all.
-  const price = (value: unknown): number | undefined => (
-    typeof value === 'number' && Number.isFinite(value) ? value : undefined
-  );
-  const priceInput = price(model.priceInput);
-  const priceOutput = price(model.priceOutput);
-  const hasCost = priceInput !== undefined && priceOutput !== undefined;
-  return {
-    id: model.id,
-    ...(model.name && model.name !== model.id ? { name: model.name } : {}),
-    ...(model.hasReasoning ? { reasoning: true } : {}),
-    ...(model.hasVision ? { imageInput: true } : {}),
-    ...(contextWindow ? { contextWindow } : {}),
-    ...(outTokens && outTokens > 0 ? { maxTokens: Math.round(outTokens) } : {}),
-    ...(hasCost ? {
-      cost: {
-        input: priceInput,
-        output: priceOutput,
-        cacheRead: price(model.priceCacheRead) ?? 0,
-        cacheWrite: price(model.priceCacheWrite) ?? 0,
-      },
-    } : {}),
-  };
-}
-
-/**
- * Fill in metadata the listing endpoint did not provide from the models.dev
- * catalog: vision/reasoning/tool flags, context + output window, and
- * per-1M-token pricing (cache rates included). Only empty fields are filled —
- * anything the provider reported itself is kept.
- */
-async function enrichFromCatalog(
-  models: ProviderModel[],
-  providerSlug: string | undefined,
-): Promise<ProviderModel[]> {
-  const catalog = await loadModelsDevCatalog();
-  if (!catalog || Object.keys(catalog).length === 0) return models;
-  return models.map((model) => {
-    const match = findCatalogModel(catalog, providerSlug, model.id);
-    if (!match) return model;
-    const { info } = match;
-    const ctx = info.limit?.context;
-    const out = info.limit?.output;
-    const ctxLabel = !model.contextWindow && ctx && ctx > 0
-      ? Math.round(ctx / 1000)
-      : null;
-    const outLabel = out && out > 0 ? Math.round(out / 1000) : null;
-    const catalogContext = ctxLabel
-      ? (outLabel ? `${ctxLabel}K ctx · ${outLabel}K out` : `${ctxLabel}K ctx`)
-      : '';
-    return {
-      ...model,
-      name: model.name === model.id && info.name ? info.name : model.name,
-      contextWindow: model.contextWindow || catalogContext,
-      hasVision: model.hasVision || info.attachment === true,
-      hasReasoning: model.hasReasoning ?? (info.reasoning === true || undefined),
-      hasTools: model.hasTools || info.tool_call === true,
-      priceInput: model.priceInput ?? (typeof info.cost?.input === 'number' ? info.cost.input : undefined),
-      priceOutput: model.priceOutput ?? (typeof info.cost?.output === 'number' ? info.cost.output : undefined),
-      priceCacheRead: model.priceCacheRead
-        ?? (typeof info.cost?.cache_read === 'number' ? info.cost.cache_read : undefined),
-      priceCacheWrite: model.priceCacheWrite
-        ?? (typeof info.cost?.cache_write === 'number' ? info.cost.cache_write : undefined),
-    };
-  });
-}
-
 export async function action({ request }: ActionFunctionArgs) {
   if (request.method !== 'POST') {
     return json({ ok: false, error: 'Method not allowed' }, { status: 405 });
@@ -242,6 +78,10 @@ export async function action({ request }: ActionFunctionArgs) {
       apiKey?: unknown;
       providerSlug?: unknown;
       persistToOmp?: unknown;
+      api?: unknown;
+      auth?: unknown;
+      discovery?: unknown;
+      registerOnly?: unknown;
     };
     const baseUrl = typeof body.baseUrl === 'string' ? body.baseUrl.trim() : '';
     const rawApiKey = typeof body.apiKey === 'string' && body.apiKey.trim().length > 0 ? body.apiKey.trim() : undefined;
@@ -251,27 +91,50 @@ export async function action({ request }: ActionFunctionArgs) {
       ? body.providerSlug.trim()
       : undefined;
     const persistToOmp = body.persistToOmp === true;
+    const registerOnly = body.registerOnly === true;
+    // An unrecognized dialect from the client is dropped rather than written:
+    // omp disables EVERY custom provider in the file over one unknown `api`.
+    const api = isOmpProviderApi(body.api) ? body.api : undefined;
+    const auth = isProviderAuthMode(body.auth) ? body.auth : undefined;
+    const discovery = isProviderDiscoveryType(body.discovery) ? body.discovery : undefined;
     if (!baseUrl || !/^https?:\/\//i.test(baseUrl)) {
       return json({ ok: false, error: 'Base URL must be a valid http(s) endpoint' }, { status: 400 });
     }
+    // A keyless or discovery-only provider has no listing to fetch, so a
+    // register-only call is the whole operation — and it must not demand the
+    // model list that the caller deliberately did not ask for.
+    const skipListing = registerOnly || discovery !== undefined;
 
     if (isMockMode()) {
-      return json({ ok: true, models: MOCK_REMOTE_MODELS });
+      return json({ ok: true, models: skipListing ? [] : MOCK_REMOTE_MODELS });
     }
 
-    const result = await fetchRemoteModels(baseUrl, apiKey);
-    if (!result.models) {
-      return json({ ok: false, error: result.error }, { status: 502 });
+    let enriched: ProviderModel[] = [];
+    if (!skipListing) {
+      const result = await fetchRemoteModels(baseUrl, apiKey, api);
+      if (!result.models) {
+        return json({ ok: false, error: result.error }, { status: 502 });
+      }
+      enriched = await enrichFromCatalog(result.models, providerSlug);
     }
-    const enriched = await enrichFromCatalog(result.models, providerSlug);
 
-    let omp: { written: boolean; addedCount: number; backfilledCount: number; reason?: string } | undefined;
-    if (persistToOmp && providerSlug && enriched.length > 0) {
+    let omp: {
+      written: boolean;
+      addedCount: number;
+      backfilledCount: number;
+      reason?: string;
+    } | undefined;
+    if (persistToOmp && providerSlug) {
       try {
         const upsert = await upsertOmpProviderModels(providerSlug, {
           baseUrl,
           apiKey,
-          api: inferProviderApi(baseUrl),
+          api: api ?? inferProviderApi(baseUrl),
+          ...(auth ? { auth } : {}),
+          ...(discovery ? { discovery } : {}),
+          // An override/discovery provider keeps omp's own model list; writing
+          // ids here would freeze a snapshot omp would then serve twice.
+          overrideOnly: skipListing,
           models: enriched.map(toOmpSeed),
         });
         if (upsert.written) invalidateModelsCaches();

package/src/server/routes/settings/providers.ts

@@ -113,17 +113,32 @@ export async function action({ request, params }: ActionFunctionArgs) {
       if (!id) return json({ error: 'id is required' }, { status: 400 });
 
       const stored = await readStoredProviders();
-      const target = stored.find((provider) => provider.id === id);
-      const list = await providersStore.remove(db, id, { absent: DEFAULT_PROVIDERS_LIST, empty: DEFAULT_PROVIDERS_LIST });
+      // The target is looked up in the MERGED registry, not just the overlay.
+      // A provider that exists only in models.yml has no overlay row at all, so
+      // an overlay-only lookup found nothing, skipped the `removeOmpProvider`
+      // call below, and reported a delete that had removed no file entry — the
+      // provider came straight back on the next load.
+      const merged = await mergeProviders(stored).catch(() => null);
+      const target = merged?.providers.find((provider) => provider.id === id)
+        ?? stored.find((provider) => provider.id === id);
+      // The fallback list is MOCK-only demo data: seeding it in real mode would
+      // write shipped sample providers into a user's overlay on the first
+      // delete. Real mode starts from an empty overlay, which is what
+      // `providersStore.read` already does for the loader.
+      const fallback = isMockMode() ? DEFAULT_PROVIDERS_LIST : [];
+      const list = await providersStore.remove(db, id, { absent: fallback, empty: fallback });
 
       // Removing the overlay row alone left the provider registered in
       // models.yml, so omp kept serving it and the next load merged it straight
       // back into this list — a delete that visibly did nothing. Unregister it
       // from the agent's own registry too.
       let removedFromOmp = false;
+      let modelsRemoved = 0;
       if (target?.slug && !isMockMode()) {
         try {
-          removedFromOmp = (await removeOmpProvider(target.slug)).removed;
+          const removal = await removeOmpProvider(target.slug);
+          removedFromOmp = removal.removed;
+          modelsRemoved = removal.removedModels;
           // A provider omp still holds in disabledProviders would linger as a
           // "disconnected" ghost entry after its models are gone.
           await enableNativeProvider(target.slug);
@@ -131,18 +146,18 @@ export async function action({ request, params }: ActionFunctionArgs) {
           // The overlay row is already gone; report the native failure instead
           // of failing the whole request, so the UI can tell the user the entry
           // is still in models.yml.
-          const merged = await mergeProviders(list).catch(() => null);
+          const afterFailure = await mergeProviders(list).catch(() => null);
           return json({
             success: true,
-            providers: merged?.providers ?? list,
+            providers: afterFailure?.providers ?? list,
             removedFromOmp: false,
             warning: error instanceof Error ? error.message : 'models.yml cleanup failed',
           });
         }
       }
       invalidateModelsCaches();
-      const merged = await mergeProviders(list);
-      return json({ success: true, providers: merged.providers, removedFromOmp });
+      const after = await mergeProviders(list);
+      return json({ success: true, providers: after.providers, removedFromOmp, modelsRemoved });
     }
 
     if (request.method === 'POST' || request.method === 'PUT') {

package/src/server/routes/settings/usage.ts

@@ -2,56 +2,137 @@ import { json } from '@/server/lib/remix-compat';
 import type { LoaderFunctionArgs } from '@/server/lib/remix-compat';
 import { methodNotAllowed } from '@/server/lib/route-adapter';
 import { isMockMode } from '@/server/mock.server';
-import { buildKenariReport } from '@/server/lib/usage/kenari';
-import { buildDeepSeekReport } from '@/server/lib/usage/deepseek';
-import type { UsageReport } from '@/shared/types';
+import { buildUsageProviders } from '@/server/lib/usage/providers.server';
+import type { UsageProviderSummary, UsageReport } from '@/shared/types';
 
 const NO_STORE_HEADERS = { 'Cache-Control': 'no-store' };
 
-/** Deterministic demo report so the Usage panel renders under MOCK=true. */
+/** Deterministic demo report so the Usage surfaces render under MOCK=true. */
 function mockUsageReport(): UsageReport {
-  return {
-    isMock: true,
-    generatedAt: new Date().toISOString(),
-    kenari: {
-      configured: true,
-      balance: { amountRp: 25_000, raw: 'Saldo: Rp 25.000' },
-      usage: {
-        rows: [
-          { model: 'gemini-3-7-flash', requests: 37, inputTokens: 22255, outputTokens: 11487, costRp: 0 },
-          { model: 'glm-5-3-flash', requests: 2122, inputTokens: 369435677, outputTokens: 914679, costRp: 0 },
-        ],
-        totalRequests: 5941,
-        totalCostRp: 0,
-        raw: 'Pemakaian 30 hari terakhir (biaya Rupiah).',
-      },
-      quota: {
-        planName: 'Pro',
-        windows: [
-          { key: 'five_hour', label: '5 hours', usedRp: 0, remainingRp: 50_000, resetsAt: '2026-09-14T10:00:00.000Z' },
-          { key: 'week', label: 'Weekly', usedRp: 12_500, remainingRp: 287_500, resetsAt: '2026-09-20T00:00:00.000Z' },
-          { key: 'month', label: 'Monthly', usedRp: 120_000, remainingRp: 880_000, resetsAt: '2026-10-01T00:00:00.000Z' },
-        ],
-        coupon: null,
+  const providers: UsageProviderSummary[] = [
+    {
+      id: 'kenari',
+      name: 'Kenari.id',
+      credentialSources: ['models.yml'],
+      // kenari is a plain OpenAI-compatible gateway: omp ships no usage adapter.
+      tracked: false,
+      limits: [],
+      kenari: {
+        balance: { amountRp: 25_000, raw: 'Saldo: Rp 25.000' },
+        usage: {
+          rows: [
+            { model: 'gemini-3-7-flash', requests: 37, inputTokens: 22255, outputTokens: 11487, costRp: 0 },
+            { model: 'glm-5-3-flash', requests: 2122, inputTokens: 369435677, outputTokens: 914679, costRp: 0 },
+          ],
+          totalRequests: 5941,
+          totalCostRp: 0,
+          raw: 'Pemakaian 30 hari terakhir (biaya Rupiah).',
+        },
+        quota: {
+          planName: 'Pro',
+          windows: [
+            { key: 'five_hour', label: '5 hours', usedRp: 0, remainingRp: 50_000, resetsAt: '2026-09-14T10:00:00.000Z' },
+            { key: 'week', label: 'Weekly', usedRp: 12_500, remainingRp: 287_500, resetsAt: '2026-09-20T00:00:00.000Z' },
+            { key: 'month', label: 'Monthly', usedRp: 120_000, remainingRp: 880_000, resetsAt: '2026-10-01T00:00:00.000Z' },
+          ],
+          coupon: null,
+        },
       },
     },
-    deepseek: {
-      configured: true,
-      balance: {
-        isAvailable: true,
-        entries: [
-          { currency: 'USD', totalBalance: '10.00', grantedBalance: '10.00', toppedUpBalance: '0.00' },
-        ],
+    {
+      id: 'deepseek',
+      name: 'DeepSeek',
+      credentialSources: ['agent.db'],
+      tracked: false,
+      limits: [],
+      deepseek: {
+        balance: {
+          isAvailable: true,
+          entries: [
+            { currency: 'USD', totalBalance: '10.00', grantedBalance: '10.00', toppedUpBalance: '0.00' },
+          ],
+        },
       },
     },
-  };
+    {
+      id: 'anthropic',
+      name: 'Anthropic (Claude Pro/Max)',
+      credentialSources: ['agent.db'],
+      tracked: true,
+      limits: [
+        {
+          id: 'anthropic:5h',
+          label: 'Claude 5 hour limit',
+          windowLabel: '5h',
+          used: 42,
+          limit: 100,
+          usedFraction: 0.42,
+          unit: 'percent',
+          status: 'ok',
+          resetsAt: Date.now() + 3 * 60 * 60 * 1000,
+        },
+        {
+          id: 'anthropic:7d',
+          label: 'Claude weekly limit',
+          windowLabel: '7d',
+          used: 88,
+          limit: 100,
+          usedFraction: 0.88,
+          unit: 'percent',
+          status: 'warning',
+          resetsAt: Date.now() + 4 * 24 * 60 * 60 * 1000,
+        },
+        {
+          id: 'anthropic:fast',
+          label: 'Fast requests',
+          windowLabel: '24h',
+          used: 320,
+          limit: 500,
+          usedFraction: 0.64,
+          unit: 'requests',
+          status: 'ok',
+          resetsAt: Date.now() + 6 * 60 * 60 * 1000,
+        },
+      ],
+    },
+    {
+      // A pay-as-you-go vendor: no omp adapter, only a credit balance.
+      id: 'openrouter',
+      name: 'OpenRouter',
+      credentialSources: ['agent.db'],
+      tracked: false,
+      limits: [
+        {
+          id: 'openrouter:credits',
+          label: 'Key credits',
+          used: 25.5,
+          limit: 100,
+          remaining: 74.5,
+          usedFraction: 0.255,
+          unit: 'usd',
+          status: 'ok',
+        },
+        {
+          id: 'openrouter:daily',
+          label: 'Spent today (monthly)',
+          used: 1.82,
+          unit: 'usd',
+          status: 'unknown',
+        },
+      ],
+    },
+  ];
+
+  return { isMock: true, generatedAt: new Date().toISOString(), providers };
 }
 
 /**
- * GET /api/settings/usage — balance / usage / quota for the configured
- * providers. Both provider reports are always present; a missing key is
- * `configured: false`, an upstream failure is a per-provider `error` (HTTP
- * 200), and only a genuinely unexpected internal failure returns 500.
+ * GET /api/settings/usage — provider quota and balance.
+ *
+ * Only providers with a detected credential appear in `providers`; a provider
+ * whose key is missing is omitted rather than rendered as an empty row. A
+ * provider-side failure is a per-provider `error` (HTTP 200), and only a
+ * genuinely unexpected internal failure returns 500.
  */
 export async function loader({ request, params }: LoaderFunctionArgs) {
   if (request.method !== 'GET') {
@@ -61,15 +142,14 @@ export async function loader({ request, params }: LoaderFunctionArgs) {
     return json(mockUsageReport(), { headers: NO_STORE_HEADERS });
   }
   try {
-    const [kenari, deepseek] = await Promise.all([
-      buildKenariReport(),
-      buildDeepSeekReport(),
-    ]);
+    // `?refresh=1` is the user's own Refresh button: provider quota is cached
+    // for a minute (each read calls every provider's endpoint), but a manual
+    // refresh must show fresh numbers rather than that snapshot.
+    const force = new URL(request.url).searchParams.get('refresh') === '1';
     const report: UsageReport = {
       isMock: false,
       generatedAt: new Date().toISOString(),
-      kenari,
-      deepseek,
+      providers: await buildUsageProviders({ force }),
     };
     return json(report, { headers: NO_STORE_HEADERS });
   } catch (error) {

package/src/server/routes/telemetry/tokens.ts

@@ -4,7 +4,8 @@ import { methodNotAllowed } from '@/server/lib/route-adapter';
 import { BREAKDOWN_DATA, MOCK_CHART_SERIES, MOCK_CUSTOM_RANGE_DATA, MOCK_RANGE_DATA, TIME_RANGES } from '@/client/data/mock/token-usage';
 import { isMockMode } from '@/server/mock.server';
 import { loadModelsDevCatalog } from '@/shared/lib/models/catalog';
-import { aggregateUsage, buildChartSeries, toBreakdownRows, toMetricSet, type UsageWindow } from '@/server/lib/omp/session/usage';
+import { aggregateUsage, type UsageWindow } from '@/server/lib/omp/session/usage/aggregate';
+import { buildChartSeries, toBreakdownRows, toMetricSet } from '@/server/lib/omp/session/usage/shaping';
 import type { BreakdownRow, BreakdownTab, CadenceType, ChartSeriesPoint, TimeRangeType, TokenUsageMetricSet } from '@/shared/types';
 
 const REAL_ZERO_METRIC: TokenUsageMetricSet = {

package/src/shared/lib/chat/{todo-parser.ts → todo/parser.ts}

@@ -1,3 +1,20 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Renderer-side parser for one `todo` tool call: reads the human-readable
+ * checklist omp returns as the tool's text output (and the `list` argument as a
+ * fallback) into phase groups for the chat timeline's tool card.
+ *
+ * This is NOT the authoritative list — a tool card shows what that ONE call
+ * did, while the session's live list is the deepest committed snapshot on the
+ * active branch (`./snapshot.ts`, surfaced by the right-panel Todo view). The
+ * two must not be merged: a card that displayed the session-wide list would
+ * attribute every other call's work to this one.
+ */
+
 import type { ToolCallData } from '@/shared/types';
 
 export interface ParsedTask {