tokentracker-cli 1.5.2 → 1.5.4

package/src/lib/pricing/index.js

@@ -172,6 +172,17 @@ function computeModelPricingInfo(model, opts, sourceKey) {
     output: Number(rates.output) || 0,
     cache_read: Number(rates.cache_read) || 0,
     cache_write: Number(rates.cache_write) || 0,
+    // Speed-tier multipliers so the dashboard can label Fast/Ultrafast
+    // sub-rows with the actual premium instead of hardcoding 2x/6x (issue 886).
+    // Mirrored from the raw entry only when it publishes them — the info
+    // object must keep matching getModelPricing key-for-key
+    // (session-performance.test.js pins that contract).
+    ...(Number.isFinite(Number(rates.priority_multiplier))
+      ? { priority_multiplier: Number(rates.priority_multiplier) }
+      : null),
+    ...(Number.isFinite(Number(rates.ultrafast_multiplier))
+      ? { ultrafast_multiplier: Number(rates.ultrafast_multiplier) }
+      : null),
   };
 }
 
@@ -221,6 +232,110 @@ function getRowPricing(row) {
   };
 }
 
+// Codex-family reasoning folding, shared by computeRowCost and the speed-tier
+// allocation below. OmO, like Codex, reports reasoning as a subset of `output`
+// (its own usage.cost bills no separate reasoning component), so charging it
+// again here would double-bill every reasoning token. Cline is the same: its
+// `outputTokens` is the AI SDK total (text + reasoning), so
+// reasoning_output_tokens is a subset marker, never a second line item.
+function reasoningFoldsIntoOutput(row) {
+  return (
+    row.source === "codex" ||
+    row.source === "acode" ||
+    row.source === "every-code" ||
+    row.source === "omo" ||
+    row.source === "cline" ||
+    row.source === "muse"
+  );
+}
+
+// One row's observed-subset context: the bounded long-context columns that the
+// speed-tier subsets intersect with, plus whether the row's model prices a
+// long-context tier at all. Pure arithmetic on the row; both computeRowCost
+// and computeRowTierCosts build it so their per-tier math cannot drift.
+function rowSubsetContext(row, reasoningIncludedInOutput) {
+  const bounded = (value, total) => Math.min(
+    Math.max(0, Number(value) || 0),
+    Math.max(0, Number(total) || 0),
+  );
+  const model = String(row?.model || "").toLowerCase();
+  const usesOpenAILongContextTier =
+    model === "gpt-5.6" || model.includes("gpt-5.6-sol") || model.includes("gpt-6-astra") ||
+    model.includes("gpt-6-sol") || model.includes("gpt-6.1-sol") ||
+    model.includes("gpt-6.1-terra");
+  // Both premium families below read "observed subset" columns: how much of the
+  // row's own token columns came from requests with a given property. They are
+  // annotations, never addends — total_tokens stays the sum of the base columns
+  // whether or not they are present, and a legacy row that omits them prices
+  // exactly as it did before.
+  //
+  // The parser records only usage from requests whose cache-inclusive input
+  // exceeded 272K. OpenAI prices the whole such request at 2x input and 1.5x
+  // output, so add the premium over the standard-rate base exactly once.
+  const longInput = bounded(row.long_context_input_tokens, row.input_tokens);
+  const longCached = bounded(row.long_context_cached_input_tokens, row.cached_input_tokens);
+  const longCacheWrite = bounded(
+    row.long_context_cache_creation_input_tokens,
+    row.cache_creation_input_tokens,
+  );
+  const longOutput = bounded(row.long_context_output_tokens, row.output_tokens);
+  const longReasoning = reasoningIncludedInOutput
+    ? 0
+    : bounded(row.long_context_reasoning_output_tokens, row.reasoning_output_tokens);
+  return {
+    bounded,
+    usesOpenAILongContextTier,
+    longInput,
+    longCached,
+    longCacheWrite,
+    longOutput,
+    longReasoning,
+  };
+}
+
+// Standard-rate cost of one observed speed-tier subset (priority_/ultrafast_):
+// the tier's own token columns priced at the row's base rates, plus the same
+// treatment for its long-context intersection. computeRowCost multiplies this
+// by (multiplier - 1) for the premium; computeRowTierCosts books it to the
+// tier itself.
+function speedTierSubsetCost(row, prefix, pricing, ctx) {
+  const { bounded, usesOpenAILongContextTier, longInput, longCached, longCacheWrite, longOutput, longReasoning } = ctx;
+  const tierInput = bounded(row[`${prefix}input_tokens`], row.input_tokens);
+  const tierCached = bounded(row[`${prefix}cached_input_tokens`], row.cached_input_tokens);
+  const tierCacheWrite = bounded(
+    row[`${prefix}cache_creation_input_tokens`],
+    row.cache_creation_input_tokens,
+  );
+  const tierOutput = bounded(row[`${prefix}output_tokens`], row.output_tokens);
+  const tierReasoning = ctx.reasoningIncludedInOutput
+    ? 0
+    : bounded(row[`${prefix}reasoning_output_tokens`], row.reasoning_output_tokens);
+  const tierBase = (
+    tierInput * (pricing.input || 0) +
+    tierCached * (pricing.cache_read || 0) +
+    tierCacheWrite * (pricing.cache_write || 0) +
+    tierOutput * (pricing.output || 0) +
+    tierReasoning * (pricing.output || 0)
+  ) / 1_000_000;
+  const tierLong = usesOpenAILongContextTier ? (
+    bounded(row[`${prefix}long_context_input_tokens`], Math.min(tierInput, longInput)) *
+      (pricing.input || 0) +
+    bounded(row[`${prefix}long_context_cached_input_tokens`], Math.min(tierCached, longCached)) *
+      (pricing.cache_read || 0) +
+    bounded(
+      row[`${prefix}long_context_cache_creation_input_tokens`],
+      Math.min(tierCacheWrite, longCacheWrite),
+    ) * (pricing.cache_write || 0) +
+    0.5 * bounded(row[`${prefix}long_context_output_tokens`], Math.min(tierOutput, longOutput)) *
+      (pricing.output || 0) +
+    0.5 * bounded(
+      row[`${prefix}long_context_reasoning_output_tokens`],
+      Math.min(tierReasoning, longReasoning),
+    ) * (pricing.output || 0)
+  ) / 1_000_000 : 0;
+  return tierBase + tierLong;
+}
+
 // Same formula and Codex/every-code reasoning-folding rule as the previous
 // computeRowCost in src/lib/local-api.js. Moved here so vite mock + local
 // server share one source of truth.
