mixdog 0.9.174 → 1.0.0

package/src/runtime/shared/llm/model-pricing-rates.mjs

@@ -0,0 +1,78 @@
+// Source formats are normalized to USD per million tokens before merging.
+export const PRICING_RATE_KEYS = Object.freeze([
+  'inputCostPerM',
+  'outputCostPerM',
+  'cacheReadCostPerM',
+  'cacheWriteCostPerM',
+]);
+const LITELLM_KEYS = [
+  'input_cost_per_token',
+  'output_cost_per_token',
+  'cache_read_input_token_cost',
+  'cache_creation_input_token_cost',
+];
+const MODELSDEV_KEYS = ['input', 'output', 'cache_read', 'cache_write'];
+const validRate = (value) => typeof value === 'number' && Number.isFinite(value) && value >= 0;
+
+function rates(source, keys, multiplier) {
+  return Object.fromEntries(
+    PRICING_RATE_KEYS.map((key, i) => [key, validRate(source?.[keys[i]]) ? source[keys[i]] * multiplier : null])
+  );
+}
+
+// `suffix` selects a service-tier column set (e.g. `_priority`), published as
+// `<key>_priority` and `<key>_above_<N>k_tokens_priority`.
+export function litellmPricing(entry, suffix = '') {
+  const thresholds = new Set();
+  const tierKey = new RegExp(`^_above_(\\d+)k_tokens${suffix}$`);
+  for (const key of Object.keys(entry || {})) {
+    for (const prefix of LITELLM_KEYS) {
+      if (!key.startsWith(`${prefix}_above_`)) continue;
+      const match = key.slice(prefix.length).match(tierKey);
+      if (match) thresholds.add(Number(match[1]) * 1000);
+    }
+  }
+  return {
+    ...rates(
+      entry,
+      LITELLM_KEYS.map((key) => `${key}${suffix}`),
+      1_000_000
+    ),
+    pricingTiers: [...thresholds]
+      .sort((a, b) => a - b)
+      .map((aboveInputTokens) => ({
+        aboveInputTokens,
+        ...rates(
+          entry,
+          LITELLM_KEYS.map((key) => `${key}_above_${aboveInputTokens / 1000}k_tokens${suffix}`),
+          1_000_000
+        ),
+      })),
+  };
+}
+
+export function modelsDevPricing(cost) {
+  // Structured tiers supersede the older context_over_200k compatibility
+  // field; it can coexist with a tier whose actual boundary is not 200k.
+  let tiers = [];
+  if (Array.isArray(cost?.tiers)) {
+    tiers = cost.tiers
+      .filter((row) => row?.tier?.type === 'context' && Number.isFinite(row.tier.size) && row.tier.size > 0)
+      .map((row) => ({ aboveInputTokens: row.tier.size, ...rates(row, MODELSDEV_KEYS, 1) }));
+  } else if (cost?.context_over_200k) {
+    tiers = [{ aboveInputTokens: 200000, ...rates(cost.context_over_200k, MODELSDEV_KEYS, 1) }];
+  }
+  return {
+    ...rates(cost, MODELSDEV_KEYS, 1),
+    pricingTiers: tiers.sort((a, b) => a.aboveInputTokens - b.aboveInputTokens),
+  };
+}
+
+export function ratesForPrompt(meta, promptTokens) {
+  const result = Object.fromEntries(PRICING_RATE_KEYS.map((key) => [key, meta?.[key] ?? null]));
+  for (const tier of meta?.pricingTiers || []) {
+    if (promptTokens <= tier.aboveInputTokens) continue;
+    for (const key of PRICING_RATE_KEYS) if (tier[key] != null) result[key] = tier[key];
+  }
+  return result;
+}

package/src/runtime/shared/llm/provider-catalog-cache.mjs

