@ipv9/tokentracker-cli 0.39.40 → 0.39.42

package/src/lib/pricing/index.js

@@ -34,34 +34,110 @@ function loadSeedSync() {
 
 const seedRaw = loadSeedSync();
 
+// How long a loaded snapshot is trusted before a lookup is allowed to trigger a
+// background refresh. Mirrors the fetcher's disk-cache TTL: before this change
+// that TTL only chose which snapshot to load *at startup*, so a dashboard that
+// stayed up (the LaunchAgent stays up for days) never saw a new model or a
+// price change — claude-opus-5 billed $0 for 21 hours that way. Issue #90.
+const RELOAD_AFTER_MS = 24 * 60 * 60 * 1000;
+
+// Floor between background refreshes, so a permanently-unknown model cannot
+// turn every request into an upstream fetch.
+const RELOAD_COOLDOWN_MS = 5 * 60 * 1000;
+
+// Resolution tiers that mean "we guessed": the model matched a substring or a
+// curated fuzzy rule rather than an exact id, so the price is plausible but may
+// belong to a different model. Worth surfacing — a wrong price never looks
+// wrong, unlike a $0 one.
+const FUZZY_SOURCES = new Set(["curated:fuzzy", "litellm:fuzzy", "litellm:prefix-strip"]);
+
+// Placeholder ids that stand in for "this row has no model", so they resolve to
+// the "unattributed" tier instead of being looked up and recorded as a miss.
+// Closed set on purpose: a real model id must never be silently un-priced here.
+const UNATTRIBUTED_MODEL_IDS = new Set(["unknown"]);
+
+// `last_refresh_error` is served over HTTP to the dashboard, so it is built
+// from CLOSED sets, never from an arbitrary value. A previous version accepted
+// anything symbol-shaped, which a QA pass broke immediately: a 32-character
+// token like `sk_live_AAAA…` is symbol-shaped. There is no pattern that
+// separates "a short error symbol" from "a short secret" — only an allowlist.
+const KNOWN_ERROR_CODES = new Set([
+  // fs
+  "ENOENT", "EACCES", "EPERM", "EEXIST", "ENOSPC", "EROFS", "EISDIR", "ENOTDIR", "EMFILE", "EBUSY",
+  // network
+  "ECONNREFUSED", "ECONNRESET", "ETIMEDOUT", "ENOTFOUND", "EAI_AGAIN", "EPIPE",
+  "EHOSTUNREACH", "ENETUNREACH", "UND_ERR_CONNECT_TIMEOUT", "UND_ERR_HEADERS_TIMEOUT",
+  // error classes
+  "AbortError", "TypeError", "SyntaxError", "RangeError", "FetchError", "Error",
+]);
+
+// Whatever loadLitellmData can report as the origin of the data it returned.
+const KNOWN_SOURCES = new Set(["upstream", "disk-cache", "stale-cache", "seed-snapshot"]);
+
+function labelFrom(allowed, candidates) {
+  for (const candidate of candidates) {
+    if (typeof candidate === "string" && allowed.has(candidate)) return candidate;
+  }
+  return "unknown";
+}
+
 const state = {
   loaded: false,
   loadingPromise: null,
+  loadedAt: 0,
+  reloadPromise: null,
+  lastReloadAt: 0,
+  lastReloadError: null,
   litellmRawMap: seedRaw, // raw per-token; field shape from LiteLLM JSON
   litellmPerMillionMap: buildLitellmPerMillionMap(seedRaw), // USD/MTok
   source: Object.keys(seedRaw).length ? "seed-snapshot:sync" : null,
   // negativeCache prevents re-walking the LiteLLM map for models we've already
   // determined are unknown. Cleared on every reload.
   negativeCache: new Set(),
+  // model -> resolution tier, for the diagnostics surface. Cleared on reload.
+  tiers: new Map(),
+  // Models already warned about, so a hot path logs once, not once per row.
+  warned: new Set(),
+  reloadOptions: {},
 };
 
 function defaultCachePath() {
   return path.join(os.homedir(), ".tokentracker", "cache", "pricing.json");
 }
 
+// `requireUpstream` guards the background path. loadLitellmData falls back on
+// its own (upstream → stale disk cache → bundled seed), so a refresh that fails
+// to reach upstream would otherwise REPLACE good in-memory data with the older
+// seed — re-introducing exactly the "new model bills $0" bug this reload exists
+// to fix. Verified: with the disk cache deleted and upstream down, a model
+// priced at $5/$25 dropped to $0 after a failed refresh.
+async function loadInto(opts, { requireUpstream = false } = {}) {
+  const cachePath = opts.cachePath || defaultCachePath();
+  const { data, source } = await loadLitellmData({ ...opts, cachePath });
+  if (requireUpstream && source !== "upstream") {
+    state.lastReloadError = `refresh-fell-back-to-${labelFrom(KNOWN_SOURCES, [source])}`;
+    return;
+  }
+  state.litellmRawMap = data || {};
+  state.litellmPerMillionMap = buildLitellmPerMillionMap(state.litellmRawMap);
+  state.source = source;
+  state.loaded = true;
+  state.loadedAt = Date.now();
+  state.negativeCache.clear();
+  state.tiers.clear();
+}
+
 async function ensurePricingLoaded(opts = {}) {
   if (state.loaded) return state;
   if (state.loadingPromise) return state.loadingPromise;
 
+  // Remembered so a later background reload can reach the same cache path and
+  // fetch options without the caller having to plumb them through again.
+  state.reloadOptions = opts;
+
   state.loadingPromise = (async () => {
     try {
-      const cachePath = opts.cachePath || defaultCachePath();
-      const { data, source } = await loadLitellmData({ ...opts, cachePath });
-      state.litellmRawMap = data || {};
-      state.litellmPerMillionMap = buildLitellmPerMillionMap(state.litellmRawMap);
-      state.source = source;
-      state.loaded = true;
-      state.negativeCache.clear();
+      await loadInto(opts);
       return state;
     } finally {
       state.loadingPromise = null;
@@ -71,37 +147,158 @@ async function ensurePricingLoaded(opts = {}) {
   return state.loadingPromise;
 }
 
+// Fire-and-forget refresh. Single-flight, never awaited by a lookup: the caller
+// keeps whatever price it already has for this request and the next request
+// benefits. A failed reload leaves the existing snapshot in place.
+//
+// The cooldown matters because a model that is genuinely absent upstream (a
+// local or unlisted model) misses on every row it appears in. Without it, each
+// of those rows would queue another upstream fetch the moment the previous one
+// finished.
+function scheduleReload(nowMs = Date.now()) {
+  if (!state.loaded || state.reloadPromise) return state.reloadPromise;
+  if (nowMs - state.lastReloadAt < RELOAD_COOLDOWN_MS) return null;
+  state.lastReloadAt = nowMs;
+  state.reloadPromise = (async () => {
+    try {
+      // forceRefresh skips the disk cache; without it a reload would just
+      // re-read the same stale snapshot we already hold.
+      state.lastReloadError = null;
+      // forceRefresh skips the disk cache; without it a reload would just
+      // re-read the same stale snapshot we already hold.
+      await loadInto({ ...state.reloadOptions, forceRefresh: true }, { requireUpstream: true });
+    } catch (e) {
+      // Reached when loadLitellmData itself throws rather than falling back —
+      // statSafe rethrows a non-ENOENT stat error, so an unusable cache path
+      // lands here (QA probe: refresh-failed:TypeError). Only
+      // the error CODE is kept: messages from fs/fetch carry absolute paths and
+      // this string is served over HTTP to the dashboard.
+      state.lastReloadError = `refresh-failed:${labelFrom(KNOWN_ERROR_CODES, [e?.code, e?.name])}`;
+    } finally {
+      state.reloadPromise = null;
+    }
+  })();
+  return state.reloadPromise;
+}
+
+function isSnapshotStale(nowMs = Date.now()) {
+  return state.loaded && nowMs - state.loadedAt > RELOAD_AFTER_MS;
+}
+
 // For tests: drop loaded state so a fresh call can re-load. Seeds with the
 // bundled snapshot so getModelPricing() still works without ensurePricingLoaded.
 function resetPricingForTests() {
   state.loaded = false;
   state.loadingPromise = null;
+  state.loadedAt = 0;
+  state.reloadPromise = null;
+  state.lastReloadAt = 0;
+  state.lastReloadError = null;
   state.litellmRawMap = seedRaw;
   state.litellmPerMillionMap = buildLitellmPerMillionMap(seedRaw);
   state.source = Object.keys(seedRaw).length ? "seed-snapshot:sync" : null;
   state.negativeCache.clear();
+  state.tiers.clear();
+  state.warned.clear();
+  state.reloadOptions = {};
 }
 
-function getModelPricing(model, opts = {}) {
-  if (!model) return ZERO_PRICING;
-  let lookupSource = null;
-  if (typeof opts === "string") {
-    lookupSource = opts.toLowerCase();
-  } else if (typeof opts.source === "string") {
-    lookupSource = opts.source.toLowerCase();
-  }
+function resolveLookupSource(opts) {
+  if (typeof opts === "string") return opts.toLowerCase();
+  if (opts && typeof opts.source === "string") return opts.source.toLowerCase();
+  return null;
+}
+
+// A row whose model id could not be determined is stored and aggregated under
+// the literal id "unknown" — persisted into the queue by src/commands/sync.js
+// and src/lib/claude-categorizer.js, then coalesced to it again at read time by
+// src/lib/local-api.js. That is a placeholder for "no model", not a model, so
+// pricing it turned a missing *attribution* into a missing *price*: it recorded
+// a permanent miss, listed "unknown" in unpriced_models as though a real model
+// needed a curated price, and logged advice to add it to curated-overrides.json
+// where it could never match anything.
+// Returns the tier to report, or null when this is a real model id to look up.
+function resolvePlaceholderTier(model) {
+  if (!model) return "empty";
+  const normalized = String(model).trim().toLowerCase();
+  if (!normalized) return "empty";
+  return UNATTRIBUTED_MODEL_IDS.has(normalized) ? "unattributed" : null;
+}
+
+// Returns the price AND how it was resolved. getModelPricing keeps the old
+// bare-numbers contract for the many existing callers; anything that wants to
+// show the user how much to trust the number uses this.
+function getModelPricingMeta(model, opts = {}) {
+  const placeholderTier = resolvePlaceholderTier(model);
+  if (placeholderTier) return { pricing: ZERO_PRICING, tier: placeholderTier };
+
+  const lookupSource = resolveLookupSource(opts);
   const cacheKey = lookupSource ? `${lookupSource}\0${model}` : model;
-  if (state.negativeCache.has(cacheKey)) return ZERO_PRICING;
+
+  if (state.negativeCache.has(cacheKey)) {
+    // Still unknown as of the current snapshot. If that snapshot has aged out,
+    // a new model may have appeared upstream — refresh for the next caller.
+    if (isSnapshotStale()) scheduleReload();
+    return { pricing: ZERO_PRICING, tier: "miss" };
+  }
 
   const result = lookupPricing(model, {
     curated: curatedOverrides,
     litellm: state.litellmPerMillionMap,
     source: lookupSource,
   });
-  if (result.hit) return result.value;
+
+  if (result.hit) {
+    state.tiers.set(cacheKey, { model, source: lookupSource, tier: result.source });
+    return { pricing: result.value, tier: result.source };
+  }
 
   state.negativeCache.add(cacheKey);
-  return ZERO_PRICING;
+  state.tiers.set(cacheKey, { model, source: lookupSource, tier: "miss" });
+
+  // A miss is the strongest signal that our snapshot predates a model launch —
+  // exactly the claude-opus-5 case. Refresh in the background so the next
+  // request prices it, instead of waiting for a process restart.
+  scheduleReload();
+
+  if (!state.warned.has(cacheKey)) {
+    state.warned.add(cacheKey);
+    console.warn(
+      `[pricing] no price for model "${model}"${lookupSource ? ` (source: ${lookupSource})` : ""}`
+        + " — its cost is being counted as $0. Refreshing pricing data in the background;"
+        + " if it stays unpriced, add it to src/lib/pricing/curated-overrides.json.",
+    );
+  }
+
+  return { pricing: ZERO_PRICING, tier: "miss" };
+}
+
+function getModelPricing(model, opts = {}) {
+  return getModelPricingMeta(model, opts).pricing;
+}
+
+// Snapshot of what the pricing layer knows it got wrong or guessed at, for the
+// API to hand to the dashboard.
+function getPricingDiagnostics() {
+  // Keyed by source+model, matching the lookup itself: the same model id can
+  // resolve differently per provider (Antigravity normalises names before the
+  // lookup), so a model-only key would let one provider's exact hit hide
+  // another's miss.
+  const unpriced = new Set();
+  const fuzzy = [];
+  for (const entry of state.tiers.values()) {
+    if (entry.tier === "miss") unpriced.add(entry.model);
+    else if (FUZZY_SOURCES.has(entry.tier)) fuzzy.push({ model: entry.model, tier: entry.tier });
+  }
+  return {
+    source: state.source,
+    loaded_at: state.loadedAt ? new Date(state.loadedAt).toISOString() : null,
+    stale: isSnapshotStale(),
+    refreshing: Boolean(state.reloadPromise),
+    last_refresh_error: state.lastReloadError,
+    unpriced_models: Array.from(unpriced).sort(),
+    fuzzy_priced_models: fuzzy.sort((a, b) => a.model.localeCompare(b.model)),
+  };
 }
 
 // Same formula and Codex/every-code reasoning-folding rule as the previous
@@ -134,10 +331,14 @@ const MODEL_PRICING = curatedOverrides.exact;
 module.exports = {
   ensurePricingLoaded,
   getModelPricing,
+  getModelPricingMeta,
+  getPricingDiagnostics,
   computeRowCost,
   resetPricingForTests,
   MODEL_PRICING,
   ZERO_PRICING,
   // Internal hooks for tests.
   __getStateForTests: () => state,
+  __labelFromForTests: labelFrom,
+  __KNOWN_ERROR_CODES: KNOWN_ERROR_CODES,
 };

package/src/lib/pricing/litellm-fetcher.js

@@ -112,6 +112,11 @@ async function writeCache(cachePath, data) {
 async function loadLitellmData({
   cachePath,
   ttlMs = DEFAULT_TTL_MS,
+  // Skip the disk cache and go upstream. Needed because `ttlMs: 0` does NOT
+  // reliably force a refetch: mtime carries sub-millisecond precision while
+  // Date.now() does not, so a cache file written moments ago can compare as
+  // "written in the future" and still count as fresh.
+  forceRefresh = false,
   fetchTimeoutMs = DEFAULT_FETCH_TIMEOUT_MS,
   fetchImpl = fetchUpstream,
   url = LITELLM_PRICING_URL,
@@ -126,7 +131,7 @@ async function loadLitellmData({
 
   // 1. Fresh disk cache
   const stat = await statSafe(cachePath);
-  if (isFresh(stat, ttlMs)) {
+  if (!forceRefresh && isFresh(stat, ttlMs)) {
     try {
       const data = await readJsonAsync(cachePath);
       delete data._meta;