@@ -240,18 +355,7 @@ function computeRowCost(row) {
     reportedCost > 0
   ) return reportedCost;
   const pricing = getRowPricing(row);
-  // OmO, like Codex, reports reasoning as a subset of `output` (its own
-  // usage.cost bills no separate reasoning component), so charging it again
-  // here would double-bill every reasoning token. Cline is the same: its
-  // `outputTokens` is the AI SDK total (text + reasoning), so
-  // reasoning_output_tokens is a subset marker, never a second line item.
-  const reasoningIncludedInOutput =
-    row.source === "codex" ||
-    row.source === "acode" ||
-    row.source === "every-code" ||
-    row.source === "omo" ||
-    row.source === "cline" ||
-    row.source === "muse";
+  const reasoningIncludedInOutput = reasoningFoldsIntoOutput(row);
   const reasoningCost = reasoningIncludedInOutput
     ? 0
     : (row.reasoning_output_tokens || 0) * (pricing.output || 0);
@@ -264,11 +368,8 @@ function computeRowCost(row) {
     1_000_000
   );
 
-  const model = String(row?.model || "").toLowerCase();
-  const usesOpenAILongContextTier =
-    model === "gpt-5.6" || model.includes("gpt-5.6-sol") || model.includes("gpt-6-astra") ||
-    model.includes("gpt-6-sol") || model.includes("gpt-6.1-sol") ||
-    model.includes("gpt-6.1-terra");
+  const ctx = rowSubsetContext(row, reasoningIncludedInOutput);
+  const { usesOpenAILongContextTier } = ctx;
   // Only models whose curated entry carries an explicit Fast/priority rate get
   // the tier premium. The other OpenAI tiers have no published priority price,
   // and inventing one is worse than reporting Standard.
