@shanepadgett/tau-agent 0.1.0

package/shared/model-fallback/index.ts

@@ -0,0 +1,278 @@
+import type { Api, AssistantMessage, Message, Model, ThinkingLevel, Tool } from "@earendil-works/pi-ai";
+import { completeSimple } from "@earendil-works/pi-ai/compat";
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { loadTauExtensionSettings, updateTauExtensionSettings } from "../settings/load.ts";
+import { errorText, truncAt } from "../text.ts";
+import modelFallbackSettings from "./settings.ts";
+import type { ModelCandidate } from "./types.ts";
+
+const MAX_ATTEMPTS = 5;
+const MAX_TOOL_ATTEMPTS = 2;
+const SEVEN_DAYS_MS = 604_800_000;
+
+const PREFERRED_MODELS: ReadonlyArray<{ provider: string; model: string; reasoning: ThinkingLevel }> = [
+	{ provider: "openrouter", model: "cohere/north-mini-code:free", reasoning: "high" },
+	{ provider: "github-copilot", model: "gemini-3.5-flash", reasoning: "high" },
+	{ provider: "openai-codex", model: "gpt-5.4-mini", reasoning: "high" },
+	{ provider: "anthropic", model: "claude-haiku-4-5", reasoning: "high" },
+];
+
+interface GenerationContext {
+	ui: ExtensionContext["ui"];
+	signal: AbortSignal | undefined;
+}
+
+export async function resolveCandidates(
+	ctx: Pick<ExtensionContext, "modelRegistry" | "model" | "cwd" | "isProjectTrusted">,
+	preferredModels: ReadonlyArray<{ provider: string; model: string; reasoning: ThinkingLevel }> = PREFERRED_MODELS,
+): Promise<ModelCandidate[]> {
+	const settings = await loadTauExtensionSettings(ctx, modelFallbackSettings);
+	const candidates: ModelCandidate[] = [];
+	const seen = new Set<string>();
+	const blocked = currentBlockedProviders(settings.cooldowns ?? {});
+
+	const add = async (model: Model<Api>, reasoning: ThinkingLevel | undefined): Promise<void> => {
+		if (blocked.has(model.provider)) return;
+		const key = `${model.provider}/${model.id}`;
+		if (seen.has(key)) return;
+
+		const auth = await ctx.modelRegistry.getApiKeyAndHeaders(model);
+		if (!auth.ok || !auth.apiKey) return;
+
+		seen.add(key);
+		candidates.push({ model, apiKey: auth.apiKey, headers: auth.headers, reasoning });
+	};
+
+	for (const preferred of preferredModels) {
+		const model = ctx.modelRegistry.find(preferred.provider, preferred.model);
+		if (model) await add(model, preferred.reasoning);
+	}
+	if (ctx.model) await add(ctx.model, undefined);
+
+	if (candidates.length === 0) throw new Error("No authenticated model available for generation.");
+	return candidates;
+}
+
+export async function generateValidated<T>(
+	ctx: GenerationContext,
+	candidates: readonly ModelCandidate[],
+	prompt: string,
+	validate: (text: string) => T,
+	correctionPrompt?: (error: Error, text: string) => string,
+	options?: { statusKey?: string; notifyOnFallback?: boolean },
+): Promise<T> {
+	return withModelFallback(ctx, candidates, options, (candidate) =>
+		requestValidated(ctx, candidate, prompt, validate, correctionPrompt),
+	);
+}
+
+export async function generateToolValidated<T>(
+	ctx: GenerationContext,
+	candidates: readonly ModelCandidate[],
+	prompt: string,
+	tool: Tool,
+	validate: (input: unknown) => T,
+	correctionPrompt?: (error: Error, output: string) => string,
+	options?: { statusKey?: string; notifyOnFallback?: boolean; maxAttempts?: number },
+): Promise<T> {
+	return withModelFallback(ctx, candidates, options, (candidate) =>
+		requestToolValidated(
+			ctx,
+			candidate,
+			prompt,
+			tool,
+			validate,
+			correctionPrompt,
+			options?.maxAttempts ?? MAX_TOOL_ATTEMPTS,
+		),
+	);
+}
+
+async function withModelFallback<T>(
+	ctx: GenerationContext,
+	candidates: readonly ModelCandidate[],
+	options: { statusKey?: string; notifyOnFallback?: boolean } | undefined,
+	request: (candidate: ModelCandidate) => Promise<T>,
+): Promise<T> {
+	const failures: string[] = [];
+	const statusKey = options?.statusKey;
+	const notifyOnFallback = options?.notifyOnFallback ?? false;
+
+	for (const [index, candidate] of candidates.entries()) {
+		const label = `${candidate.model.provider}/${candidate.model.id}`;
+		if (statusKey) ctx.ui.setStatus(statusKey, `generating (${label})`);
+
+		try {
+			return await request(candidate);
+		} catch (error) {
+			if (ctx.signal?.aborted) throw new Error("Cancelled.");
+			if (shouldCooldownProvider(error)) await markProviderUnavailable(candidate.model.provider);
+			const message = errorText(error);
+			failures.push(`- ${label}: ${message}`);
+			if (index < candidates.length - 1 && notifyOnFallback) {
+				ctx.ui.notify(`Model failed (${label}): ${message}\nTrying next model.`, "info");
+			}
+		}
+	}
+
+	throw new Error(["Model generation failed for all candidates:", ...failures].join("\n"));
+}
+
+async function requestValidated<T>(
+	ctx: GenerationContext,
+	candidate: ModelCandidate,
+	prompt: string,
+	validate: (text: string) => T,
+	correctionPrompt?: (error: Error, text: string) => string,
+): Promise<T> {
+	const userMessage: Message = { role: "user", content: [{ type: "text", text: prompt }], timestamp: Date.now() };
+	const messages: Message[] = [userMessage];
+
+	for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
+		const response = await completeCandidate(ctx, candidate, messages);
+		const text = responseText(response);
+		if (response.stopReason === "error") {
+			const error = new Error(response.errorMessage || "model returned an error");
+			if (attempt < MAX_ATTEMPTS && !shouldCooldownProvider(error)) continue;
+			throw error;
+		}
+
+		try {
+			return validate(text);
+		} catch (error) {
+			if (!(error instanceof Error) || attempt >= MAX_ATTEMPTS) throw error;
+			if (!correctionPrompt) throw error;
+
+			if (text) messages.push({ ...response, content: [{ type: "text", text }] });
+			messages.push({
+				role: "user",
+				content: [{ type: "text", text: correctionPrompt(error, truncAt(text, 4_000)) }],
+				timestamp: Date.now(),
+			});
+		}
+	}
+
+	throw new Error("Model generation failed.");
+}
+
+async function requestToolValidated<T>(
+	ctx: GenerationContext,
+	candidate: ModelCandidate,
+	prompt: string,
+	tool: Tool,
+	validate: (input: unknown) => T,
+	correctionPrompt?: (error: Error, output: string) => string,
+	maxAttempts = MAX_TOOL_ATTEMPTS,
+): Promise<T> {
+	const messages: Message[] = [{ role: "user", content: [{ type: "text", text: prompt }], timestamp: Date.now() }];
+
+	for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+		const response = await completeCandidate(ctx, candidate, messages, [tool]);
+		const text = responseText(response);
+		const toolCalls = response.content.flatMap((part) => (part.type === "toolCall" ? [part] : []));
+		const output = text || formatToolCalls(toolCalls);
+		if (response.stopReason === "error") {
+			const error = new Error(response.errorMessage || "model returned an error");
+			if (attempt < maxAttempts && !shouldCooldownProvider(error)) continue;
+			throw error;
+		}
+
+		try {
+			if (toolCalls.length !== 1) throw new Error(`Model must call ${tool.name} exactly once.`);
+			const [toolCall] = toolCalls;
+			if (!toolCall) throw new Error(`Model must call ${tool.name}.`);
+			if (toolCall.name !== tool.name) throw new Error(`Model called ${toolCall.name}; expected ${tool.name}.`);
+			return validate(toolCall.arguments);
+		} catch (error) {
+			if (!(error instanceof Error) || attempt >= maxAttempts) throw error;
+			if (!correctionPrompt) throw error;
+
+			messages.push({
+				role: "user",
+				content: [{ type: "text", text: correctionPrompt(error, truncAt(output, 4_000)) }],
+				timestamp: Date.now(),
+			});
+		}
+	}
+
+	throw new Error("Model generation failed.");
+}
+
+function completeCandidate(
+	ctx: GenerationContext,
+	candidate: ModelCandidate,
+	messages: readonly Message[],
+	tools?: Tool[],
+): Promise<AssistantMessage> {
+	return completeSimple(candidate.model, tools ? { messages: [...messages], tools } : { messages: [...messages] }, {
+		apiKey: candidate.apiKey,
+		headers: candidate.headers,
+		signal: ctx.signal,
+		reasoning: candidate.reasoning,
+	});
+}
+
+function responseText(response: AssistantMessage): string {
+	if (response.stopReason === "aborted") throw new Error("Cancelled.");
+	return response.content.flatMap((part) => (part.type === "text" ? [part.text] : [])).join("\n");
+}
+
+function formatToolCalls(toolCalls: readonly { name: string; arguments: unknown }[]): string {
+	if (toolCalls.length === 0) return "(no tool call)";
+	try {
+		return JSON.stringify(
+			toolCalls.map((call) => ({ name: call.name, arguments: call.arguments })),
+			null,
+			2,
+		);
+	} catch {
+		return "(tool call arguments unavailable)";
+	}
+}
+
+function shouldCooldownProvider(error: unknown): boolean {
+	const message = errorText(error).toLowerCase();
+	return [
+		"401",
+		"402",
+		"403",
+		"429",
+		"api key",
+		"authentication",
+		"balance",
+		"billing",
+		"credit",
+		"forbidden",
+		"insufficient",
+		"payment",
+		"quota",
+		"rate limit",
+		"rate_limit",
+		"unauthorized",
+	].some((marker) => message.includes(marker));
+}
+
+function currentBlockedProviders(cooldowns: Record<string, number>): Set<string> {
+	const now = Date.now();
+	const blocked = new Set<string>();
+	for (const [provider, availableAt] of Object.entries(cooldowns)) {
+		if (availableAt > now) blocked.add(provider);
+	}
+	return blocked;
+}
+
+async function markProviderUnavailable(provider: string): Promise<void> {
+	const until = provider === "github-copilot" ? nextMonthStartMs() : Date.now() + SEVEN_DAYS_MS;
+	await updateTauExtensionSettings("global", { cwd: process.cwd() }, modelFallbackSettings, (current) => {
+		const cooldowns: Record<string, number> = { ...(current.cooldowns ?? {}) };
+		cooldowns[provider] = until;
+		return { ...current, cooldowns };
+	});
+}
+
+function nextMonthStartMs(): number {
+	const next = new Date();
+	next.setMonth(next.getMonth() + 1, 1);
+	next.setHours(0, 0, 0, 0);
+	return next.getTime();
+}

