tokentracker-cli 0.96.4 → 0.97.2

package/src/lib/codex-rollout-parser.js

@@ -30,6 +30,7 @@ const {
   currentCodexModel,
   snapshotCodexModelAttributionState,
 } = require("./codex-model-attribution");
+const { readCodexServiceTier, isPriorityServiceTier } = require("./codex-service-tier");
 
 const DISCOVERY_FULL_AUDIT_INTERVAL_MS = 60 * 1000;
 const MAX_DISCOVERY_INVENTORIES = 32;
@@ -592,6 +593,11 @@ async function parseCodexRolloutFile(filePath, {
   const modelAttributionState = createCodexModelAttributionState(
     isResuming ? resumeState.modelAttributionState || { model } : {},
   );
+  // Codex writes thread_settings_applied immediately before the turn_context of
+  // the turn it applies to, and token_count rows carry no turn id, so each one
+  // belongs to the most recent preceding tier record. Sessions that never emit
+  // the event (most CLI sessions) stay null and are billed at Standard.
+  let serviceTier = isResuming ? resumeState.serviceTier || null : null;
   let provider = isResuming ? resumeState.provider || null : null;
   let cliVersion = isResuming ? resumeState.cliVersion || null : null;
   let forkedFromId = isResuming ? resumeState.forkedFromId || null : null;
@@ -650,9 +656,20 @@ async function parseCodexRolloutFile(filePath, {
         long_context_cache_creation_input_tokens: 0,
         long_context_output_tokens: 0,
         long_context_reasoning_output_tokens: 0,
+        priority_input_tokens: 0,
+        priority_cached_input_tokens: 0,
+        priority_cache_creation_input_tokens: 0,
+        priority_output_tokens: 0,
+        priority_reasoning_output_tokens: 0,
+        priority_long_context_input_tokens: 0,
+        priority_long_context_cached_input_tokens: 0,
+        priority_long_context_cache_creation_input_tokens: 0,
+        priority_long_context_output_tokens: 0,
+        priority_long_context_reasoning_output_tokens: 0,
         usage_events: 0,
         rerouted_usage_events: 0,
         long_context_usage_events: 0,
+        priority_usage_events: 0,
         selected_models: new Set(),
         reroute_reasons: new Set(),
       };
@@ -672,7 +689,9 @@ async function parseCodexRolloutFile(filePath, {
     // OpenAI applies the long-context tier to the whole request when its raw
     // (cache-inclusive) input exceeds 272K tokens. Preserve the exact subset
     // so pricing can be recomputed later without rescanning private logs.
-    if (Number(rawRequestUsage?.input_tokens || 0) > OPENAI_LONG_CONTEXT_INPUT_THRESHOLD) {
+    const isLongContext =
+      Number(rawRequestUsage?.input_tokens || 0) > OPENAI_LONG_CONTEXT_INPUT_THRESHOLD;
+    if (isLongContext) {
       row.long_context_usage_events += 1;
       row.long_context_input_tokens += delta.input_tokens;
       row.long_context_cached_input_tokens += delta.cached_input_tokens;
@@ -680,6 +699,27 @@ async function parseCodexRolloutFile(filePath, {
       row.long_context_output_tokens += delta.output_tokens;
       row.long_context_reasoning_output_tokens += delta.reasoning_output_tokens;
     }
+    // Astra Fast bills at a flat multiple of whichever context tier the request
+    // was on, so the priority premium multiplies the long-context premium
+    // instead of replacing it. The two subsets alone cannot say how much usage
+    // was on BOTH, so record the intersection explicitly — otherwise a long
+    // Fast request prices at 3x Standard input where it should be 4x.
+    if (isPriorityServiceTier(serviceTier)) {
+      row.priority_usage_events += 1;
+      row.priority_input_tokens += delta.input_tokens;
+      row.priority_cached_input_tokens += delta.cached_input_tokens;
+      row.priority_cache_creation_input_tokens += delta.cache_creation_input_tokens;
+      row.priority_output_tokens += delta.output_tokens;
+      row.priority_reasoning_output_tokens += delta.reasoning_output_tokens;
+      if (isLongContext) {
+        row.priority_long_context_input_tokens += delta.input_tokens;
+        row.priority_long_context_cached_input_tokens += delta.cached_input_tokens;
+        row.priority_long_context_cache_creation_input_tokens +=
+          delta.cache_creation_input_tokens;
+        row.priority_long_context_output_tokens += delta.output_tokens;
+        row.priority_long_context_reasoning_output_tokens += delta.reasoning_output_tokens;
+      }
+    }
   }
 
   function ensureTool(name) {
@@ -936,6 +976,12 @@ async function parseCodexRolloutFile(filePath, {
       }
     }
 
+    const appliedServiceTier = readCodexServiceTier(obj);
+    if (appliedServiceTier) {
+      serviceTier = appliedServiceTier;
+      continue;
+    }
+
     if (obj.type === "turn_context") {
       const p = obj.payload || {};
       if (typeof p.cwd === "string") cwd = p.cwd;
@@ -1020,6 +1066,7 @@ async function parseCodexRolloutFile(filePath, {
       cwd,
       model,
       modelAttributionState: snapshotCodexModelAttributionState(modelAttributionState),
+      serviceTier,
       provider,
       cliVersion,
       forkedFromId,

package/src/lib/codex-service-tier.js

@@ -0,0 +1,49 @@
+// Codex service-tier attribution.
+//
+// The request tier is NOT on the token_count rows. Codex emits it as its own
+// rollout record — `type: "event_msg"`, `payload.type:
+// "thread_settings_applied"`, `payload.thread_settings.service_tier` — written
+// immediately before the `turn_context` of the turn it applies to. A session's
+// first turn has no such record, and CLI-originated sessions
+// (originator codex_cli_rs / codex-tui) often have none at all: on a 1213-file
+// local corpus only 167 files carried the event, covering 25% of token_count
+// events.
+//
+// Attribution rule, and the only one the log shape permits: a token_count row
+// belongs to the most recent preceding thread_settings_applied. With no
+// preceding record the tier is unknown, and unknown is never guessed — it is
+// billed at Standard, exactly as before this file existed.
+
+"use strict";
+
+// Cheap line prefilter for parsers that avoid JSON.parse on most records.
+const CODEX_SERVICE_TIER_MARKER = '"thread_settings_applied"';
+
+// Observed values on the local corpus are "default" (814) and "priority" (58).
+// "priority" is what the CLI writes for what OpenAI's price table and the Codex
+// UI both call Fast; accept the product-facing spelling too so a future rename
+// does not silently fall back to Standard.
+const PRIORITY_SERVICE_TIERS = new Set(["priority", "fast"]);
+
+function readCodexServiceTier(obj) {
+  if (!obj || obj.type !== "event_msg") return null;
+  const payload = obj.payload;
+  if (!payload || typeof payload !== "object") return null;
+  if (payload.type !== "thread_settings_applied") return null;
+  const settings = payload.thread_settings;
+  if (!settings || typeof settings !== "object") return null;
+  const tier = settings.service_tier;
+  if (typeof tier !== "string" || !tier.trim()) return null;
+  return tier.trim().toLowerCase();
+}
+
+function isPriorityServiceTier(tier) {
+  return typeof tier === "string" && PRIORITY_SERVICE_TIERS.has(tier);
+}
+
+module.exports = {
+  CODEX_SERVICE_TIER_MARKER,
+  PRIORITY_SERVICE_TIERS,
+  readCodexServiceTier,
+  isPriorityServiceTier,
+};

package/src/lib/pricing/curated-overrides.json

@@ -53,7 +53,8 @@
       "output": 50,
       "cache_read": 1,
       "cache_write": 12.5,
-      "note": "Official Standard USD/MTok rates verified 2026-09-07: https://developers.openai.com/api/docs/models/gpt-6-astra. Requests above 272K input tokens use 2x input/cache and 1.5x output rates; computeRowCost applies this only to observed long-context request subsets. Cloud aggregates use Standard short-context estimates because they do not retain per-request context or service tier. Reasoning-effort suffixes use the same base rates."
+      "priority_multiplier": 2,
+      "note": "Official Standard USD/MTok rates verified 2026-09-07: https://developers.openai.com/api/docs/models/gpt-6-astra. Requests above 272K input tokens use 2x input/cache and 1.5x output rates; computeRowCost applies this only to observed long-context request subsets. priority_multiplier is the Fast tier, whose published table (20/2/25/100 short, 40/4/50/150 long, verified 2026-09-12) is exactly 2x the Standard rate of the same context tier — it multiplies, it does not replace, the long-context premium. The 2.5x figure in the Codex speed docs is a subscription-credit rate and must not be used here. computeRowCost applies it only to observed priority request subsets; usage whose service tier the logs never recorded stays Standard. Cloud aggregates use Standard short-context estimates because they do not retain per-request context or service tier. Reasoning-effort suffixes use the same base rates."
     },
     "gpt-5.6-sol": {
       "input": 4,

package/src/lib/pricing/index.js

@@ -194,8 +194,14 @@ 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.
   const reasoningIncludedInOutput =
-    row.source === "codex" || row.source === "acode" || row.source === "every-code";
+    row.source === "codex" ||
+    row.source === "acode" ||
+    row.source === "every-code" ||
+    row.source === "omo";
   const reasoningCost = reasoningIncludedInOutput
     ? 0
     : (row.reasoning_output_tokens || 0) * (pricing.output || 0);
@@ -211,12 +217,23 @@ function computeRowCost(row) {
   const model = String(row?.model || "").toLowerCase();
   const usesOpenAILongContextTier =
     model === "gpt-5.6" || model.includes("gpt-5.6-sol") || model.includes("gpt-6-astra");
-  if (!usesOpenAILongContextTier) return baseCost;
+  // 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.
+  const priorityMultiplier = Number(pricing.priority_multiplier);
+  const hasPriorityRates = Number.isFinite(priorityMultiplier) && priorityMultiplier > 1;
+  if (!usesOpenAILongContextTier && !hasPriorityRates) 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.
@@ -230,14 +247,61 @@ function computeRowCost(row) {
   const longReasoning = reasoningIncludedInOutput
     ? 0
     : bounded(row.long_context_reasoning_output_tokens, row.reasoning_output_tokens);
-  const longContextPremium = (
+  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)
+  ) / 1_000_000 : 0;
+
+  if (!hasPriorityRates) return baseCost + longContextPremium;
+
+  // Astra Fast is a flat multiple of whichever context tier the request was on
+  // (short 10/1/12.5/50 -> 20/2/25/100; long 20/2/25/75 -> 40/4/50/150), so the
+  // tier multiplier and the long-context premium are orthogonal: a request that
+  // is both bills at the LONG rate times the multiplier, not standard times the
+  // multiplier. That needs the intersection, which is why the parser records
+  // priority_long_context_* alongside priority_*; without it (queue rows, which
+  // carry no context-length subset at all) the overlap is 0 and the premium
+  // falls back to the short-context multiple, matching the row's own base.
+  const priorityInput = bounded(row.priority_input_tokens, row.input_tokens);
+  const priorityCached = bounded(row.priority_cached_input_tokens, row.cached_input_tokens);
+  const priorityCacheWrite = bounded(
+    row.priority_cache_creation_input_tokens,
+    row.cache_creation_input_tokens,
+  );
+  const priorityOutput = bounded(row.priority_output_tokens, row.output_tokens);
+  const priorityReasoning = reasoningIncludedInOutput
+    ? 0
+    : bounded(row.priority_reasoning_output_tokens, row.reasoning_output_tokens);
+  const priorityBase = (
+    priorityInput * (pricing.input || 0) +
+    priorityCached * (pricing.cache_read || 0) +
+    priorityCacheWrite * (pricing.cache_write || 0) +
+    priorityOutput * (pricing.output || 0) +
+    priorityReasoning * (pricing.output || 0)
   ) / 1_000_000;
-  return baseCost + longContextPremium;
+
+  const priorityLong = usesOpenAILongContextTier ? (
+    bounded(row.priority_long_context_input_tokens, Math.min(priorityInput, longInput)) *
+      (pricing.input || 0) +
+    bounded(row.priority_long_context_cached_input_tokens, Math.min(priorityCached, longCached)) *
+      (pricing.cache_read || 0) +
+    bounded(
+      row.priority_long_context_cache_creation_input_tokens,
+      Math.min(priorityCacheWrite, longCacheWrite),
+    ) * (pricing.cache_write || 0) +
+    0.5 * bounded(row.priority_long_context_output_tokens, Math.min(priorityOutput, longOutput)) *
+      (pricing.output || 0) +
+    0.5 * bounded(
+      row.priority_long_context_reasoning_output_tokens,
+      Math.min(priorityReasoning, longReasoning),
+    ) * (pricing.output || 0)
+  ) / 1_000_000 : 0;
+
+  const priorityPremium = (priorityMultiplier - 1) * (priorityBase + priorityLong);
+  return baseCost + longContextPremium + priorityPremium;
 }
 
 // Backwards-compatible MODEL_PRICING export. Test at