@@ -278,35 +379,12 @@ function computeRowCost(row) {
   const hasUltrafastRatesEarly = Number.isFinite(ultrafastMultiplierEarly) && ultrafastMultiplierEarly > 1;
   if (!usesOpenAILongContextTier && !hasPriorityRates && !hasUltrafastRatesEarly) return baseCost;
 
-  const bounded = (value, total) => Math.min(
-    Math.max(0, Number(value) || 0),
-    Math.max(0, Number(total) || 0),
-  );
-  // Both premium families below read "observed subset" columns: how much of the
-  // row's own token columns came from requests with a given property. They are
-  // annotations, never addends — total_tokens stays the sum of the base columns
-  // whether or not they are present, and a legacy row that omits them prices
-  // exactly as it did before.
-  //
-  // The parser records only usage from requests whose cache-inclusive input
-  // exceeded 272K. OpenAI prices the whole such request at 2x input and 1.5x
-  // output, so add the premium over the standard-rate base exactly once.
-  const longInput = bounded(row.long_context_input_tokens, row.input_tokens);
-  const longCached = bounded(row.long_context_cached_input_tokens, row.cached_input_tokens);
-  const longCacheWrite = bounded(
-    row.long_context_cache_creation_input_tokens,
-    row.cache_creation_input_tokens,
-  );
-  const longOutput = bounded(row.long_context_output_tokens, row.output_tokens);
-  const longReasoning = reasoningIncludedInOutput
-    ? 0
-    : bounded(row.long_context_reasoning_output_tokens, row.reasoning_output_tokens);
   const longContextPremium = usesOpenAILongContextTier ? (
-    longInput * (pricing.input || 0) +
-    longCached * (pricing.cache_read || 0) +
-    longCacheWrite * (pricing.cache_write || 0) +
-    0.5 * longOutput * (pricing.output || 0) +
-    0.5 * longReasoning * (pricing.output || 0)
+    ctx.longInput * (pricing.input || 0) +
+    ctx.longCached * (pricing.cache_read || 0) +
+    ctx.longCacheWrite * (pricing.cache_write || 0) +
+    0.5 * ctx.longOutput * (pricing.output || 0) +
+    0.5 * ctx.longReasoning * (pricing.output || 0)
   ) / 1_000_000 : 0;
 
   const ultrafastMultiplier = ultrafastMultiplierEarly;
@@ -317,40 +395,7 @@ function computeRowCost(row) {
   // are mutually exclusive per request; both can appear in one aggregated row.
   function tierPremium(multiplier, prefix) {
     if (!(Number.isFinite(multiplier) && multiplier > 1)) return 0;
-    const tierInput = bounded(row[`${prefix}input_tokens`], row.input_tokens);
-    const tierCached = bounded(row[`${prefix}cached_input_tokens`], row.cached_input_tokens);
-    const tierCacheWrite = bounded(
-      row[`${prefix}cache_creation_input_tokens`],
-      row.cache_creation_input_tokens,
-    );
-    const tierOutput = bounded(row[`${prefix}output_tokens`], row.output_tokens);
-    const tierReasoning = reasoningIncludedInOutput
-      ? 0
-      : bounded(row[`${prefix}reasoning_output_tokens`], row.reasoning_output_tokens);
-    const tierBase = (
-      tierInput * (pricing.input || 0) +
-      tierCached * (pricing.cache_read || 0) +
-      tierCacheWrite * (pricing.cache_write || 0) +
-      tierOutput * (pricing.output || 0) +
-      tierReasoning * (pricing.output || 0)
-    ) / 1_000_000;
-    const tierLong = usesOpenAILongContextTier ? (
-      bounded(row[`${prefix}long_context_input_tokens`], Math.min(tierInput, longInput)) *
-        (pricing.input || 0) +
-      bounded(row[`${prefix}long_context_cached_input_tokens`], Math.min(tierCached, longCached)) *
-        (pricing.cache_read || 0) +
-      bounded(
-        row[`${prefix}long_context_cache_creation_input_tokens`],
-        Math.min(tierCacheWrite, longCacheWrite),
-      ) * (pricing.cache_write || 0) +
-      0.5 * bounded(row[`${prefix}long_context_output_tokens`], Math.min(tierOutput, longOutput)) *
-        (pricing.output || 0) +
-      0.5 * bounded(
-        row[`${prefix}long_context_reasoning_output_tokens`],
-        Math.min(tierReasoning, longReasoning),
-      ) * (pricing.output || 0)
-    ) / 1_000_000 : 0;
-    return (multiplier - 1) * (tierBase + tierLong);
+    return (multiplier - 1) * speedTierSubsetCost(row, prefix, pricing, { ...ctx, reasoningIncludedInOutput });
   }
 
   // Astra Fast is a flat multiple of whichever context tier the request was on
@@ -367,6 +412,63 @@ function computeRowCost(row) {
   return baseCost + longContextPremium + priorityPremium + ultrafastPremium;
 }
 
+// Speed tiers computeRowCost can allocate: prefix of the observed subset
+// columns and the pricing multiplier key that prices them.
+const SPEED_TIERS = [
+  { prefix: "priority_", multiplierKey: "priority_multiplier" },
+  { prefix: "ultrafast_", multiplierKey: "ultrafast_multiplier" },
+];
+
+// Cost of one speed-tier subset: its standard-rate portion plus, when the
+// model's pricing carries the tier multiplier, the same (multiplier - 1)
+// premium computeRowCost adds on top. Zero-cost (local inference, Pi
+// subscription) and authoritative-cost (Grok) rows have no tier allocation —
+// everything stays under standard there.
+const SPEED_TIER_COLUMN_SUFFIXES = [
+  "input_tokens",
+  "cached_input_tokens",
+  "cache_creation_input_tokens",
+  "output_tokens",
+  "reasoning_output_tokens",
+];
+
+function speedTierCost(row, prefix, multiplierKey) {
+  // Skip the pricing lookup entirely for rows without observed columns of
+  // this tier — the allocation below is 0 for them anyway, and the
+  // model-breakdown endpoint calls this for every row of every source.
+  if (!SPEED_TIER_COLUMN_SUFFIXES.some((suffix) => Number(row?.[`${prefix}${suffix}`]) > 0)) return 0;
+  if (LOCAL_INFERENCE_SOURCES.has(String(row?.source || "").toLowerCase())) return 0;
+  if (PI_SUBSCRIPTION_SOURCES.has(String(row?.source || "").toLowerCase())) return 0;
+  const reportedCost = Number(row?.total_cost_usd);
+  if (
+    SOURCES_WITH_AUTHORITATIVE_COST.has(row?.source) &&
+    Number.isFinite(reportedCost) &&
+    reportedCost > 0
+  ) return 0;
+  const pricing = getRowPricing(row);
+  const reasoningIncludedInOutput = reasoningFoldsIntoOutput(row);
+  const ctx = rowSubsetContext(row, reasoningIncludedInOutput);
+  const portion = speedTierSubsetCost(row, prefix, pricing, { ...ctx, reasoningIncludedInOutput });
+  const multiplier = Number(pricing[multiplierKey]);
+  if (!(Number.isFinite(multiplier) && multiplier > 1)) return portion;
+  return portion + (multiplier - 1) * portion;
+}
+
+// Exact per-tier allocation of computeRowCost for one usage row. Fast and
+// Ultrafast book their observed subset tokens at the tier's multiplier;
+// everything else — tokens outside the tier subsets, rows without tier
+// columns, provider-reported costs, zero-cost sources — stays under standard.
+// standard is computed as the residual, so the three values always add up to
+// computeRowCost(row) by construction (issue #886: surface the Fast/Ultrafast
+// split that the parser already records).
+function computeRowTierCosts(row) {
+  if (!row || typeof row !== "object") return { standard: 0, priority: 0, ultrafast: 0 };
+  const priority = speedTierCost(row, SPEED_TIERS[0].prefix, SPEED_TIERS[0].multiplierKey);
+  const ultrafast = speedTierCost(row, SPEED_TIERS[1].prefix, SPEED_TIERS[1].multiplierKey);
+  const standard = computeRowCost(row) - priority - ultrafast;
+  return { standard, priority, ultrafast };
+}
+
 // Backwards-compatible MODEL_PRICING export. Test at
 // test/model-breakdown.test.js:236 reads `localApi.MODEL_PRICING["kiro-agent"]`
 // and expects { input, output, cache_read, cache_write } shape. We expose the
@@ -382,6 +484,7 @@ module.exports = {
   getModelPricingInfo,
   getRowPricing,
   computeRowCost,
+  computeRowTierCosts,
   resetPricingForTests,
   MODEL_PRICING,
   ZERO_PRICING,