@shanepadgett/tau-agent 0.27.0 → 0.28.1

package/extensions/explore/read-cache.ts

@@ -1,273 +0,0 @@
-import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { resolve } from "node:path";
-import { replayContextPruningState } from "../../shared/context-pruning-state.ts";
-import { applyCompleteFileDiff, COMPLETE_FILE_SCOPE, decodeCompleteFileSource } from "./full-file-knowledge.ts";
-
-export type ReadCacheMode = "baseline" | "recovery" | "unchanged" | "diff";
-export type ReadCachePresentation = "plain" | "line-numbered";
-
-export interface ReadCacheMetaV1 {
-	v: 1;
-	pathKey: string;
-	scopeKey: string;
-	presentation: ReadCachePresentation;
-	servedHash: string;
-	baseHash?: string;
-	mode: ReadCacheMode;
-	baselineTokens: number;
-	returnedTokens: number;
-	totalLines: number;
-	summary: string;
-}
-
-export interface ReadCacheScopeTrust {
-	hash: string;
-	text?: string;
-	rowIds: readonly string[];
-}
-
-export interface AcceptedReadCacheRow {
-	rowId: string;
-	pathKey: string;
-	scopeKey: string;
-	meta: ReadCacheMetaV1;
-	dependencyRowIds: readonly string[];
-}
-
-export interface CompleteFileDependencyChain {
-	pathKey: string;
-	servedHash: string;
-	rowIds: readonly string[];
-	sourceText: string;
-}
-
-export interface ReadCacheReplayResult {
-	scopeTrust: ReadonlyMap<string, ReadonlyMap<string, ReadCacheScopeTrust>>;
-	acceptedRows: readonly AcceptedReadCacheRow[];
-	completeFileChains: ReadonlyMap<string, CompleteFileDependencyChain>;
-	failedPatchRecoveryPaths: ReadonlySet<string>;
-}
-
-export interface ReadCacheDecision {
-	baseHash?: string;
-	baselineText?: string;
-	recovery: boolean;
-}
-
-export interface ReadCacheStore {
-	decision(ctx: ExtensionContext, pathKey: string, scopeKey: string): ReadCacheDecision;
-}
-
-export function createReadCacheStore(): ReadCacheStore {
-	return {
-		decision(ctx, pathKey, scopeKey) {
-			const manager = ctx.sessionManager;
-			if (!manager) {
-				return { baseHash: undefined, baselineText: undefined, recovery: false };
-			}
-			const pruning = replayContextPruningState(manager.getBranch());
-			const ignoredRowIds = new Set([...pruning.prunedToolCallIds, ...pruning.prunedAutoreadRowIds]);
-			for (const id of pruning.retainedToolCallIds) ignoredRowIds.delete(id);
-			const state = replayReadCache(manager.buildContextEntries(), ctx.cwd, ignoredRowIds);
-			const trust = state.scopeTrust.get(pathKey)?.get(scopeKey);
-			return {
-				baseHash: trust?.hash,
-				baselineText: trust?.text,
-				recovery: state.failedPatchRecoveryPaths.has(pathKey),
-			};
-		},
-	};
-}
-
-function parseReadCacheMeta(value: unknown): ReadCacheMetaV1 | undefined {
-	if (!isRecord(value) || value.v !== 1) return undefined;
-	if (typeof value.pathKey !== "string" || typeof value.scopeKey !== "string") return undefined;
-	if (value.presentation !== "plain" && value.presentation !== "line-numbered") return undefined;
-	if (typeof value.servedHash !== "string" || value.servedHash.length === 0) return undefined;
-	if (!isReadCacheMode(value.mode)) return undefined;
-	if (!isNonNegativeFinite(value.baselineTokens) || !isNonNegativeFinite(value.returnedTokens)) return undefined;
-	if (!isNonNegativeFinite(value.totalLines) || typeof value.summary !== "string") return undefined;
-	if (value.baseHash !== undefined && typeof value.baseHash !== "string") return undefined;
-	if ((value.mode === "unchanged" || value.mode === "diff") && !value.baseHash) return undefined;
-	return {
-		v: 1,
-		pathKey: value.pathKey,
-		scopeKey: value.scopeKey,
-		presentation: value.presentation,
-		servedHash: value.servedHash,
-		baseHash: value.baseHash,
-		mode: value.mode,
-		baselineTokens: value.baselineTokens,
-		returnedTokens: value.returnedTokens,
-		totalLines: value.totalLines,
-		summary: value.summary,
-	};
-}
-
-export function readMetaFromMessage(message: unknown): ReadCacheMetaV1 | undefined {
-	if (!isRecord(message)) return undefined;
-	const isReadResult = message.role === "toolResult" && message.toolName === "read";
-	const isAutoread = message.customType === "tau.autoread";
-	if (!isReadResult && !isAutoread) return undefined;
-	if (!isRecord(message.details)) return undefined;
-	if (isAutoread && message.details.status !== "read") return undefined;
-	return parseReadCacheMeta(message.details.readCache);
-}
-
-export function replayReadCache(
-	entries: readonly unknown[],
-	cwd: string,
-	ignoredRowIds: ReadonlySet<string> = new Set(),
-): ReadCacheReplayResult {
-	const trust = new Map<string, Map<string, ReadCacheScopeTrust>>();
-	const acceptedRows: AcceptedReadCacheRow[] = [];
-	const failedPatchRecoveryPaths = new Set<string>();
-	for (const entry of entries) {
-		if (!isRecord(entry)) continue;
-		let message: unknown;
-		if (entry.type === "message" && "message" in entry) message = entry.message;
-		else if (entry.type === "custom_message") message = entry;
-		else continue;
-		const parsedMeta = readMetaFromMessage(message);
-		if (parsedMeta) {
-			const rowId = readRowId(message);
-			if (!rowId || ignoredRowIds.has(rowId)) continue;
-			const pathKey = resolve(cwd, parsedMeta.pathKey);
-			const meta = pathKey === parsedMeta.pathKey ? parsedMeta : { ...parsedMeta, pathKey };
-			if (applyReadMeta(trust, failedPatchRecoveryPaths, message, meta, rowId)) {
-				const acceptedTrust = trust.get(meta.pathKey)?.get(meta.scopeKey);
-				if (acceptedTrust)
-					acceptedRows.push({
-						rowId,
-						pathKey: meta.pathKey,
-						scopeKey: meta.scopeKey,
-						meta,
-						dependencyRowIds: [...acceptedTrust.rowIds],
-					});
-			}
-			continue;
-		}
-		for (const path of failedPatchPaths(message, cwd)) failedPatchRecoveryPaths.add(path);
-	}
-	const completeFileChains = new Map<string, CompleteFileDependencyChain>();
-	for (const [pathKey, scopes] of trust) {
-		const complete = scopes.get(COMPLETE_FILE_SCOPE);
-		if (!complete || complete.text === undefined) continue;
-		completeFileChains.set(pathKey, {
-			pathKey,
-			servedHash: complete.hash,
-			rowIds: [...complete.rowIds],
-			sourceText: complete.text,
-		});
-	}
-	return { scopeTrust: trust, acceptedRows, completeFileChains, failedPatchRecoveryPaths };
-}
-
-function applyReadMeta(
-	trust: Map<string, Map<string, ReadCacheScopeTrust>>,
-	failedPatchRecoveryPaths: Set<string>,
-	message: unknown,
-	meta: ReadCacheMetaV1,
-	rowId: string,
-): boolean {
-	const existing = trust.get(meta.pathKey)?.get(meta.scopeKey);
-	if (meta.mode === "baseline" || meta.mode === "recovery") {
-		let text: string | undefined;
-		if (meta.scopeKey === COMPLETE_FILE_SCOPE) {
-			if (!isRecord(message)) return false;
-			let pathHeader: string | undefined;
-			if (message.customType === "tau.autoread") {
-				if (!isRecord(message.details)) return false;
-				if (typeof message.details.path !== "string" || typeof message.details.cwd !== "string") return false;
-				if (resolve(message.details.cwd, message.details.path) !== meta.pathKey) return false;
-				pathHeader = message.details.path;
-			}
-			const decoded = decodeCompleteFileSource({
-				content: message.content,
-				autoread: message.customType === "tau.autoread",
-				...(pathHeader === undefined ? {} : { pathHeader }),
-				presentation: meta.presentation,
-				servedHash: meta.servedHash,
-			});
-			if (!decoded.valid || decoded.text === undefined) return false;
-			text = decoded.text;
-		}
-		setTrust(trust, meta.pathKey, meta.scopeKey, { hash: meta.servedHash, text, rowIds: [rowId] });
-		failedPatchRecoveryPaths.delete(meta.pathKey);
-		return true;
-	}
-	if (!meta.baseHash || existing?.hash !== meta.baseHash) return false;
-	if (meta.mode === "unchanged" && meta.servedHash !== meta.baseHash) return false;
-	let text = meta.mode === "unchanged" ? existing.text : undefined;
-	if (meta.scopeKey === COMPLETE_FILE_SCOPE && meta.mode === "diff") {
-		if (existing.text === undefined) return false;
-		const decoded = applyCompleteFileDiff({
-			content: isRecord(message) ? message.content : undefined,
-			baseText: existing.text,
-			baseHash: meta.baseHash,
-			servedHash: meta.servedHash,
-		});
-		if (!decoded.valid || decoded.text === undefined) return false;
-		text = decoded.text;
-	}
-	setTrust(trust, meta.pathKey, meta.scopeKey, {
-		hash: meta.servedHash,
-		text,
-		rowIds: [...existing.rowIds, rowId],
-	});
-	return true;
-}
-
-function readRowId(message: unknown): string | undefined {
-	if (!isRecord(message)) return undefined;
-	if (message.role === "toolResult" && message.toolName === "read") {
-		return typeof message.toolCallId === "string" && message.toolCallId.length > 0 ? message.toolCallId : undefined;
-	}
-	if (message.customType !== "tau.autoread" || !isRecord(message.details)) return undefined;
-	return typeof message.details.rowId === "string" && message.details.rowId.length > 0
-		? message.details.rowId
-		: undefined;
-}
-
-function failedPatchPaths(message: unknown, cwd: string): string[] {
-	if (!isRecord(message) || message.role !== "toolResult" || message.toolName !== "patch") return [];
-	if (
-		!isRecord(message.details) ||
-		message.details.status === "completed" ||
-		!Array.isArray(message.details.failures)
-	) {
-		return [];
-	}
-	const paths: string[] = [];
-	for (const failure of message.details.failures) {
-		if (!isRecord(failure) || typeof failure.path !== "string" || failure.path.trim().length === 0) continue;
-		paths.push(resolve(cwd, failure.path));
-	}
-	return paths;
-}
-
-function setTrust(
-	trust: Map<string, Map<string, ReadCacheScopeTrust>>,
-	pathKey: string,
-	scopeKey: string,
-	value: ReadCacheScopeTrust,
-): void {
-	let scopes = trust.get(pathKey);
-	if (!scopes) {
-		scopes = new Map();
-		trust.set(pathKey, scopes);
-	}
-	scopes.set(scopeKey, value);
-}
-
-function isReadCacheMode(value: unknown): value is ReadCacheMode {
-	return value === "baseline" || value === "recovery" || value === "unchanged" || value === "diff";
-}
-
-function isNonNegativeFinite(value: unknown): value is number {
-	return typeof value === "number" && Number.isFinite(value) && value >= 0;
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-	return typeof value === "object" && value !== null;
-}