package/shared/model-fallback/settings.ts

@@ -0,0 +1,18 @@
+import { Type } from "typebox";
+import { defineTauExtensionSettings } from "../settings/define.ts";
+
+export default defineTauExtensionSettings({
+	key: "modelFallback",
+	defaults: { cooldowns: {} },
+	schema: Type.Object(
+		{
+			cooldowns: Type.Optional(
+				Type.Record(
+					Type.String(),
+					Type.Number({ description: "Unix epoch milliseconds when the provider becomes available again." }),
+				),
+			),
+		},
+		{ additionalProperties: false },
+	),
+});

package/shared/model-fallback/types.ts

@@ -0,0 +1,8 @@
+import type { Api, Model, ThinkingLevel } from "@earendil-works/pi-ai";
+
+export interface ModelCandidate {
+	model: Model<Api>;
+	apiKey: string;
+	headers: Record<string, string> | undefined;
+	reasoning: ThinkingLevel | undefined;
+}

package/shared/ranges.ts

@@ -0,0 +1,21 @@
+export interface LineRange {
+	startLine: number;
+	endLine: number;
+}
+
+export function mergeLineRanges<Range extends LineRange>(ranges: Range[]): Range[] {
+	const sorted = ranges
+		.filter((range) => Number.isInteger(range.startLine) && Number.isInteger(range.endLine) && range.startLine > 0)
+		.map((range) => ({ ...range, endLine: Math.max(range.startLine, range.endLine) }))
+		.sort((a, b) => a.startLine - b.startLine || a.endLine - b.endLine);
+	const merged: Range[] = [];
+	for (const range of sorted) {
+		const previous = merged[merged.length - 1];
+		if (previous && range.startLine <= previous.endLine + 3) {
+			previous.endLine = Math.max(previous.endLine, range.endLine);
+		} else {
+			merged.push({ ...range });
+		}
+	}
+	return merged;
+}

