@cursor/july 0.1.25 → 0.1.27

package/src/internal/model-pricing.ts

@@ -0,0 +1,426 @@
+/**
+ * Best-effort dollar-cost estimation for agent turns.
+ *
+ * The Cursor harness streams token usage (`turn-ended`) but no dollar cost,
+ * and server-billed cost is only queryable for cloud agents — so the
+ * framework prices token usage against a built-in snapshot of Cursor's
+ * published per-model API rates. Estimates are marked `source: "estimate"`
+ * everywhere they surface (traces, playground, A/B metrics, CLI); the billed
+ * amount on the Cursor dashboard remains the source of truth.
+ *
+ * Unknown models produce no estimate rather than a wrong one. Deployments
+ * can extend or correct the table without a package upgrade via the
+ * `AGENT_SERVE_MODEL_PRICING` environment variable (a JSON object merged
+ * over the defaults, keyed by model id).
+ */
+
+import type { ModelSetting, TurnCost, TurnUsage } from "../types.js";
+
+/** USD per million tokens for one pricing tier. */
+export interface ModelPricingTier {
+  inputUsdPerMTok: number;
+  outputUsdPerMTok: number;
+  cacheReadUsdPerMTok: number;
+  /** Defaults to {@link inputUsdPerMTok} when omitted (provider convention). */
+  cacheWriteUsdPerMTok?: number;
+}
+
+export interface ModelPricing extends ModelPricingTier {
+  /** Rates when the model's `fast` parameter is `"true"`. */
+  fast?: ModelPricingTier;
+}
+
+const M = 1_000_000;
+
+/**
+ * Snapshot of Cursor API per-model token rates (USD per million tokens).
+ * Keyed by normalized model id; family aliases (`sonnet`, `gpt`, …) point at
+ * the model they currently resolve to.
+ */
+export const DEFAULT_MODEL_PRICING: Readonly<Record<string, ModelPricing>> = {
+  // xAI / Cursor-served Grok
+  "grok-4.5": {
+    inputUsdPerMTok: 2,
+    outputUsdPerMTok: 6,
+    cacheReadUsdPerMTok: 0.5,
+    fast: { inputUsdPerMTok: 4, outputUsdPerMTok: 18, cacheReadUsdPerMTok: 1 },
+  },
+  "grok-4.20": {
+    inputUsdPerMTok: 2,
+    outputUsdPerMTok: 6,
+    cacheReadUsdPerMTok: 0.2,
+  },
+  "grok-4.3": {
+    inputUsdPerMTok: 1.25,
+    outputUsdPerMTok: 2.5,
+    cacheReadUsdPerMTok: 0.125,
+  },
+  "grok-code": {
+    inputUsdPerMTok: 0.2,
+    outputUsdPerMTok: 1.5,
+    cacheReadUsdPerMTok: 0.02,
+  },
+
+  // Anthropic
+  "opus-5": {
+    inputUsdPerMTok: 5,
+    outputUsdPerMTok: 25,
+    cacheReadUsdPerMTok: 0.5,
+    cacheWriteUsdPerMTok: 6.25,
+    fast: {
+      inputUsdPerMTok: 10,
+      outputUsdPerMTok: 50,
+      cacheReadUsdPerMTok: 1,
+      cacheWriteUsdPerMTok: 12.5,
+    },
+  },
+  "opus-4.8": {
+    inputUsdPerMTok: 5,
+    outputUsdPerMTok: 25,
+    cacheReadUsdPerMTok: 0.5,
+    cacheWriteUsdPerMTok: 6.25,
+    fast: {
+      inputUsdPerMTok: 10,
+      outputUsdPerMTok: 50,
+      cacheReadUsdPerMTok: 1,
+      cacheWriteUsdPerMTok: 12.5,
+    },
+  },
+  "opus-4.7": {
+    inputUsdPerMTok: 5,
+    outputUsdPerMTok: 25,
+    cacheReadUsdPerMTok: 0.5,
+    cacheWriteUsdPerMTok: 6.25,
+    fast: {
+      inputUsdPerMTok: 30,
+      outputUsdPerMTok: 150,
+      cacheReadUsdPerMTok: 3,
+      cacheWriteUsdPerMTok: 37.5,
+    },
+  },
+  "opus-4.6": {
+    inputUsdPerMTok: 5,
+    outputUsdPerMTok: 25,
+    cacheReadUsdPerMTok: 0.5,
+    cacheWriteUsdPerMTok: 6.25,
+  },
+  "opus-4.5": {
+    inputUsdPerMTok: 5,
+    outputUsdPerMTok: 25,
+    cacheReadUsdPerMTok: 0.5,
+    cacheWriteUsdPerMTok: 6.25,
+  },
+  "sonnet-5": {
+    inputUsdPerMTok: 3,
+    outputUsdPerMTok: 15,
+    cacheReadUsdPerMTok: 0.3,
+    cacheWriteUsdPerMTok: 3.75,
+  },
+  "sonnet-4.6": {
+    inputUsdPerMTok: 3,
+    outputUsdPerMTok: 15,
+    cacheReadUsdPerMTok: 0.3,
+    cacheWriteUsdPerMTok: 3.75,
+  },
+  "sonnet-4.5": {
+    inputUsdPerMTok: 3,
+    outputUsdPerMTok: 15,
+    cacheReadUsdPerMTok: 0.3,
+    cacheWriteUsdPerMTok: 3.75,
+  },
+  "haiku-4.5": {
+    inputUsdPerMTok: 1,
+    outputUsdPerMTok: 5,
+    cacheReadUsdPerMTok: 0.1,
+    cacheWriteUsdPerMTok: 1.25,
+  },
+  "fable-5": {
+    inputUsdPerMTok: 10,
+    outputUsdPerMTok: 50,
+    cacheReadUsdPerMTok: 1,
+    cacheWriteUsdPerMTok: 12.5,
+  },
+
+  // OpenAI
+  "gpt-5.6": {
+    inputUsdPerMTok: 5,
+    outputUsdPerMTok: 30,
+    cacheReadUsdPerMTok: 0.5,
+    cacheWriteUsdPerMTok: 6.25,
+    fast: {
+      inputUsdPerMTok: 10,
+      outputUsdPerMTok: 60,
+      cacheReadUsdPerMTok: 1,
+      cacheWriteUsdPerMTok: 12.5,
+    },
+  },
+  "gpt-5.5": {
+    inputUsdPerMTok: 5,
+    outputUsdPerMTok: 30,
+    cacheReadUsdPerMTok: 0.5,
+  },
+  "gpt-5.4": {
+    inputUsdPerMTok: 2.5,
+    outputUsdPerMTok: 15,
+    cacheReadUsdPerMTok: 0.25,
+  },
+  "gpt-5.2": {
+    inputUsdPerMTok: 1.75,
+    outputUsdPerMTok: 14,
+    cacheReadUsdPerMTok: 0.175,
+  },
+  "gpt-mini": {
+    inputUsdPerMTok: 0.75,
+    outputUsdPerMTok: 4.5,
+    cacheReadUsdPerMTok: 0.075,
+  },
+  "codex-5.3": {
+    inputUsdPerMTok: 1.75,
+    outputUsdPerMTok: 14,
+    cacheReadUsdPerMTok: 0.175,
+  },
+  "codex-5.2": {
+    inputUsdPerMTok: 1.75,
+    outputUsdPerMTok: 14,
+    cacheReadUsdPerMTok: 0.175,
+  },
+
+  // Google
+  "gemini-3.1-pro": {
+    inputUsdPerMTok: 2,
+    outputUsdPerMTok: 12,
+    cacheReadUsdPerMTok: 0.2,
+  },
+  "gemini-3-pro": {
+    inputUsdPerMTok: 2,
+    outputUsdPerMTok: 12,
+    cacheReadUsdPerMTok: 0.2,
+  },
+  "gemini-3.6-flash": {
+    inputUsdPerMTok: 1.5,
+    outputUsdPerMTok: 7.5,
+    cacheReadUsdPerMTok: 0.15,
+  },
+  "gemini-3.5-flash": {
+    inputUsdPerMTok: 1.5,
+    outputUsdPerMTok: 9,
+    cacheReadUsdPerMTok: 0.15,
+  },
+
+  // Cursor Composer
+  "composer-2.5": {
+    inputUsdPerMTok: 0.5,
+    outputUsdPerMTok: 2.5,
+    cacheReadUsdPerMTok: 0.2,
+    fast: {
+      inputUsdPerMTok: 3,
+      outputUsdPerMTok: 15,
+      cacheReadUsdPerMTok: 0.5,
+    },
+  },
+  "composer-2": {
+    inputUsdPerMTok: 0.5,
+    outputUsdPerMTok: 2.5,
+    cacheReadUsdPerMTok: 0.2,
+  },
+
+  // Moonshot / Zhipu
+  "kimi-k3": {
+    inputUsdPerMTok: 3,
+    outputUsdPerMTok: 15,
+    cacheReadUsdPerMTok: 0.3,
+  },
+  "kimi-k2.7": {
+    inputUsdPerMTok: 0.95,
+    outputUsdPerMTok: 4,
+    cacheReadUsdPerMTok: 0.19,
+  },
+  "kimi-k2.5": {
+    inputUsdPerMTok: 0.6,
+    outputUsdPerMTok: 3,
+    cacheReadUsdPerMTok: 0.1,
+  },
+  "glm-5.2": {
+    inputUsdPerMTok: 1.4,
+    outputUsdPerMTok: 4.4,
+    cacheReadUsdPerMTok: 0.26,
+  },
+};
+
+/** Family aliases → the model id they currently resolve to. */
+const MODEL_ID_ALIASES: Readonly<Record<string, string>> = {
+  grok: "grok-4.20",
+  "grok-latest": "grok-4.3",
+  "grok-code-latest": "grok-code",
+  opus: "opus-5",
+  "opus-latest": "opus-5",
+  sonnet: "sonnet-4.6",
+  "sonnet-latest": "sonnet-5",
+  haiku: "haiku-4.5",
+  "haiku-latest": "haiku-4.5",
+  fable: "fable-5",
+  gpt: "gpt-5.6",
+  "gpt-latest": "gpt-5.6",
+  "gpt-5-6-sol": "gpt-5.6",
+  "gpt-5-5": "gpt-5.5",
+  "gpt-mini-latest": "gpt-mini",
+  codex: "codex-5.3",
+  "codex-latest": "codex-5.3",
+  gemini: "gemini-3.1-pro",
+  "gemini-latest": "gemini-3.1-pro",
+  "gemini-pro": "gemini-3.1-pro",
+  "gemini-pro-latest": "gemini-3.1-pro",
+  "gemini-flash": "gemini-3.6-flash",
+  "gemini-flash-latest": "gemini-3.6-flash",
+  composer: "composer-2.5",
+  "composer-latest": "composer-2.5",
+  "composer-2-5": "composer-2.5",
+  kimi: "kimi-k2.7",
+  "kimi-latest": "kimi-k2.7",
+};
+
+/** Env var holding a JSON pricing override merged over the defaults. */
+export const MODEL_PRICING_ENV_VAR = "AGENT_SERVE_MODEL_PRICING";
+
+let cachedEnvOverride:
+  | { raw: string | undefined; table: Record<string, ModelPricing> }
+  | undefined;
+
+function envOverrideTable(): Record<string, ModelPricing> {
+  const raw = process.env[MODEL_PRICING_ENV_VAR];
+  if (cachedEnvOverride !== undefined && cachedEnvOverride.raw === raw) {
+    return cachedEnvOverride.table;
+  }
+  let table: Record<string, ModelPricing> = {};
+  if (raw !== undefined && raw.trim() !== "") {
+    try {
+      const parsed = JSON.parse(raw) as unknown;
+      if (typeof parsed === "object" && parsed !== null) {
+        for (const [key, value] of Object.entries(parsed)) {
+          const tier = parsePricing(value);
+          if (tier !== undefined) {
+            table[normalizeModelId(key)] = tier;
+          }
+        }
+      }
+    } catch {
+      table = {};
+    }
+  }
+  cachedEnvOverride = { raw, table };
+  return table;
+}
+
+function parseTier(value: unknown): ModelPricingTier | undefined {
+  if (typeof value !== "object" || value === null) {
+    return undefined;
+  }
+  const row = value as Record<string, unknown>;
+  const input = row.inputUsdPerMTok;
+  const output = row.outputUsdPerMTok;
+  const cacheRead = row.cacheReadUsdPerMTok;
+  if (
+    !isRate(input) ||
+    !isRate(output) ||
+    (cacheRead !== undefined && !isRate(cacheRead))
+  ) {
+    return undefined;
+  }
+  const cacheWrite = row.cacheWriteUsdPerMTok;
+  return {
+    inputUsdPerMTok: input,
+    outputUsdPerMTok: output,
+    cacheReadUsdPerMTok: isRate(cacheRead) ? cacheRead : input,
+    cacheWriteUsdPerMTok: isRate(cacheWrite) ? cacheWrite : undefined,
+  };
+}
+
+function parsePricing(value: unknown): ModelPricing | undefined {
+  const base = parseTier(value);
+  if (base === undefined) {
+    return undefined;
+  }
+  const fast = parseTier((value as Record<string, unknown>).fast);
+  return { ...base, fast };
+}
+
+function isRate(value: unknown): value is number {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0;
+}
+
+export function normalizeModelId(id: string): string {
+  return id.trim().toLowerCase();
+}
+
+function modelId(model: ModelSetting): string {
+  return typeof model === "string" ? model : model.id;
+}
+
+function modelHasFastParam(model: ModelSetting): boolean {
+  if (typeof model === "string") {
+    return false;
+  }
+  return (
+    model.params?.some(
+      (param) => param.id === "fast" && param.value === "true"
+    ) === true
+  );
+}
+
+/**
+ * Rates for a model selection, honoring its `fast` parameter. `undefined`
+ * when the model is not in the table (no estimate is better than a wrong
+ * one).
+ */
+export function resolveModelPricing(
+  model: ModelSetting
+): ModelPricingTier | undefined {
+  const overrides = envOverrideTable();
+  const rawId = normalizeModelId(modelId(model));
+  const canonicalId = MODEL_ID_ALIASES[rawId] ?? rawId;
+  const pricing =
+    overrides[rawId] ??
+    overrides[canonicalId] ??
+    DEFAULT_MODEL_PRICING[rawId] ??
+    DEFAULT_MODEL_PRICING[canonicalId];
+  if (pricing === undefined) {
+    return undefined;
+  }
+  if (modelHasFastParam(model) && pricing.fast !== undefined) {
+    return pricing.fast;
+  }
+  return pricing;
+}
+
+/**
+ * Estimate the dollar cost of one turn's token usage. `undefined` when the
+ * model has no known rates.
+ */
+export function estimateTurnCost(
+  model: ModelSetting,
+  usage: TurnUsage
+): TurnCost | undefined {
+  const tier = resolveModelPricing(model);
+  if (tier === undefined) {
+    return undefined;
+  }
+  const cacheWriteRate = tier.cacheWriteUsdPerMTok ?? tier.inputUsdPerMTok;
+  const inputUsd = (usage.inputTokens / M) * tier.inputUsdPerMTok;
+  const outputUsd = (usage.outputTokens / M) * tier.outputUsdPerMTok;
+  const cacheReadUsd = (usage.cacheReadTokens / M) * tier.cacheReadUsdPerMTok;
+  const cacheWriteUsd = (usage.cacheWriteTokens / M) * cacheWriteRate;
+  return {
+    totalUsd: roundUsd(inputUsd + outputUsd + cacheReadUsd + cacheWriteUsd),
+    inputUsd: roundUsd(inputUsd),
+    outputUsd: roundUsd(outputUsd),
+    cacheReadUsd: roundUsd(cacheReadUsd),
+    cacheWriteUsd: roundUsd(cacheWriteUsd),
+    model: normalizeModelId(modelId(model)),
+    source: "estimate",
+  };
+}
+
+/** Keep persisted estimates readable: micro-dollar precision. */
+function roundUsd(usd: number): number {
+  return Math.round(usd * 1e6) / 1e6;
+}

