typescript-cost-tracking-nan-total-tokens

Answer

Root cause. The legacy engine's cost tracker read a top-level totalTokens field that never existed on the tracker record. The actual usage object is nested under estimatedCost.tokens.totalTokens. Reading the missing field yields undefined; Number(undefined) → NaN, and every downstream aggregation (avgTokens = totalTokens / games, avgCost, avgLatency) silently coerced NaN to 0 — so all 621 benchmark games reported 0 tokens/cost/latency despite "cost tracking" being advertised.

The fix has three parts.

1. Read the nested field in the tracker.

// legacy engine, before
const totalTokens = Number(result.totalTokens);        // undefined -> NaN -> 0
const cost = Number(result.totalCostUSD);

// after — nested shape from APITracker
const est = result.estimatedCost ?? {};
const tokens = est.tokens ?? {};
const totalTokens =
  finite(tokens.totalTokens) ??
  finite(tokens.promptTokens) + finite(tokens.completionTokens); // streaming fallback
const cost = finite(est.costInUSD?.total) ?? 0;
const latency = finite(result.latencyInSeconds ?? est.latencyInSeconds) ?? 0;

function finite(v: unknown): number | undefined {
  const n = Number(v);
  return Number.isFinite(n) ? n : undefined;
}

2. Extract usage collection into a testable legacy-usage-collector.js (pure functions over APITracker records — no DB, no globals):

'use strict';
// legacy-usage-collector.js

const safe = (v, fallback = 0) => {
  const n = Number(v);
  return Number.isFinite(n) ? n : fallback;
};
const modelOf = (r) => String((r && r.model) || 'unknown').trim();

/** Pull the real values out of one APITracker record. */
function extractUsage(record) {
  const est = (record && record.estimatedCost) || {};
  const tokens = est.tokens || {};
  const promptTokens = safe(tokens.promptTokens);
  const completionTokens = safe(tokens.completionTokens);
  return {
    model: modelOf(record),
    promptTokens,
    completionTokens,
    totalTokens: safe(tokens.totalTokens, promptTokens + completionTokens),
    cost: safe(est.costInUSD && est.costInUSD.total),
    latencyInSeconds: safe(record.latencyInSeconds || est.latencyInSeconds),
  };
}

/** Aggregate token/cost counts across tracker records, per model. */
function collectUsage(records) {
  const byModel = new Map();
  for (const rec of records || []) {
    const u = extractUsage(rec);
    if (!byModel.has(u.model)) {
      byModel.set(u.model, { model: u.model, games: 0, totalTokens: 0, cost: 0, latencySum: 0 });
    }
    const a = byModel.get(u.model);
    a.games += 1;
    a.totalTokens += u.totalTokens;
    a.cost += u.cost;
    a.latencySum += u.latencyInSeconds;
  }
  return [...byModel.values()].map((a) => ({
    model: a.model,
    games: a.games,
    totalTokens: a.totalTokens,
    avgTokens: a.games ? a.totalTokens / a.games : 0,
    avgCost: a.games ? a.cost / a.games : 0,
    avgLatency: a.games ? a.latencySum / a.games : 0,
  }));
}

/** Per-model average latency in seconds (for stats-collector). */
function collectLatencyByModel(records) {
  const acc = new Map();
  for (const rec of records || []) {
    const u = extractUsage(rec);
    if (!acc.has(u.model)) acc.set(u.model, []);
    acc.get(u.model).push(u.latencyInSeconds);
  }
  const out = {};
  for (const [model, list] of acc) out[model] = list.reduce((x, y) => x + y, 0) / list.length;
  return out;
}

module.exports = { extractUsage, collectUsage, collectLatencyByModel };

3. Fill stats-collector/models.ts + repository.ts from real DB rows instead of hardcoded zeros:

// stats-collector/models.ts
export interface ModelStats {
  model: string;
  games: number;
  totalTokens: number;
  avgTokens: number;
  avgCost: number;
  avgLatency: number;
}

export interface UsageRow {
  model: string;
  games: number;
  total_tokens: number;   // prompt + completion
  cost_usd: number;
  avg_latency_s: number;
}

export function modelStatsFromRows(rows: UsageRow[]): ModelStats[] {
  return rows.map((r) => ({
    model: r.model,
    games: r.games,
    totalTokens: r.total_tokens,
    avgTokens: r.games > 0 ? r.total_tokens / r.games : 0,
    avgCost: r.games > 0 ? r.cost_usd / r.games : 0,
    avgLatency: r.avg_latency_s,
  }));
}

// stats-collector/repository.ts
// Before: SELECT ... returned literal 0 rows/zeros for token/cost columns.
export async function getModelUsage(runId: string): Promise<ModelStats[]> {
  const { rows } = await pool.query(
    `SELECT
        COALESCE(model, 'unknown')                              AS model,
        COUNT(*)                                                AS games,
        COALESCE(SUM(COALESCE(prompt_tokens,0) + COALESCE(completion_tokens,0)), 0) AS total_tokens,
        COALESCE(SUM(COALESCE(cost_usd,0)), 0)                  AS cost_usd,
        COALESCE(AVG(COALESCE(latency_ms,0)) / 1000.0, 0)       AS avg_latency_s
     FROM api_calls
     WHERE benchmark_run_id = $1
     GROUP BY model`,
    [runId],
  );
  return modelStatsFromRows(rows);
}

token_usage and api_calls rows are joined/coalesced so NULLs and missing columns never propagate NaN into the report; the collector above is the single source of truth for tracker-shaped data, and the repository is the single source for DB-shaped data.