pi-mono-all 1.0.0

package/node_modules/pi-mono-team-mode/__tests__/agent-manager-transient.test.ts

@@ -0,0 +1,75 @@
+import assert from "node:assert/strict";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { describe, test } from "node:test";
+
+import { TeamMateStore } from "../core/store.ts";
+import { AgentManager } from "../managers/agent-manager.ts";
+
+async function withManager(fn: (manager: AgentManager, store: TeamMateStore) => Promise<void>) {
+	const root = await mkdtemp(path.join(tmpdir(), "team-mode-test-"));
+	try {
+		const store = new TeamMateStore(root);
+		const manager = new AgentManager({
+			store,
+			getParentSessionId: () => "parent",
+			getDefaultCwd: () => process.cwd(),
+			runTransientSession: async (opts) => ({
+				teammateId: opts.id,
+				name: opts.name,
+				description: opts.description,
+				status: "completed",
+				result: `TRANSIENT:${opts.message}`,
+				exitCode: 0,
+				provider: opts.provider,
+				model: opts.model,
+				thinkingLevel: opts.thinkingLevel,
+				modelRationale: opts.modelRationale,
+				runtime: "transient",
+			}),
+		});
+		await fn(manager, store);
+	} finally {
+		await rm(root, { recursive: true, force: true });
+	}
+}
+
+describe("AgentManager transient runtime", () => {
+	test("routes transient spawn without durable teammate record", async () => {
+		await withManager(async (manager, store) => {
+			const result = await manager.spawn({
+				description: "quick scan",
+				prompt: "Summarize files",
+				runtime: "transient",
+			});
+
+			assert.equal(result.status, "completed");
+			assert.equal(result.runtime, "transient");
+			assert.match(result.result, /Task: quick scan/);
+			assert.deepEqual(await store.listTeammates(), []);
+			assert.deepEqual(await store.getNameIndex("parent"), {});
+		});
+	});
+
+	test("rejects transient-incompatible options", async () => {
+		await withManager(async (manager) => {
+			await assert.rejects(
+				() => manager.spawn({ description: "x", prompt: "p", runtime: "transient", isolation: "worktree" }),
+				/does not support isolation "worktree"/,
+			);
+			await assert.rejects(
+				() => manager.spawn({ description: "x", prompt: "p", runtime: "transient", background: true }),
+				/does not support run_in_background/,
+			);
+			await assert.rejects(
+				() => manager.spawn({ description: "x", prompt: "p", runtime: "transient", teamId: "team-1" }),
+				/does not support team_name/,
+			);
+			await assert.rejects(
+				() => manager.spawn({ description: "x", prompt: "p", runtime: "transient", name: "later" }),
+				/does not support name/,
+			);
+		});
+	});
+});

package/node_modules/pi-mono-team-mode/__tests__/delegation-manager.test.ts

