@dropalltables/yacu 0.1.0 → 1.0.0

package/README.md

@@ -15,7 +15,7 @@ bun add --global @dropalltables/yacu
 yacu
 ```
 
-`yacu` reads local Claude Code, Codex, Cursor, Gemini CLI, OpenCode, and Grok session stores. It does not require accounts, API keys, or network access. Cursor token totals are estimated from local agent transcripts; the other sources use locally recorded usage fields.
+`yacu` reads local Claude Code, Codex, Cursor, Gemini CLI, OpenCode, and Grok session stores. It fetches current model pricing from [models.dev](https://models.dev) and does not require an account or API key. Cursor token totals are estimated from local agent transcripts; the other sources use locally recorded usage fields.
 
 ## Keys
 

package/dist/yacu.js

@@ -134,46 +134,6 @@ function buildDashboard(dataset, range, metric) {
 import { homedir } from "os";
 import { join, resolve } from "path";
 
-// src/data/pricing.ts
-import {
-  estimateUsdCost,
-  normalizeTokenUsage,
-  pricingFromUsdPerMillion
-} from "tokentally";
-var PRICING = [
-  [/claude.*opus/i, pricingFromUsdPerMillion({ inputUsdPerMillion: 5, outputUsdPerMillion: 25, cachedInputUsdPerMillion: 0.5, cacheCreationInputUsdPerMillion: 6.25 })],
-  [/claude.*sonnet/i, pricingFromUsdPerMillion({ inputUsdPerMillion: 3, outputUsdPerMillion: 15, cachedInputUsdPerMillion: 0.3, cacheCreationInputUsdPerMillion: 3.75 })],
-  [/claude.*haiku/i, pricingFromUsdPerMillion({ inputUsdPerMillion: 1, outputUsdPerMillion: 5, cachedInputUsdPerMillion: 0.1, cacheCreationInputUsdPerMillion: 1.25 })],
-  [/(^|\/)gpt-5|codex/i, pricingFromUsdPerMillion({ inputUsdPerMillion: 1.75, outputUsdPerMillion: 14, cachedInputUsdPerMillion: 0.175 })],
-  [/grok|composer/i, pricingFromUsdPerMillion({ inputUsdPerMillion: 2, outputUsdPerMillion: 10, cachedInputUsdPerMillion: 0.2 })],
-  [/deepseek/i, pricingFromUsdPerMillion({ inputUsdPerMillion: 0.27, outputUsdPerMillion: 1.1, cachedInputUsdPerMillion: 0.07 })],
-  [/gemini-3\.1-pro/i, pricingFromUsdPerMillion({ inputUsdPerMillion: 2, outputUsdPerMillion: 12, cachedInputUsdPerMillion: 0.2 })],
-  [/gemini-2\.5-pro/i, pricingFromUsdPerMillion({ inputUsdPerMillion: 1.25, outputUsdPerMillion: 10, cachedInputUsdPerMillion: 0.125 })],
-  [/gemini-3\.[67]-flash/i, pricingFromUsdPerMillion({ inputUsdPerMillion: 0.75, outputUsdPerMillion: 3.75, cachedInputUsdPerMillion: 0.075 })],
-  [/gemini-3\.5-flash/i, pricingFromUsdPerMillion({ inputUsdPerMillion: 1.5, outputUsdPerMillion: 9, cachedInputUsdPerMillion: 0.15 })],
-  [/gemini-3\.1-flash-lite/i, pricingFromUsdPerMillion({ inputUsdPerMillion: 0.25, outputUsdPerMillion: 1.5, cachedInputUsdPerMillion: 0.025 })],
-  [/gemini.*flash/i, pricingFromUsdPerMillion({ inputUsdPerMillion: 0.3, outputUsdPerMillion: 2.5, cachedInputUsdPerMillion: 0.03 })]
-];
-function resolvePricing(model) {
-  return PRICING.find(([pattern]) => pattern.test(model))?.[1] ?? null;
-}
-function estimateCost(model, tokens) {
-  const usage = normalizeTokenUsage({
-    inputTokens: tokens.inputTokens,
-    outputTokens: tokens.outputTokens,
-    cachedInputTokens: tokens.cacheReadTokens,
-    cacheCreationInputTokens: tokens.cacheCreationTokens
-  });
-  return estimateUsdCost({ usage, pricing: resolvePricing(model) })?.totalUsd ?? 0;
-}
-function estimateCacheSavings(model, cachedReadTokens) {
-  const pricing = resolvePricing(model);
-  if (pricing == null)
-    return 0;
-  const cachedRate = pricing.cachedInputUsdPerToken ?? pricing.inputUsdPerToken;
-  return Math.max(0, cachedReadTokens * (pricing.inputUsdPerToken - cachedRate));
-}
-
 // src/data/jsonl.ts
 import { stat } from "fs/promises";
 async function forEachJsonLine(path, callback) {
@@ -244,7 +204,7 @@ function stringValue(value) {
 }
 
 // src/data/sources/claude.ts
-async function loadClaudeUsage() {
+async function loadClaudeUsage(pricing) {
   const files = [...new Set((await Promise.all(claudeRoots().map((root) => globFiles(join(root, "projects"), "**/*.jsonl", { includeSymlinks: true })))).flat())];
   const records = [];
   const sessions = new Map;
@@ -275,8 +235,8 @@ async function loadClaudeUsage() {
         model: entry.model,
         sessionId,
         ...tokens,
-        costUsd: estimateCost(entry.model, tokens),
-        cacheSavingsUsd: estimateCacheSavings(entry.model, entry.cacheReadTokens)
+        costUsd: pricing.estimateCost("anthropic", entry.model, tokens),
+        cacheSavingsUsd: pricing.estimateCacheSavings("anthropic", entry.model, tokens)
       });
       if (sessionId != null) {
         const existing = sessions.get(sessionId);
@@ -326,7 +286,7 @@ function sumTokens(tokens) {
 // src/data/sources/codex.ts
 import { homedir as homedir2 } from "os";
 import { join as join2 } from "path";
-async function loadCodexUsage() {
+async function loadCodexUsage(pricing) {
   const root = join2(process.env.CODEX_HOME ?? join2(homedir2(), ".codex"), "sessions");
   const files = await globFiles(root, "**/*.jsonl");
   const records = [];
@@ -334,6 +294,7 @@ async function loadCodexUsage() {
   for (const path of files) {
     let sessionId = path;
     let model = "codex";
+    let provider = "openai";
     let skipSession = false;
     let previousTotal = "";
     await forEachJsonLine(path, (unknownValue) => {
@@ -342,9 +303,10 @@ async function loadCodexUsage() {
       const type = stringValue(value?.type);
       if (type === "session_meta") {
         sessionId = stringValue(payload?.id) ?? sessionId;
+        provider = stringValue(payload?.model_provider) ?? provider;
         const timestamp2 = stringValue(payload?.timestamp) ?? stringValue(value?.timestamp);
-        const threadSource = payload?.thread_source;
-        skipSession = typeof threadSource !== "string" && JSON.stringify(threadSource).toLowerCase().includes("sub");
+        const sessionSource = JSON.stringify([payload?.thread_source, payload?.source]).toLowerCase();
+        skipSession = sessionSource.includes("subagent");
         previousTotal = "";
         if (timestamp2 != null && !skipSession) {
           sessions.set(sessionId, { id: `codex:${sessionId}`, source: "codex", date: localDate(timestamp2) });
@@ -380,8 +342,8 @@ async function loadCodexUsage() {
         model,
         sessionId: `codex:${sessionId}`,
         ...tokens,
-        costUsd: estimateCost(model, tokens),
-        cacheSavingsUsd: estimateCacheSavings(model, cached)
+        costUsd: pricing.estimateCost(provider, model, tokens),
+        cacheSavingsUsd: pricing.estimateCacheSavings(provider, model, tokens)
       });
     });
   }
@@ -393,7 +355,7 @@ import { stat as stat2 } from "fs/promises";
 import { homedir as homedir3 } from "os";
 import { basename, dirname, join as join3 } from "path";
 import { countTokens } from "gpt-tokenizer/encoding/o200k_base";
-async function loadCursorUsage() {
+async function loadCursorUsage(pricing) {
   const root = process.env.CURSOR_CONFIG_DIR ?? join3(homedir3(), ".cursor");
   const files = await globFiles(join3(root, "projects"), "**/agent-transcripts/**/*.jsonl");
   const fallbackModel = await readConfiguredModel(join3(root, "cli-config.json"));
@@ -426,7 +388,7 @@ async function loadCursorUsage() {
       model,
       sessionId,
       ...tokens,
-      costUsd: estimateCost(model, tokens),
+      costUsd: pricing.estimateCost("cursor", model, tokens),
       cacheSavingsUsd: 0
     });
     sessions.push({ id: sessionId, source: "cursor", date });
@@ -464,7 +426,7 @@ async function readConfiguredModel(path) {
 // src/data/sources/gemini.ts
 import { homedir as homedir4 } from "os";
 import { basename as basename2, join as join4 } from "path";
-async function loadGeminiUsage() {
+async function loadGeminiUsage(pricing) {
   const root = process.env.GEMINI_HOME ?? join4(homedir4(), ".gemini");
   const files = [
     ...await globFiles(join4(root, "tmp"), "**/chats/*.json"),
@@ -510,8 +472,8 @@ async function loadGeminiUsage() {
         model,
         sessionId,
         ...tokens,
-        costUsd: estimateCost(model, tokens),
-        cacheSavingsUsd: estimateCacheSavings(model, cached)
+        costUsd: pricing.estimateCost("google", model, tokens),
+        cacheSavingsUsd: pricing.estimateCacheSavings("google", model, tokens)
       });
       sessions.set(sessionId, { id: sessionId, source: "gemini", date });
     }
@@ -566,7 +528,7 @@ function parseGeminiConversation(text, fallbackId = "session") {
 // src/data/sources/grok.ts
 import { homedir as homedir5 } from "os";
 import { basename as basename3, dirname as dirname2, join as join5 } from "path";
-async function loadGrokUsage() {
+async function loadGrokUsage(pricing) {
   const root = process.env.GROK_HOME ?? join5(homedir5(), ".grok");
   const files = await globFiles(join5(root, "sessions"), "**/updates.jsonl");
   const records = [];
@@ -584,13 +546,7 @@ async function loadGrokUsage() {
       const date = localDate(timestamp);
       const models = asObject(usage.modelUsage);
       const entries = models == null ? [["grok-build", usage]] : Object.entries(models);
-      const cost = numberValue(usage.costUsdTicks) / 1e9;
-      const tokenWeights = entries.map(([, entry]) => {
-        const tokens = asObject(entry);
-        return numberValue(tokens?.inputTokens) + numberValue(tokens?.outputTokens);
-      });
-      const totalWeight = tokenWeights.reduce((sum, value2) => sum + value2, 0);
-      entries.forEach(([model, entry], index) => {
+      entries.forEach(([model, entry]) => {
         const raw = asObject(entry);
         const cached = numberValue(raw?.cachedReadTokens);
         const input = Math.max(0, numberValue(raw?.inputTokens) - cached);
@@ -600,15 +556,14 @@ async function loadGrokUsage() {
           cacheCreationTokens: 0,
           cacheReadTokens: cached
         };
-        const allocatedCost = totalWeight > 0 ? cost * (tokenWeights[index] / totalWeight) : 0;
         records.push({
           date,
           source: "grok",
           model,
           sessionId,
           ...tokens,
-          costUsd: allocatedCost || estimateCost(model, tokens),
-          cacheSavingsUsd: estimateCacheSavings(model, cached)
+          costUsd: pricing.estimateCost("xai", model, tokens),
+          cacheSavingsUsd: pricing.estimateCacheSavings("xai", model, tokens)
         });
       });
       sessions.set(sessionId, { id: sessionId, source: "grok", date });
@@ -620,7 +575,7 @@ async function loadGrokUsage() {
 // src/data/sources/opencode.ts
 import { homedir as homedir6 } from "os";
 import { join as join6 } from "path";
-async function loadOpenCodeUsage() {
+async function loadOpenCodeUsage(pricing) {
   const root = process.env.OPENCODE_DATA_DIR ?? join6(homedir6(), ".local", "share", "opencode");
   const files = await globFiles(join6(root, "storage", "message"), "**/*.json");
   const seen = new Set;
@@ -631,6 +586,7 @@ async function loadOpenCodeUsage() {
       const message = asObject(await Bun.file(path).json());
       const id = stringValue(message?.id);
       const model = stringValue(message?.modelID);
+      const provider = stringValue(message?.providerID) ?? "opencode";
       const tokensValue = asObject(message?.tokens);
       if (id == null || model == null || tokensValue == null || seen.has(id))
         continue;
@@ -648,15 +604,14 @@ async function loadOpenCodeUsage() {
       const date = localDate(numberValue(time?.created) || Date.now());
       const rawSession = stringValue(message?.sessionID) ?? id;
       const sessionId = `opencode:${rawSession}`;
-      const localCost = typeof message?.cost === "number" ? message.cost : null;
       records.push({
         date,
         source: "opencode",
         model,
         sessionId,
         ...tokens,
-        costUsd: localCost ?? estimateCost(model, tokens),
-        cacheSavingsUsd: estimateCacheSavings(model, tokens.cacheReadTokens)
+        costUsd: pricing.estimateCost(provider, model, tokens),
+        cacheSavingsUsd: pricing.estimateCacheSavings(provider, model, tokens)
       });
       sessions.set(sessionId, { id: sessionId, source: "opencode", date });
     } catch {
@@ -666,6 +621,155 @@ async function loadOpenCodeUsage() {
   return { records, sessions: [...sessions.values()], files: files.length };
 }
 
+// src/data/pricing.ts
+var MODELS_DEV_API_URL = process.env.MODELS_DEV_API_URL ?? "https://models.dev/api.json";
+var TOKENS_PER_MILLION = 1e6;
+async function loadPricingCatalog() {
+  const response = await fetch(MODELS_DEV_API_URL);
+  if (!response.ok)
+    throw new Error(`models.dev pricing request failed (${response.status})`);
+  return createPricingCatalog(await response.json());
+}
+function createPricingCatalog(value) {
+  const providers = parseProviders(value);
+  const resolve2 = (provider, model, tokens) => {
+    const direct = resolveFromProvider(providers.get(normalizeId(provider)), provider, model);
+    const resolved = direct ?? resolveUnambiguousModel(providers, model);
+    return resolved == null ? null : applyContextTier(resolved.cost, tokens);
+  };
+  return {
+    resolve: resolve2,
+    estimateCost(provider, model, tokens) {
+      const cost = resolve2(provider, model, tokens);
+      if (cost == null)
+        return 0;
+      const input = tokens.inputTokens * cost.input;
+      const output = tokens.outputTokens * cost.output;
+      const cacheRead = tokens.cacheReadTokens * (cost.cache_read ?? cost.input);
+      const cacheWrite = tokens.cacheCreationTokens * (cost.cache_write ?? cost.input);
+      return (input + output + cacheRead + cacheWrite) / TOKENS_PER_MILLION;
+    },
+    estimateCacheSavings(provider, model, tokens) {
+      const cost = resolve2(provider, model, tokens);
+      if (cost == null)
+        return 0;
+      return Math.max(0, tokens.cacheReadTokens * (cost.input - (cost.cache_read ?? cost.input)) / TOKENS_PER_MILLION);
+    }
+  };
+}
+function parseProviders(value) {
+  const providers = new Map;
+  if (!isObject(value))
+    throw new Error("models.dev returned an invalid catalog");
+  for (const [providerKey, providerValue] of Object.entries(value)) {
+    if (!isObject(providerValue) || !isObject(providerValue.models))
+      continue;
+    const models = new Map;
+    for (const [modelKey, modelValue] of Object.entries(providerValue.models)) {
+      const model = parseModel(modelKey, modelValue);
+      if (model == null)
+        continue;
+      models.set(normalizeId(modelKey), model);
+      models.set(normalizeId(model.id), model);
+    }
+    providers.set(normalizeId(providerKey), models);
+    if (typeof providerValue.id === "string")
+      providers.set(normalizeId(providerValue.id), models);
+  }
+  if (providers.size === 0)
+    throw new Error("models.dev returned an empty catalog");
+  return providers;
+}
+function parseModel(modelKey, value) {
+  if (!isObject(value) || !isObject(value.cost))
+    return null;
+  const input = finiteNumber2(value.cost.input);
+  const output = finiteNumber2(value.cost.output);
+  if (input == null || output == null)
+    return null;
+  return {
+    id: typeof value.id === "string" ? value.id : modelKey,
+    cost: {
+      input,
+      output,
+      cache_read: finiteNumber2(value.cost.cache_read) ?? undefined,
+      cache_write: finiteNumber2(value.cost.cache_write) ?? undefined,
+      tiers: parseTiers(value.cost.tiers)
+    }
+  };
+}
+function parseTiers(value) {
+  if (!Array.isArray(value))
+    return [];
+  return value.flatMap((entry) => {
+    if (!isObject(entry) || !isObject(entry.tier) || entry.tier.type !== "context")
+      return [];
+    const size = finiteNumber2(entry.tier.size);
+    if (size == null)
+      return [];
+    return [{
+      input: finiteNumber2(entry.input) ?? undefined,
+      output: finiteNumber2(entry.output) ?? undefined,
+      cache_read: finiteNumber2(entry.cache_read) ?? undefined,
+      cache_write: finiteNumber2(entry.cache_write) ?? undefined,
+      tier: { type: "context", size }
+    }];
+  }).sort((left, right) => left.tier.size - right.tier.size);
+}
+function resolveFromProvider(models, provider, model) {
+  if (models == null)
+    return null;
+  for (const candidate of modelCandidates(provider, model)) {
+    const match = models.get(candidate);
+    if (match != null)
+      return match;
+  }
+  return null;
+}
+function resolveUnambiguousModel(providers, model) {
+  const matches = new Map;
+  const candidate = normalizeId(model);
+  for (const models of new Set(providers.values())) {
+    const match = models.get(candidate);
+    if (match != null)
+      matches.set(costSignature(match.cost), match);
+  }
+  return matches.size === 1 ? [...matches.values()][0] : null;
+}
+function applyContextTier(cost, tokens) {
+  if (tokens == null)
+    return cost;
+  const contextTokens = tokens.inputTokens + tokens.cacheCreationTokens + tokens.cacheReadTokens;
+  const tier = cost.tiers.findLast((candidate) => contextTokens > candidate.tier.size);
+  if (tier == null)
+    return cost;
+  return {
+    ...cost,
+    input: tier.input ?? cost.input,
+    output: tier.output ?? cost.output,
+    cache_read: tier.cache_read ?? cost.cache_read,
+    cache_write: tier.cache_write ?? cost.cache_write
+  };
+}
+function modelCandidates(provider, model) {
+  const normalizedProvider = normalizeId(provider);
+  const normalizedModel = normalizeId(model);
+  const prefix = `${normalizedProvider}/`;
+  return normalizedModel.startsWith(prefix) ? [normalizedModel, normalizedModel.slice(prefix.length)] : [normalizedModel];
+}
+function costSignature(cost) {
+  return JSON.stringify(cost);
+}
+function normalizeId(value) {
+  return value.trim().toLowerCase();
+}
+function finiteNumber2(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : null;
+}
+function isObject(value) {
+  return typeof value === "object" && value != null && !Array.isArray(value);
+}
+
 // src/data/load.ts
 var SOURCES = [
   { id: "claude", load: loadClaudeUsage },
@@ -676,12 +780,13 @@ var SOURCES = [
   { id: "grok", load: loadGrokUsage }
 ];
 async function loadUsageDataset(onProgress) {
+  const pricing = await loadPricingCatalog();
   let completed = 0;
   const results = await Promise.all(SOURCES.map(async (source) => {
     const common = { source: source.id, label: SOURCE_META[source.id].label, total: SOURCES.length };
     onProgress?.({ ...common, status: "scanning", completed });
     try {
-      const value = await source.load();
+      const value = await source.load(pricing);
       completed += 1;
       onProgress?.({
         ...common,
@@ -1032,7 +1137,7 @@ function Summary({
       }),
       /* @__PURE__ */ jsx5("text", {
         fg: theme.muted,
-        children: `${dashboard.sessions.toLocaleString("en-US")} sessions \xB7 API estimate`
+        children: `${dashboard.sessions.toLocaleString("en-US")} sessions \xB7 models.dev estimate`
       }),
       /* @__PURE__ */ jsx5("box", {
         height: 1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dropalltables/yacu",
-  "version": "0.1.0",
+  "version": "1.0.0",
   "description": "Local coding-agent usage dashboard for the terminal",
   "repository": {
     "type": "git",
@@ -51,8 +51,7 @@
     "@opentui/core": "^0.5.9",
     "@opentui/react": "^0.5.9",
     "gpt-tokenizer": "4.0.0",
-    "react": "^19.2.8",
-    "tokentally": "^0.1.4"
+    "react": "^19.2.8"
   },
   "devDependencies": {
     "@types/bun": "^1.4.0",

package/src/data/load.ts

@@ -5,11 +5,12 @@ import { loadCursorUsage } from "./sources/cursor"
 import { loadGeminiUsage } from "./sources/gemini"
 import { loadGrokUsage } from "./sources/grok"
 import { loadOpenCodeUsage } from "./sources/opencode"
+import { loadPricingCatalog, type PricingCatalog } from "./pricing"
 import type { ScanProgressHandler, SourceLoadResult } from "./types"
 
 type SourceLoader = {
   id: SourceId
-  load: () => Promise<SourceLoadResult>
+  load: (pricing: PricingCatalog) => Promise<SourceLoadResult>
 }
 
 const SOURCES: SourceLoader[] = [
@@ -22,12 +23,13 @@ const SOURCES: SourceLoader[] = [
 ]
 
 export async function loadUsageDataset(onProgress?: ScanProgressHandler): Promise<UsageDataset> {
+  const pricing = await loadPricingCatalog()
   let completed = 0
   const results = await Promise.all(SOURCES.map(async (source) => {
     const common = { source: source.id, label: SOURCE_META[source.id].label, total: SOURCES.length }
     onProgress?.({ ...common, status: "scanning", completed })
     try {
-      const value = await source.load()
+      const value = await source.load(pricing)
       completed += 1
       onProgress?.({
         ...common,

package/src/data/pricing.test.ts

@@ -1,22 +1,86 @@
 import { describe, expect, test } from "bun:test"
-import { estimateCacheSavings, estimateCost, resolvePricing } from "./pricing"
+import { createPricingCatalog } from "./pricing"
 
-describe("pricing", () => {
-  test("matches supported model families", () => {
-    expect(resolvePricing("claude-opus-4-1")).not.toBeNull()
-    expect(resolvePricing("gpt-5-codex")).not.toBeNull()
-    expect(resolvePricing("unknown-local-model")).toBeNull()
+const pricing = createPricingCatalog({
+  openai: {
+    id: "openai",
+    models: {
+      "gpt-example": {
+        id: "gpt-example",
+        cost: {
+          input: 2,
+          output: 8,
+          cache_read: 0.2,
+          cache_write: 2.5,
+          tiers: [{
+            input: 4,
+            output: 12,
+            cache_read: 0.4,
+            cache_write: 5,
+            tier: { type: "context", size: 200_000 },
+          }],
+        },
+      },
+    },
+  },
+  gateway: {
+    id: "gateway",
+    models: {
+      "gpt-example": {
+        id: "gpt-example",
+        cost: { input: 3, output: 9 },
+      },
+      "shared-model": {
+        id: "shared-model",
+        cost: { input: 1, output: 2 },
+      },
+    },
+  },
+  another: {
+    id: "another",
+    models: {
+      "shared-model": {
+        id: "shared-model",
+        cost: { input: 1, output: 2 },
+      },
+    },
+  },
+})
+
+describe("models.dev pricing", () => {
+  test("resolves exact provider and model identifiers", () => {
+    expect(pricing.resolve("openai", "gpt-example")?.input).toBe(2)
+    expect(pricing.resolve("openai", "openai/gpt-example")?.input).toBe(2)
+    expect(pricing.resolve("missing", "shared-model")?.input).toBe(1)
+    expect(pricing.resolve("missing", "gpt-example")).toBeNull()
+    expect(pricing.resolve("openai", "unknown-model")).toBeNull()
   })
 
-  test("estimates cost and cache savings", () => {
-    const cost = estimateCost("gpt-5-codex", {
-      inputTokens: 1_000_000,
+  test("uses input, output, cache read, and cache write rates", () => {
+    const cost = pricing.estimateCost("openai", "gpt-example", {
+      inputTokens: 50_000,
+      outputTokens: 100_000,
+      cacheCreationTokens: 50_000,
+      cacheReadTokens: 50_000,
+    })
+
+    expect(cost).toBeCloseTo(1.035)
+    expect(pricing.estimateCacheSavings("openai", "gpt-example", {
+      inputTokens: 0,
       outputTokens: 0,
       cacheCreationTokens: 0,
+      cacheReadTokens: 1_000_000,
+    })).toBeCloseTo(3.6)
+  })
+
+  test("applies context pricing tiers", () => {
+    const cost = pricing.estimateCost("openai", "gpt-example", {
+      inputTokens: 200_001,
+      outputTokens: 1_000_000,
+      cacheCreationTokens: 0,
       cacheReadTokens: 0,
     })
 
-    expect(cost).toBeCloseTo(1.75)
-    expect(estimateCacheSavings("gpt-5-codex", 1_000_000)).toBeCloseTo(1.575)
+    expect(cost).toBeCloseTo(12.800004)
   })
 })

package/src/data/pricing.ts

@@ -1,10 +1,3 @@
-import {
-  estimateUsdCost,
-  normalizeTokenUsage,
-  pricingFromUsdPerMillion,
-  type Pricing,
-} from "tokentally"
-
 export type TokenParts = {
   inputTokens: number
   outputTokens: number
@@ -12,38 +5,179 @@ export type TokenParts = {
   cacheReadTokens: number
 }
 
-const PRICING: Array<[RegExp, Pricing]> = [
-  [/claude.*opus/i, pricingFromUsdPerMillion({ inputUsdPerMillion: 5, outputUsdPerMillion: 25, cachedInputUsdPerMillion: 0.5, cacheCreationInputUsdPerMillion: 6.25 })],
-  [/claude.*sonnet/i, pricingFromUsdPerMillion({ inputUsdPerMillion: 3, outputUsdPerMillion: 15, cachedInputUsdPerMillion: 0.3, cacheCreationInputUsdPerMillion: 3.75 })],
-  [/claude.*haiku/i, pricingFromUsdPerMillion({ inputUsdPerMillion: 1, outputUsdPerMillion: 5, cachedInputUsdPerMillion: 0.1, cacheCreationInputUsdPerMillion: 1.25 })],
-  [/(^|\/)gpt-5|codex/i, pricingFromUsdPerMillion({ inputUsdPerMillion: 1.75, outputUsdPerMillion: 14, cachedInputUsdPerMillion: 0.175 })],
-  [/grok|composer/i, pricingFromUsdPerMillion({ inputUsdPerMillion: 2, outputUsdPerMillion: 10, cachedInputUsdPerMillion: 0.2 })],
-  [/deepseek/i, pricingFromUsdPerMillion({ inputUsdPerMillion: 0.27, outputUsdPerMillion: 1.1, cachedInputUsdPerMillion: 0.07 })],
-  [/gemini-3\.1-pro/i, pricingFromUsdPerMillion({ inputUsdPerMillion: 2, outputUsdPerMillion: 12, cachedInputUsdPerMillion: 0.2 })],
-  [/gemini-2\.5-pro/i, pricingFromUsdPerMillion({ inputUsdPerMillion: 1.25, outputUsdPerMillion: 10, cachedInputUsdPerMillion: 0.125 })],
-  [/gemini-3\.[67]-flash/i, pricingFromUsdPerMillion({ inputUsdPerMillion: 0.75, outputUsdPerMillion: 3.75, cachedInputUsdPerMillion: 0.075 })],
-  [/gemini-3\.5-flash/i, pricingFromUsdPerMillion({ inputUsdPerMillion: 1.5, outputUsdPerMillion: 9, cachedInputUsdPerMillion: 0.15 })],
-  [/gemini-3\.1-flash-lite/i, pricingFromUsdPerMillion({ inputUsdPerMillion: 0.25, outputUsdPerMillion: 1.5, cachedInputUsdPerMillion: 0.025 })],
-  [/gemini.*flash/i, pricingFromUsdPerMillion({ inputUsdPerMillion: 0.3, outputUsdPerMillion: 2.5, cachedInputUsdPerMillion: 0.03 })],
-]
-
-export function resolvePricing(model: string): Pricing | null {
-  return PRICING.find(([pattern]) => pattern.test(model))?.[1] ?? null
-}
-
-export function estimateCost(model: string, tokens: TokenParts): number {
-  const usage = normalizeTokenUsage({
-    inputTokens: tokens.inputTokens,
-    outputTokens: tokens.outputTokens,
-    cachedInputTokens: tokens.cacheReadTokens,
-    cacheCreationInputTokens: tokens.cacheCreationTokens,
-  })
-  return estimateUsdCost({ usage, pricing: resolvePricing(model) })?.totalUsd ?? 0
-}
-
-export function estimateCacheSavings(model: string, cachedReadTokens: number): number {
-  const pricing = resolvePricing(model)
-  if (pricing == null) return 0
-  const cachedRate = pricing.cachedInputUsdPerToken ?? pricing.inputUsdPerToken
-  return Math.max(0, cachedReadTokens * (pricing.inputUsdPerToken - cachedRate))
+type ModelsDevCost = {
+  input: number
+  output: number
+  cache_read?: number
+  cache_write?: number
+  tiers: Array<{
+    input?: number
+    output?: number
+    cache_read?: number
+    cache_write?: number
+    tier: { type: "context", size: number }
+  }>
+}
+
+type ModelsDevModel = {
+  id: string
+  cost: ModelsDevCost
+}
+
+type ProviderModels = Map<string, ModelsDevModel>
+
+export type PricingCatalog = {
+  resolve: (provider: string, model: string, tokens?: TokenParts) => ModelsDevCost | null
+  estimateCost: (provider: string, model: string, tokens: TokenParts) => number
+  estimateCacheSavings: (provider: string, model: string, tokens: TokenParts) => number
+}
+
+const MODELS_DEV_API_URL = process.env.MODELS_DEV_API_URL ?? "https://models.dev/api.json"
+const TOKENS_PER_MILLION = 1_000_000
+
+export async function loadPricingCatalog(): Promise<PricingCatalog> {
+  const response = await fetch(MODELS_DEV_API_URL)
+  if (!response.ok) throw new Error(`models.dev pricing request failed (${response.status})`)
+  return createPricingCatalog(await response.json())
+}
+
+export function createPricingCatalog(value: unknown): PricingCatalog {
+  const providers = parseProviders(value)
+
+  const resolve = (provider: string, model: string, tokens?: TokenParts): ModelsDevCost | null => {
+    const direct = resolveFromProvider(providers.get(normalizeId(provider)), provider, model)
+    const resolved = direct ?? resolveUnambiguousModel(providers, model)
+    return resolved == null ? null : applyContextTier(resolved.cost, tokens)
+  }
+
+  return {
+    resolve,
+    estimateCost(provider, model, tokens) {
+      const cost = resolve(provider, model, tokens)
+      if (cost == null) return 0
+      const input = tokens.inputTokens * cost.input
+      const output = tokens.outputTokens * cost.output
+      const cacheRead = tokens.cacheReadTokens * (cost.cache_read ?? cost.input)
+      const cacheWrite = tokens.cacheCreationTokens * (cost.cache_write ?? cost.input)
+      return (input + output + cacheRead + cacheWrite) / TOKENS_PER_MILLION
+    },
+    estimateCacheSavings(provider, model, tokens) {
+      const cost = resolve(provider, model, tokens)
+      if (cost == null) return 0
+      return Math.max(0, tokens.cacheReadTokens * (cost.input - (cost.cache_read ?? cost.input)) / TOKENS_PER_MILLION)
+    },
+  }
+}
+
+function parseProviders(value: unknown): Map<string, ProviderModels> {
+  const providers = new Map<string, ProviderModels>()
+  if (!isObject(value)) throw new Error("models.dev returned an invalid catalog")
+
+  for (const [providerKey, providerValue] of Object.entries(value)) {
+    if (!isObject(providerValue) || !isObject(providerValue.models)) continue
+    const models: ProviderModels = new Map()
+    for (const [modelKey, modelValue] of Object.entries(providerValue.models)) {
+      const model = parseModel(modelKey, modelValue)
+      if (model == null) continue
+      models.set(normalizeId(modelKey), model)
+      models.set(normalizeId(model.id), model)
+    }
+    providers.set(normalizeId(providerKey), models)
+    if (typeof providerValue.id === "string") providers.set(normalizeId(providerValue.id), models)
+  }
+
+  if (providers.size === 0) throw new Error("models.dev returned an empty catalog")
+  return providers
+}
+
+function parseModel(modelKey: string, value: unknown): ModelsDevModel | null {
+  if (!isObject(value) || !isObject(value.cost)) return null
+  const input = finiteNumber(value.cost.input)
+  const output = finiteNumber(value.cost.output)
+  if (input == null || output == null) return null
+
+  return {
+    id: typeof value.id === "string" ? value.id : modelKey,
+    cost: {
+      input,
+      output,
+      cache_read: finiteNumber(value.cost.cache_read) ?? undefined,
+      cache_write: finiteNumber(value.cost.cache_write) ?? undefined,
+      tiers: parseTiers(value.cost.tiers),
+    },
+  }
+}
+
+function parseTiers(value: unknown): ModelsDevCost["tiers"] {
+  if (!Array.isArray(value)) return []
+  return value.flatMap((entry) => {
+    if (!isObject(entry) || !isObject(entry.tier) || entry.tier.type !== "context") return []
+    const size = finiteNumber(entry.tier.size)
+    if (size == null) return []
+    return [{
+      input: finiteNumber(entry.input) ?? undefined,
+      output: finiteNumber(entry.output) ?? undefined,
+      cache_read: finiteNumber(entry.cache_read) ?? undefined,
+      cache_write: finiteNumber(entry.cache_write) ?? undefined,
+      tier: { type: "context" as const, size },
+    }]
+  }).sort((left, right) => left.tier.size - right.tier.size)
+}
+
+function resolveFromProvider(models: ProviderModels | undefined, provider: string, model: string): ModelsDevModel | null {
+  if (models == null) return null
+  for (const candidate of modelCandidates(provider, model)) {
+    const match = models.get(candidate)
+    if (match != null) return match
+  }
+  return null
+}
+
+function resolveUnambiguousModel(providers: Map<string, ProviderModels>, model: string): ModelsDevModel | null {
+  const matches = new Map<string, ModelsDevModel>()
+  const candidate = normalizeId(model)
+  for (const models of new Set(providers.values())) {
+    const match = models.get(candidate)
+    if (match != null) matches.set(costSignature(match.cost), match)
+  }
+  return matches.size === 1 ? [...matches.values()][0]! : null
+}
+
+function applyContextTier(cost: ModelsDevCost, tokens?: TokenParts): ModelsDevCost {
+  if (tokens == null) return cost
+  const contextTokens = tokens.inputTokens + tokens.cacheCreationTokens + tokens.cacheReadTokens
+  const tier = cost.tiers.findLast((candidate) => contextTokens > candidate.tier.size)
+  if (tier == null) return cost
+  return {
+    ...cost,
+    input: tier.input ?? cost.input,
+    output: tier.output ?? cost.output,
+    cache_read: tier.cache_read ?? cost.cache_read,
+    cache_write: tier.cache_write ?? cost.cache_write,
+  }
+}
+
+function modelCandidates(provider: string, model: string): string[] {
+  const normalizedProvider = normalizeId(provider)
+  const normalizedModel = normalizeId(model)
+  const prefix = `${normalizedProvider}/`
+  return normalizedModel.startsWith(prefix)
+    ? [normalizedModel, normalizedModel.slice(prefix.length)]
+    : [normalizedModel]
+}
+
+function costSignature(cost: ModelsDevCost): string {
+  return JSON.stringify(cost)
+}
+
+function normalizeId(value: string): string {
+  return value.trim().toLowerCase()
+}
+
+function finiteNumber(value: unknown): number | null {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : null
+}
+
+function isObject(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value != null && !Array.isArray(value)
 }

package/src/data/sources/claude.ts

@@ -2,7 +2,7 @@ import { homedir } from "node:os"
 import { join, resolve } from "node:path"
 import { localDate } from "../../domain/dates"
 import type { UsageRecord, UsageSession } from "../../domain/types"
-import { estimateCacheSavings, estimateCost } from "../pricing"
+import type { PricingCatalog } from "../pricing"
 import { asObject, forEachJsonLine, globFiles, numberValue, stringValue } from "../jsonl"
 import type { SourceLoadResult } from "../types"
 
@@ -18,7 +18,7 @@ type ClaudeEntry = {
   cacheReadTokens: number
 }
 
-export async function loadClaudeUsage(): Promise<SourceLoadResult> {
+export async function loadClaudeUsage(pricing: PricingCatalog): Promise<SourceLoadResult> {
   const files = [...new Set((await Promise.all(
     claudeRoots().map((root) => globFiles(
       join(root, "projects"),
@@ -57,8 +57,8 @@ export async function loadClaudeUsage(): Promise<SourceLoadResult> {
         model: entry.model,
         sessionId,
         ...tokens,
-        costUsd: estimateCost(entry.model, tokens),
-        cacheSavingsUsd: estimateCacheSavings(entry.model, entry.cacheReadTokens),
+        costUsd: pricing.estimateCost("anthropic", entry.model, tokens),
+        cacheSavingsUsd: pricing.estimateCacheSavings("anthropic", entry.model, tokens),
       })
 
       if (sessionId != null) {

package/src/data/sources/codex.ts

@@ -2,11 +2,11 @@ import { homedir } from "node:os"
 import { join } from "node:path"
 import { localDate } from "../../domain/dates"
 import type { UsageRecord, UsageSession } from "../../domain/types"
-import { estimateCacheSavings, estimateCost } from "../pricing"
+import type { PricingCatalog } from "../pricing"
 import { asObject, forEachJsonLine, globFiles, numberValue, stringValue } from "../jsonl"
 import type { SourceLoadResult } from "../types"
 
-export async function loadCodexUsage(): Promise<SourceLoadResult> {
+export async function loadCodexUsage(pricing: PricingCatalog): Promise<SourceLoadResult> {
   const root = join(process.env.CODEX_HOME ?? join(homedir(), ".codex"), "sessions")
   const files = await globFiles(root, "**/*.jsonl")
   const records: UsageRecord[] = []
@@ -15,6 +15,7 @@ export async function loadCodexUsage(): Promise<SourceLoadResult> {
   for (const path of files) {
     let sessionId = path
     let model = "codex"
+    let provider = "openai"
     let skipSession = false
     let previousTotal = ""
 
@@ -25,9 +26,10 @@ export async function loadCodexUsage(): Promise<SourceLoadResult> {
 
       if (type === "session_meta") {
         sessionId = stringValue(payload?.id) ?? sessionId
+        provider = stringValue(payload?.model_provider) ?? provider
         const timestamp = stringValue(payload?.timestamp) ?? stringValue(value?.timestamp)
-        const threadSource = payload?.thread_source
-        skipSession = typeof threadSource !== "string" && JSON.stringify(threadSource).toLowerCase().includes("sub")
+        const sessionSource = JSON.stringify([payload?.thread_source, payload?.source]).toLowerCase()
+        skipSession = sessionSource.includes("subagent")
         previousTotal = ""
         if (timestamp != null && !skipSession) {
           sessions.set(sessionId, { id: `codex:${sessionId}`, source: "codex", date: localDate(timestamp) })
@@ -63,8 +65,8 @@ export async function loadCodexUsage(): Promise<SourceLoadResult> {
         model,
         sessionId: `codex:${sessionId}`,
         ...tokens,
-        costUsd: estimateCost(model, tokens),
-        cacheSavingsUsd: estimateCacheSavings(model, cached),
+        costUsd: pricing.estimateCost(provider, model, tokens),
+        cacheSavingsUsd: pricing.estimateCacheSavings(provider, model, tokens),
       })
     })
   }

package/src/data/sources/cursor.ts

@@ -4,7 +4,7 @@ import { basename, dirname, join } from "node:path"
 import { countTokens } from "gpt-tokenizer/encoding/o200k_base"
 import { localDate } from "../../domain/dates"
 import type { UsageRecord, UsageSession } from "../../domain/types"
-import { estimateCost } from "../pricing"
+import type { PricingCatalog } from "../pricing"
 import { asObject, forEachJsonLine, globFiles, stringValue } from "../jsonl"
 import type { SourceLoadResult } from "../types"
 
@@ -13,7 +13,7 @@ type TranscriptCount = {
   outputTokens: number
 }
 
-export async function loadCursorUsage(): Promise<SourceLoadResult> {
+export async function loadCursorUsage(pricing: PricingCatalog): Promise<SourceLoadResult> {
   const root = process.env.CURSOR_CONFIG_DIR ?? join(homedir(), ".cursor")
   const files = await globFiles(join(root, "projects"), "**/agent-transcripts/**/*.jsonl")
   const fallbackModel = await readConfiguredModel(join(root, "cli-config.json"))
@@ -45,7 +45,7 @@ export async function loadCursorUsage(): Promise<SourceLoadResult> {
       model,
       sessionId,
       ...tokens,
-      costUsd: estimateCost(model, tokens),
+      costUsd: pricing.estimateCost("cursor", model, tokens),
       cacheSavingsUsd: 0,
     })
     sessions.push({ id: sessionId, source: "cursor", date })

package/src/data/sources/gemini.ts

@@ -2,7 +2,7 @@ import { homedir } from "node:os"
 import { basename, join } from "node:path"
 import { localDate } from "../../domain/dates"
 import type { UsageRecord, UsageSession } from "../../domain/types"
-import { estimateCacheSavings, estimateCost } from "../pricing"
+import type { PricingCatalog } from "../pricing"
 import { asObject, globFiles, numberValue, stringValue } from "../jsonl"
 import type { SourceLoadResult } from "../types"
 
@@ -12,7 +12,7 @@ type ParsedConversation = {
   messages: Array<Record<string, unknown>>
 }
 
-export async function loadGeminiUsage(): Promise<SourceLoadResult> {
+export async function loadGeminiUsage(pricing: PricingCatalog): Promise<SourceLoadResult> {
   const root = process.env.GEMINI_HOME ?? join(homedir(), ".gemini")
   const files = [
     ...await globFiles(join(root, "tmp"), "**/chats/*.json"),
@@ -56,8 +56,8 @@ export async function loadGeminiUsage(): Promise<SourceLoadResult> {
         model,
         sessionId,
         ...tokens,
-        costUsd: estimateCost(model, tokens),
-        cacheSavingsUsd: estimateCacheSavings(model, cached),
+        costUsd: pricing.estimateCost("google", model, tokens),
+        cacheSavingsUsd: pricing.estimateCacheSavings("google", model, tokens),
       })
       sessions.set(sessionId, { id: sessionId, source: "gemini", date })
     }

package/src/data/sources/grok.ts

@@ -2,11 +2,11 @@ import { homedir } from "node:os"
 import { basename, dirname, join } from "node:path"
 import { localDate } from "../../domain/dates"
 import type { UsageRecord, UsageSession } from "../../domain/types"
-import { estimateCacheSavings, estimateCost } from "../pricing"
+import type { PricingCatalog } from "../pricing"
 import { asObject, forEachJsonLine, globFiles, numberValue, stringValue } from "../jsonl"
 import type { SourceLoadResult } from "../types"
 
-export async function loadGrokUsage(): Promise<SourceLoadResult> {
+export async function loadGrokUsage(pricing: PricingCatalog): Promise<SourceLoadResult> {
   const root = process.env.GROK_HOME ?? join(homedir(), ".grok")
   const files = await globFiles(join(root, "sessions"), "**/updates.jsonl")
   const records: UsageRecord[] = []
@@ -24,14 +24,7 @@ export async function loadGrokUsage(): Promise<SourceLoadResult> {
       const date = localDate(timestamp)
       const models = asObject(usage.modelUsage)
       const entries = models == null ? [["grok-build", usage] as const] : Object.entries(models)
-      const cost = numberValue(usage.costUsdTicks) / 1_000_000_000
-      const tokenWeights = entries.map(([, entry]) => {
-        const tokens = asObject(entry)
-        return numberValue(tokens?.inputTokens) + numberValue(tokens?.outputTokens)
-      })
-      const totalWeight = tokenWeights.reduce((sum, value) => sum + value, 0)
-
-      entries.forEach(([model, entry], index) => {
+      entries.forEach(([model, entry]) => {
         const raw = asObject(entry)
         const cached = numberValue(raw?.cachedReadTokens)
         const input = Math.max(0, numberValue(raw?.inputTokens) - cached)
@@ -41,15 +34,14 @@ export async function loadGrokUsage(): Promise<SourceLoadResult> {
           cacheCreationTokens: 0,
           cacheReadTokens: cached,
         }
-        const allocatedCost = totalWeight > 0 ? cost * (tokenWeights[index]! / totalWeight) : 0
         records.push({
           date,
           source: "grok",
           model,
           sessionId,
           ...tokens,
-          costUsd: allocatedCost || estimateCost(model, tokens),
-          cacheSavingsUsd: estimateCacheSavings(model, cached),
+          costUsd: pricing.estimateCost("xai", model, tokens),
+          cacheSavingsUsd: pricing.estimateCacheSavings("xai", model, tokens),
         })
       })
       sessions.set(sessionId, { id: sessionId, source: "grok", date })

package/src/data/sources/opencode.ts

@@ -2,11 +2,11 @@ import { homedir } from "node:os"
 import { join } from "node:path"
 import { localDate } from "../../domain/dates"
 import type { UsageRecord, UsageSession } from "../../domain/types"
-import { estimateCacheSavings, estimateCost } from "../pricing"
+import type { PricingCatalog } from "../pricing"
 import { asObject, globFiles, numberValue, stringValue } from "../jsonl"
 import type { SourceLoadResult } from "../types"
 
-export async function loadOpenCodeUsage(): Promise<SourceLoadResult> {
+export async function loadOpenCodeUsage(pricing: PricingCatalog): Promise<SourceLoadResult> {
   const root = process.env.OPENCODE_DATA_DIR ?? join(homedir(), ".local", "share", "opencode")
   const files = await globFiles(join(root, "storage", "message"), "**/*.json")
   const seen = new Set<string>()
@@ -18,6 +18,7 @@ export async function loadOpenCodeUsage(): Promise<SourceLoadResult> {
       const message = asObject(await Bun.file(path).json())
       const id = stringValue(message?.id)
       const model = stringValue(message?.modelID)
+      const provider = stringValue(message?.providerID) ?? "opencode"
       const tokensValue = asObject(message?.tokens)
       if (id == null || model == null || tokensValue == null || seen.has(id)) continue
       seen.add(id)
@@ -33,15 +34,14 @@ export async function loadOpenCodeUsage(): Promise<SourceLoadResult> {
       const date = localDate(numberValue(time?.created) || Date.now())
       const rawSession = stringValue(message?.sessionID) ?? id
       const sessionId = `opencode:${rawSession}`
-      const localCost = typeof message?.cost === "number" ? message.cost : null
       records.push({
         date,
         source: "opencode",
         model,
         sessionId,
         ...tokens,
-        costUsd: localCost ?? estimateCost(model, tokens),
-        cacheSavingsUsd: estimateCacheSavings(model, tokens.cacheReadTokens),
+        costUsd: pricing.estimateCost(provider, model, tokens),
+        cacheSavingsUsd: pricing.estimateCacheSavings(provider, model, tokens),
       })
       sessions.set(sessionId, { id: sessionId, source: "opencode", date })
     } catch {

package/src/tui/components/Summary.tsx

@@ -25,7 +25,7 @@ export function Summary({
   return (
     <box flexDirection="column" width="100%" gap={1}>
       <text fg={theme.text}><strong>{total}</strong></text>
-      <text fg={theme.muted}>{`${dashboard.sessions.toLocaleString("en-US")} sessions · API estimate`}</text>
+      <text fg={theme.muted}>{`${dashboard.sessions.toLocaleString("en-US")} sessions · models.dev estimate`}</text>
       <box height={1} />
       {dashboard.providers.map((provider) => {
         const meta = SOURCE_META[provider.source]