package/shared/settings/define.ts

@@ -0,0 +1,15 @@
+import type { TSchema } from "typebox";
+
+export type JsonObject = Record<string, unknown>;
+
+export interface TauExtensionSettingsSpec<TDefaults extends JsonObject = JsonObject> {
+	key: string;
+	defaults: TDefaults;
+	schema: TSchema;
+}
+
+export function defineTauExtensionSettings<const TDefaults extends JsonObject>(
+	spec: TauExtensionSettingsSpec<TDefaults>,
+): TauExtensionSettingsSpec<TDefaults> {
+	return spec;
+}

package/shared/settings/files.ts

@@ -0,0 +1,20 @@
+import type { Dirent } from "node:fs";
+import { readdir } from "node:fs/promises";
+import { join } from "node:path";
+
+export async function listSettingsFiles(root: string): Promise<string[]> {
+	let entries: Dirent<string>[];
+	try {
+		entries = await readdir(root, { withFileTypes: true });
+	} catch {
+		return [];
+	}
+
+	const files: string[] = [];
+	for (const entry of entries) {
+		const path = join(root, entry.name);
+		if (entry.isDirectory()) files.push(...(await listSettingsFiles(path)));
+		else if (entry.isFile() && entry.name === "settings.ts") files.push(path);
+	}
+	return files.sort();
+}