@@ -0,0 +1,118 @@
+import assert from "node:assert/strict";
+import { describe, test } from "node:test";
+
+import { DelegationManager } from "../managers/delegation-manager.ts";
+
+type SpawnCall = {
+	description: string;
+	prompt: string;
+	name?: string;
+	thinkingLevel?: string;
+	runtime?: string;
+};
+
+function makeFakeAgents() {
+	const calls: SpawnCall[] = [];
+	let queued = 0;
+	let idx = 0;
+	return {
+		calls,
+		get queued() {
+			return queued;
+		},
+		setQueuedCount(value: number) {
+			queued = value;
+		},
+		async spawn(opts: SpawnCall & Record<string, unknown>) {
+			calls.push(opts);
+			idx += 1;
+			return {
+				teammateId: `agent-${idx}`,
+				name: opts.name ?? `agent-${idx}`,
+				description: opts.description,
+				status: "completed" as const,
+				result: `RESULT:${opts.prompt}`,
+				exitCode: 0,
+			};
+		},
+	};
+}
+
+describe("DelegationManager", () => {
+	test("runParallel expands count and aggregates", async () => {
+		const fake = makeFakeAgents();
+		const manager = new DelegationManager(fake as never);
+		const result = await manager.runParallel({
+			tasks: [{ description: "scan", prompt: "P", name: "worker", count: 2, thinkingLevel: "low" }],
+			concurrency: 2,
+		});
+		assert.equal(result.mode, "parallel");
+		assert.equal(result.steps, 2);
+		assert.equal(fake.calls.length, 2);
+		assert.equal(fake.calls[0]?.name, "worker-1");
+		assert.equal(fake.calls[1]?.name, "worker-2");
+		assert.equal(fake.calls[0]?.thinkingLevel, "low");
+		assert.match(result.output, /Parallel Task 1/);
+	});
+
+	test("runChain applies templates and chain_dir files", async () => {
+		const fake = makeFakeAgents();
+		const manager = new DelegationManager(fake as never);
+		const result = await manager.runChain({
+			task: "TOP",
+			chain: [
+				{
+					description: "one",
+					prompt: "Task={task}",
+					output: "step1.txt",
+				},
+				{
+					description: "two",
+					reads: ["step1.txt"],
+					prompt: "Prev={previous}",
+				},
+			],
+		});
+		assert.equal(result.mode, "chain");
+		assert.ok(result.chainDir);
+		assert.equal(fake.calls.length, 2);
+		assert.match(fake.calls[0]?.prompt ?? "", /Task=TOP/);
+		assert.match(fake.calls[1]?.prompt ?? "", /--- step1\.txt ---/);
+		assert.match(fake.calls[1]?.prompt ?? "", /RESULT:Task=TOP/);
+	});
+
+	test("runParallel applies top-level transient runtime and task overrides", async () => {
+		const fake = makeFakeAgents();
+		const manager = new DelegationManager(fake as never);
+		await manager.runParallel({
+			runtime: "transient",
+			tasks: [
+				{ description: "fast", prompt: "P1" },
+				{ description: "durable", prompt: "P2", runtime: "subprocess" },
+			],
+		});
+		assert.equal(fake.calls[0]?.runtime, "transient");
+		assert.equal(fake.calls[1]?.runtime, "subprocess");
+	});
+
+	test("runChain forwards transient runtime to chain and parallel steps", async () => {
+		const fake = makeFakeAgents();
+		const manager = new DelegationManager(fake as never);
+		await manager.runChain({
+			task: "TOP",
+			runtime: "transient",
+			chain: [
+				{ description: "one", prompt: "P1" },
+				{
+					parallel: [
+						{ description: "two", prompt: "P2" },
+						{ description: "three", prompt: "P3", runtime: "subprocess" },
+					],
+				},
+			],
+		});
+		assert.equal(fake.calls[0]?.runtime, "transient");
+		assert.equal(fake.calls[1]?.runtime, "transient");
+		assert.equal(fake.calls[2]?.runtime, "subprocess");
+	});
+});

package/node_modules/pi-mono-team-mode/__tests__/formatters.test.ts

