fix(usage-cost): surface unpriced-model spend as missingCostEntries instead of $0

MichaelZelbel · claude · steipete · commit 1cc0a96df1a1 · 2026-05-25T23:06:44.000+01:00
Models that ship an all-zero cost block (e.g. codex gpt-5.5, whose Codex backend exposes no per-token price) made usage-cost report totalCost: 0 with missingCostEntries: 0 -- a confident, complete $0 -- so every budget/spike safeguard keyed off totalCost was silently blind to real pay-per-token spend. scanTranscriptFile now treats a resolved cost config with no positive per-token rate (and no tiered pricing) as "pricing unknown": for turns that burned tokens it drops the transport's fabricated $0 and surfaces the turn as a missing-cost entry, mirroring the existing tiered-pricing override. Models with positive or tiered pricing and zero-token entries are unaffected. Verified on a real OpenClaw 2026.5.20 host (default openai/gpt-5.5, api_key): 1,780,235 tokens that previously reported missingCostEntries 0 now report 32. Related: #85858 Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
diff --git a/src/infra/session-cost-usage.test.ts b/src/infra/session-cost-usage.test.ts
@@ -149,6 +149,64 @@ describe("session cost usage", () => {
     });
   });
 
+  it("counts token usage for an unpriced (all-zero cost) model as missing, not a confident $0", async () => {
+    const root = await makeSessionCostRoot("cost-unknown-pricing");
+    const sessionsDir = path.join(root, "agents", "main", "sessions");
+    await fs.mkdir(sessionsDir, { recursive: true });
+
+    // A real assistant turn that burned tokens. The transport recorded cost.total: 0,
+    // derived from the model's all-zero catalog pricing — exactly what codex/gpt-5.x
+    // models produce, since the Codex backend exposes no per-token price.
+    const entry = {
+      type: "message",
+      timestamp: new Date().toISOString(),
+      message: {
+        role: "assistant",
+        provider: "openai",
+        model: "gpt-5.5",
+        usage: {
+          input: 881,
+          output: 6,
+          cacheRead: 22400,
+          cacheWrite: 0,
+          totalTokens: 23287,
+          cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+        },
+      },
+    };
+
+    await fs.writeFile(
+      path.join(sessionsDir, "sess-1.jsonl"),
+      transcriptText("sess-1", entry),
+      "utf-8",
+    );
+
+    // The model resolves to an all-zero cost config, i.e. its pricing is unknown.
+    const config = {
+      models: {
+        providers: {
+          openai: {
+            models: [
+              {
+                id: "gpt-5.5",
+                cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+              },
+            ],
+          },
+        },
+      },
+    } as unknown as OpenClawConfig;
+
+    await withStateDir(root, async () => {
+      const summary = await loadCostUsageSummary({ days: 30, config });
+      expect(summary.totals.totalTokens).toBe(23287);
+      expect(summary.totals.totalCost).toBe(0);
+      // Unknown pricing must be surfaced as missing rather than reported as a
+      // confident $0 that would blind budget/spike monitoring to real spend.
+      expect(summary.totals.missingCostEntries).toBe(1);
+    });
+  });
+
   it("ignores compaction checkpoint transcript snapshots in daily totals and discovery", async () => {
     const root = await makeSessionCostRoot("cost-checkpoint");
     const sessionsDir = path.join(root, "agents", "main", "sessions");
diff --git a/src/infra/session-cost-usage.ts b/src/infra/session-cost-usage.ts
@@ -1013,6 +1013,22 @@ const applyCostTotal = (totals: CostUsageTotals, costTotal: number | undefined)
   totals.totalCost += costTotal;
 };
 
+// A resolved cost config only counts as "known" pricing when it carries at least one
+// positive per-token rate (or tiered pricing). An all-zero config is indistinguishable
+// from "pricing unknown": e.g. codex models ship cost {input:0,output:0,...} in the
+// generated models.json because the Codex backend exposes no per-token price. Treating
+// such a config as a real $0 makes usage-cost report confident zero spend, which
+// silently blinds every budget/spike safeguard that keys off totalCost.
+const isModelPricingKnown = (cost: ReturnType<typeof resolveModelCostConfig>): boolean => {
+  if (!cost) {
+    return false;
+  }
+  if (cost.tieredPricing && cost.tieredPricing.length > 0) {
+    return true;
+  }
+  return cost.input > 0 || cost.output > 0 || cost.cacheRead > 0 || cost.cacheWrite > 0;
+};
+
 async function canReadJsonlFromOffset(filePath: string, startOffset: number): Promise<boolean> {
   if (startOffset <= 0) {
     return true;
@@ -1099,6 +1115,17 @@ async function scanTranscriptFile(params: {
         // instead of the stale flat-rate breakdown from the transport layer.
         entry.costTotal = estimateUsageCost({ usage: entry.usage, cost });
         entry.costBreakdown = undefined;
+      } else if (
+        !isModelPricingKnown(cost) &&
+        computeUsageTokenTotals(entry.usage).totalTokens > 0
+      ) {
+        // Pricing for this model is unknown (no positive per-token rate). Any cost the
+        // transport recorded is a fabricated $0 derived from an all-zero catalog entry,
+        // not a real price. Drop it and surface the turn as a missing-cost entry so the
+        // tokens it burned are not reported as confident $0 spend — otherwise every
+        // budget/spike safeguard that reads totalCost stays blind to it.
+        entry.costTotal = undefined;
+        entry.costBreakdown = undefined;
       } else if (entry.costTotal === undefined) {
         // Fill in missing cost estimates.
         entry.costTotal = estimateUsageCost({ usage: entry.usage, cost });