package/shared/settings/json.ts

@@ -0,0 +1,41 @@
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+import type { JsonObject } from "./define.ts";
+
+export type JsonStatus =
+	| { exists: false; path: string }
+	| { exists: true; path: string; ok: true; value: JsonObject }
+	| { exists: true; path: string; ok: false; error: string };
+
+const writeQueues = new Map<string, Promise<void>>();
+
+export function asObject(value: unknown): JsonObject | undefined {
+	return value && typeof value === "object" && !Array.isArray(value) ? (value as JsonObject) : undefined;
+}
+
+export async function readJsonStatus(path: string): Promise<JsonStatus> {
+	try {
+		const raw = await readFile(path, "utf8");
+		const value = asObject(JSON.parse(raw)) ?? {};
+		return { exists: true, path, ok: true, value };
+	} catch (error) {
+		if (error && typeof error === "object" && "code" in error && error.code === "ENOENT")
+			return { exists: false, path };
+		return { exists: true, path, ok: false, error: error instanceof Error ? error.message : String(error) };
+	}
+}
+
+export async function writeJsonObject(path: string, value: JsonObject): Promise<void> {
+	const previous = writeQueues.get(path) ?? Promise.resolve();
+	const next = previous.then(async () => {
+		await mkdir(dirname(path), { recursive: true });
+		const temp = `${path}.${process.pid}.${Date.now()}.tmp`;
+		await writeFile(temp, `${JSON.stringify(value, null, "\t")}\n`, "utf8");
+		await rename(temp, path);
+	});
+	writeQueues.set(
+		path,
+		next.catch(() => undefined),
+	);
+	await next;
+}

package/shared/settings/load.ts