@@ -0,0 +1,104 @@
+/**
+ * Pi Team-Mode — Formatter Tests (pure functions, no I/O)
+ */
+
+import assert from "node:assert/strict";
+import { describe, test } from "node:test";
+
+import {
+	formatTeamDashboard,
+	formatTeammateLine,
+	formatTeammateList,
+	formatTeammateStatus,
+} from "../ui/formatters.ts";
+import type { TeamRecord, TeammateRecord } from "../core/types.ts";
+
+function tm(overrides: Partial<TeammateRecord> = {}): TeammateRecord {
+	return {
+		id: "researcher-abc",
+		name: "researcher",
+		isolation: "none",
+		cwd: "/tmp",
+		status: "running",
+		background: false,
+		createdAt: "2026-04-23T00:00:00Z",
+		updatedAt: "2026-04-23T00:00:00Z",
+		...overrides,
+	};
+}
+
+function tm2(): TeamRecord {
+	return {
+		id: "billing-abc",
+		name: "billing",
+		createdAt: "2026-04-23T00:00:00Z",
+		defaultIsolation: "worktree",
+	};
+}
+
+describe("formatTeammateLine", () => {
+	test("includes name, status icon, role, team, isolation", () => {
+		const line = formatTeammateLine(
+			tm({ subagentType: "researcher", teamId: "billing-abc", isolation: "worktree" }),
+		);
+		assert.match(line, /researcher/);
+		assert.match(line, /\[researcher\]/);
+		assert.match(line, /team=billing-abc/);
+		assert.match(line, /wt/);
+	});
+
+	test("running shows ▸ icon", () => {
+		assert.match(formatTeammateLine(tm({ status: "running" })), /▸/);
+	});
+
+	test("completed shows ✓ icon", () => {
+		assert.match(formatTeammateLine(tm({ status: "completed" })), /✓/);
+	});
+
+	test("failed shows ✗ icon", () => {
+		assert.match(formatTeammateLine(tm({ status: "failed" })), /✗/);
+	});
+});
+
+describe("formatTeammateList", () => {
+	test("empty list shows placeholder", () => {
+		assert.equal(formatTeammateList([]), "No teammates.");
+	});
+
+	test("renders each teammate on its own line", () => {
+		const out = formatTeammateList([tm({ name: "a" }), tm({ name: "b" })]);
+		assert.equal(out.split("\n").length, 2);
+	});
+});
+
+describe("formatTeamDashboard", () => {
+	test("groups teammates under their team", () => {
+		const out = formatTeamDashboard(
+			[tm2()],
+			[tm({ teamId: "billing-abc", name: "writer" })],
+		);
+		assert.match(out, /Teams:/);
+		assert.match(out, /billing/);
+		assert.match(out, /writer/);
+	});
+
+	test("shows unassigned teammates separately", () => {
+		const out = formatTeamDashboard([], [tm({ name: "orphan" })]);
+		assert.match(out, /Unassigned teammates:/);
+		assert.match(out, /orphan/);
+	});
+
+	test("empty state", () => {
+		assert.match(formatTeamDashboard([], []), /No teams and no teammates\./);
+	});
+});
+
+describe("formatTeammateStatus", () => {
+	test("prints multi-line status block", () => {
+		const out = formatTeammateStatus(tm({ lastExitCode: 0, lastResult: "done" }));
+		assert.match(out, /Teammate: researcher/);
+		assert.match(out, /Status: running/);
+		assert.match(out, /Last exit: 0/);
+		assert.match(out, /Last result:\ndone/);
+	});
+});

package/node_modules/pi-mono-team-mode/__tests__/model-config.test.ts

