burner-cc 0.1.2 → 0.3.0

package/src/pricing-fallback.json

@@ -1,9 +1,202 @@
 {
-  "_comment": "Last-resort snapshot only, used when there's no network AND no prior cache at ~/.burner-cc-cache/litellm-pricing.json. Normal operation fetches live from LiteLLM's Anthropic-sourced pricing JSON — see src/pricing.js. Values below are USD per million tokens, captured 2026-09-27.",
-  "models": {
-    "claude-opus-5": { "displayName": "Claude Opus 5", "input": 5, "output": 25, "cacheWrite5m": 6.25, "cacheWrite1h": 10, "cacheRead": 0.5 },
-    "claude-sonnet-5": { "displayName": "Claude Sonnet 5", "input": 2, "output": 10, "cacheWrite5m": 2.5, "cacheWrite1h": 4, "cacheRead": 0.2 },
-    "claude-haiku-4-5": { "displayName": "Claude Haiku 4.5", "input": 1, "output": 5, "cacheWrite5m": 1.25, "cacheWrite1h": 2, "cacheRead": 0.1 },
-    "claude-fable-5": { "displayName": "Claude Fable 5", "input": 10, "output": 50, "cacheWrite5m": 12.5, "cacheWrite1h": 20, "cacheRead": 1 }
+ "_comment": "Last-resort snapshot used only when offline with no cache. Live prices come from LiteLLM (src/pricing.js). USD per million tokens.",
+ "capturedAt": 1792919926365,
+ "models": {
+  "claude-3-5-haiku": {
+   "input": 0.8,
+   "output": 4,
+   "cacheWrite5m": 1,
+   "cacheWrite1h": 1.6,
+   "cacheRead": 0.08
+  },
+  "claude-3-5-sonnet": {
+   "input": 3,
+   "output": 15,
+   "cacheWrite5m": 3.75,
+   "cacheWrite1h": 6,
+   "cacheRead": 0.3
+  },
+  "claude-3-7-sonnet": {
+   "input": 3.6,
+   "output": 18,
+   "cacheWrite5m": 4.5,
+   "cacheWrite1h": 7.2,
+   "cacheRead": 0.36
+  },
+  "claude-3-haiku": {
+   "input": 0.25,
+   "output": 1.25,
+   "cacheWrite5m": 0.3125,
+   "cacheWrite1h": 0.5,
+   "cacheRead": 0.025
+  },
+  "claude-3-opus": {
+   "input": 15,
+   "output": 75,
+   "cacheWrite5m": 18.75,
+   "cacheWrite1h": 30,
+   "cacheRead": 1.5
+  },
+  "claude-3-sonnet": {
+   "input": 3,
+   "output": 15,
+   "cacheWrite5m": 3.75,
+   "cacheWrite1h": 6,
+   "cacheRead": 0.3
+  },
+  "claude-fable-5": {
+   "input": 10,
+   "output": 50,
+   "cacheWrite5m": 12.5,
+   "cacheWrite1h": 20,
+   "cacheRead": 1
+  },
+  "claude-fable-5-1": {
+   "input": 10,
+   "output": 50,
+   "cacheWrite5m": 12.5,
+   "cacheWrite1h": 20,
+   "cacheRead": 0.25
+  },
+  "claude-haiku-4-5": {
+   "input": 1,
+   "output": 5,
+   "cacheWrite5m": 1.25,
+   "cacheWrite1h": 2,
+   "cacheRead": 0.1
+  },
+  "claude-haiku-5-5": {
+   "input": 0.1,
+   "output": 0.5,
+   "cacheWrite5m": 0.125,
+   "cacheWrite1h": 0.2,
+   "cacheRead": 0.01
+  },
+  "claude-instant": {
+   "input": 0.8,
+   "output": 2.4,
+   "cacheWrite5m": 1,
+   "cacheWrite1h": 1.6,
+   "cacheRead": 0.08
+  },
+  "claude-mythos-5": {
+   "input": 10,
+   "output": 50,
+   "cacheWrite5m": 12.5,
+   "cacheWrite1h": 20,
+   "cacheRead": 1
+  },
+  "claude-mythos-5-1": {
+   "input": 10,
+   "output": 50,
+   "cacheWrite5m": 12.5,
+   "cacheWrite1h": 20,
+   "cacheRead": 0.25
+  },
+  "claude-mythos-preview": {
+   "input": 10,
+   "output": 50,
+   "cacheWrite5m": 12.5,
+   "cacheWrite1h": 20,
+   "cacheRead": 1
+  },
+  "claude-opus-4": {
+   "input": 15,
+   "output": 75,
+   "cacheWrite5m": 18.75,
+   "cacheWrite1h": 30,
+   "cacheRead": 1.5
+  },
+  "claude-opus-4-1": {
+   "input": 15,
+   "output": 75,
+   "cacheWrite5m": 18.75,
+   "cacheWrite1h": 30,
+   "cacheRead": 1.5
+  },
+  "claude-opus-4-5": {
+   "input": 5,
+   "output": 25,
+   "cacheWrite5m": 6.25,
+   "cacheWrite1h": 10,
+   "cacheRead": 0.5
+  },
+  "claude-opus-4-6": {
+   "input": 5,
+   "output": 25,
+   "cacheWrite5m": 6.25,
+   "cacheWrite1h": 10,
+   "cacheRead": 0.5
+  },
+  "claude-opus-4-7": {
+   "input": 5,
+   "output": 25,
+   "cacheWrite5m": 6.25,
+   "cacheWrite1h": 10,
+   "cacheRead": 0.5
+  },
+  "claude-opus-4-8": {
+   "input": 5,
+   "output": 25,
+   "cacheWrite5m": 6.25,
+   "cacheWrite1h": 10,
+   "cacheRead": 0.5
+  },
+  "claude-opus-5": {
+   "input": 5,
+   "output": 25,
+   "cacheWrite5m": 6.25,
+   "cacheWrite1h": 10,
+   "cacheRead": 0.5
+  },
+  "claude-opus-5-5": {
+   "input": 4,
+   "output": 20,
+   "cacheWrite5m": 5,
+   "cacheWrite1h": 8,
+   "cacheRead": 0.2
+  },
+  "claude-opus-5-5-fast": {
+   "input": 8,
+   "output": 40,
+   "cacheWrite5m": 10,
+   "cacheWrite1h": 16,
+   "cacheRead": 0.4
+  },
+  "claude-sonnet-4": {
+   "input": 3,
+   "output": 15,
+   "cacheWrite5m": 3.75,
+   "cacheWrite1h": 6,
+   "cacheRead": 0.3
+  },
+  "claude-sonnet-4-5": {
+   "input": 3,
+   "output": 15,
+   "cacheWrite5m": 3.75,
+   "cacheWrite1h": 6,
+   "cacheRead": 0.3
+  },
+  "claude-sonnet-4-6": {
+   "input": 3,
+   "output": 15,
+   "cacheWrite5m": 3.75,
+   "cacheWrite1h": 6,
+   "cacheRead": 0.3
+  },
+  "claude-sonnet-5": {
+   "input": 2,
+   "output": 10,
+   "cacheWrite5m": 2.5,
+   "cacheWrite1h": 4,
+   "cacheRead": 0.2
+  },
+  "claude-sonnet-5-5": {
+   "input": 2,
+   "output": 10,
+   "cacheWrite5m": 2.5,
+   "cacheWrite1h": 4,
+   "cacheRead": 0.1
   }
+ }
 }

package/src/pricing.js

@@ -1,143 +1,221 @@
-import { readFileSync, writeFileSync, mkdirSync, existsSync, statSync } from 'node:fs';
+import { readFileSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
 import path from 'node:path';
-import os from 'node:os';
+import { execFile } from 'node:child_process';
+import { FILES, readJson, writeJson, loadPricingOverrides } from './config.js';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const cacheDir = path.join(os.homedir(), '.burner-cc-cache');
-const cacheFile = path.join(cacheDir, 'litellm-pricing.json');
 const fallbackFile = path.join(__dirname, 'pricing-fallback.json');
 
-const SOURCE_URL = 'https://raw.githubusercontent.com/BerriAI/litellm/main/model_prices_and_context_window.json';
-const TTL_MS = 6 * 60 * 60 * 1000; // 6h — pricing changes rarely, this just avoids hammering GitHub.
+export const SOURCE_URL = 'https://raw.githubusercontent.com/BerriAI/litellm/main/model_prices_and_context_window.json';
+const TTL_MS = 24 * 60 * 60 * 1000;
+const RATE_KEYS = ['input', 'output', 'cacheWrite5m', 'cacheWrite1h', 'cacheRead'];
 
-// Anthropic bare-alias shorthands Claude Code sometimes writes instead of a
-// dated/versioned model id (e.g. subagent transcripts saying "sonnet").
-const ALIAS_FAMILIES = ['opus', 'sonnet', 'haiku', 'fable', 'mythos'];
+async function fetchText(url, timeoutMs = 15000) {
+  try {
+    const res = await fetch(url, { signal: AbortSignal.timeout(timeoutMs) });
+    if (!res.ok) throw new Error(`HTTP ${res.status}`);
+    return await res.text();
+  } catch (err) {
+    // Node's fetch ignores HTTP(S)_PROXY; curl honours it.
+    const proxy = process.env.HTTPS_PROXY || process.env.https_proxy || process.env.HTTP_PROXY || process.env.http_proxy;
+    const args = ['--silent', '--show-error', '--fail', '--location', '--max-time', String(Math.ceil(timeoutMs / 1000)), '--compressed'];
+    if (proxy) args.push('--proxy', proxy);
+    args.push(url);
+    return new Promise((resolve, reject) => {
+      execFile('curl', args, { maxBuffer: 64 * 1024 * 1024 }, (cerr, stdout, stderr) => {
+        if (cerr) reject(new Error(`${err.message}; curl: ${(stderr || cerr.message).trim()}`));
+        else resolve(stdout);
+      });
+    });
+  }
+}
 
-function toRates(entry, displayName) {
-  const mtok = 1_000_000;
+const PROVIDER_PREFIX = /^(anthropic|bedrock|bedrock_converse|vertex_ai|vertex_ai_beta|openrouter|azure|azure_ai|openai|google|gemini|deepseek|mistral|groq|together_ai|fireworks_ai|xai|ollama|ollama_chat|zai|moonshot|dashscope|databricks|litellm_proxy)\//;
+
+// Collapses the many spellings of one model to a lookup key:
+// "us.anthropic.claude-sonnet-4-5-20250929-v1:0" → "claude-sonnet-4-5",
+// "claude-opus-4-1@20250805" → "claude-opus-4-1", "claude-sonnet-4[1m]" → "claude-sonnet-4".
+export function normalizeModelId(raw) {
+  let s = String(raw ?? '').trim().toLowerCase();
+  for (let i = 0; i < 3 && PROVIDER_PREFIX.test(s); i++) s = s.replace(PROVIDER_PREFIX, '');
+  s = s.replace(/\[[^\]]*\]$/, '');
+  s = s.replace(/^(us|eu|apac|global|au|jp)\./, '').replace(/^anthropic\./, '');
+  s = s.replace(/-v\d+(:\d+)?$/, '').replace(/:\d+$/, '');
+  s = s.replace(/@[a-z0-9-]+$/, '').replace(/-\d{8}$/, '').replace(/-latest$/, '');
+  return s;
+}
+
+export function isClaudeModel(raw) {
+  const n = normalizeModelId(raw);
+  return n.startsWith('claude-') || /^(opus|sonnet|haiku|fable|mythos)(-|$)/.test(n);
+}
+
+function toRates(entry) {
+  const perM = (v) => Math.round(v * 1_000_000 * 1e6) / 1e6;
+  const inp = entry.input_cost_per_token;
   return {
-    displayName,
-    input: entry.input_cost_per_token * mtok,
-    output: entry.output_cost_per_token * mtok,
-    cacheWrite5m: (entry.cache_creation_input_token_cost ?? 0) * mtok,
-    cacheWrite1h: (entry.cache_creation_input_token_cost_above_1hr ?? entry.cache_creation_input_token_cost ?? 0) * mtok,
-    cacheRead: (entry.cache_read_input_token_cost ?? 0) * mtok,
+    input: perM(inp),
+    output: perM(entry.output_cost_per_token),
+    cacheWrite5m: perM(entry.cache_creation_input_token_cost ?? inp * 1.25),
+    cacheWrite1h: perM(entry.cache_creation_input_token_cost_above_1hr ?? inp * 2),
+    cacheRead: perM(entry.cache_read_input_token_cost ?? inp * 0.1),
   };
 }
 
-function buildTableFromLiteLLM(raw) {
+const PROVIDER_RANK = { anthropic: 0, openai: 1, gemini: 2, vertex_ai: 3, deepseek: 4, mistral: 5, xai: 6, zai: 7, moonshot: 8, dashscope: 9 };
+
+// Keyed by normalized id. For each id, the first-party provider's price wins
+// over resellers (OpenRouter, Bedrock regional markups, …).
+export function buildTable(raw) {
   const models = {};
+  const rank = {};
   for (const [key, entry] of Object.entries(raw)) {
-    if (entry.litellm_provider !== 'anthropic' || entry.mode !== 'chat') continue;
+    if (!entry || typeof entry !== 'object') continue;
+    if (entry.mode && entry.mode !== 'chat' && entry.mode !== 'responses') continue;
     if (typeof entry.input_cost_per_token !== 'number' || typeof entry.output_cost_per_token !== 'number') continue;
-    models[key] = toRates(entry, prettyName(key));
+    const id = normalizeModelId(key);
+    if (!id) continue;
+    const r = PROVIDER_RANK[entry.litellm_provider] ?? 50;
+    const hasPrefix = PROVIDER_PREFIX.test(key.toLowerCase()) || /^(us|eu|apac|global)\./.test(key);
+    const score = r * 2 + (hasPrefix ? 1 : 0);
+    if (rank[id] != null && rank[id] <= score) continue;
+    rank[id] = score;
+    models[id] = { ...toRates(entry), provider: entry.litellm_provider ?? null, sourceKey: key };
   }
   return models;
 }
 
-function prettyName(modelId) {
-  const parts = modelId.split('-').filter((p) => p !== 'claude');
-  if (!parts.length) return modelId;
-  const family = parts[0][0].toUpperCase() + parts[0].slice(1);
-  const rest = parts.slice(1).join('.');
-  return rest ? `Claude ${family} ${rest}` : `Claude ${family}`;
+export async function refreshPricing() {
+  const text = await fetchText(SOURCE_URL);
+  const models = buildTable(JSON.parse(text));
+  if (Object.keys(models).length < 50) throw new Error('pricing source looked truncated');
+  const fetchedAt = Date.now();
+  writeJson(FILES.pricingCache, { fetchedAt, url: SOURCE_URL, models });
+  return { models, source: 'live', fetchedAt };
 }
 
-async function fetchLiteLLMTable() {
-  const res = await fetch(SOURCE_URL, { signal: AbortSignal.timeout(8000) });
-  if (!res.ok) throw new Error(`pricing source returned ${res.status}`);
-  const raw = await res.json();
-  return buildTableFromLiteLLM(raw);
-}
-
-function readCache() {
-  if (!existsSync(cacheFile)) return null;
-  try {
-    return JSON.parse(readFileSync(cacheFile, 'utf-8'));
-  } catch {
-    return null;
+// Resolved once per run: fresh cache, else live fetch, else stale cache,
+// else the bundled snapshot. User overrides from pricing.yaml are layered
+// on top by lookupPricing.
+export async function loadPricingTable({ force = false, offline = false } = {}) {
+  const overrides = loadPricingOverrides();
+  const cache = readJson(FILES.pricingCache, null);
+  const fresh = cache?.models && Date.now() - cache.fetchedAt < TTL_MS;
+  if (fresh && !force) return { models: cache.models, overrides, source: 'cache', fetchedAt: cache.fetchedAt };
+  if (!offline) {
+    try {
+      return { ...(await refreshPricing()), overrides };
+    } catch (err) {
+      if (cache?.models) return { models: cache.models, overrides, source: 'stale-cache', fetchedAt: cache.fetchedAt, error: err.message };
+      const fb = JSON.parse(readFileSync(fallbackFile, 'utf-8'));
+      return { models: fb.models, overrides, source: 'bundled-fallback', fetchedAt: fb.capturedAt ?? null, error: err.message };
+    }
   }
+  if (cache?.models) return { models: cache.models, overrides, source: 'cache', fetchedAt: cache.fetchedAt };
+  const fb = JSON.parse(readFileSync(fallbackFile, 'utf-8'));
+  return { models: fb.models, overrides, source: 'bundled-fallback', fetchedAt: fb.capturedAt ?? null };
 }
 
-function writeCache(models) {
-  mkdirSync(cacheDir, { recursive: true });
-  writeFileSync(cacheFile, JSON.stringify({ fetchedAt: Date.now(), models }, null, 2), 'utf-8');
-}
+const ALIAS_FAMILIES = ['opus', 'sonnet', 'haiku', 'fable', 'mythos'];
 
-function cacheIsFresh(cache) {
-  return cache && Date.now() - cache.fetchedAt < TTL_MS;
+function versionOf(id) {
+  return id.replace(/^claude-[a-z]+-?/, '').split(/[-.]/).map(Number);
 }
 
-// Resolves the full pricing table once per CLI invocation: fresh cache wins,
-// otherwise re-fetch from LiteLLM's community-maintained (Anthropic-sourced)
-// pricing JSON, falling back to a stale cache or the bundled snapshot if
-// offline. This is the whole point: nobody has to hand-edit prices.
-export async function loadPricingTable() {
-  const cache = readCache();
-  if (cacheIsFresh(cache)) {
-    return { models: cache.models, source: 'cache', fetchedAt: cache.fetchedAt };
-  }
-
-  try {
-    const models = await fetchLiteLLMTable();
-    writeCache(models);
-    return { models, source: 'live', fetchedAt: Date.now() };
-  } catch (err) {
-    if (cache) {
-      return { models: cache.models, source: 'stale-cache', fetchedAt: cache.fetchedAt, error: err.message };
+function newestInFamily(family, models) {
+  const ids = Object.keys(models).filter((k) => new RegExp(`^claude-${family}(-[\\d.]+)*(-\\d)?$`).test(k));
+  ids.sort((a, b) => {
+    const va = versionOf(a);
+    const vb = versionOf(b);
+    for (let i = 0; i < Math.max(va.length, vb.length); i++) {
+      const d = (vb[i] ?? 0) - (va[i] ?? 0);
+      if (d) return d;
     }
-    const fallback = JSON.parse(readFileSync(fallbackFile, 'utf-8'));
-    return { models: fallback.models, source: 'bundled-fallback', fetchedAt: null, error: err.message };
-  }
+    return 0;
+  });
+  return ids[0] ?? null;
 }
 
-function resolveAlias(rawModel, models) {
-  const family = ALIAS_FAMILIES.find((f) => rawModel === f || rawModel.startsWith(f + '-'));
-  if (!family) return null;
-  // Pick the newest-looking concrete model in that family: prefer bare
-  // "claude-<family>-<N>" ids (no date suffix) and take the highest one.
-  const candidates = Object.keys(models).filter((k) => k.startsWith(`claude-${family}-`) && /^claude-[a-z]+-[\d.]+$/.test(k));
-  candidates.sort((a, b) => b.localeCompare(a, undefined, { numeric: true }));
-  return candidates[0] ?? null;
+function cleanRates(r) {
+  const out = {};
+  for (const k of RATE_KEYS) out[k] = Number(r?.[k]) || 0;
+  return out;
 }
 
-export function lookupPricing(rawModel, table) {
-  if (!rawModel) return { fidelity: 'unknown', rates: null, displayName: 'unknown model' };
-  const models = table.models;
+function findOverride(rawModel, overrides) {
+  if (!overrides) return null;
+  if (overrides[rawModel]) return overrides[rawModel];
+  const n = normalizeModelId(rawModel);
+  for (const [k, v] of Object.entries(overrides)) if (normalizeModelId(k) === n) return v;
+  return null;
+}
 
-  if (models[rawModel]) {
-    return { fidelity: 'measured', rates: models[rawModel], displayName: models[rawModel].displayName };
+// Returns { rates, fidelity, suggested }
+//   fidelity: override | measured | approximate-alias | unpriced
+//   unpriced → rates are all zero; `suggested` carries the public list price
+//   when one exists so the Pricing page can offer it.
+export function lookupPricing(rawModel, table) {
+  if (!rawModel) return { fidelity: 'unpriced', rates: cleanRates(null), suggested: null };
+  const models = table.models ?? {};
+  const override = findOverride(rawModel, table.overrides);
+  const n = normalizeModelId(rawModel);
+  const claude = isClaudeModel(rawModel);
+
+  let publicRates = models[n] ?? models[rawModel] ?? null;
+  let fidelity = 'measured';
+  if (!publicRates && claude) {
+    const family = ALIAS_FAMILIES.find((f) => n === f || n.startsWith(f + '-') || n === `claude-${f}`);
+    const target = family ? newestInFamily(family, models) : null;
+    if (target) {
+      publicRates = models[target];
+      fidelity = 'approximate-alias';
+    }
   }
 
-  const aliasTarget = resolveAlias(rawModel, models);
-  if (aliasTarget) {
-    const rates = models[aliasTarget];
-    return { fidelity: 'approximate-alias', rates, displayName: `${rates.displayName} (via alias "${rawModel}")` };
+  if (override) return { fidelity: 'override', rates: cleanRates(override), suggested: publicRates ? cleanRates(publicRates) : null };
+  if (publicRates && claude) {
+    return { fidelity, rates: cleanRates(publicRates), suggested: null };
   }
+  // Non-Claude model behind the Claude Code harness (gateway, on-prem, local):
+  // we can't know what it costs this user, so it's $0 until they say otherwise.
+  return { fidelity: 'unpriced', rates: cleanRates(null), suggested: publicRates ? cleanRates(publicRates) : null };
+}
 
-  // Longest-prefix match as a last resort (handles dated variants Claude
-  // Code might report that aren't in the pricing source verbatim).
-  const prefixMatch = Object.keys(models)
-    .filter((k) => rawModel.startsWith(k) || k.startsWith(rawModel))
-    .sort((a, b) => b.length - a.length)[0];
-  if (prefixMatch) {
-    const rates = models[prefixMatch];
-    return { fidelity: 'approximate-alias', rates, displayName: `${rates.displayName} (matched from "${rawModel}")` };
+// Looks a model id up in the public price list: exact (after normalizing
+// provider prefixes / dates), else the newest Claude of the same family,
+// else close matches the user can pick from.
+export function lookupPublic(rawModel, table) {
+  const models = table.models ?? {};
+  const n = normalizeModelId(rawModel);
+  const exact = models[n] ?? models[String(rawModel).trim().toLowerCase()];
+  if (exact) {
+    const id = models[n] ? n : String(rawModel).trim().toLowerCase();
+    return { found: true, match: 'exact', id, rates: cleanRates(exact), provider: exact.provider ?? null, sourceKey: exact.sourceKey ?? id };
   }
-
-  return { fidelity: 'unpriced', rates: null, displayName: rawModel };
+  const q = n.replace(/[^a-z0-9]/g, '');
+  const common = (k) => { let i = 0; while (i < q.length && i < k.length && q[i] === k[i]) i++; return i; };
+  const scored = [];
+  for (const id of Object.keys(models)) {
+    const k = id.replace(/[^a-z0-9]/g, '');
+    const score = q.length >= 3 && (k.includes(q) || q.includes(k)) ? 100 : common(k);
+    if (score >= 5) scored.push([id, score]);
+  }
+  scored.sort((x, y) => y[1] - x[1] || x[0].length - y[0].length);
+  const candidates = scored.slice(0, 8).map(([id]) => ({ id, rates: cleanRates(models[id]), provider: models[id].provider ?? null }));
+  return { found: false, match: 'none', id: n, candidates };
 }
 
 export function costFor(usage, rates) {
   if (!rates) return null;
   const mtok = 1_000_000;
-  const cacheWrite5m = usage.cacheWrite5m ?? 0;
-  const cacheWrite1h = usage.cacheWrite1h ?? 0;
-  const input = (usage.input / mtok) * rates.input;
-  const output = (usage.output / mtok) * rates.output;
-  const cacheWrite = (cacheWrite5m / mtok) * rates.cacheWrite5m + (cacheWrite1h / mtok) * rates.cacheWrite1h;
-  const cacheRead = (usage.cacheRead / mtok) * rates.cacheRead;
+  const input = ((usage.input ?? 0) / mtok) * rates.input;
+  const output = ((usage.output ?? 0) / mtok) * rates.output;
+  const cacheWrite = ((usage.cacheWrite5m ?? 0) / mtok) * rates.cacheWrite5m + ((usage.cacheWrite1h ?? 0) / mtok) * rates.cacheWrite1h;
+  const cacheRead = ((usage.cacheRead ?? 0) / mtok) * rates.cacheRead;
   return { input, output, cacheWrite, cacheRead, total: input + output + cacheWrite + cacheRead };
 }
+
+export function pricingInfo(table) {
+  return { source: table.source, fetchedAt: table.fetchedAt ?? null, error: table.error ?? null, url: SOURCE_URL, modelCount: Object.keys(table.models ?? {}).length };
+}