package/extensions/explore/read-snapshots.ts

@@ -1,57 +0,0 @@
-import { MAX_COMPLETE_FILE_SNAPSHOT_BYTES } from "./full-file-knowledge.ts";
-
-const MAX_TOTAL_BYTES = 16 * 1024 * 1024;
-
-interface Snapshot {
-	text: string;
-	bytes: number;
-}
-
-export interface ReadSnapshotStore {
-	get(hash: string): string | undefined;
-	epoch(): number;
-	isCurrent(epoch: number): boolean;
-	set(hash: string, text: string, bytes: number, epoch: number): boolean;
-	clear(): void;
-}
-
-export function createReadSnapshotStore(): ReadSnapshotStore {
-	const snapshots = new Map<string, Snapshot>();
-	let totalBytes = 0;
-	let epoch = 0;
-
-	return {
-		get(hash) {
-			const snapshot = snapshots.get(hash);
-			if (!snapshot) return undefined;
-			snapshots.delete(hash);
-			snapshots.set(hash, snapshot);
-			return snapshot.text;
-		},
-		epoch() {
-			return epoch;
-		},
-		isCurrent(candidate) {
-			return candidate === epoch;
-		},
-		set(hash, text, bytes, candidateEpoch) {
-			if (candidateEpoch !== epoch || bytes > MAX_COMPLETE_FILE_SNAPSHOT_BYTES) return false;
-			if (snapshots.has(hash)) return true;
-			snapshots.set(hash, { text, bytes });
-			totalBytes += bytes;
-			while (totalBytes > MAX_TOTAL_BYTES) {
-				const oldestHash = snapshots.keys().next().value as string | undefined;
-				if (oldestHash === undefined) break;
-				const oldest = snapshots.get(oldestHash);
-				snapshots.delete(oldestHash);
-				totalBytes -= oldest?.bytes ?? 0;
-			}
-			return true;
-		},
-		clear() {
-			snapshots.clear();
-			totalBytes = 0;
-			epoch += 1;
-		},
-	};
-}