@@ -0,0 +1,272 @@
+/**
+ * Pi Team-Mode — Model Config Tests
+ *
+ * Covers loadModelConfig / resolveModel / detectProvider and asserts the
+ * exact shape the user keeps at ~/.pi/agent/extensions/team-mode/model-config.json
+ * resolves to openai-codex/gpt-5.4-{mini,regular,:high} by role/tier.
+ */
+
+import assert from "node:assert/strict";
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { describe, test } from "node:test";
+
+import {
+	DEFAULT_MODEL_CONFIG,
+	detectProvider,
+	isModelTier,
+	loadModelConfig,
+	modelConfigPath,
+	resolveModel,
+	saveModelConfig,
+	type ModelConfig,
+} from "../core/model-config.ts";
+
+function withEnv<T>(patch: NodeJS.ProcessEnv, fn: () => T): T {
+	const prev: NodeJS.ProcessEnv = {};
+	for (const k of Object.keys(patch)) {
+		prev[k] = process.env[k];
+		if (patch[k] === undefined) delete process.env[k];
+		else process.env[k] = patch[k];
+	}
+	try {
+		return fn();
+	} finally {
+		for (const k of Object.keys(patch)) {
+			if (prev[k] === undefined) delete process.env[k];
+			else process.env[k] = prev[k];
+		}
+	}
+}
+
+const USER_CONFIG: ModelConfig = {
+	provider: "openai-codex",
+	providers: {
+		anthropic: {
+			cheap: "anthropic/claude-haiku-4-5",
+			mid: "anthropic/claude-sonnet-4-6",
+			deep: "anthropic/claude-opus-4-7:high",
+		},
+		"openai-codex": {
+			cheap: "openai-codex/gpt-5.4-mini",
+			mid: "openai-codex/gpt-5.4",
+			deep: "openai-codex/gpt-5.4:high",
+		},
+	},
+	tiers: {
+		...DEFAULT_MODEL_CONFIG.tiers,
+		cheap: { name: "Cheap", thinkingLevel: "minimal" },
+		mid: { name: "Mid", thinkingLevel: "medium" },
+		deep: { name: "Deep", thinkingLevel: "high" },
+	},
+	roles: {
+		...DEFAULT_MODEL_CONFIG.roles,
+		researcher: "cheap",
+		docs: "cheap",
+		backend: "mid",
+		frontend: "mid",
+		tester: "mid",
+		planner: "deep",
+		reviewer: "deep",
+		leader: "mid",
+	},
+	roleTiers: {
+		researcher: "cheap",
+		docs: "cheap",
+		backend: "mid",
+		frontend: "mid",
+		tester: "mid",
+		planner: "deep",
+		reviewer: "deep",
+		leader: "mid",
+	},
+	defaultTier: "mid",
+	defaultThinkingLevel: undefined,
+	tierThinkingLevels: {
+		...(DEFAULT_MODEL_CONFIG.tierThinkingLevels ?? {}),
+		cheap: "minimal",
+		mid: "medium",
+		deep: "high",
+	},
+	roleThinkingLevels: {},
+};
+
+describe("isModelTier", () => {
+	test("accepts the three tiers", () => {
+		assert.equal(isModelTier("cheap"), true);
+		assert.equal(isModelTier("mid"), true);
+		assert.equal(isModelTier("deep"), true);
+	});
+
+	test("rejects anything else", () => {
+		assert.equal(isModelTier("MID"), false);
+		assert.equal(isModelTier("fast"), false);
+		assert.equal(isModelTier(""), false);
+	});
+});
+
+describe("loadModelConfig / saveModelConfig", () => {
+	test("round-trips a config to disk", async () => {
+		const dir = await mkdtemp(join(tmpdir(), "team-mode-cfg-"));
+		try {
+			await saveModelConfig(USER_CONFIG, dir);
+			const loaded = await loadModelConfig(dir);
+			assert.deepEqual(loaded, USER_CONFIG);
+		} finally {
+			await rm(dir, { recursive: true, force: true });
+		}
+	});
+
+	test("returns defaults when config file is missing", async () => {
+		const dir = await mkdtemp(join(tmpdir(), "team-mode-cfg-"));
+		try {
+			const loaded = await loadModelConfig(dir);
+			assert.deepEqual(loaded, DEFAULT_MODEL_CONFIG);
+		} finally {
+			await rm(dir, { recursive: true, force: true });
+		}
+	});
+
+	test("merges partial config with defaults", async () => {
+		const dir = await mkdtemp(join(tmpdir(), "team-mode-cfg-"));
+		try {
+			await writeFile(
+				modelConfigPath(dir),
+				JSON.stringify({ provider: "openai-codex", defaultTier: "cheap" }),
+				"utf8",
+			);
+			const loaded = await loadModelConfig(dir);
+			assert.equal(loaded.provider, "openai-codex");
+			assert.equal(loaded.defaultTier, "cheap");
+			// defaults are still there
+			assert.equal(loaded.roleTiers.researcher, "cheap");
+			assert.ok(loaded.providers.anthropic);
+		} finally {
+			await rm(dir, { recursive: true, force: true });
+		}
+	});
+
+	test("accepts compact tiers/roles config", async () => {
+		const dir = await mkdtemp(join(tmpdir(), "team-mode-cfg-"));
+		try {
+			await writeFile(
+				modelConfigPath(dir),
+				JSON.stringify({
+					provider: "openai-codex",
+					defaultTier: "md",
+					tiers: {
+						sm: { name: "Small", thinkingLevel: "low" },
+						md: { name: "Medium", thinkingLevel: "medium" },
+						lg: { name: "Large", thinkingLevel: "high" },
+					},
+					roles: {
+						researcher: "sm",
+						backend: "md",
+						planner: "lg",
+					},
+				}),
+				"utf8",
+			);
+			const loaded = await loadModelConfig(dir);
+			assert.equal(loaded.roles.researcher, "sm");
+			assert.equal(loaded.tiers.sm?.thinkingLevel, "low");
+			const resolved = resolveModel(loaded, "planner");
+			assert.ok(resolved);
+			assert.equal(resolved.tier, "lg");
+			assert.equal(resolved.model, "gpt-5.4");
+			assert.equal(resolved.thinkingLevel, "high");
+		} finally {
+			await rm(dir, { recursive: true, force: true });
+		}
+	});
+});
+
+describe("resolveModel — user's real config", () => {
+	test("researcher → openai-codex/gpt-5.4-mini", () => {
+		const resolved = resolveModel(USER_CONFIG, "researcher");
+		assert.ok(resolved);
+		assert.equal(resolved.provider, "openai-codex");
+		assert.equal(resolved.model, "gpt-5.4-mini");
+		assert.equal(resolved.tier, "cheap");
+		assert.match(resolved.rationale, /researcher/);
+	});
+
+	test("backend → openai-codex/gpt-5.4", () => {
+		const resolved = resolveModel(USER_CONFIG, "backend");
+		assert.ok(resolved);
+		assert.equal(resolved.model, "gpt-5.4");
+		assert.equal(resolved.tier, "mid");
+	});
+
+	test("reviewer → openai-codex/gpt-5.4 with high thinking (deep)", () => {
+		const resolved = resolveModel(USER_CONFIG, "reviewer");
+		assert.ok(resolved);
+		assert.equal(resolved.model, "gpt-5.4");
+		assert.equal(resolved.tier, "deep");
+		assert.equal(resolved.thinkingLevel, "high");
+	});
+
+	test("roleThinkingLevels overrides tier defaults", () => {
+		const resolved = resolveModel(
+			{
+				...USER_CONFIG,
+				roleThinkingLevels: { reviewer: "xhigh" },
+			},
+			"reviewer",
+		);
+		assert.ok(resolved);
+		assert.equal(resolved.model, "gpt-5.4");
+		assert.equal(resolved.thinkingLevel, "xhigh");
+	});
+
+	test("unknown role falls back to defaultTier (mid)", () => {
+		const resolved = resolveModel(USER_CONFIG, "unknown-role");
+		assert.ok(resolved);
+		assert.equal(resolved.tier, "mid");
+		assert.match(resolved.rationale, /default tier/);
+	});
+
+	test("tierOverride wins over role", () => {
+		const resolved = resolveModel(USER_CONFIG, "reviewer", "cheap");
+		assert.ok(resolved);
+		assert.equal(resolved.tier, "cheap");
+		assert.equal(resolved.model, "gpt-5.4-mini");
+		assert.match(resolved.rationale, /override/);
+	});
+
+	test("returns null when resolved provider has no catalog", () => {
+		const noOpenAI: ModelConfig = {
+			...USER_CONFIG,
+			provider: "missing-provider",
+		};
+		assert.equal(resolveModel(noOpenAI, "backend"), null);
+	});
+});
+
+describe("detectProvider", () => {
+	test("explicit non-auto wins", () => {
+		assert.equal(detectProvider("anthropic"), "anthropic");
+		assert.equal(detectProvider("openai-codex"), "openai-codex");
+	});
+
+	test("auto consults PI_TEAM_MATE_MODEL_PROVIDER env", () => {
+		withEnv({ PI_TEAM_MATE_MODEL_PROVIDER: "openai-codex" }, () => {
+			assert.equal(detectProvider("auto"), "openai-codex");
+		});
+	});
+
+	test("auto falls through to anthropic when nothing is configured", () => {
+		withEnv(
+			{
+				PI_TEAM_MATE_MODEL_PROVIDER: undefined,
+				PI_CODING_AGENT_DIR: "/tmp/nonexistent-dir-for-test",
+				ANTHROPIC_API_KEY: undefined,
+				OPENAI_API_KEY: undefined,
+			},
+			() => {
+				assert.equal(detectProvider("auto"), "anthropic");
+			},
+		);
+	});
+});