@@ -0,0 +1,130 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { resolvePluginData } from '../plugin-paths.mjs';
+import { ANTIGRAVITY_MODELS, ANTIGRAVITY_PRICING_ALIASES, normalizeGrokModelId } from './provider-model-identities.mjs';
+
+const PROVIDER_CACHE_FILES = Object.freeze({
+  'openai-oauth': ['openai-oauth-models.json'],
+  'anthropic-oauth': ['anthropic-oauth-models.json'],
+  anthropic: ['anthropic-oauth-models.json'],
+  gemini: ['gemini-models.json'],
+  'grok-oauth': ['grok-oauth-models.json'],
+  'antigravity-oauth': ['antigravity-oauth-models.json'],
+});
+
+export function providerUsesEndpointScopedLimits(provider) {
+  const p = String(provider || '').toLowerCase();
+  return p === 'openai-oauth' || p === 'anthropic-oauth' || p === 'grok-oauth';
+}
+
+function num(value) {
+  const n = Number(value);
+  return Number.isFinite(n) && n > 0 ? Math.floor(n) : null;
+}
+
+function readModelsFromCacheFile(fileName) {
+  try {
+    const file = join(resolvePluginData(), fileName);
+    if (!existsSync(file)) return [];
+    const raw = JSON.parse(readFileSync(file, 'utf-8'));
+    return [raw?.models, raw].find(Array.isArray) ?? [];
+  } catch {
+    return [];
+  }
+}
+
+export function providerCachedModelsSync(provider) {
+  const p = String(provider || '').toLowerCase();
+  const files = PROVIDER_CACHE_FILES[p] || [];
+  const rows = [];
+  const seen = new Set();
+  for (const fileName of files) {
+    for (const row of readModelsFromCacheFile(fileName)) {
+      const id = rowId(row);
+      if (!id || seen.has(id)) continue;
+      seen.add(id);
+      rows.push({ ...row, id });
+    }
+  }
+  return rows;
+}
+
+export function cachedProviderModelListsSync() {
+  return Object.fromEntries(
+    Object.keys(PROVIDER_CACHE_FILES)
+      .filter((provider) => provider !== 'anthropic')
+      .map((provider) => [provider, providerCachedModelsSync(provider)])
+  );
+}
+
+/** Only explicit catalog wire mappings establish an alias. Never strip an
+ * effort/date/preview suffix: gateway labels can point to a different version. */
+export function providerPricingModelSync(provider, model) {
+  if (provider === 'grok-oauth') return normalizeGrokModelId(model);
+  if (provider !== 'antigravity-oauth') return model;
+  const row = [...providerCachedModelsSync(provider), ...ANTIGRAVITY_MODELS].find(
+    (entry) =>
+      entry.id === model ||
+      entry.wire === model ||
+      (entry.wire && typeof entry.wire === 'object' && Object.values(entry.wire).includes(model))
+  );
+  const id = row?.pricingModel || row?.id || model;
+  return ANTIGRAVITY_PRICING_ALIASES[id] || id;
+}
+
+function modelAliases(id) {
+  const text = String(id || '').trim();
+  if (!text) return [];
+  const aliases = new Set([text]);
+  aliases.add(text.replace(/-\d{4}-\d{2}-\d{2}$/, ''));
+  aliases.add(text.replace(/-\d{8}$/, ''));
+  return [...aliases].filter(Boolean);
+}
+
+function rowId(row) {
+  return String(row?.id || row?.name || row?.slug || '').trim();
+}
+
+function getProviderCachedModelSync(provider, model) {
+  const p = String(provider || '').toLowerCase();
+  const files = PROVIDER_CACHE_FILES[p] || [];
+  if (!files.length || !model) return null;
+  const aliases = new Set(modelAliases(model));
+  for (const fileName of files) {
+    for (const row of readModelsFromCacheFile(fileName)) {
+      const id = rowId(row);
+      if (!id || !aliases.has(id)) continue;
+      return row;
+    }
+  }
+  return null;
+}
+
+export function providerCachedModelMetadataSync(provider, model) {
+  const p = String(provider || '').toLowerCase();
+  const row = getProviderCachedModelSync(provider, model);
+  if (!row) return null;
+  return {
+    contextWindow: num(
+      row.contextWindow ?? row.context_window ?? row.maxContextWindow ?? row.max_context_window ?? row.max_input_tokens
+    ),
+    // Grok's /models response currently publishes a context window but no
+    // output ceiling. Older enriched cache rows copied contextWindow into
+    // outputTokens; never feed that derived value back as provider-native.
+    outputTokens:
+      p === 'grok-oauth'
+        ? null
+        : num(row.outputTokens ?? row.maxOutputTokens ?? row.max_output_tokens ?? row.output_token_limit),
+    supportsVision: row.supportsVision === true,
+    supportsFunctionCalling: row.supportsFunctionCalling === true,
+    supportsWebSearch: row.supportsWebSearch === true,
+    supportsPromptCaching: row.supportsPromptCaching === true,
+    supportsReasoning: row.supportsReasoning === true,
+    reasoningOptions: Array.isArray(row.reasoningOptions) ? row.reasoningOptions : [],
+    reasoningContentField: row.reasoningContentField || null,
+    mode: row.mode || null,
+    displayName: row.displayName || row.display || row.name || null,
+    name: row.name || row.display || null,
+    rawProviderModel: row,
+  };
+}