package/extensions/explore/read-stats-panel.ts

@@ -1,176 +0,0 @@
-import { formatSize, type Theme } from "@earendil-works/pi-coding-agent";
-import { type Component, type KeybindingsManager, truncateToWidth, type TUI } from "@earendil-works/pi-tui";
-import { bindingHint, Tabs, ToolPanel, type ToolPanelConfig } from "@shanepadgett/tau-tui";
-import type { ReadCacheMode } from "./read-cache.ts";
-import type { OrientationTelemetry } from "./orientation-state.ts";
-
-export interface ReadSavingsSnapshot {
-	label: string;
-	secondary: string;
-	baselineTokens: number;
-	returnedTokens: number;
-	costSaved: number;
-	unchangedCost: number;
-	diffCost: number;
-	counts: Record<ReadCacheMode, number>;
-	gate: OrientationTelemetry;
-}
-
-export function createReadStatsPanel(
-	tui: TUI,
-	theme: Theme,
-	keybindings: KeybindingsManager,
-	done: (result: unknown) => void,
-	current: ReadSavingsSnapshot,
-	whole: ReadSavingsSnapshot,
-): Component {
-	return new ReadStatsPanel(tui, theme, keybindings, done, current, whole);
-}
-
-class ReadStatsPanel implements Component {
-	private readonly tui: TUI;
-	private readonly keybindings: KeybindingsManager;
-	private readonly done: (result: unknown) => void;
-	private readonly snapshots: readonly [ReadSavingsSnapshot, ReadSavingsSnapshot];
-	private readonly tabs: Tabs;
-	private readonly config: ToolPanelConfig;
-	private readonly panel: ToolPanel;
-
-	constructor(
-		tui: TUI,
-		theme: Theme,
-		keybindings: KeybindingsManager,
-		done: (result: unknown) => void,
-		current: ReadSavingsSnapshot,
-		whole: ReadSavingsSnapshot,
-	) {
-		this.tui = tui;
-		this.keybindings = keybindings;
-		this.done = done;
-		this.snapshots = [current, whole];
-		this.tabs = new Tabs(
-			theme,
-			this.snapshots.map((snapshot) => ({
-				id: snapshot.label,
-				label: snapshot.label,
-				body: new SavingsBody(theme, snapshot),
-			})),
-			current.label,
-		);
-		this.config = {
-			title: "Read savings",
-			secondary: current.secondary,
-			body: this.tabs,
-			footer: {
-				kind: "hints",
-				hints: [...this.tabs.getKeyHints(), bindingHint("tui.select.cancel", "close")],
-			},
-			border: "box",
-		};
-		this.panel = new ToolPanel(theme, this.config);
-	}
-
-	handleInput(data: string): void {
-		if (this.keybindings.matches(data, "tui.select.cancel")) {
-			this.done(undefined);
-			return;
-		}
-		this.tabs.handleInput(data);
-		const snapshot = this.snapshots.find((item) => item.label === this.tabs.getActiveId()) ?? this.snapshots[0];
-		this.config.secondary = snapshot.secondary;
-		this.tui.requestRender();
-	}
-
-	render(width: number): string[] {
-		return this.panel.render(width);
-	}
-
-	invalidate(): void {
-		this.panel.invalidate();
-	}
-}
-
-class SavingsBody implements Component {
-	private readonly theme: Theme;
-	private readonly snapshot: ReadSavingsSnapshot;
-
-	constructor(theme: Theme, snapshot: ReadSavingsSnapshot) {
-		this.theme = theme;
-		this.snapshot = snapshot;
-	}
-
-	render(width: number): string[] {
-		const avoided = Math.max(0, this.snapshot.baselineTokens - this.snapshot.returnedTokens);
-		const reduction = this.snapshot.baselineTokens > 0 ? avoided / this.snapshot.baselineTokens : 0;
-		const sourceAvoided = Math.max(0, this.snapshot.gate.sourceBytesDeflected - this.snapshot.gate.overflowReadBytes);
-		return [
-			this.theme.bold("Tokens"),
-			metricRow("Without cache", formatTokens(this.snapshot.baselineTokens), width),
-			metricRow("With cache", formatTokens(this.snapshot.returnedTokens), width),
-			metricRow(
-				"Saved",
-				this.theme.fg("success", `${formatTokens(avoided)} tokens (${Math.round(reduction * 100)}%)`),
-				width,
-			),
-			"",
-			this.theme.bold("Cost saved"),
-			metricRow("Total", this.theme.fg("success", this.theme.bold(formatCost(this.snapshot.costSaved))), width),
-			metricRow("Unchanged", formatCost(this.snapshot.unchangedCost), width),
-			metricRow("Changes only", formatCost(this.snapshot.diffCost), width),
-			"",
-			this.theme.bold("Read results"),
-			countRow("Baseline", this.snapshot.counts.baseline, "Unchanged", this.snapshot.counts.unchanged, width),
-			countRow("Changes", this.snapshot.counts.diff, "Recovery", this.snapshot.counts.recovery, width),
-			"",
-			this.theme.bold("AST-first reads"),
-			countRow(
-				"Blocked",
-				this.snapshot.gate.blockedReadAttempts,
-				"Permitted",
-				this.snapshot.gate.permittedReadAttempts,
-				width,
-			),
-			metricRow("Fallback reads", String(this.snapshot.gate.fallbackReadAttempts), width),
-			metricRow("Source avoided", formatSize(sourceAvoided), width),
-			metricRow("Direct returned", formatSize(this.snapshot.gate.directReadBytes), width),
-			metricRow("Overflow reread", formatSize(this.snapshot.gate.overflowReadBytes), width),
-			"",
-			this.theme.bold("AST bytes"),
-			metricRow("Worker input", formatSize(this.snapshot.gate.workerInputBytes), width),
-			metricRow("Full rendered", formatSize(this.snapshot.gate.completeRenderedBytes), width),
-			metricRow("Model visible", formatSize(this.snapshot.gate.modelVisibleAstBytes), width),
-			metricRow("Temporary", formatSize(this.snapshot.gate.temporaryOutputBytes), width),
-			"",
-			truncateToWidth(
-				this.theme.fg("dim", "Estimates include repeated chat history and prompt caching."),
-				width,
-				"",
-			),
-		];
-	}
-
-	invalidate(): void {}
-}
-
-function formatTokens(value: number): string {
-	if (value >= 1_000_000) return `~${(value / 1_000_000).toFixed(2)}M`;
-	if (value >= 1_000) return `~${Math.round(value / 1_000)}k`;
-	return `~${Math.max(0, Math.round(value))}`;
-}
-
-function formatCost(value: number): string {
-	if (value > 0 && value < 0.01) return "<$0.01";
-	return `~$${Math.max(0, value).toFixed(2)}`;
-}
-
-function metricRow(label: string, value: string, width: number): string {
-	return truncateToWidth(`${label.padEnd(16)}${value}`, width, "");
-}
-
-function countRow(left: string, leftCount: number, right: string, rightCount: number, width: number): string {
-	return truncateToWidth(
-		`${left.padEnd(11)}${String(leftCount).padEnd(6)}${right.padEnd(11)}${rightCount}`,
-		width,
-		"",
-	);
-}