package/node_modules/pi-mono-team-mode/__tests__/notification-box.test.ts

@@ -0,0 +1,34 @@
+import assert from "node:assert/strict";
+import { describe, test } from "node:test";
+
+import { renderTaskNotification } from "../ui/notification-box.ts";
+
+describe("renderTaskNotification", () => {
+	const theme = {
+		fg: (_c: string, text: string) => text,
+		bg: (_c: string, text: string) => text,
+		bold: (text: string) => text,
+	} as never;
+
+	test("returns undefined when details are missing", () => {
+		const out = renderTaskNotification({ content: "x" }, { expanded: false }, theme);
+		assert.equal(out, undefined);
+	});
+
+	test("returns a component when details exist", () => {
+		const out = renderTaskNotification(
+			{
+				content: "Result text",
+				details: {
+					taskId: "agent-1",
+					status: "completed",
+					durationMs: 1500,
+					summary: "done",
+				},
+			},
+			{ expanded: false },
+			theme,
+		);
+		assert.ok(out);
+	});
+});

package/node_modules/pi-mono-team-mode/__tests__/parallel-utils.test.ts

@@ -0,0 +1,32 @@
+import assert from "node:assert/strict";
+import { describe, test } from "node:test";
+
+import { aggregateParallelOutputs, mapConcurrent } from "../core/parallel-utils.ts";
+
+describe("mapConcurrent", () => {
+	test("keeps result order while limiting concurrency", async () => {
+		let running = 0;
+		let maxRunning = 0;
+		const out = await mapConcurrent([30, 10, 20], 2, async (ms, idx) => {
+			running += 1;
+			maxRunning = Math.max(maxRunning, running);
+			await new Promise((resolve) => setTimeout(resolve, ms));
+			running -= 1;
+			return `#${idx}`;
+		});
+		assert.deepEqual(out, ["#0", "#1", "#2"]);
+		assert.ok(maxRunning <= 2);
+	});
+});
+
+describe("aggregateParallelOutputs", () => {
+	test("renders per-task sections", () => {
+		const text = aggregateParallelOutputs([
+			{ name: "one", output: "A", exitCode: 0 },
+			{ name: "two", output: "B", exitCode: 1, error: "boom" },
+		]);
+		assert.match(text, /Parallel Task 1 \(one\)/);
+		assert.match(text, /Parallel Task 2 \(two\)/);
+		assert.match(text, /error: boom/);
+	});
+});