package/src/runtime/shared/llm/usage-accounting.mjs

@@ -23,8 +23,18 @@ export async function accountProviderSend(provider, instance, send, model, opts
   } catch (error) {
     openingError = error;
   }
+  const identity = {
+    provider,
+    requestedModel: model,
+    sessionId,
+    sourceType,
+    inputTokensInclusive,
+  };
   const record = async (result) => {
     if (!result?.usage) return;
+    // A nested send (e.g. a fallback model re-send) already stamped its own
+    // final attempt's tier; the outer context only saw the abandoned attempt.
+    result.requestServiceTier ??= identity.requestServiceTier || '';
     if (openingError) throw openingError;
     if (!ledger) return;
     const usage = result.usage;
@@ -46,7 +56,7 @@ export async function accountProviderSend(provider, instance, send, model, opts
       cacheWrite1hTokens: usage.cacheWrite1hTokens,
       costUsd: usage.costUsd,
       serviceTier: result.serviceTier || usage.raw?.service_tier,
-      fast: opts.fast === true,
+      requestServiceTier: result.requestServiceTier,
       responseId: result.responseId,
       // The account this send is bound to, so quota history can tell one
       // connected subscription's records from another's.
@@ -68,16 +78,7 @@ export async function accountProviderSend(provider, instance, send, model, opts
   };
   let result;
   try {
-    result = await withUsageContext(
-      {
-        provider,
-        requestedModel: model,
-        sessionId,
-        sourceType,
-        inputTokensInclusive,
-      },
-      send
-    );
+    result = await withUsageContext(identity, send);
   } catch (error) {
     // Only provider-reported partial usage is recordable; never invent
     // tokens for a failed request or reinterpret an error as a success.

package/src/runtime/shared/llm/usage-context.mjs

@@ -4,3 +4,10 @@ import { AsyncLocalStorage } from 'node:async_hooks';
 const context = new AsyncLocalStorage();
 export const withUsageContext = (identity, send) => context.run(identity, send);
 export const currentUsageContext = () => context.getStore();
+// Each wire attempt stamps the tier it actually sent on its own send's
+// context object, so the last attempt (the one that produced the usage) wins
+// and concurrent sends never observe each other's tier.
+export const noteRequestServiceTier = (tier) => {
+  const identity = context.getStore();
+  if (identity) identity.requestServiceTier = tier || '';
+};

package/src/runtime/shared/llm/usage-ledger-import.mjs

@@ -144,10 +144,21 @@ export async function importUsageHistory(ledger, dataDir, { now = Date.now(), re
   const traceRows = await readTrace(dataDir, until);
   result.traceRows = traceRows.length;
   accept(traceRows);
-  const gateway = await optionalFile(join(dataDir, 'gateway-usage.local.json'));
-  if (gateway)
+  // The JSONL store supersedes the legacy JSON file (it is migrated from it).
+  const gatewayJsonl = await optionalFile(join(dataDir, 'gateway-usage.local.jsonl'));
+  const gateway = gatewayJsonl === null ? await optionalFile(join(dataDir, 'gateway-usage.local.json')) : null;
+  if (gatewayJsonl !== null || gateway)
     accept(
-      (JSON.parse(gateway).events || []).map((event) => ({
+      (gatewayJsonl !== null
+        ? gatewayJsonl.split('\n').flatMap((line) => {
+            try {
+              return line.trim() ? [JSON.parse(line)] : [];
+            } catch {
+              return []; // torn append
+            }
+          })
+        : JSON.parse(gateway).events || []
+      ).map((event) => ({
         ...event,
         kind: 'usage',
         session_id: event.sessionId,

package/src/runtime/shared/llm/usage-ledger-quota.mjs

@@ -98,7 +98,9 @@ function sameWindow(previous, sample) {
 export function recordQuotaSamples(db, samples) {
   const latest = db.prepare(`SELECT ts,seen_until,used_pct,reset_at FROM quota_samples
       WHERE provider=? AND account=? AND label=? ORDER BY ts DESC LIMIT 1`);
-  const extend = db.prepare('UPDATE quota_samples SET seen_until=? WHERE provider=? AND account=? AND label=? AND ts=?');
+  const extend = db.prepare(
+    'UPDATE quota_samples SET seen_until=? WHERE provider=? AND account=? AND label=? AND ts=?'
+  );
   const insert = db.prepare('INSERT OR IGNORE INTO quota_samples VALUES (?,?,?,?,?,?,?)');
   let written = 0;
   db.exec('BEGIN IMMEDIATE');
@@ -148,10 +150,14 @@ function listQuotaSeries(db) {
 // on its shortest.
 const WEEKLY_WINDOW = /^(?:7D|W)$/i;
 
-function pickSelection(series, { provider, account, label }) {
+// No account asked for: the one its account pool has in use (`inUse`, per
+// provider), else the one whose meter moved last.
+function pickSelection(series, { provider, account, label, inUse = {} }) {
+  const chosen = provider || series[0]?.provider;
+  const accountId = account || inUse[chosen] || '';
   const entry =
-    series.find((row) => row.provider === provider && row.account === account) ||
-    series.find((row) => row.provider === provider) ||
+    series.find((row) => row.provider === chosen && row.account === accountId) ||
+    series.find((row) => row.provider === chosen) ||
     series[0];
   if (!entry) return null;
   const wanted = String(label || '').toLowerCase();
@@ -322,20 +328,48 @@ function firstAfter(events, time) {
   return low;
 }
 
+// Records written before accounts were recorded carry none. They were made
+// through the account the provider was used through when recording began: the
+// one on its earliest record that names an account. Once set it never
+// changes, so it is read once per connection.
+const legacyAccountOwners = new WeakMap();
+
+function legacyAccountOwner(db, provider) {
+  let owners = legacyAccountOwners.get(db);
+  if (!owners) {
+    owners = new Map();
+    legacyAccountOwners.set(db, owners);
+  }
+  if (owners.has(provider)) return owners.get(provider);
+  const row = db
+    .prepare(`
+      SELECT json_extract(r.signature,'$[8]') AS account
+      FROM usage_events e JOIN usage_routes r ON r.id=e.route
+      WHERE json_extract(r.signature,'$[0]')=? AND COALESCE(json_extract(r.signature,'$[8]'),'')<>''
+      ORDER BY e.ts LIMIT 1`)
+    .get(provider);
+  if (!row) return null;
+  owners.set(provider, row.account);
+  return row.account;
+}
+
 /**
  * The provider account's token records in [fromMs, toMs], summed per minute
  * and model, keeping the best-ranked origin per day and model like the usage
  * rollups. The provider and account are read off the route table once — far
- * smaller than the records — so no record is decoded. Records written before
- * accounts were recorded carry none and count for every account.
+ * smaller than the records — so no record is decoded. Records without an
+ * account belong to the legacy owner only, or to every account while no
+ * record names one.
  */
 function readQuotaEvents(db, { provider, account, fromMs, toMs }) {
+  const owner = legacyAccountOwner(db, provider);
+  const unlabeled = owner === null || owner === account ? '' : account;
   const rows = db
     .prepare(`
       WITH routes AS (
           SELECT id,json_extract(signature,'$[1]') AS model,json_extract(signature,'$[7]') AS rank
           FROM usage_routes
-          WHERE json_extract(signature,'$[0]')=? AND COALESCE(json_extract(signature,'$[8]'),'') IN (?,'')
+          WHERE json_extract(signature,'$[0]')=? AND COALESCE(json_extract(signature,'$[8]'),'') IN (?,?)
       )
       SELECT (e.ts/60000)*60000 AS minute,e.day,r.model,r.rank,COUNT(*) AS turns,
           SUM(e.input) AS input,SUM(e.output) AS output,SUM(e.cache_read) AS cacheRead,
@@ -344,7 +378,7 @@ function readQuotaEvents(db, { provider, account, fromMs, toMs }) {
       WHERE e.ts>=? AND e.ts<=?
       GROUP BY minute,e.day,r.model,r.rank
       ORDER BY minute`)
-    .all(provider, account, fromMs, toMs);
+    .all(provider, account, unlabeled, fromMs, toMs);
   const best = new Map();
   const ranks = db.prepare(`SELECT day,model,MIN(rank) AS rank FROM daily
       WHERE provider=? AND day BETWEEN ? AND ? GROUP BY day,model`);
@@ -408,9 +442,14 @@ function allocateQuota(instances, events) {
           turns += events[index].turns;
         }
         let weight = 'turns';
-        if (cost > 0) weight = 'costUsd';
-        else if (tokens > 0) weight = 'tokens';
-        const total = cost > 0 ? cost : tokens > 0 ? tokens : turns;
+        let total = turns;
+        if (cost > 0) {
+          weight = 'costUsd';
+          total = cost;
+        } else if (tokens > 0) {
+          weight = 'tokens';
+          total = tokens;
+        }
         if (total > 0) {
           for (let index = start; index < end; index += 1) shares[index] += (delta * events[index][weight]) / total;
           instance.attributed += delta;
@@ -533,6 +572,30 @@ function modelSeries(slots, instances, keys, now) {
   return series;
 }
 
+/** Outside usage is spread over the time its interval covers; returns its total within the domain. */
+function spreadOutsideUsage(outside, slots, slotAt, domainFrom, domainTo) {
+  let total = 0;
+  for (const interval of outside) {
+    const from = Math.max(interval.fromMs, domainFrom);
+    const to = Math.min(interval.toMs, domainTo);
+    if (interval.toMs <= interval.fromMs) {
+      if (interval.toMs < domainFrom || interval.toMs > domainTo) continue;
+      slots[slotAt(interval.toMs)].outside += interval.points;
+      total += interval.points;
+      continue;
+    }
+    for (let index = slotAt(from); index < slots.length && slots[index].fromMs < to; index += 1) {
+      const slot = slots[index];
+      const overlap = Math.min(to, slot.toMs) - Math.max(from, slot.fromMs);
+      if (overlap <= 0) continue;
+      const part = (interval.points * overlap) / (interval.toMs - interval.fromMs);
+      slot.outside += part;
+      total += part;
+    }
+  }
+  return total;
+}
+
 function historyRow(instance, events) {
   const start = firstAfter(events, instance.startMs - 1);
   const end = firstAfter(events, instance.endMs);
@@ -577,10 +640,20 @@ function readQuotaRows(db, { provider, account, label }) {
  */
 export function readQuotaHistory(
   db,
-  { provider = '', account = '', label = '', view = 'window', anchor = null, fromMs = null, toMs = null, now = Date.now() } = {}
+  {
+    provider = '',
+    account = '',
+    label = '',
+    inUse = {},
+    view = 'window',
+    anchor = null,
+    fromMs = null,
+    toMs = null,
+    now = Date.now(),
+  } = {}
 ) {
   const subscriptions = listQuotaSeries(db);
-  const selection = pickSelection(subscriptions, { provider, account, label });
+  const selection = pickSelection(subscriptions, { provider, account, label, inUse });
   const base = { generatedAt: now, view, subscriptions, selection };
   if (!selection) return { ...base, period: null };
   const rows = readQuotaRows(db, selection);
@@ -603,7 +676,9 @@ export function readQuotaHistory(
   const { shares, outside } = allocateQuota(shown, events);
   const points = quotaPoints(shown);
 
-  const slotMs = SLOT_SIZES.find((size) => (domainTo - domainFrom) / size <= MAX_SLOTS) ?? Math.ceil((domainTo - domainFrom) / MAX_SLOTS);
+  const slotMs =
+    SLOT_SIZES.find((size) => (domainTo - domainFrom) / size <= MAX_SLOTS) ??
+    Math.ceil((domainTo - domainFrom) / MAX_SLOTS);
   const slots = [];
   for (let start = domainFrom; start < domainTo; start += slotMs) {
     slots.push({
@@ -633,26 +708,7 @@ export function readQuotaHistory(
     slot.models.set(event.model, slotModel);
     addUsage(slotModel, event, share);
   });
-  // Outside usage is spread over the time its interval covers.
-  let outsideTotal = 0;
-  for (const interval of outside) {
-    const from = Math.max(interval.fromMs, domainFrom);
-    const to = Math.min(interval.toMs, domainTo);
-    if (interval.toMs <= interval.fromMs) {
-      if (interval.toMs < domainFrom || interval.toMs > domainTo) continue;
-      slots[slotAt(interval.toMs)].outside += interval.points;
-      outsideTotal += interval.points;
-      continue;
-    }
-    for (let index = slotAt(from); index < slots.length && slots[index].fromMs < to; index += 1) {
-      const slot = slots[index];
-      const overlap = Math.min(to, slot.toMs) - Math.max(from, slot.fromMs);
-      if (overlap <= 0) continue;
-      const part = (interval.points * overlap) / (interval.toMs - interval.fromMs);
-      slot.outside += part;
-      outsideTotal += part;
-    }
-  }
+  const outsideTotal = spreadOutsideUsage(outside, slots, slotAt, domainFrom, domainTo);
 
   const exportedModels = [...models].map(([model, usage]) => ({ model, ...exportUsage(usage) })).sort(byConsumption);
   const seriesKeys = exportedModels
@@ -690,7 +746,8 @@ export function readQuotaHistory(
       costUsd: round(totals.costUsd, 6),
       costPerPercent: totals.consumed > 0.05 ? round(attributedCost / totals.consumed, 6) : null,
       maxedOut: peaks.filter(
-        (instance) => instance.exhaustedAt !== null && instance.exhaustedAt >= domainFrom && instance.exhaustedAt <= domainTo
+        (instance) =>
+          instance.exhaustedAt !== null && instance.exhaustedAt >= domainFrom && instance.exhaustedAt <= domainTo
       ).length,
     },
     totals: exportUsage(totals),
@@ -731,8 +788,11 @@ export function readQuotaHistory(
  * opened, with its peak, the shape it rose in and what the requests behind it
  * cost. `page` is clamped to the pages there are.
  */
-export function readQuotaWindows(db, { provider = '', account = '', label = '', page = 0, now = Date.now() } = {}) {
-  const selection = pickSelection(listQuotaSeries(db), { provider, account, label });
+export function readQuotaWindows(
+  db,
+  { provider = '', account = '', label = '', inUse = {}, page = 0, now = Date.now() } = {}
+) {
+  const selection = pickSelection(listQuotaSeries(db), { provider, account, label, inUse });
   const base = { generatedAt: now, selection, page: 0, pageCount: 0, total: 0, windows: [] };
   if (!selection) return base;
   const listed = quotaInstances(readQuotaRows(db, selection), selection.label, now)

package/src/runtime/shared/llm/usage-ledger-repair.mjs

@@ -81,8 +81,10 @@ function* planUsageRepair(rows, { providerOverrides = {}, price = priceUsage })
               cacheReadTokens: row.cache_read,
               cacheWriteTokens: row.cache_write,
               cacheWrite1hTokens: oldRates?.cacheWrite1hTokens,
-              fast: oldRates?.fast,
+              // Rows written before the sent tier was recorded carry `fast`.
+              requestServiceTier: oldRates?.requestServiceTier ?? (oldRates?.fast ? 'fast' : undefined),
               serviceTier: oldRates?.serviceTier,
+              kind,
               ts: row.ts,
               historical: true,
             });

package/src/runtime/shared/llm/usage-ledger-rollup.mjs

@@ -14,13 +14,9 @@
  * here mutates stored rows. Storage, schema and inserts stay in
  * usage-ledger.mjs.
  */
-import { isConversationUsageSource } from './usage-rollup.mjs';
+import { isConversationUsageSource, num } from './usage-rollup.mjs';
 import { normalizeUsageMeasurement, normalizeLegacyUsageDay } from './usage-measurement.mjs';
 
-// The same non-negative coercion the ledger applies on write: legacy day
-// documents are arbitrary retained JSON and can carry anything.
-const number = (value) => (Number.isFinite(Number(value)) && Number(value) >= 0 ? Number(value) : 0);
-
 // A detail and its terminal summary can overlap on the SAME route.
 // Another provider/model on that day is independent and must survive.
 const best = `SELECT day,provider,model,MIN(rank) AS rank FROM daily
@@ -241,11 +237,11 @@ function mergeLegacyDays(db, { days, hourly, hourlyDay, fromDay, toDay }) {
           'durationTurns',
           'unmeasuredTurns',
         ])
-          target[field] += number(source[field]);
-        if (source.costKnownTurns != null) target.costKnownTurns += number(source.costKnownTurns);
-        else if (number(source.costUsd) > 0 || route.kind === 'local') target.costKnownTurns += number(source.turns);
-        target.costBilled += number(source.costBilled);
-        target.costEstimated += number(source.costEstimated ?? source.costUsd);
+          target[field] += num(source[field]);
+        if (source.costKnownTurns != null) target.costKnownTurns += num(source.costKnownTurns);
+        else if (num(source.costUsd) > 0 || route.kind === 'local') target.costKnownTurns += num(source.turns);
+        target.costBilled += num(source.costBilled);
+        target.costEstimated += num(source.costEstimated ?? source.costUsd);
         target.sessionsComplete = false;
       };
       merge(day, route);

package/src/runtime/shared/llm/usage-ledger.mjs

@@ -9,7 +9,7 @@ import { mkdirSync, mkdtempSync } from 'node:fs';
 import { basename, dirname, join } from 'node:path';
 import { createHash, randomUUID } from 'node:crypto';
 import { resolvePluginData } from '../plugin-paths.mjs';
-import { usageRollupDayKey, isConversationUsageSource } from './usage-rollup.mjs';
+import { usageRollupDayKey, isConversationUsageSource, num } from './usage-rollup.mjs';
 import { priceUsage } from './cost.mjs';
 import { rollupUsage } from './usage-ledger-rollup.mjs';
 import { QUOTA_SCHEMA, readQuotaHistory, readQuotaWindows, recordQuotaSamples } from './usage-ledger-quota.mjs';
@@ -37,7 +37,6 @@ export function usageLedgerWorkerRunning() {
 }
 const stores = new Map();
 const ROLLUP_CACHE_LIMIT = 8;
-const number = (value) => (Number.isFinite(Number(value)) && Number(value) >= 0 ? Number(value) : 0);
 const text = (value) => (typeof value === 'string' ? value.slice(0, 300) : '');
 
 // Keep the full identifier, not a shortened hash. The tag also makes arbitrary
@@ -233,7 +232,7 @@ export function makeUsageRecord(args) {
   const ts = Number(args.ts ?? Date.now());
   if (!Number.isSafeInteger(ts) || ts <= 0) throw new Error('Usage requires a valid timestamp');
   const kind = args.kind || usageRouteKind(provider);
-  const priced = priceUsage({ ...args, provider, model, ts });
+  const priced = priceUsage({ ...args, provider, model, ts, kind });
   const supplied =
     args.costUsd !== null &&
     args.costUsd !== undefined &&
@@ -265,16 +264,16 @@ export function makeUsageRecord(args) {
     sessionId: ['no-session', '(none)'].includes(args.sessionId) ? '' : text(args.sessionId),
     sourceType: text(args.sourceType),
     input: priced.input,
-    output: number(args.outputTokens),
-    cacheRead: number(args.cacheReadTokens),
-    cacheWrite: number(args.cacheWriteTokens),
+    output: num(args.outputTokens),
+    cacheRead: num(args.cacheReadTokens),
+    cacheWrite: num(args.cacheWriteTokens),
     costUsd,
     costSource: usageCostSource({ kind, costUsd, subscription, reported }),
     rates,
     responseId: text(args.responseId),
     account: text(args.account),
     origin: args.origin || 'live',
-    durationMs: number(args.durationMs),
+    durationMs: num(args.durationMs),
   };
   row.id = args.id || (row.origin === 'live' && !row.responseId ? randomUUID() : usageRecordId(row));
   return row;

package/src/runtime/shared/llm/usage-pricing-refresh.mjs

@@ -1,4 +1,4 @@
-import { pricingCatalogRevisionSync } from '../../agent/orchestrator/providers/model-catalog.mjs';
+import { pricingCatalogRevisionSync } from './model-catalog.mjs';
 import { repairUsageLedger, repairUsageLedgerAsync } from './usage-ledger-repair.mjs';
 
 const checked = new WeakMap();

package/src/runtime/shared/llm/usage-rollup.mjs

@@ -193,7 +193,6 @@ export function knownCostTurns(usage, amount = num) {
 
 function readTurnTotals(raw, target) {
   readRouteTotals(raw, target);
-  target.costBilled = round6(num(raw?.costBilled));
   target.costEstimated = round6(num(raw?.costEstimated));
   target.costKnownTurns = num(raw?.costKnownTurns);
   target.durationMs = num(raw?.durationMs);