package/extensions/explore/read-stats.ts

@@ -1,138 +0,0 @@
-import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
-import type { OrientationState } from "./orientation-state.ts";
-import { readMetaFromMessage, type ReadCacheMode } from "./read-cache.ts";
-import { createReadStatsPanel, type ReadSavingsSnapshot } from "./read-stats-panel.ts";
-
-interface ContextTotals {
-	baseline: number;
-	returned: number;
-	unchangedSaved: number;
-	diffSaved: number;
-}
-
-export async function showReadStats(ctx: ExtensionCommandContext, orientation: OrientationState): Promise<void> {
-	const entries = ctx.sessionManager.getEntries();
-	const branchIds = new Set(ctx.sessionManager.getBranch().map((entry) => entry.id));
-	const current = calculateSnapshot(
-		entries,
-		branchIds,
-		"Current chat",
-		orientation.telemetry(toolCallIds(entries, branchIds)),
-	);
-	const whole = calculateSnapshot(entries, undefined, "Whole session", orientation.telemetry(undefined));
-	await ctx.ui.custom(
-		(tui, theme, keybindings, done) => createReadStatsPanel(tui, theme, keybindings, done, current, whole),
-		{
-			overlay: true,
-			overlayOptions: { anchor: "center", width: "54%", minWidth: 50, maxHeight: "85%", margin: 2 },
-		},
-	);
-}
-
-function calculateSnapshot(
-	entries: readonly unknown[],
-	includedIds: ReadonlySet<string> | undefined,
-	label: string,
-	gate: ReadSavingsSnapshot["gate"],
-): ReadSavingsSnapshot {
-	const states = new Map<string, ContextTotals>();
-	const counts: Record<ReadCacheMode, number> = { baseline: 0, recovery: 0, unchanged: 0, diff: 0 };
-	let baselineTokens = 0;
-	let returnedTokens = 0;
-	let costSaved = 0;
-	let unchangedCost = 0;
-	let diffCost = 0;
-	let readCount = 0;
-
-	for (const entry of entries) {
-		if (!isRecord(entry) || typeof entry.id !== "string") continue;
-		const parent = typeof entry.parentId === "string" ? states.get(entry.parentId) : undefined;
-		const state: ContextTotals = parent
-			? { ...parent }
-			: { baseline: 0, returned: 0, unchangedSaved: 0, diffSaved: 0 };
-		if (entry.type === "compaction") {
-			state.baseline = 0;
-			state.returned = 0;
-			state.unchangedSaved = 0;
-			state.diffSaved = 0;
-		}
-
-		if (entry.type === "message" && "message" in entry) {
-			const meta = readMetaFromMessage(entry.message);
-			if (meta) {
-				state.baseline += meta.baselineTokens;
-				state.returned += meta.returnedTokens;
-				const saved = Math.max(0, meta.baselineTokens - meta.returnedTokens);
-				if (meta.mode === "unchanged") state.unchangedSaved += saved;
-				if (meta.mode === "diff") state.diffSaved += saved;
-				if (!includedIds || includedIds.has(entry.id)) {
-					counts[meta.mode] += 1;
-					readCount += 1;
-				}
-			}
-
-			if ((!includedIds || includedIds.has(entry.id)) && isAssistantMessage(entry.message)) {
-				baselineTokens += state.baseline;
-				returnedTokens += state.returned;
-				const inputTokens =
-					entry.message.usage.input + entry.message.usage.cacheRead + entry.message.usage.cacheWrite;
-				const inputCost =
-					entry.message.usage.cost.input +
-					entry.message.usage.cost.cacheRead +
-					entry.message.usage.cost.cacheWrite;
-				const costPerToken = inputTokens > 0 ? inputCost / inputTokens : 0;
-				unchangedCost += state.unchangedSaved * costPerToken;
-				diffCost += state.diffSaved * costPerToken;
-				costSaved += (state.baseline - state.returned) * costPerToken;
-			}
-		}
-		states.set(entry.id, state);
-	}
-
-	return {
-		label,
-		secondary: `${readCount} read${readCount === 1 ? "" : "s"} ${label === "Current chat" ? "in this chat" : "across everything done in this session"}`,
-		baselineTokens,
-		returnedTokens,
-		costSaved,
-		unchangedCost,
-		diffCost,
-		counts,
-		gate,
-	};
-}
-
-function toolCallIds(entries: readonly unknown[], includedIds: ReadonlySet<string>): Set<string> {
-	const ids = new Set<string>();
-	for (const entry of entries) {
-		if (!isRecord(entry) || typeof entry.id !== "string" || !includedIds.has(entry.id)) continue;
-		if (entry.type !== "message" || !isRecord(entry.message)) continue;
-		if (typeof entry.message.toolCallId === "string") ids.add(entry.message.toolCallId);
-	}
-	return ids;
-}
-
-function isAssistantMessage(value: unknown): value is {
-	role: "assistant";
-	usage: {
-		input: number;
-		cacheRead: number;
-		cacheWrite: number;
-		cost: { input: number; cacheRead: number; cacheWrite: number };
-	};
-} {
-	if (!isRecord(value) || value.role !== "assistant" || !isRecord(value.usage)) return false;
-	if (!isRecord(value.usage.cost)) return false;
-	return (
-		typeof value.usage.input === "number" &&
-		typeof value.usage.cacheRead === "number" &&
-		typeof value.usage.cacheWrite === "number" &&
-		typeof value.usage.cost.input === "number" &&
-		typeof value.usage.cost.cacheRead === "number" &&
-		typeof value.usage.cost.cacheWrite === "number"
-	);
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-	return typeof value === "object" && value !== null;
-}