repositories / pi-ext
pi-ext
bugabingas pi extensions
owned by admin
extensions/cost/__tests__/contract.test.ts
Rawimport {
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<typeof import("node:fs/promises")>();
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<PiSession> {
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<void>((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<void>((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",
);
});
});