@@ -0,0 +1,59 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { Value } from "typebox/value";
+import type { JsonObject, TauExtensionSettingsSpec } from "./define.ts";
+import { asObject, readJsonStatus, writeJsonObject } from "./json.ts";
+import { mergeSettings } from "./merge.ts";
+import { globalTauSettingsPath, projectTauSettingsPath, TAU_SCHEMA_URL } from "./paths.ts";
+
+export type TauSettingsScope = "global" | "project";
+
+export async function loadTauExtensionSettings<TDefaults extends JsonObject>(
+	ctx: Pick<ExtensionContext, "cwd" | "isProjectTrusted">,
+	spec: TauExtensionSettingsSpec<TDefaults>,
+): Promise<TDefaults> {
+	const [globalStatus, projectStatus] = await Promise.all([
+		readJsonStatus(globalTauSettingsPath()),
+		ctx.isProjectTrusted() ? readJsonStatus(await projectTauSettingsPath(ctx.cwd)) : Promise.resolve(undefined),
+	]);
+
+	let merged = spec.defaults;
+	if (globalStatus?.exists && globalStatus.ok)
+		merged = mergeSettings(merged, extensionSection(globalStatus.value, spec.key));
+	if (projectStatus?.exists && projectStatus.ok)
+		merged = mergeSettings(merged, extensionSection(projectStatus.value, spec.key));
+
+	return Value.Check(spec.schema, merged) ? merged : spec.defaults;
+}
+
+export async function updateTauExtensionSettings<TDefaults extends JsonObject>(
+	scope: TauSettingsScope,
+	ctx: Pick<ExtensionContext, "cwd">,
+	spec: TauExtensionSettingsSpec<TDefaults>,
+	updater: (current: TDefaults) => TDefaults,
+): Promise<void> {
+	await updateTauSettings(scope, ctx, (current) => {
+		const next = { ...current };
+		const extensions = asObject(next.extensions) ?? {};
+		extensions[spec.key] = updater((asObject(extensions[spec.key]) as TDefaults | undefined) ?? spec.defaults);
+		next.extensions = extensions;
+		return next;
+	});
+}
+
+async function updateTauSettings(
+	scope: TauSettingsScope,
+	ctx: Pick<ExtensionContext, "cwd">,
+	updater: (current: JsonObject) => JsonObject,
+): Promise<void> {
+	const path = scope === "global" ? globalTauSettingsPath() : await projectTauSettingsPath(ctx.cwd);
+	const currentStatus = await readJsonStatus(path);
+	const current =
+		currentStatus.exists && currentStatus.ok ? currentStatus.value : { $schema: TAU_SCHEMA_URL, extensions: {} };
+	const next = updater(current);
+	next.$schema = typeof next.$schema === "string" ? next.$schema : TAU_SCHEMA_URL;
+	await writeJsonObject(path, next);
+}
+
+function extensionSection(root: JsonObject, key: string): JsonObject | undefined {
+	return asObject(asObject(root.extensions)?.[key]);
+}

package/shared/settings/merge.ts

@@ -0,0 +1,21 @@
+import { asObject } from "./json.ts";
+
+export function mergeSettings<T>(base: T, override: unknown): T {
+	return mergeNode(base, override) as T;
+}
+
+function mergeNode(base: unknown, override: unknown): unknown {
+	if (override === undefined) return clone(base);
+
+	const baseObject = asObject(base);
+	const overrideObject = asObject(override);
+	if (!baseObject || !overrideObject) return clone(override);
+
+	const merged = { ...baseObject };
+	for (const key of Object.keys(overrideObject)) merged[key] = mergeNode(merged[key], overrideObject[key]);
+	return merged;
+}
+
+function clone(value: unknown): unknown {
+	return value === undefined ? undefined : JSON.parse(JSON.stringify(value));
+}

package/shared/settings/paths.ts