package/node_modules/pi-mono-team-mode/__tests__/pi-stream-parser.test.ts

@@ -0,0 +1,64 @@
+import assert from "node:assert/strict";
+import { describe, test } from "node:test";
+
+import { PiStreamParser } from "../runtime/pi-stream-parser.ts";
+
+describe("PiStreamParser", () => {
+	test("handles split JSON chunks", () => {
+		const parser = new PiStreamParser();
+		const first = parser.push('{"type":"message_update","assistantMessageEvent":{"type":"text_delta","text":"Hel');
+		assert.equal(first.length, 0);
+		const second = parser.push('lo"}}\n');
+		assert.deepEqual(second, [{ type: "assistant_delta", text: "Hello" }]);
+	});
+
+	test("ignores non-json lines", () => {
+		const parser = new PiStreamParser();
+		const events = parser.push("plain text\n{\"type\":\"turn_end\"}\n");
+		assert.deepEqual(events, [{ type: "turn_end" }]);
+	});
+
+	test("maps assistant message usage + tool events", () => {
+		const parser = new PiStreamParser();
+		const input = [
+			JSON.stringify({ type: "tool_execution_start", toolName: "Read", args: { path: "a.ts" } }),
+			JSON.stringify({ type: "tool_execution_end", toolName: "Read", result: "ok" }),
+			JSON.stringify({
+				type: "message_end",
+				message: {
+					role: "assistant",
+					content: [{ type: "text", text: "Done" }],
+					usage: { totalTokens: 42 },
+				},
+			}),
+		].join("\n");
+		const events = parser.push(`${input}\n`);
+		assert.equal(events[0]?.type, "tool_start");
+		assert.equal(events[1]?.type, "tool_end");
+		assert.equal(events[2]?.type, "assistant_message");
+		if (events[2]?.type !== "assistant_message") return;
+		assert.equal(events[2].text, "Done");
+		assert.equal(events[2].usage?.totalTokens, 42);
+	});
+
+	test("maps tool-only assistant messages so tool-use turns count", () => {
+		const parser = new PiStreamParser();
+		const events = parser.push(
+			`${JSON.stringify({
+				type: "message_end",
+				message: {
+					role: "assistant",
+					content: [{ type: "toolCall", id: "call_1", name: "read", arguments: { path: "a.ts" } }],
+					usage: { input: 10, output: 2, cacheRead: 30, cacheWrite: 0 },
+				},
+			})}\n`,
+		);
+		assert.equal(events.length, 1);
+		assert.equal(events[0]?.type, "assistant_message");
+		if (events[0]?.type !== "assistant_message") return;
+		assert.equal(events[0].text, "");
+		assert.equal(events[0].usage?.inputTokens, 10);
+		assert.equal(events[0].usage?.cacheReadTokens, 30);
+		assert.equal(events[0].usage?.totalTokens, 42);
+	});
+});