@shanepadgett/tau-agent 0.26.0 → 0.28.0

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

@@ -1,154 +0,0 @@
-import 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";
-
-export interface ReadSavingsSnapshot {
-	label: string;
-	secondary: string;
-	baselineTokens: number;
-	returnedTokens: number;
-	costSaved: number;
-	unchangedCost: number;
-	diffCost: number;
-	counts: Record<ReadCacheMode, number>;
-}
-
-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;
-		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),
-			"",
-			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,120 +0,0 @@
-import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
-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): 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");
-	const whole = calculateSnapshot(entries, undefined, "Whole session");
-	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,
-): 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,
-	};
-}
-
-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;
-}

package/extensions/explore/read.ts

@@ -1,335 +0,0 @@
-import {
-	createReadToolDefinition,
-	DEFAULT_MAX_BYTES,
-	formatSize,
-	truncateHead,
-	type ReadToolDetails,
-	type ToolDefinition,
-} from "@earendil-works/pi-coding-agent";
-import { Container, Text } from "@earendil-works/pi-tui";
-import { createHash } from "node:crypto";
-import { readFile } from "node:fs/promises";
-import { isAbsolute, resolve } from "node:path";
-import { Type, type Static } from "typebox";
-import { formatToolRowTitle, type ToolRowStateStore } from "../../shared/tool-row-state.js";
-import {
-	createCompleteFileMeta,
-	estimateTokens,
-	readScopeKey,
-	selectCompleteFileResponse,
-} from "./full-file-knowledge.ts";
-import { normalizeCountLimit } from "./limits.ts";
-import { stripLeadingAt } from "./path-display.ts";
-import {
-	createReadCacheStore,
-	type ReadCacheMetaV1,
-	type ReadCachePresentation,
-	type ReadCacheStore,
-} from "./read-cache.ts";
-import { createReadSnapshotStore, type ReadSnapshotStore } from "./read-snapshots.ts";
-
-const readSchema = Type.Object({
-	path: Type.String({ description: "Path to the file to read (relative or absolute)" }),
-	offset: Type.Optional(Type.Number({ description: "Line number to start reading from (1-indexed)" })),
-	limit: Type.Optional(Type.Number({ description: "Maximum number of lines to read" })),
-	lineNumbers: Type.Optional(Type.Boolean({ description: "Prefix text lines with their 1-indexed file line number" })),
-});
-
-type ReadToolInput = Static<typeof readSchema>;
-type BaseReadDefinition = ReturnType<typeof createReadToolDefinition>;
-interface ExploreReadDetails extends ReadToolDetails {
-	readCache?: ReadCacheMetaV1;
-}
-type ReadDefinition = ToolDefinition<typeof readSchema, ExploreReadDetails | undefined>;
-type ReadExecute = ReadDefinition["execute"];
-type ReadRenderCall = NonNullable<ReadDefinition["renderCall"]>;
-type ReadRenderResult = NonNullable<ReadDefinition["renderResult"]>;
-
-interface BaselineTextResult {
-	text: string;
-	details: ReadToolDetails | undefined;
-	totalLines: number;
-	startLine: number;
-	endLine: number;
-	completeFile: boolean;
-	scopeKey: string;
-	presentation: ReadCachePresentation;
-	summary: string;
-	cacheable: boolean;
-}
-
-const readDefinitionByCwd = new Map<string, BaseReadDefinition>();
-
-function readDefinitionForCwd(cwd: string): BaseReadDefinition {
-	const existing = readDefinitionByCwd.get(cwd);
-	if (existing) return existing;
-	const definition = createReadToolDefinition(cwd);
-	readDefinitionByCwd.set(cwd, definition);
-	return definition;
-}
-
-function normalizeReadParams(params: ReadToolInput): ReadToolInput {
-	return {
-		...params,
-		path: stripLeadingAt(params.path),
-		limit: params.limit === undefined ? undefined : normalizeCountLimit(params.limit, 1),
-	};
-}
-
-function isSupportedImage(buffer: Buffer): boolean {
-	return (
-		(buffer[0] === 0xff && buffer[1] === 0xd8 && buffer[2] === 0xff) ||
-		buffer.subarray(0, 8).equals(Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a])) ||
-		buffer.subarray(0, 6).toString("ascii") === "GIF87a" ||
-		buffer.subarray(0, 6).toString("ascii") === "GIF89a" ||
-		(buffer.subarray(0, 4).toString("ascii") === "RIFF" && buffer.subarray(8, 12).toString("ascii") === "WEBP") ||
-		buffer.subarray(0, 2).toString("ascii") === "BM"
-	);
-}
-
-function renderCallSummary(args: ReadToolInput | undefined): string {
-	if (!args) return "";
-	const path = stripLeadingAt(args.path);
-	if (args.offset === undefined && args.limit === undefined) return path;
-	const start = args.offset ?? 1;
-	const limit = args.limit === undefined ? undefined : normalizeCountLimit(args.limit, 1);
-	const end = limit === undefined ? "" : start + limit - 1;
-	return `${path}:${start}${end === "" ? "" : `-${end}`}`;
-}
-
-function baselineText(text: string, params: ReadToolInput): BaselineTextResult {
-	const allLines = text.split("\n");
-	const startIndex = params.offset ? Math.max(0, params.offset - 1) : 0;
-	const startLine = startIndex + 1;
-	if (startIndex >= allLines.length) {
-		throw new Error(`Offset ${params.offset} is beyond end of file (${allLines.length} lines total)`);
-	}
-
-	const selectedEnd =
-		params.limit === undefined ? allLines.length : Math.min(startIndex + params.limit, allLines.length);
-	const selectedLines = allLines.slice(startIndex, selectedEnd);
-	const selectedContent = selectedLines
-		.map((line, index) => (params.lineNumbers ? `${startLine + index}: ${line}` : line))
-		.join("\n");
-	const truncation = truncateHead(selectedContent);
-	let outputText: string;
-	let details: ReadToolDetails | undefined;
-	let outputLines = selectedLines.length;
-	let cacheable = true;
-
-	if (truncation.firstLineExceedsLimit) {
-		const firstLineSize = formatSize(Buffer.byteLength(selectedLines[0] ?? "", "utf-8"));
-		outputText = `[Line ${startLine} is ${firstLineSize}, exceeds ${formatSize(DEFAULT_MAX_BYTES)} limit. Use bash: sed -n '${startLine}p' ${params.path} | head -c ${DEFAULT_MAX_BYTES}]`;
-		details = { truncation };
-		outputLines = 0;
-		cacheable = false;
-	} else if (truncation.truncated) {
-		outputLines = truncation.outputLines;
-		const endLineDisplay = startLine + outputLines - 1;
-		const nextOffset = endLineDisplay + 1;
-		outputText = truncation.content;
-		outputText +=
-			truncation.truncatedBy === "lines"
-				? `\n\n[Showing lines ${startLine}-${endLineDisplay} of ${allLines.length}. Use offset=${nextOffset} to continue.]`
-				: `\n\n[Showing lines ${startLine}-${endLineDisplay} of ${allLines.length} (${formatSize(DEFAULT_MAX_BYTES)} limit). Use offset=${nextOffset} to continue.]`;
-		details = { truncation };
-	} else if (selectedEnd < allLines.length) {
-		outputText = `${truncation.content}\n\n[${allLines.length - selectedEnd} more lines in file. Use offset=${selectedEnd + 1} to continue.]`;
-	} else {
-		outputText = truncation.content;
-	}
-
-	const endLine = outputLines === 0 ? startLine : startLine + outputLines - 1;
-	const completeFile = startIndex === 0 && selectedEnd === allLines.length && !truncation.truncated;
-	const presentation: ReadCachePresentation = params.lineNumbers ? "line-numbered" : "plain";
-	const scopeKey = readScopeKey(completeFile, startLine, endLine, presentation);
-	const summary = completeFile ? `${allLines.length} lines` : `${outputLines} lines`;
-	return {
-		text: outputText,
-		details,
-		totalLines: allLines.length,
-		startLine,
-		endLine,
-		completeFile,
-		scopeKey,
-		presentation,
-		summary,
-		cacheable,
-	};
-}
-
-function withMeta(baseline: BaselineTextResult, meta: ReadCacheMetaV1, text = baseline.text) {
-	return {
-		content: [{ type: "text" as const, text }],
-		details: { ...baseline.details, readCache: meta },
-	};
-}
-
-function createMeta(
-	baseline: BaselineTextResult,
-	pathKey: string,
-	hash: string,
-	mode: ReadCacheMetaV1["mode"],
-	returnedText: string,
-	baseHash?: string,
-	summary = baseline.summary,
-): ReadCacheMetaV1 {
-	if (baseline.completeFile) {
-		return createCompleteFileMeta({
-			pathKey,
-			presentation: baseline.presentation,
-			servedHash: hash,
-			mode,
-			sourceText: baseline.text,
-			returnedText,
-			totalLines: baseline.totalLines,
-			summary,
-			baseHash,
-		});
-	}
-	return {
-		v: 1,
-		pathKey,
-		scopeKey: baseline.scopeKey,
-		presentation: baseline.presentation,
-		servedHash: hash,
-		baseHash,
-		mode,
-		baselineTokens: estimateTokens(baseline.text),
-		returnedTokens: estimateTokens(returnedText),
-		totalLines: baseline.totalLines,
-		summary,
-	};
-}
-
-export function createExploreReadTool(
-	rowState: ToolRowStateStore,
-	cache: ReadCacheStore = createReadCacheStore(),
-	snapshots: ReadSnapshotStore = createReadSnapshotStore(),
-): ReadDefinition {
-	const baseDefinition = readDefinitionForCwd(process.cwd());
-	return {
-		...baseDefinition,
-		description:
-			"Read a relevant file as a whole by omitting offset, limit, and lineNumbers. Later whole-file reads avoid repeating unchanged content and return useful diffs or current source after changes. Use ranges only for targeted peripheral inspection or to continue after truncation.",
-		parameters: readSchema,
-		async execute(
-			toolCallId: Parameters<ReadExecute>[0],
-			params: Parameters<ReadExecute>[1],
-			signal: Parameters<ReadExecute>[2],
-			onUpdate: Parameters<ReadExecute>[3],
-			ctx: Parameters<ReadExecute>[4],
-		) {
-			const definition = readDefinitionForCwd(ctx.cwd);
-			const normalized = normalizeReadParams(params);
-			const path = isAbsolute(normalized.path) ? resolve(normalized.path) : resolve(ctx.cwd, normalized.path);
-			const snapshotEpoch = snapshots.epoch();
-			const buffer = await readFile(path);
-			if (isSupportedImage(buffer)) {
-				return definition.execute(
-					toolCallId,
-					{ path: normalized.path, offset: normalized.offset, limit: normalized.limit },
-					signal,
-					onUpdate,
-					ctx,
-				);
-			}
-
-			if (signal?.aborted) throw new Error("Operation aborted");
-			let text: string;
-			try {
-				text = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(buffer);
-			} catch {
-				return definition.execute(toolCallId, normalized, signal, onUpdate, ctx);
-			}
-
-			const baseline = baselineText(text, normalized);
-			if (!baseline.cacheable) {
-				return { content: [{ type: "text", text: baseline.text }], details: baseline.details };
-			}
-			const hash = createHash("sha256").update(buffer).digest("hex");
-			const staleEpoch = !snapshots.isCurrent(snapshotEpoch);
-			const decision = staleEpoch
-				? { baseHash: undefined, baselineText: undefined, recovery: false }
-				: cache.decision(ctx, path, baseline.scopeKey);
-			let output = baseline.text;
-			let mode: ReadCacheMetaV1["mode"] = decision.recovery ? "recovery" : "baseline";
-			let summary = baseline.summary;
-
-			if (baseline.completeFile) {
-				const selected = selectCompleteFileResponse({
-					displayPath: normalized.path,
-					currentText: text,
-					currentHash: hash,
-					fullText: baseline.text,
-					totalLines: baseline.totalLines,
-					recovery: decision.recovery,
-					baseHash: decision.baseHash,
-					baselineText:
-						decision.baselineText ??
-						(decision.baseHash === undefined ? undefined : snapshots.get(decision.baseHash)),
-				});
-				output = selected.text;
-				mode = selected.mode;
-				summary = selected.summary;
-			} else if (!decision.recovery && decision.baseHash === hash) {
-				output = `unchanged, lines ${baseline.startLine}-${baseline.endLine} of ${baseline.totalLines}`;
-				mode = "unchanged";
-				summary = output;
-			}
-
-			if (signal?.aborted) throw new Error("Operation aborted");
-			snapshots.set(hash, text, buffer.byteLength, snapshotEpoch);
-			const meta = createMeta(baseline, path, hash, mode, output, decision.baseHash, summary);
-			return withMeta(baseline, meta, output);
-		},
-		renderCall(
-			args: Parameters<ReadRenderCall>[0],
-			theme: Parameters<ReadRenderCall>[1],
-			context: Parameters<ReadRenderCall>[2],
-		) {
-			rowState.watch(context.toolCallId, context.invalidate);
-			const text = (context.lastComponent as Text | undefined) ?? new Text("", 0, 0);
-			if (context.executionStarted || !context.isPartial) {
-				text.setText("");
-				return text;
-			}
-			const title = formatToolRowTitle(rowState, context.toolCallId, "read", theme);
-			text.setText(`${title} ${theme.fg("muted", renderCallSummary(args))}`);
-			return text;
-		},
-		renderResult(
-			result: Parameters<ReadRenderResult>[0],
-			options: Parameters<ReadRenderResult>[1],
-			theme: Parameters<ReadRenderResult>[2],
-			context: Parameters<ReadRenderResult>[3],
-		) {
-			rowState.watch(context.toolCallId, context.invalidate);
-			const container = new Container();
-			const title = formatToolRowTitle(rowState, context.toolCallId, "read", theme);
-			const args = context.args as ReadToolInput | undefined;
-			const details = result.details as ExploreReadDetails | undefined;
-			const summary = details?.readCache?.summary;
-			const summaryText = context.isError
-				? theme.fg("error", "error")
-				: summary
-					? theme.fg(
-							details?.readCache?.mode === "unchanged"
-								? "success"
-								: details?.readCache?.mode === "diff"
-									? "accent"
-									: "muted",
-							summary,
-						)
-					: "";
-			const header = `${title} ${theme.fg("muted", renderCallSummary(args))}${summaryText ? `  ${summaryText}` : ""}`;
-			container.addChild(new Text(header, 0, 0));
-			if (options.expanded) {
-				const definition = readDefinitionForCwd(context.cwd);
-				const body = definition.renderResult?.(result, { ...options, expanded: true }, theme, context);
-				if (body) container.addChild(body);
-			}
-			return container;
-		},
-	};
-}

package/extensions/explore/result.ts

@@ -1,29 +0,0 @@
-import type { AgentToolResult } from "@earendil-works/pi-coding-agent";
-
-export interface ExploreTextDetails {
-	humanText?: string;
-}
-
-export function createExploreTextResult(
-	agentText: string,
-	humanText?: string,
-): AgentToolResult<ExploreTextDetails | undefined> {
-	return {
-		content: [{ type: "text", text: agentText }],
-		details: humanText !== undefined && humanText !== agentText ? { humanText } : undefined,
-	};
-}
-
-export function firstTextContent(result: { content: readonly { type: string; text?: string }[] }): string {
-	for (const item of result.content) {
-		if (item.type === "text" && typeof item.text === "string") return item.text;
-	}
-	return "";
-}
-
-export function expandedExploreText(result: {
-	content: readonly { type: string; text?: string }[];
-	details?: ExploreTextDetails;
-}): string {
-	return result.details?.humanText ?? firstTextContent(result);
-}