package/src/internal/reminder-runner.ts

@@ -664,6 +664,7 @@ export class ReminderRunner {
       host: this.engine.host,
       mcp: this.engine.host.mcp,
       appAuth: APP_AUTH,
+      artifacts: this.engine.artifacts,
       async followup(args: { message: string }) {
         const auth = await self.resolveFollowupAuth(
           record.channelId,

package/src/internal/schedule-runner.ts

@@ -151,6 +151,7 @@ export class ScheduleRunner {
       },
       appAuth: APP_AUTH,
       host: this.engine.host,
+      artifacts: this.engine.artifacts,
     });
     // Collect ids from receive() calls the handler chose not to await
     // (commonly wrapped in waitUntil); receive resolves at message accept,

package/src/internal/sdk-runner.ts

@@ -431,9 +431,17 @@ export class CursorSdkRunner implements AgentRunner {
     if (request.isFirstTurn) {
       return Agent.create(options);
     }
-    throw new Error(
-      `Cloud session ${request.sessionId} is missing sdkAgentId; cannot resume.`
+    // A cloud session past its first turn should carry the bound agent id
+    // (the engine persists it via onSdkAgentId as soon as create() reports
+    // one). Reaching here means the binding turn failed before the server
+    // ever minted an agent — e.g. create() rejected its PR attach — so the
+    // session would otherwise fail every future turn. Mirror the local
+    // host-replacement path above: a fresh conversation beats failing this
+    // thread forever, and the new id binds to the session for later resumes.
+    this.log(
+      `[agentkit] cloud session ${request.sessionId} has no bound cloud agent; creating a fresh one`
     );
+    return Agent.create(options);
   }
 
   private getStore(stateDir: string): Promise<LocalAgentStore> {

package/src/internal/server.ts

@@ -494,6 +494,7 @@ export async function startServer(
           interruptContinuation: (continuationToken) =>
             engine.interruptContinuation(channel.id, continuationToken),
           logger,
+          artifacts: engine.artifacts,
         };
         try {
           await definition.onStart(startArgs);
@@ -1778,6 +1779,7 @@ async function startCursorSlackRelay(input: {
         envelope,
         send: args.send,
         host: args.host,
+        artifacts: args.artifacts,
         hasContinuationSession: (continuationToken) =>
           target.runtime.engine.hasContinuationSession(
             target.channelId,

package/src/internal/session-cost.ts

@@ -0,0 +1,231 @@
+/**
+ * Per-session cost metrics folded from a durable session event stream.
+ *
+ * Powers `agent-serve cost [sessionId]`: each `turn.completed` event carries
+ * the turn's token usage and the estimated dollar cost recorded by the
+ * engine (see `model-pricing.ts`), so a session's spend is a pure fold over
+ * its `events.ndjson` — no server-side aggregation required.
+ */
+
+import type { SessionEvent, TurnCost, TurnUsage } from "../types.js";
+import { formatCostUsd, roundCostUsd } from "./trajectory.js";
+
+/** One agent loop pass (turn) with its usage and estimated cost. */
+export interface SessionCostTurn {
+  turnId: string;
+  failed: boolean;
+  usage?: TurnUsage;
+  cost?: TurnCost;
+}
+
+export interface SessionCostTotals {
+  turns: number;
+  turnFailures: number;
+  inputTokens: number;
+  outputTokens: number;
+  cacheReadTokens: number;
+  cacheWriteTokens: number;
+  /** Sum of per-turn estimated costs (USD). */
+  costUsd: number;
+  /** Turns that reported usage but had no known model rates. */
+  unpricedTurns: number;
+}
+
+export interface SessionCostReport {
+  sessionId: string;
+  turns: SessionCostTurn[];
+  totals: SessionCostTotals;
+}
+
+export function emptySessionCostTotals(): SessionCostTotals {
+  return {
+    turns: 0,
+    turnFailures: 0,
+    inputTokens: 0,
+    outputTokens: 0,
+    cacheReadTokens: 0,
+    cacheWriteTokens: 0,
+    costUsd: 0,
+    unpricedTurns: 0,
+  };
+}
+
+export function addSessionCostTotals(
+  target: SessionCostTotals,
+  delta: SessionCostTotals
+): void {
+  target.turns += delta.turns;
+  target.turnFailures += delta.turnFailures;
+  target.inputTokens += delta.inputTokens;
+  target.outputTokens += delta.outputTokens;
+  target.cacheReadTokens += delta.cacheReadTokens;
+  target.cacheWriteTokens += delta.cacheWriteTokens;
+  target.costUsd = roundCostUsd(target.costUsd + delta.costUsd);
+  target.unpricedTurns += delta.unpricedTurns;
+}
+
+/** Fold a session event stream into per-turn and total cost metrics. */
+export function buildSessionCostReport(
+  events: readonly SessionEvent[]
+): SessionCostReport {
+  let sessionId = "";
+  const turns: SessionCostTurn[] = [];
+  const totals = emptySessionCostTotals();
+
+  for (const event of events) {
+    if (sessionId === "" && typeof event.sessionId === "string") {
+      sessionId = event.sessionId;
+    }
+    if (event.type !== "turn.completed" && event.type !== "turn.failed") {
+      continue;
+    }
+    const turn: SessionCostTurn = {
+      turnId: event.turnId ?? `turn_${turns.length + 1}`,
+      failed: event.type === "turn.failed",
+    };
+    totals.turns += 1;
+    if (event.type === "turn.failed") {
+      totals.turnFailures += 1;
+      turns.push(turn);
+      continue;
+    }
+    const usage = event.data.usage;
+    if (usage !== undefined) {
+      turn.usage = usage;
+      totals.inputTokens += usage.inputTokens;
+      totals.outputTokens += usage.outputTokens;
+      totals.cacheReadTokens += usage.cacheReadTokens;
+      totals.cacheWriteTokens += usage.cacheWriteTokens;
+    }
+    const cost = event.data.cost;
+    if (cost !== undefined) {
+      turn.cost = cost;
+      totals.costUsd = roundCostUsd(totals.costUsd + cost.totalUsd);
+    } else if (usage !== undefined) {
+      totals.unpricedTurns += 1;
+    }
+    turns.push(turn);
+  }
+
+  return { sessionId, turns, totals };
+}
+
+function formatCount(value: number): string {
+  return String(value);
+}
+
+/** Per-turn table for `agent-serve cost <sessionId>`. */
+export function formatSessionCostText(report: SessionCostReport): string {
+  const lines: string[] = [];
+  lines.push(
+    `session ${report.sessionId || "(unknown)"}  est. cost: ${formatCostUsd(report.totals.costUsd)}`
+  );
+  if (report.turns.length === 0) {
+    lines.push("No turns recorded.");
+    return `${lines.join("\n")}\n`;
+  }
+  const header = [
+    "TURN",
+    "IN",
+    "OUT",
+    "CACHE R",
+    "CACHE W",
+    "EST COST",
+    "MODEL",
+    "STATUS",
+  ];
+  const rows = report.turns.map((turn) => [
+    turn.turnId,
+    turn.usage === undefined ? "—" : formatCount(turn.usage.inputTokens),
+    turn.usage === undefined ? "—" : formatCount(turn.usage.outputTokens),
+    turn.usage === undefined ? "—" : formatCount(turn.usage.cacheReadTokens),
+    turn.usage === undefined ? "—" : formatCount(turn.usage.cacheWriteTokens),
+    turn.cost === undefined ? "—" : formatCostUsd(turn.cost.totalUsd),
+    turn.cost?.model ?? "—",
+    turn.failed ? "failed" : "ok",
+  ]);
+  rows.push([
+    "total",
+    formatCount(report.totals.inputTokens),
+    formatCount(report.totals.outputTokens),
+    formatCount(report.totals.cacheReadTokens),
+    formatCount(report.totals.cacheWriteTokens),
+    formatCostUsd(report.totals.costUsd),
+    "",
+    report.totals.turnFailures > 0
+      ? `${report.totals.turnFailures} failed`
+      : "",
+  ]);
+  lines.push(renderTable(header, rows));
+  appendUnpricedNote(lines, report.totals.unpricedTurns);
+  return `${lines.join("\n")}\n`;
+}
+
+export interface SessionCostRow {
+  sessionId: string;
+  channelId: string;
+  title?: string;
+  updatedAt?: string;
+  totals: SessionCostTotals;
+}
+
+/** All-sessions table for `agent-serve cost` (no session id). */
+export function formatSessionsCostText(rows: SessionCostRow[]): string {
+  if (rows.length === 0) {
+    return "No sessions.\n";
+  }
+  const header = [
+    "SESSION",
+    "CHANNEL",
+    "TURNS",
+    "IN",
+    "OUT",
+    "EST COST",
+    "UPDATED",
+  ];
+  const totals = emptySessionCostTotals();
+  const body = rows.map((row) => {
+    addSessionCostTotals(totals, row.totals);
+    return [
+      row.sessionId,
+      row.channelId,
+      formatCount(row.totals.turns),
+      formatCount(row.totals.inputTokens),
+      formatCount(row.totals.outputTokens),
+      formatCostUsd(row.totals.costUsd),
+      row.updatedAt ?? "",
+    ];
+  });
+  body.push([
+    "total",
+    "",
+    formatCount(totals.turns),
+    formatCount(totals.inputTokens),
+    formatCount(totals.outputTokens),
+    formatCostUsd(totals.costUsd),
+    "",
+  ]);
+  const lines = [renderTable(header, body)];
+  appendUnpricedNote(lines, totals.unpricedTurns);
+  return `${lines.join("\n")}\n`;
+}
+
+function appendUnpricedNote(lines: string[], unpricedTurns: number): void {
+  if (unpricedTurns > 0) {
+    lines.push(
+      `note: ${unpricedTurns} turn(s) reported usage for a model with no known rates; est. cost excludes them.`
+    );
+  }
+}
+
+function renderTable(header: string[], rows: string[][]): string {
+  const widths = header.map((h, i) =>
+    Math.max(h.length, ...rows.map((row) => (row[i] ?? "").length))
+  );
+  const renderRow = (row: string[]): string =>
+    row
+      .map((cell, i) => cell.padEnd(widths[i] ?? 0))
+      .join("  ")
+      .trimEnd();
+  return [renderRow(header), ...rows.map(renderRow)].join("\n");
+}