@@ -0,0 +1,41 @@
+import { access } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { getAgentDir } from "@earendil-works/pi-coding-agent";
+
+const CONFIG_DIR_NAME = ".pi";
+
+export const TAU_SCHEMA_URL =
+	"https://raw.githubusercontent.com/shanepadgett/tau-agent/refs/heads/main/packages/agent/schemas/tau.schema.json";
+
+export function globalTauSettingsPath(): string {
+	return join(getAgentDir(), "tau", "settings.json");
+}
+
+export async function projectTauSettingsPath(cwd: string): Promise<string> {
+	return join(await resolveProjectRoot(cwd), CONFIG_DIR_NAME, "tau", "settings.json");
+}
+
+export async function exists(path: string): Promise<boolean> {
+	try {
+		await access(path);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+export async function resolveProjectRoot(cwd: string): Promise<string> {
+	const start = resolve(cwd);
+	let current = start;
+	while (true) {
+		if (resolve(current) !== resolve(homedir()) && (await isProjectRoot(current))) return current;
+		const parent = dirname(current);
+		if (parent === current) return start;
+		current = parent;
+	}
+}
+
+async function isProjectRoot(path: string): Promise<boolean> {
+	return (await exists(join(path, ".git"))) || (await exists(join(path, CONFIG_DIR_NAME, "tau", "settings.json")));
+}

package/shared/settings/schema.ts

@@ -0,0 +1,25 @@
+import type { JsonObject, TauExtensionSettingsSpec } from "./define.ts";
+import { TAU_SCHEMA_URL } from "./paths.ts";
+
+export function buildTauSettingsSchema(specs: readonly TauExtensionSettingsSpec[]): JsonObject {
+	return {
+		$schema: "https://json-schema.org/draft/2020-12/schema",
+		$id: TAU_SCHEMA_URL,
+		title: "Tau Configuration",
+		description: "Configuration for Tau and Tau extensions.",
+		type: "object",
+		properties: {
+			$schema: {
+				type: "string",
+				description: "Optional schema reference used by editors for validation and autocomplete.",
+			},
+			extensions: {
+				type: "object",
+				properties: Object.fromEntries(specs.map((spec) => [spec.key, spec.schema])),
+				additionalProperties: true,
+				default: {},
+			},
+		},
+		additionalProperties: false,
+	};
+}

package/shared/settings/specs.ts

@@ -0,0 +1,23 @@
+import { dirname, join } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import type { TauExtensionSettingsSpec } from "./define.ts";
+import { listSettingsFiles } from "./files.ts";
+
+const PACKAGE_ROOT = join(dirname(fileURLToPath(import.meta.url)), "../..");
+
+export async function discoverTauSettingsSpecs(_cwd?: string): Promise<TauExtensionSettingsSpec[]> {
+	const roots = [join(PACKAGE_ROOT, "extensions"), join(PACKAGE_ROOT, "shared")];
+	const files = (await Promise.all(roots.map(listSettingsFiles))).flat();
+	const specs: TauExtensionSettingsSpec[] = [];
+
+	for (const file of files) {
+		const module = (await import(pathToFileURL(file).href)) as { default?: unknown };
+		if (isSpec(module.default)) specs.push(module.default);
+	}
+
+	return specs.sort((left, right) => left.key.localeCompare(right.key));
+}
+
+function isSpec(value: unknown): value is TauExtensionSettingsSpec {
+	return !!value && typeof value === "object" && "key" in value && "defaults" in value && "schema" in value;
+}

package/shared/text.ts

@@ -0,0 +1,11 @@
+// Small text helpers shared across extensions.
+
+export { formatAge, preview } from "@shanepadgett/tau-tui";
+
+export function errorText(error: unknown): string {
+	return error instanceof Error ? error.message : String(error);
+}
+
+export function truncAt(text: string, cap: number): string {
+	return text.length > cap ? `${text.slice(0, cap)}\n(truncated)` : text;
+}

package/shared/tool-row-state.ts

@@ -0,0 +1,43 @@
+import type { ExtensionAPI, Theme } from "@earendil-works/pi-coding-agent";
+import { onTauEvent } from "./events.js";
+
+export type ToolRowVisualState = "pruned";
+
+interface EventAPI extends Pick<ExtensionAPI, "events"> {
+	on(event: "session_start", handler: () => void): void;
+	on(event: "session_shutdown", handler: () => void): void;
+}
+
+export interface ToolRowStateStore {
+	get(rowId: string): ToolRowVisualState | undefined;
+	watch(rowId: string, invalidate: () => void): void;
+	clear(): void;
+}
+
+export function createToolRowStateStore(pi: EventAPI, owner: string): ToolRowStateStore {
+	const states = new Map<string, ToolRowVisualState>();
+	const invalidators = new Map<string, () => void>();
+	onTauEvent(pi, owner, "tau:tool-row-state.set", ({ rowId, state }) => {
+		if (state === undefined) states.delete(rowId);
+		else states.set(rowId, state);
+		invalidators.get(rowId)?.();
+	});
+
+	return {
+		get(rowId) {
+			return states.get(rowId);
+		},
+		watch(rowId, invalidate) {
+			invalidators.set(rowId, invalidate);
+		},
+		clear() {
+			states.clear();
+			invalidators.clear();
+		},
+	};
+}
+
+export function formatToolRowTitle(store: ToolRowStateStore, rowId: string, toolName: string, theme: Theme): string {
+	const color = store.get(rowId) === "pruned" ? "warning" : "toolTitle";
+	return theme.fg(color, theme.bold(toolName));
+}