@trazum/core 1.10.0 → 1.26.0

package/src/config-schema.ts

@@ -48,6 +48,21 @@ export interface BaselineConfig {
   maxGrowthPct?: number;
 }
 
+/**
+ * Money budgets, in dollars, for the log-reading side of the tool.
+ *
+ * A budget for a workload that made no calls is **not** a pass and not a
+ * failure: it is a measurement that did not happen, and the report says so
+ * rather than reporting green over an absence. That is the same three-state
+ * rule the counts, the timestamps and the stop reasons all follow.
+ */
+export interface SpendConfig {
+  /** Whole-log budget. `--max-usd` overrides it. */
+  maxUsd?: number;
+  /** Per-label budgets, each gated against that label's own spend. */
+  byLabel?: Record<string, number>;
+}
+
 export interface TrazumConfig {
   level?: RuleLevel;
   locale?: Locale;
@@ -59,6 +74,32 @@ export interface TrazumConfig {
    * leaving it to be inferred.
    */
   budgets?: Record<string, number>;
+  /**
+   * Which prompt file each usage-log label sends, so `profile` can close the
+   * loop it opens.
+   *
+   * `profile` can say "caching loses money on `support-rag`" and nothing more —
+   * the log carries counts, not content. With this map it reads the named file
+   * and says *why*: where the first placeholder sits, how many stable tokens
+   * never reach the cacheable prefix, and whether the model's minimum is met at
+   * all. The file is whatever is in the repository today, which may not be what
+   * produced the log, and the report says so.
+   */
+  labels?: Record<string, string>;
+  /**
+   * Money budgets for `trazum profile`, in dollars.
+   *
+   * `budgets` gates the tokens a prompt file may hold; this gates the dollars
+   * a usage log records — the same difference `check` and `profile` have
+   * everywhere else. Written in the repository rather than passed as a flag
+   * because a per-workload budget is a policy several people agree on, and a
+   * policy that lives in one CI invocation is a policy nobody can read.
+   *
+   * `maxUsd` is the default for `--max-usd`; `byLabel` gates each named
+   * workload against its own limit in the same run. A flag still wins over
+   * the config, as everywhere in this tool.
+   */
+  spend?: SpendConfig;
   /** Default for `trazum diff --max-growth`, in tokens. */
   maxGrowth?: number;
   /**
@@ -94,6 +135,8 @@ export const CONFIG_KEYS = [
   'disable',
   'usage',
   'budgets',
+  'labels',
+  'spend',
   'maxGrowth',
   'baseline',
   'extensions',
@@ -102,6 +145,8 @@ export const CONFIG_KEYS = [
 
 export const CONFIG_BASELINE_KEYS = ['path', 'maxGrowthTokens', 'maxGrowthPct'] as const;
 
+export const CONFIG_SPEND_KEYS = ['maxUsd', 'byLabel'] as const;
+
 export const CONFIG_USAGE_KEYS = [
   'model',
   'callsPerMonth',
@@ -217,6 +262,31 @@ function parseUsage(raw: unknown, source: string): Partial<UsageProfile> {
  */
 const IS_ABSOLUTE = /^(?:[/\\]|[A-Za-z]:[/\\])/;
 
+function parseLabels(raw: unknown, source: string): Record<string, string> {
+  if (!isPlainObject(raw)) throw new ConfigError('"labels" must be an object', source);
+
+  const labels: Record<string, string> = {};
+  for (const [label, value] of Object.entries(raw)) {
+    if (label.length === 0) {
+      throw new ConfigError('"labels" has an empty label', source);
+    }
+    if (typeof value !== 'string' || value.length === 0) {
+      throw new ConfigError(`labels["${label}"] must be a file path`, source);
+    }
+    // Same boundary as budgets, for the same reason: an absolute path or one
+    // that climbs out with ".." points outside the project, and both are
+    // mistakes worth naming rather than files worth reading.
+    if (IS_ABSOLUTE.test(value) || value.includes('..')) {
+      throw new ConfigError(
+        `labels["${label}"] must be a relative path inside the project`,
+        source,
+      );
+    }
+    labels[label] = value;
+  }
+  return labels;
+}
+
 function parseBudgets(raw: unknown, source: string): Record<string, number> {
   if (!isPlainObject(raw)) throw new ConfigError('"budgets" must be an object', source);
 
@@ -243,6 +313,40 @@ function parseBudgets(raw: unknown, source: string): Record<string, number> {
   return budgets;
 }
 
+/**
+ * Validates the `spend` block.
+ *
+ * Dollars, not tokens, so non-integers are legitimate — $0.50 is a budget
+ * somebody means. Negative is not: a budget below zero can only fail, which
+ * makes it a mistake dressed as a policy. An empty label is rejected for the
+ * reason the empty string is the unlabelled bucket's sentinel: a config that
+ * meant "calls with no label" should say so through a real key, not through a
+ * value that collides with an internal one.
+ */
+function parseSpend(raw: unknown, source: string): SpendConfig {
+  if (!isPlainObject(raw)) throw new ConfigError('"spend" must be an object', source);
+  rejectUnknownKeys(raw, CONFIG_SPEND_KEYS, source, 'spend.');
+
+  const spend: SpendConfig = {};
+  if (raw.maxUsd !== undefined) {
+    spend.maxUsd = requireNonNegativeNumber(raw.maxUsd, 'spend.maxUsd', source);
+  }
+  if (raw.byLabel !== undefined) {
+    if (!isPlainObject(raw.byLabel)) {
+      throw new ConfigError('"spend.byLabel" must be an object', source);
+    }
+    const byLabel: Record<string, number> = {};
+    for (const [label, value] of Object.entries(raw.byLabel)) {
+      if (label.trim().length === 0) {
+        throw new ConfigError('"spend.byLabel" has an empty label', source);
+      }
+      byLabel[label] = requireNonNegativeNumber(value, `spend.byLabel["${label}"]`, source);
+    }
+    spend.byLabel = byLabel;
+  }
+  return spend;
+}
+
 /**
  * Validates the `baseline` block.
  *
@@ -390,6 +494,8 @@ export function parseConfig(raw: string, source = CONFIG_FILENAME): TrazumConfig
 
   if (document.usage !== undefined) config.usage = parseUsage(document.usage, source);
   if (document.budgets !== undefined) config.budgets = parseBudgets(document.budgets, source);
+  if (document.labels !== undefined) config.labels = parseLabels(document.labels, source);
+  if (document.spend !== undefined) config.spend = parseSpend(document.spend, source);
   if (document.baseline !== undefined) {
     config.baseline = parseBaselineConfig(document.baseline, source);
   }

package/src/conversation.ts

@@ -0,0 +1,305 @@
+import { effectivePricing, multipliersFor } from './pricing.js';
+import { UNLABELLED } from './usage.js';
+import type { PricingCatalogue } from './pricing.js';
+import type { UsageRecord } from './usage.js';
+
+/**
+ * What re-sending the conversation costs.
+ *
+ * ## The line nothing was watching
+ *
+ * A chat or agent workload sends the whole conversation back on every turn. Turn
+ * one is a system prompt and a question; turn twenty is a system prompt and
+ * nineteen previous exchanges and a question. The input grows linearly with the
+ * turn count, and on an agent bill that growth is routinely the largest single
+ * line — larger than the prompt, larger than the answers.
+ *
+ * Nothing in this package could see it. A prompt file shows the system prompt and
+ * not the history. A total shows the sum and not the shape. Even `profile` reported
+ * "input is 71% of this bill" without being able to say that most of that input was
+ * the same sentences, sent again.
+ *
+ * ## What it will and will not claim
+ *
+ * The honest figure is a **ceiling**, and the token half of it is exact: the
+ * input tokens beyond every turn being the size of the session's smallest turn.
+ * That quantity is order-independent — the first-seen anchor made the identical
+ * workload vanish when exported newest-first — and it is immune to billing
+ * rates: a cost-based anchor charged an ordinary 5-minute-TTL agent 77.5%
+ * "growth" on a conversation that never grew, because a cache-miss turn costs
+ * 12.5x a cache-hit turn of the same size. The dollars are that token share of
+ * what the session actually spent, at its own blended rate.
+ *
+ * It is a ceiling and not a saving because part of that growth is the user's own
+ * new messages, which nobody can truncate away, and this module cannot tell those
+ * apart from re-sent history — it sees counts, not content. Reporting the ceiling
+ * as an opportunity would be the flattering direction; reporting nothing because
+ * the exact split is unknowable would be worse. So it reports the bound and says
+ * what it is.
+ *
+ * ## The session key never leaves this module
+ *
+ * A session identifier is somebody's conversation, and in a real log it is often an
+ * account id, a ticket number or an email. It is used to group calls and count
+ * turns; **no figure reported anywhere carries it**, and every result is aggregated
+ * per label. The promise that a usage log handed to Trazum contains no content is
+ * only worth something if nothing identifying comes back out either.
+ */
+
+/** How one label-and-model slice grows across a conversation. */
+export interface ConversationGrowth {
+  label: string;
+  model: string;
+  modelName: string;
+  /** How many distinct conversations were seen. Never which ones. */
+  sessions: number;
+  calls: number;
+  /** Mean input tokens on the smallest turn of a conversation. */
+  minTurnTokens: number;
+  /** Mean input tokens on the largest turn. */
+  maxTurnTokens: number;
+  /** Turns in the longest conversation seen. */
+  longestSession: number;
+  /** Input-side spend: plain input, cache reads and cache writes. */
+  inputUsd: number;
+  /** What that would have been if every turn had cost what its cheapest turn did. */
+  flatUsd: number;
+  /**
+   * `inputUsd - flatUsd`. **A ceiling on what removing conversation growth could
+   * be worth, not a saving** — part of it is the user's own new messages.
+   */
+  growthUsd: number;
+  /** `growthUsd` as a fraction of the whole bill in the log. */
+  shareOfBill: number;
+}
+
+export interface ConversationOptions {
+  catalogue: PricingCatalogue;
+  on?: Date;
+  /**
+   * Slices whose growth is below this share of the bill are dropped, and slices
+   * shorter than `minTurns` never count as conversations at all.
+   */
+  minShare?: number;
+  /**
+   * Conversations shorter than this are ignored.
+   *
+   * Two turns is not a conversation, it is a retry — and a workload that never
+   * exceeds two turns has no growth to measure, so including it would put a row on
+   * screen whose figure is arithmetic noise. Default 3.
+   */
+  minTurns?: number;
+}
+
+/** Input-side cost of one call at its own model's rates. */
+function inputCostOf(record: UsageRecord, catalogue: PricingCatalogue, on: Date): number | null {
+  const model = catalogue.byId.get(record.model);
+  if (!model) return null;
+  const { inputPerMTok } = effectivePricing(model, on);
+  const rates = multipliersFor(model);
+  const per = (tokens: number, rate: number): number => (tokens / 1_000_000) * rate;
+  return (
+    per(record.inputTokens, inputPerMTok) +
+    per(record.cacheReadTokens, inputPerMTok * rates.cacheRead) +
+    per(record.cacheWrite5mTokens, inputPerMTok * rates.cacheWrite5m) +
+    per(record.cacheWrite1hTokens, inputPerMTok * rates.cacheWrite1h)
+  );
+}
+
+/** Every input-side token of one call, whatever rate it was billed at. */
+const inputTokensOf = (r: UsageRecord): number =>
+  r.inputTokens + r.cacheReadTokens + r.cacheWrite5mTokens + r.cacheWrite1hTokens;
+
+interface Session {
+  turns: number;
+  /**
+   * The smallest turn by **tokens**, not by billed cost.
+   *
+   * Two faults taught this shape. Anchoring on the first record seen made the
+   * measurement depend on the order of the log: the identical workload exported
+   * newest-first computed a *negative* growth and the section silently vanished.
+   * Anchoring on the cheapest turn's *cost* fixed the ordering and introduced
+   * the second fault: per-turn cost varies with the cache multiplier even when
+   * the input never grows — an identical 10,000-token turn costs 12.5x more as
+   * a cache write than as a cache read — so an ordinary 5-minute-TTL agent
+   * whose conversation stayed flat reported 77.5% of its bill as "conversation
+   * growth", and the report recommended trimming history that was not there.
+   *
+   * Tokens are what growth *is*, and they are immune to both: order-independent,
+   * and identical however each turn happened to be billed.
+   */
+  minTokens: number;
+  maxTokens: number;
+  totalTokens: number;
+  totalUsd: number;
+}
+
+/**
+ * Measures what conversation growth costs, from records that carry a session.
+ *
+ * Records without one are skipped rather than lumped together: calls from
+ * different conversations pushed into a single bucket would report a turn count
+ * that is really a call count, and a growth figure derived from it would be
+ * arithmetic performed on a fiction.
+ *
+ * Takes records rather than a report because turn order is the whole measurement,
+ * and a breakdown has already thrown it away.
+ */
+export interface ConversationTracker {
+  /** Feed one parsed record. Records without a session are ignored. */
+  add(record: UsageRecord): void;
+  /** The finished measurement, once the whole bill is known. */
+  finish(totalUsd: number): ConversationGrowth[];
+}
+
+/**
+ * An accumulator, so a profile can measure this in the pass it already makes.
+ *
+ * The alternative was holding every record to hand to a pure function afterwards,
+ * and a usage log is measured in megabytes — a profile that needs the whole file in
+ * memory to answer one question is a profile that stops working on the logs most
+ * worth reading. What this holds is bounded by the number of **conversations**, and
+ * only ever four numbers each.
+ */
+export function createConversationTracker(options: ConversationOptions): ConversationTracker {
+  const { catalogue, on = new Date(), minShare = 0.01, minTurns = 3 } = options;
+
+  // Keyed on the pair, then on the session inside it. A newline cannot occur in a
+  // model id, and both halves are trimmed strings.
+  const slices = new Map<string, Map<string, Session>>();
+
+  const add = (record: UsageRecord): void => {
+    if (record.session === null) return;
+    const cost = inputCostOf(record, catalogue, on);
+    // An unpriced model contributes no dollars anywhere else either; including it
+    // here would report growth of zero on a workload that grew.
+    if (cost === null) return;
+
+    const sliceKey = `${record.label ?? UNLABELLED}\n${record.model}`;
+    let sessions = slices.get(sliceKey);
+    if (!sessions) {
+      sessions = new Map();
+      slices.set(sliceKey, sessions);
+    }
+
+    const tokens = inputTokensOf(record);
+    const existing = sessions.get(record.session);
+    if (!existing) {
+      sessions.set(record.session, {
+        turns: 1,
+        minTokens: tokens,
+        maxTokens: tokens,
+        totalTokens: tokens,
+        totalUsd: cost,
+      });
+      return;
+    }
+    existing.turns += 1;
+    existing.minTokens = Math.min(existing.minTokens, tokens);
+    existing.maxTokens = Math.max(existing.maxTokens, tokens);
+    existing.totalTokens += tokens;
+    existing.totalUsd += cost;
+  };
+
+  const finish = (totalUsd: number): ConversationGrowth[] => {
+  const out: ConversationGrowth[] = [];
+
+  for (const [sliceKey, sessions] of slices) {
+    const split = sliceKey.indexOf('\n');
+    const label = sliceKey.slice(0, split);
+    const modelId = sliceKey.slice(split + 1);
+    const model = catalogue.byId.get(modelId);
+    if (!model) continue;
+
+    /**
+     * Only conversations long enough to have grown. A two-turn session has one
+     * step of growth and is as likely to be a retry, and averaging it in drags the
+     * measured shape towards flat — understating the real thing, which is the
+     * direction that flatters.
+     */
+    const long = [...sessions.values()].filter((s) => s.turns >= minTurns);
+    if (long.length === 0) continue;
+
+    let inputUsd = 0;
+    let flatUsd = 0;
+    let minTokens = 0;
+    let maxTokens = 0;
+    let calls = 0;
+    let longestSession = 0;
+
+    for (const session of long) {
+      inputUsd += session.totalUsd;
+      /**
+       * The growth is measured in tokens — `totalTokens - minTokens·turns`,
+       * which is exact, order-independent, and zero for a conversation whose
+       * turns never change size however each one was billed. The money is that
+       * token share of what the session actually spent: pricing the excess at
+       * any single rate would either overstate it (full input rate, when most
+       * re-sent history is cache-read cheap) or move with billing noise (the
+       * cheapest turn's rate, which is what mis-billed a flat cached agent).
+       */
+      const flatTokens = session.minTokens * session.turns;
+      flatUsd +=
+        session.totalTokens > 0
+          ? session.totalUsd * (flatTokens / session.totalTokens)
+          : session.totalUsd;
+      minTokens += session.minTokens;
+      maxTokens += session.maxTokens;
+      calls += session.turns;
+      longestSession = Math.max(longestSession, session.turns);
+    }
+
+    const growthUsd = inputUsd - flatUsd;
+    const shareOfBill = totalUsd > 0 ? growthUsd / totalUsd : 0;
+    /**
+     * Below the attention threshold — **and that covers shrinking conversations
+     * too**, because a negative share is below any threshold at or above zero.
+     *
+     * There was a separate `growthUsd <= 0` check here. No mutation could break
+     * it: every case it caught, this one caught first. A guard nothing can
+     * distinguish is not defence in depth, it is a second place for the intent to
+     * drift from the code, so the intent lives in this comment instead.
+     *
+     * The case it was written for is ordinary: an opening turn carrying an
+     * attachment or a retrieved document is bigger than everything after it, and
+     * reporting that as "conversation growth" would be a negative ceiling
+     * presented as an opportunity.
+     */
+    if (shareOfBill < minShare) continue;
+
+    out.push({
+      label,
+      model: modelId,
+      modelName: model.displayName,
+      sessions: long.length,
+      calls,
+      minTurnTokens: minTokens / long.length,
+      maxTurnTokens: maxTokens / long.length,
+      longestSession,
+      inputUsd,
+      flatUsd,
+      growthUsd,
+      shareOfBill,
+    });
+  }
+
+    return out.sort((a, b) => b.growthUsd - a.growthUsd);
+  };
+
+  return { add, finish };
+}
+
+/**
+ * The same measurement over a list of records, for a caller holding one already.
+ *
+ * `profileUsage` uses the tracker instead, so it never has to keep the log.
+ */
+export function conversationGrowth(
+  records: readonly UsageRecord[],
+  totalUsd: number,
+  options: ConversationOptions,
+): ConversationGrowth[] {
+  const tracker = createConversationTracker(options);
+  for (const record of records) tracker.add(record);
+  return tracker.finish(totalUsd);
+}

package/src/csv.ts

@@ -0,0 +1,184 @@
+import { UNLABELLED } from './usage.js';
+import type { UsageProfileReport } from './usage.js';
+
+/**
+ * The profile as a spreadsheet.
+ *
+ * ## Why a file format is a feature
+ *
+ * The terminal report is read once and closed. The people who decide what a
+ * workload is allowed to cost live in spreadsheets, and handing them a
+ * screenshot of a terminal is how a finding stops at the person who ran the
+ * command. `--json` is for machines; this is for the pivot table that gets
+ * shown to whoever signs off the bill.
+ *
+ * ## One row per label and model, and no total row
+ *
+ * `byLabelAndModel` is the grouping a decision is actually made at — routing
+ * `classify` to a cheaper model is a question about one label's calls to one
+ * model — so it is the grain of the file.
+ *
+ * **There is deliberately no TOTAL row.** A total inside a data file is the
+ * oldest spreadsheet trap there is: somebody sums the column, the total row is
+ * included, and every figure downstream is exactly twice what it should be.
+ * The sum of this file is the bill, and a spreadsheet can compute it.
+ *
+ * ## Unpriced models get empty cells, never zeros
+ *
+ * A model the catalogue does not know has real tokens and unknown dollars.
+ * Writing `0` there would be a claim — that those calls were free — and it
+ * would survive into every chart built on the file. An empty cell is the
+ * absence it actually is, and spreadsheets already know how to skip one.
+ */
+
+/** Columns, in order. Exported so a test can pin the header rather than a string. */
+export const PROFILE_CSV_COLUMNS = [
+  'label',
+  'model',
+  'calls',
+  'input_tokens',
+  'cache_read_tokens',
+  'cache_write_tokens',
+  'output_tokens',
+  'input_usd',
+  'cache_read_usd',
+  'cache_write_usd',
+  'output_usd',
+  'total_usd',
+] as const;
+
+/**
+ * One CSV field, RFC 4180.
+ *
+ * Labels are arbitrary strings out of somebody's log: a label containing a
+ * comma would shift every column after it, and one containing a quote would
+ * break the row it sits in. Both are quoted here rather than sanitised,
+ * because changing the label would make the file disagree with every other
+ * rendering about what the workload is called.
+ *
+ * A leading `=`, `+`, `-` or `@` is prefixed with an apostrophe: those are
+ * how a spreadsheet is told a cell is a formula, and a label out of a log is
+ * data. This is the one place a value is altered, and it is altered to stop
+ * a log from executing anything when the file is opened.
+ */
+function field(value: string): string {
+  const guarded = /^[=+\-@\t\r]/.test(value) ? `'${value}` : value;
+  return /[",\n\r]/.test(guarded) ? `"${guarded.replace(/"/g, '""')}"` : guarded;
+}
+
+/** A dollar figure with enough places to survive being summed. */
+const usd = (value: number): string => value.toFixed(6);
+
+export interface ProfileCsvOptions {
+  /** What to call the bucket for calls carrying no label. */
+  unlabelled: string;
+  /**
+   * Which table to write.
+   *
+   * `slice` is one row per label and model — the grain a routing or budget
+   * decision is made at. `day` and `hour` are the time series, which is what
+   * a spreadsheet gets asked to chart; keeping them behind a choice rather
+   * than in extra columns means every file has one row shape, and a
+   * spreadsheet that has to filter before it can sum is a spreadsheet
+   * somebody sums wrong.
+   */
+  shape?: ProfileCsvShape;
+}
+
+export type ProfileCsvShape = 'slice' | 'day' | 'hour';
+
+/** Columns for the per-day series. */
+export const PROFILE_CSV_DAY_COLUMNS = ['day', 'usd', 'calls', 'top_label', 'top_label_usd'] as const;
+
+/** Columns for the per-hour-of-UTC-day series. */
+export const PROFILE_CSV_HOUR_COLUMNS = ['hour_utc', 'usd', 'calls'] as const;
+
+/**
+ * The report as CSV text, one row per label and model.
+ *
+ * Rows arrive in the report's own order — largest bill first — because a
+ * spreadsheet can re-sort and a reader opening the file should see the
+ * expensive workload at the top either way.
+ */
+export function profileToCsv(report: UsageProfileReport, options: ProfileCsvOptions): string {
+  if (options.shape === 'day') {
+    const rows: string[] = [PROFILE_CSV_DAY_COLUMNS.join(',')];
+    for (const day of report.spendByDay) {
+      rows.push(
+        [
+          day.day,
+          usd(day.usd),
+          String(day.calls),
+          // A day whose calls carried no label at all has no top label, and an
+          // empty cell is that absence. Naming the unlabelled bucket here
+          // would claim a label the log never carried.
+          day.topLabel === null
+            ? ''
+            : field(day.topLabel === UNLABELLED ? options.unlabelled : day.topLabel),
+          day.topLabel === null ? '' : usd(day.topLabelUsd),
+        ].join(','),
+      );
+    }
+    return `${rows.join('\n')}\n`;
+  }
+
+  if (options.shape === 'hour') {
+    const rows: string[] = [PROFILE_CSV_HOUR_COLUMNS.join(',')];
+    for (const hour of report.spendByHour) {
+      rows.push([String(hour.hour), usd(hour.usd), String(hour.calls)].join(','));
+    }
+    return `${rows.join('\n')}\n`;
+  }
+
+  const rows: string[] = [PROFILE_CSV_COLUMNS.join(',')];
+
+  for (const { label, model, breakdown } of report.byLabelAndModel) {
+    rows.push(
+      [
+        field(label === UNLABELLED ? options.unlabelled : label),
+        field(model),
+        String(breakdown.calls),
+        String(breakdown.inputTokens),
+        String(breakdown.cacheReadTokens),
+        String(breakdown.cacheWriteTokens),
+        String(breakdown.outputTokens),
+        usd(breakdown.inputUsd),
+        usd(breakdown.cacheReadUsd),
+        usd(breakdown.cacheWriteUsd),
+        usd(breakdown.outputUsd),
+        usd(breakdown.totalUsd),
+      ].join(','),
+    );
+  }
+
+  /**
+   * The unpriced calls, with their tokens and no dollars.
+   *
+   * They are absent from `byLabelAndModel` — which holds what could be priced
+   * — and leaving them out of the file entirely would make its token columns
+   * disagree with the log. `byModel` keeps them, so they are recovered from
+   * there, with empty dollar cells rather than zeros.
+   */
+  for (const model of report.unpricedModels) {
+    const row = report.byModel.find((entry) => entry.model === model);
+    if (!row) continue;
+    rows.push(
+      [
+        field(options.unlabelled),
+        field(model),
+        String(row.breakdown.calls),
+        String(row.breakdown.inputTokens),
+        String(row.breakdown.cacheReadTokens),
+        String(row.breakdown.cacheWriteTokens),
+        String(row.breakdown.outputTokens),
+        '',
+        '',
+        '',
+        '',
+        '',
+      ].join(','),
+    );
+  }
+
+  return `${rows.join('\n')}\n`;
+}