import { appendFileSync, mkdirSync, mkdtempSync, rmSync, statSync, utimesSync, writeFileSync, } from "node:fs"; import { readdir, readFile, stat } from "node:fs/promises"; import { tmpdir } from "node:os"; import path from "node:path"; import { fileURLToPath } from "node:url"; import { fauxAssistantMessage } from "@earendil-works/pi-ai"; import type { ExtensionAPI, ExtensionContext, } from "@earendil-works/pi-coding-agent"; import { afterEach, describe, expect, it, type MockInstance, vi } from "vitest"; import { createPiSession, type PiSession, } from "../../../test/fixture/create-pi-session.ts"; import costExtension, { __test } from "../index.ts"; vi.mock("node:fs/promises", async (importOriginal) => { const actual = await importOriginal(); return { ...actual, readFile: vi.fn(actual.readFile), readdir: vi.fn(actual.readdir), stat: vi.fn(actual.stat), }; }); const STATUS_ID = "cost"; const noModel = () => undefined; /** Catalog lookup as the extension sees it: `ctx.modelRegistry.find`. */ async function registryFind(): Promise<{ session: PiSession; find: ExtensionContext["modelRegistry"]["find"]; }> { let registry: ExtensionContext["modelRegistry"] | undefined; const probe = (pi: ExtensionAPI) => { pi.on("session_start", (_event, ctx) => { registry = ctx.modelRegistry; }); }; const s = await createPiSession({ extensionFactories: [costExtension, probe], }); await s.session.extensionRunner.emit({ type: "session_start", reason: "startup", }); if (!registry) throw new Error("probe never saw session_start"); return { session: s, find: registry.find.bind(registry) }; } function extensionPath(): string { return fileURLToPath(new URL("../index.ts", import.meta.url)); } function costEntry(cost: number, timestamp = Date.now(), id?: string): string { return `${JSON.stringify({ type: "message", ...(id ? { id } : {}), timestamp: new Date(timestamp).toISOString(), message: { role: "assistant", timestamp, usage: { cost: { total: cost } } }, })}\n`; } function monthKey(): string { const now = new Date(); return `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, "0")}`; } describe("cost contract", () => { let session: PiSession | undefined; let root: string | undefined; let statusSpy: MockInstance | undefined; afterEach(async () => { await session?.dispose(); if (root) rmSync(root, { recursive: true, force: true }); session = undefined; root = undefined; statusSpy = undefined; vi.restoreAllMocks(); vi.clearAllMocks(); vi.useRealTimers(); vi.unstubAllEnvs(); }); function sessionDirectory(): string { root = mkdtempSync(path.join(tmpdir(), "pi-cost-test-")); const dir = path.join(root, "project"); mkdirSync(dir); return dir; } function sessionFile(dir: string, name: string, cost: number): string { const file = path.join(dir, `${monthKey()}-${name}.jsonl`); writeFileSync(file, costEntry(cost), "utf8"); return file; } async function start(dir: string): Promise { session = await createPiSession({ extensionFactories: [costExtension] }); const runner = session.session.extensionRunner; const ui = { ...runner.getUIContext() }; statusSpy = vi.spyOn(ui, "setStatus"); runner.setUIContext(ui, "print"); vi.spyOn(session.session.sessionManager, "getSessionDir").mockReturnValue( dir, ); await runner.emit({ type: "session_start", reason: "startup" }); return session; } function statusCalls(): Array<[string, unknown?]> { return (statusSpy?.mock.calls ?? []) as Array<[string, unknown?]>; } function status(): string | undefined { return statusCalls() .filter((call) => call[0] === STATUS_ID) .at(-1)?.[1] as string | undefined; } it("loads in real Pi extension runtime", async () => { session = await createPiSession({ extensionPaths: [extensionPath()] }); expect(session.extensions).toHaveLength(1); }); it("scans every project of the default store but only the configured flat store", async () => { const dir = sessionDirectory(); vi.stubEnv("PI_CODING_AGENT_DIR", root!); const store = path.join(root!, "sessions"); const project = path.join(store, "project-a"); const sibling = path.join(store, "project-b"); mkdirSync(project, { recursive: true }); mkdirSync(sibling); sessionFile(project, "session", 1.25); sessionFile(sibling, "sibling", 2); sessionFile(store, "loose", 50); sessionFile(dir, "session", 3); sessionFile(path.dirname(dir), "foreign", 4); const nested = path.join(dir, "nested"); mkdirSync(nested); sessionFile(nested, "ignored", 100); writeFileSync( path.join(dir, "2000-01-old.jsonl"), costEntry(100, new Date(2000, 0, 1).getTime()), ); writeFileSync(path.join(dir, `${monthKey()}-ignored.txt`), costEntry(100)); await expect(__test.calculateMonthlyCost(project, noModel)).resolves.toBe( 3.25, ); await expect(__test.calculateMonthlyCost(dir, noModel)).resolves.toBe(3); vi.mocked(readdir).mockClear(); await expect( __test.calculateMonthlyCost(dir, noModel, () => false), ).resolves.toBeUndefined(); expect(readdir).not.toHaveBeenCalled(); }); it("marks an empty month as estimated", async () => { const dir = sessionDirectory(); const provenance = vi.fn(); await expect( __test.calculateMonthlyCost( dir, noModel, () => true, new Map(), provenance, ), ).resolves.toBe(0); expect(provenance).toHaveBeenCalledWith(false); }); it("ignores user entries when deciding cost provenance", () => { expect( __test.plainLabel({ usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 }, turnCost: 0, sessionCost: 0, monthlyCost: 0, sessionTotalFromProvider: __test.allCostsFromProvider?.([ { type: "message", message: { role: "user" } }, ]), }), ).not.toContain("≈"); }); it("buckets usage by response time, not the session filename", async () => { vi.useFakeTimers({ toFake: ["Date"] }); vi.setSystemTime(new Date(2026, 1, 10, 12)); const dir = sessionDirectory(); const jan = new Date(2026, 0, 31, 23, 59).getTime(); const feb = new Date(2026, 1, 1, 0, 0).getTime(); writeFileSync( path.join(dir, "2026-01-old-session.jsonl"), costEntry(8, jan) + costEntry(2, feb), ); writeFileSync( path.join(dir, "2026-02-new-session.jsonl"), costEntry(20, jan), ); writeFileSync(path.join(dir, "custom-name.jsonl"), costEntry(3, feb)); await expect(__test.calculateMonthlyCost(dir, noModel)).resolves.toBe(5); }); it("recalculates an unchanged cross-month file at calendar rollover", async () => { vi.useFakeTimers({ toFake: ["Date"] }); vi.setSystemTime(new Date(2026, 0, 31, 12)); const dir = sessionDirectory(); const file = path.join(dir, "2026-01-long-session.jsonl"); writeFileSync( file, costEntry(8, new Date(2026, 0, 31, 10).getTime()) + costEntry(2, new Date(2026, 1, 1, 10).getTime()), ); const cache = new Map(); await expect( __test.calculateMonthlyCost(dir, noModel, () => true, cache), ).resolves.toBe(8); vi.setSystemTime(new Date(2026, 1, 1, 12)); await expect( __test.calculateMonthlyCost(dir, noModel, () => true, cache), ).resolves.toBe(2); }); it("counts copied assistant records once without merging separate responses", async () => { const dir = sessionDirectory(); const copied = costEntry(2, Date.now(), "shared-entry"); writeFileSync( path.join(dir, "original.jsonl"), copied + costEntry(3, Date.now(), "different-entry"), ); writeFileSync(path.join(dir, "fork.jsonl"), copied); const cache = new Map(); for (let scan = 0; scan < 2; scan++) { await expect( __test.calculateMonthlyCost(dir, noModel, () => true, cache), ).resolves.toBe(5); } }); it("includes every persisted native usage record once", async () => { const dir = sessionDirectory(); const timestamp = new Date().toISOString(); const media = { type: "message", id: "media", timestamp, message: { role: "toolResult", toolCallId: "media-call", toolName: "media_generate", usage: { input: 2, cost: { total: 2, totalFromProvider: false } }, }, }; writeFileSync( path.join(dir, "parent.jsonl"), [ { type: "message", id: "assistant", timestamp, message: { role: "assistant", provider: "provider-a", model: "model-a", timestamp: Date.now(), usage: { cost: { total: 1, totalFromProvider: true } }, }, }, media, { type: "usage", id: "standalone", timestamp, kind: "speech", provider: "minimax", model: "speech-2.6-hd", usage: { input: 3, cost: { total: 3, totalFromProvider: false } }, }, { type: "compaction", id: "compaction", timestamp, usage: { input: 4, cost: { total: 4, totalFromProvider: false } }, }, { type: "branch_summary", id: "summary", timestamp, usage: { input: 5, cost: { total: 5, totalFromProvider: false } }, }, ] .map((entry) => JSON.stringify(entry)) .join("\n"), ); writeFileSync( path.join(dir, "child.jsonl"), costEntry(20, Date.now(), "child-assistant"), ); writeFileSync( path.join(dir, "fork.jsonl"), JSON.stringify({ ...media, parentId: "rewritten-by-fork" }), ); const provenance = vi.fn(); await expect( __test.calculateMonthlyCost( dir, noModel, () => true, new Map(), provenance, ), ).resolves.toBe(35); expect(provenance).toHaveBeenLastCalledWith(false); }); it("reuses unchanged subtotals and rereads only new or changed files", async () => { const dir = sessionDirectory(); const file = sessionFile(dir, "parent", 1); sessionFile(dir, "child", 2); const cache = new Map(); const refresh = () => __test.calculateMonthlyCost(dir, noModel, () => true, cache); await expect(refresh()).resolves.toBe(3); expect(readFile).toHaveBeenCalledTimes(2); vi.mocked(readFile).mockClear(); await expect(refresh()).resolves.toBe(3); expect(readFile).not.toHaveBeenCalled(); // Same-size rewrite: modification time must invalidate the subtotal. const before = statSync(file); writeFileSync(file, costEntry(4)); utimesSync(file, before.atime, new Date(before.mtimeMs + 2000)); await expect(refresh()).resolves.toBe(6); expect(readFile).toHaveBeenCalledExactlyOnceWith(file, "utf-8"); // Changed size with unchanged mtime must also invalidate it. vi.mocked(readFile).mockClear(); const modified = statSync(file); appendFileSync(file, costEntry(5)); utimesSync(file, modified.atime, modified.mtime); sessionFile(dir, "new-child", 3); await expect(refresh()).resolves.toBe(14); expect(readFile).toHaveBeenCalledTimes(2); vi.mocked(readFile).mockClear(); rmSync(file); await expect(refresh()).resolves.toBe(5); expect(cache.has(file)).toBe(false); expect(readFile).not.toHaveBeenCalled(); }); it("excludes previous-month response costs on rollover", async () => { vi.useFakeTimers({ toFake: ["Date"] }); vi.setSystemTime(new Date(2026, 0, 31, 12)); const dir = sessionDirectory(); const old = sessionFile(dir, "old", 8); const cache = new Map(); await expect( __test.calculateMonthlyCost(dir, noModel, () => true, cache), ).resolves.toBe(8); vi.setSystemTime(new Date(2026, 1, 1, 12)); const next = sessionFile(dir, "new", 2); await expect( __test.calculateMonthlyCost(dir, noModel, () => true, cache), ).resolves.toBe(2); expect(readFile).toHaveBeenCalledWith(old, "utf-8"); expect(readFile).toHaveBeenCalledWith(next, "utf-8"); }); it("does not cache failed reads or stats, and retries next refresh", async () => { const dir = sessionDirectory(); sessionFile(dir, "session", 2); const cache = new Map(); const refresh = () => __test.calculateMonthlyCost(dir, noModel, () => true, cache); vi.mocked(readFile).mockRejectedValueOnce(new Error("unreadable")); await expect(refresh()).resolves.toBe(0); expect(cache.size).toBe(0); await expect(refresh()).resolves.toBe(2); vi.mocked(stat).mockRejectedValueOnce(new Error("removed during scan")); await expect(refresh()).resolves.toBe(0); expect(cache.size).toBe(0); await expect(refresh()).resolves.toBe(2); }); it("does not commit a scan invalidated during a file read", async () => { const dir = sessionDirectory(); const file = sessionFile(dir, "session", 2); const cache = new Map(); await __test.calculateMonthlyCost(dir, noModel, () => true, cache); const original = cache.get(file); appendFileSync(file, costEntry(3)); let current = true; vi.mocked(readFile).mockImplementationOnce(async () => { current = false; return costEntry(5); }); await expect( __test.calculateMonthlyCost(dir, noModel, () => current, cache), ).resolves.toBeUndefined(); expect(cache.get(file)).toBe(original); }); it("refreshes persisted child costs after agent_end without rereading unchanged files", async () => { const dir = sessionDirectory(); sessionFile(dir, "parent", 1); const s = await start(dir); await vi.waitFor(() => expect(status()).toContain("$1.00")); vi.mocked(readFile).mockClear(); const child = sessionFile(dir, "child", 2); await s.session.extensionRunner.emit({ type: "agent_end", messages: [], }); await vi.waitFor(() => expect(status()).toContain("$3.00")); expect(readFile).toHaveBeenCalledExactlyOnceWith(child, "utf-8"); }); it("coalesces requests during a blocked scan without blocking agent_end", async () => { const dir = sessionDirectory(); sessionFile(dir, "parent", 1); const s = await start(dir); let release!: () => void; const gate = new Promise((resolve) => { release = resolve; }); vi.mocked(readFile).mockClear(); vi.mocked(readFile).mockImplementationOnce(async () => { await gate; return costEntry(1); }); try { await vi.waitFor(() => expect(readFile).toHaveBeenCalledOnce()); vi.mocked(readdir).mockClear(); sessionFile(dir, "child", 2); for (let i = 0; i < 3; i++) { await s.session.extensionRunner.emit({ type: "agent_end", messages: [], }); } expect(readdir).not.toHaveBeenCalled(); } finally { release(); } await vi.waitFor(() => expect(status()).toContain("$3.00")); expect(readFile).toHaveBeenCalledTimes(2); // One follow-up scan of the configured flat store. expect(readdir).toHaveBeenCalledOnce(); }); it.each(["shutdown", "replacement"])( "discards an in-flight monthly result on session %s", async (event) => { const dir = sessionDirectory(); sessionFile(dir, "parent", 9); const s = await start(dir); let release!: () => void; const gate = new Promise((resolve) => { release = resolve; }); vi.mocked(readFile).mockClear(); vi.mocked(readFile).mockImplementationOnce(async () => { await gate; return costEntry(9); }); let callsAfterShutdown = 0; try { await vi.waitFor(() => expect(readFile).toHaveBeenCalledOnce()); await s.session.extensionRunner.emit({ type: "session_shutdown", reason: "quit", }); callsAfterShutdown = statusCalls().length; if (event === "replacement") { const nextDir = path.join(dir, "separate-root", "project"); mkdirSync(nextDir, { recursive: true }); sessionFile(nextDir, "replacement", 2); vi.spyOn(s.session.sessionManager, "getSessionDir").mockReturnValue( nextDir, ); await s.session.extensionRunner.emit({ type: "session_start", reason: "reload", }); } } finally { release(); } if (event === "replacement") { await vi.waitFor(() => expect(status()).toContain("$2.00")); } else { await new Promise((resolve) => setTimeout(resolve, 20)); expect(statusCalls()).toHaveLength(callsAfterShutdown); } expect( statusCalls().some((call) => String(call[1]).includes("$9.00")), ).toBe(false); }, ); it("keeps full-session spending after switching to an earlier branch", async () => { const dir = sessionDirectory(); const s = await start(dir); const manager = s.session.sessionManager; const response = (cost: number) => ({ ...fauxAssistantMessage("response"), usage: { input: 10, output: 2, cacheRead: 0, cacheWrite: 0, totalTokens: 12, cost: { input: cost, output: 0, cacheRead: 0, cacheWrite: 0, total: cost, }, }, }); const first = manager.appendMessage(response(1)); manager.appendMessage(response(2)); manager.appendUsage("cache_warm", "fixture", "model", response(3).usage); manager.branch(first); await s.session.extensionRunner.emit({ type: "agent_end", messages: [] }); expect(status()).toContain("session ≈$6.00"); }); it("shows a nonzero calendar-month figure even when lifetime session cost is higher", () => { const label = __test.plainLabel({ usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 }, turnCost: 0, sessionCost: 8, monthlyCost: 2, }); expect(label).toContain("session ≈$8.00"); expect(label).toContain("month ≈$2.00"); }); it.each([ { flag: true, estimated: false }, { flag: false, estimated: true }, { flag: undefined, estimated: true }, ])( "preserves session and monthly provenance with historical flag $flag", async ({ flag, estimated }) => { const dir = sessionDirectory(); const s = await start(dir); const manager = s.session.sessionManager; const response = ( total: number, totalFromProvider: boolean | undefined, ) => ({ ...fauxAssistantMessage("response"), usage: { input: 1, output: 1, cacheRead: 0, cacheWrite: 0, totalTokens: 2, cost: { input: 99, output: 99, cacheRead: 0, cacheWrite: 0, total, ...(totalFromProvider === undefined ? {} : { totalFromProvider }), }, }, }); manager.appendMessage(response(1, true)); manager.appendMessage(response(2, flag)); writeFileSync( path.join(dir, "provenance.jsonl"), [response(1, true), response(3, flag)] .map((message) => JSON.stringify({ type: "message", timestamp: new Date().toISOString(), message, }), ) .join("\n"), ); await s.session.extensionRunner.emit({ type: "agent_end", messages: [] }); expect(status()).toContain(`session ${estimated ? "≈" : ""}$3.00`); await vi.waitFor(() => expect(status()).toContain(`month ${estimated ? "≈" : ""}$4.00`), ); const provenance = vi.fn(); const cache = new Map(); await expect( __test.calculateMonthlyCost( dir, noModel, () => true, cache, provenance, ), ).resolves.toBe(4); expect(provenance).toHaveBeenLastCalledWith(!estimated); await expect( __test.calculateMonthlyCost( dir, noModel, () => true, cache, provenance, ), ).resolves.toBe(4); expect(provenance).toHaveBeenLastCalledWith(!estimated); }, ); it("counts zero-cost historical native usage as estimated without contaminating assistant-only monthly totals", async () => { const dir = sessionDirectory(); const s = await start(dir); const assistant = { ...fauxAssistantMessage("billed"), usage: { input: 1, output: 1, cacheRead: 0, cacheWrite: 0, totalTokens: 2, cost: { input: 100, output: 100, cacheRead: 0, cacheWrite: 0, total: 2, totalFromProvider: true, }, }, }; const manager = s.session.sessionManager; manager.appendMessage(assistant); manager.appendUsage("cache_warm", "fixture", "model", { ...assistant.usage, cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 }, }); writeFileSync( path.join(dir, "assistant.jsonl"), JSON.stringify({ type: "message", timestamp: new Date().toISOString(), message: assistant, }), ); await s.session.extensionRunner.emit({ type: "agent_end", messages: [] }); expect(status()).toContain("session ≈$2.00"); const provenance = vi.fn(); await expect( __test.calculateMonthlyCost( dir, noModel, () => true, new Map(), provenance, ), ).resolves.toBe(2); expect(provenance).toHaveBeenCalledWith(true); }); it("honors provider-reported zero without losing unbilled catalog fallback", async () => { const probe = await registryFind(); session = probe.session; const lookup = vi.fn(probe.find); const entry = (totalFromProvider?: boolean) => ({ type: "message", message: { role: "assistant", provider: "zai", model: "glm-4.7", usage: { input: 1_000_000, cost: { total: 0, totalFromProvider } }, }, }); expect(__test.sumMessageCosts([entry(true)], lookup)).toBe(0); expect(lookup).not.toHaveBeenCalled(); expect(__test.sumMessageCosts([entry(false)], lookup)).toBeGreaterThan(0); expect(__test.sumMessageCosts([entry()], lookup)).toBeGreaterThan(0); }); it("prices concrete responders before requested models without overriding recorded billing", async () => { const probe = await registryFind(); session = probe.session; const base = probe.find("zai", "glm-4.7")!; const lookup = vi.fn((_provider: string, id: string) => id === "concrete" || id === "requested" ? { ...base, id, cost: { input: id === "concrete" ? 2 : 7, output: 0, cacheRead: 0, cacheWrite: 0, }, } : undefined, ); const entry = ( responseModel?: string, total = 0, totalFromProvider?: boolean, ) => ({ type: "message", message: { role: "assistant", provider: "router", model: "requested", responseModel, usage: { input: 1_000_000, cost: { total, totalFromProvider } }, }, }); expect(__test.sumMessageCosts([entry("concrete")], lookup)).toBe(2); expect(__test.sumMessageCosts([entry("unknown")], lookup)).toBe(7); expect(__test.sumMessageCosts([entry()], lookup)).toBe(7); expect(__test.sumMessageCosts([entry("")], lookup)).toBe(7); lookup.mockClear(); expect(__test.sumMessageCosts([entry("concrete", 0, true)], lookup)).toBe( 0, ); expect(__test.sumMessageCosts([entry("concrete", 3)], lookup)).toBe(3); expect(lookup).not.toHaveBeenCalled(); expect(__test.sumMessageCosts([entry("unknown")], noModel)).toBe(0); const dir = sessionDirectory(); writeFileSync( path.join(dir, "routed.jsonl"), [ entry("concrete"), entry("unknown"), entry("concrete", 0, true), { type: "usage", provider: "router", model: "requested", kind: "cache_warm", usage: { input: 5, cost: { total: 4, totalFromProvider: true } }, }, ] .map((row) => JSON.stringify({ ...row, timestamp: new Date().toISOString() }), ) .join("\n"), ); await expect(__test.calculateMonthlyCost(dir, lookup)).resolves.toBe(13); }); it("prices zero-cost assistant messages from the model catalog", async () => { const probe = await registryFind(); session = probe.session; const findModel = probe.find; const model = findModel("zai", "glm-4.7"); expect(model?.cost.input).toBeGreaterThan(0); const usage = { input: 1_000_000, output: 0, cacheRead: 0, cacheWrite: 0 }; const entries = [ { type: "message", message: { role: "assistant", provider: "zai", model: "glm-4.7", usage, }, }, { type: "message", message: { role: "assistant", provider: "nobody", model: "unknown", usage, }, }, { type: "message", message: { role: "assistant", provider: "zai", model: "glm-4.7", usage: { ...usage, cost: { total: 0.5 } }, }, }, ]; expect(__test.sumMessageCosts(entries, findModel)).toBeCloseTo( (model?.cost.input ?? Number.NaN) + 0.5, ); expect(__test.sumMessageCosts(entries, noModel)).toBe(0.5); }); it("publishes native tool and standalone usage in the footer", async () => { const dir = sessionDirectory(); const s = await start(dir); const manager = s.session.sessionManager; const usage = { input: 1, output: 0, cacheRead: 0, cacheWrite: 0, totalTokens: 1, cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 1 }, }; manager.appendMessage({ role: "toolResult", toolCallId: "media", toolName: "media_generate", content: [], isError: false, timestamp: Date.now(), usage, }); manager.appendUsage("speech", "minimax", "speech-2.6-hd", { ...usage, cost: { ...usage.cost, total: 2 }, }); manager.appendCompaction("summary", null, 0, undefined, false, { ...usage, cost: { ...usage.cost, total: 3 }, }); await s.session.extensionRunner.emit({ type: "agent_end", messages: [] }); expect(status()).toContain("session ≈$6.00"); }); it("includes every native usage-bearing entry in session costs and tokens", () => { const entries = [ { type: "message", message: { role: "assistant", usage: { input: 1, cost: { total: 1 } } }, }, { type: "message", message: { role: "toolResult", usage: { input: 2, cost: { total: 2 } }, }, }, { type: "compaction", usage: { input: 3, cost: { total: 3 } } }, { type: "branch_summary", usage: { input: 4, cost: { total: 4 } } }, { type: "usage", kind: "future-kind", usage: { input: 5, cost: { total: 5 } }, }, { type: "message", message: { role: "user", usage: { input: 99, cost: { total: 99 } } }, }, ]; expect(__test.sumMessageCosts(entries, noModel)).toBe(15); expect(__test.sessionUsage(entries).input).toBe(15); }); it("charges cache writes through the catalog", async () => { const probe = await registryFind(); session = probe.session; const findModel = probe.find; const model = findModel("anthropic", "claude-haiku-4-5"); expect(model?.cost.cacheWrite).toBeGreaterThan(0); const entries = [ { type: "message", message: { role: "assistant", provider: "anthropic", model: "claude-haiku-4-5", usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 1_000_000 }, }, }, ]; expect(__test.sumMessageCosts(entries, findModel)).toBeCloseTo( model?.cost.cacheWrite ?? Number.NaN, ); }); it("sums session usage from native usage-bearing entries", () => { expect( __test.sessionUsage([ { type: "message", message: { role: "assistant", usage: { input: 100, output: 20, cacheRead: 300 }, }, }, { type: "message", message: { role: "toolResult", usage: { input: 10, output: 5 } }, }, { type: "compaction", usage: { input: 50, cacheWrite: 40 } }, { type: "branch_summary", usage: { output: 7 } }, { type: "message", message: { role: "user", usage: { input: 999 } } }, ]), ).toEqual({ input: 160, output: 32, cacheRead: 300, cacheWrite: 40 }); }); it("uses the latest assistant prompt for cache hit rate", () => { expect( __test.latestAssistantCacheHitRate([ { type: "message", message: { role: "assistant", usage: { input: 90, cacheRead: 10 } }, }, { type: "message", message: { role: "assistant", usage: { input: 10, cacheRead: 80, cacheWrite: 10 }, }, }, ]), ).toBe(80); }); it("shows only input, output, and cache hit rate in the tui label", () => { expect( __test.tokenLabel( { input: 1100, output: 978, cacheRead: 108900, cacheWrite: 2100, }, 98, ), ).toBe("↑1.1k ↓978  98%"); }); it("scales large token counts into millions", () => { expect( __test.tokenLabel( { input: 1_618_000, output: 448_000, cacheRead: 0, cacheWrite: 0 }, 100, ), ).toBe("↑1.6M ↓448k  100%"); }); it("spells out the non-tui label without glyphs", () => { expect( __test.plainLabel({ usage: { input: 1_618_000, output: 448_000, cacheRead: 121_527_000, cacheWrite: 1_381_000, }, cacheHitRate: 100, turnCost: 0.16, sessionCost: 70.7, monthlyCost: 3146.2, }), ).toBe( "in 1.6M, out 448k, cache hit 100%, turn ≈$0.16, session ≈$70.7, month ≈$3.1k", ); }); });