@oh-my-pi/pi-coding-agent 14.5.2 → 14.5.5

package/src/tools/path-utils.ts

@@ -157,6 +157,27 @@ export function resolveToCwd(filePath: string, cwd: string): string {
 	return path.resolve(cwd, expanded);
 }
 
+export function formatPathRelativeToCwd(
+	filePath: string,
+	cwd: string,
+	options: { trailingSlash?: boolean } = {},
+): string {
+	const resolvedCwd = path.resolve(cwd);
+	const normalized = normalizeLocalScheme(filePath);
+	if (isInternalUrlPath(normalized)) {
+		return normalized;
+	}
+	const expanded = expandPath(normalized);
+	const resolvedPath = path.isAbsolute(expanded) ? path.resolve(expanded) : path.resolve(cwd, expanded);
+	const relative = path.relative(resolvedCwd, resolvedPath);
+	const isWithinCwd = relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
+	let displayPath = normalizePosixPath(isWithinCwd ? relative || "." : resolvedPath);
+	if (options.trailingSlash && displayPath !== "." && !displayPath.endsWith("/")) {
+		displayPath += "/";
+	}
+	return displayPath;
+}
+
 /**
  * Strip matching surrounding double quotes from a path string.
  * Common when users paste quoted paths from Windows Explorer or shell copy-paste.
@@ -381,8 +402,14 @@ function findCommonBasePath(paths: string[]): string {
 	return joined || path.parse(path.resolve(paths[0])).root;
 }
 
-function toScopeDisplay(items: string[]): string {
-	return items.map(item => normalizePosixPath(item)).join(", ");
+function toScopeDisplay(items: string[], cwd: string): string {
+	return items
+		.map(item =>
+			formatPathRelativeToCwd(item, cwd, {
+				trailingSlash: item.endsWith("/") || item.endsWith("\\"),
+			}),
+		)
+		.join(", ");
 }
 
 function looksLikeDelimitedPathToken(token: string): boolean {
@@ -533,7 +560,7 @@ export async function resolveMultiSearchPath(
 	return {
 		basePath: commonBasePath,
 		glob: buildBraceUnion(combinedPatterns),
-		scopePath: toScopeDisplay(pathItems),
+		scopePath: toScopeDisplay(pathItems, cwd),
 		exactFilePaths: allExactFiles ? parsedItems.map(item => item.absoluteBasePath) : undefined,
 	};
 }
@@ -571,7 +598,7 @@ export async function resolveMultiFindPattern(
 	return {
 		basePath: commonBasePath,
 		globPattern: buildBraceUnion(combinedPatterns) ?? "**/*",
-		scopePath: toScopeDisplay(patternItems),
+		scopePath: toScopeDisplay(patternItems, cwd),
 	};
 }
 

package/src/tools/read.ts

@@ -40,7 +40,7 @@ import {
 } from "./fetch";
 import { applyListLimit } from "./list-limit";
 import { formatFullOutputReference, formatStyledTruncationWarning, type OutputMeta } from "./output-meta";
-import { expandPath, resolveReadPath } from "./path-utils";
+import { expandPath, formatPathRelativeToCwd, resolveReadPath } from "./path-utils";
 import { formatAge, formatBytes, shortenPath, wrapBrackets } from "./render-utils";
 import {
 	executeReadQuery,
@@ -1046,7 +1046,10 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 							? "- Alpha: no"
 							: "- Alpha: unknown",
 					"",
-					`If you want to analyze the image, call inspect_image with path="${readPath}" and a question describing what to inspect and the desired output format.`,
+					`If you want to analyze the image, call inspect_image with path="${formatPathRelativeToCwd(
+						absolutePath,
+						this.session.cwd,
+					)}" and a question describing what to inspect and the desired output format.`,
 				];
 				content = [{ type: "text", text: metadataLines.join("\n") }];
 				details = {};
@@ -1110,12 +1113,15 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 			const effectiveLimit = limit ?? DEFAULT_LIMIT;
 			const maxLinesToCollect = Math.min(effectiveLimit, DEFAULT_MAX_LINES);
 			const selectedLineLimit = effectiveLimit;
+			// Scale byte budget with line limit so the configured line count actually fits.
+			// Assume ~512 bytes/line average; never go below the shared default.
+			const maxBytesForRead = Math.max(DEFAULT_MAX_BYTES, maxLinesToCollect * 512);
 
 			const streamResult = await streamLinesFromFile(
 				absolutePath,
 				startLine,
 				maxLinesToCollect,
-				DEFAULT_MAX_BYTES,
+				maxBytesForRead,
 				selectedLineLimit,
 				signal,
 			);
@@ -1146,7 +1152,7 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 			const totalSelectedLines = totalFileLines - startLine;
 			const totalSelectedBytes = collectedBytes;
 			const wasTruncated = collectedLines.length < totalSelectedLines || stoppedByByteLimit;
-			const firstLineExceedsLimit = firstLineByteLength !== undefined && firstLineByteLength > DEFAULT_MAX_BYTES;
+			const firstLineExceedsLimit = firstLineByteLength !== undefined && firstLineByteLength > maxBytesForRead;
 
 			const truncation: TruncationResult = {
 				content: selectedContent,
@@ -1178,14 +1184,14 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 				if (shouldAddHashLines) {
 					outputText = `[Line ${startLineDisplay} is ${formatBytes(
 						firstLineBytes,
-					)}, exceeds ${formatBytes(DEFAULT_MAX_BYTES)} limit. Hashline output requires full lines; cannot compute hashes for a truncated preview.]`;
+					)}, exceeds ${formatBytes(maxBytesForRead)} limit. Hashline output requires full lines; cannot compute hashes for a truncated preview.]`;
 				} else {
 					outputText = formatText(snippet.text, startLineDisplay);
 				}
 				if (snippet.text.length === 0) {
 					outputText = `[Line ${startLineDisplay} is ${formatBytes(
 						firstLineBytes,
-					)}, exceeds ${formatBytes(DEFAULT_MAX_BYTES)} limit. Unable to display a valid UTF-8 snippet.]`;
+					)}, exceeds ${formatBytes(maxBytesForRead)} limit. Unable to display a valid UTF-8 snippet.]`;
 				}
 				details = { truncation };
 				sourcePath = absolutePath;

package/src/tools/renderers.ts

@@ -18,13 +18,13 @@ import { calculatorToolRenderer } from "./calculator";
 import { debugToolRenderer } from "./debug";
 import { findToolRenderer } from "./find";
 import { githubToolRenderer } from "./gh-renderer";
-import { grepToolRenderer } from "./grep";
 import { inspectImageToolRenderer } from "./inspect-image-renderer";
 import { jobToolRenderer } from "./job";
 import { notebookToolRenderer } from "./notebook";
 import { pythonToolRenderer } from "./python";
 import { readToolRenderer } from "./read";
 import { resolveToolRenderer } from "./resolve";
+import { searchToolRenderer } from "./search";
 import { searchToolBm25Renderer } from "./search-tool-bm25";
 import { sshToolRenderer } from "./ssh";
 import { todoWriteToolRenderer } from "./todo-write";
@@ -54,7 +54,7 @@ export const toolRenderers: Record<string, ToolRenderer> = {
 	edit: editToolRenderer as ToolRenderer,
 	apply_patch: editToolRenderer as ToolRenderer,
 	find: findToolRenderer as ToolRenderer,
-	grep: grepToolRenderer as ToolRenderer,
+	search: searchToolRenderer as ToolRenderer,
 	lsp: lspToolRenderer as ToolRenderer,
 	notebook: notebookToolRenderer as ToolRenderer,
 	inspect_image: inspectImageToolRenderer as ToolRenderer,

package/src/tools/{grep.ts → search.ts}

@@ -8,15 +8,17 @@ import { prompt, untilAborted } from "@oh-my-pi/pi-utils";
 import { type Static, Type } from "@sinclair/typebox";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import type { Theme } from "../modes/theme/theme";
-import grepDescription from "../prompts/tools/grep.md" with { type: "text" };
+import searchDescription from "../prompts/tools/search.md" with { type: "text" };
 import { DEFAULT_MAX_COLUMN, type TruncationResult, truncateHead } from "../session/streaming-output";
 import { Ellipsis, Hasher, type RenderCache, renderStatusLine, renderTreeList, truncateToWidth } from "../tui";
 import { resolveFileDisplayMode } from "../utils/file-display-mode";
 import type { ToolSession } from ".";
-import { createFileRecorder } from "./file-recorder";
+import { createFileRecorder, formatResultPath } from "./file-recorder";
+import { formatGroupedFiles } from "./grouped-file-output";
 import { formatMatchLine } from "./match-line-format";
 import { formatFullOutputReference, type OutputMeta } from "./output-meta";
 import {
+	formatPathRelativeToCwd,
 	hasGlobPathChars,
 	normalizePathLikeInput,
 	parseSearchPath,
@@ -33,7 +35,7 @@ import {
 import { ToolError } from "./tool-errors";
 import { toolResult } from "./tool-result";
 
-const grepSchema = Type.Object({
+const searchSchema = Type.Object({
 	pattern: Type.String({ description: "regex pattern", examples: ["function\\s+\\w+", "TODO"] }),
 	path: Type.String({
 		description: "file, directory, glob, comma-separated paths, or internal URL to search",
@@ -44,11 +46,11 @@ const grepSchema = Type.Object({
 	skip: Type.Optional(Type.Number({ description: "matches to skip", default: 0 })),
 });
 
-export type GrepToolInput = Static<typeof grepSchema>;
+export type SearchToolInput = Static<typeof searchSchema>;
 
 const DEFAULT_MATCH_LIMIT = 20;
 
-export interface GrepToolDetails {
+export interface SearchToolDetails {
 	truncation?: TruncationResult;
 	matchLimitReached?: number;
 	resultLimitReached?: number;
@@ -67,18 +69,18 @@ export interface GrepToolDetails {
 	displayContent?: string;
 }
 
-type GrepParams = Static<typeof grepSchema>;
+type SearchParams = Static<typeof searchSchema>;
 
-export class GrepTool implements AgentTool<typeof grepSchema, GrepToolDetails> {
-	readonly name = "grep";
-	readonly label = "Grep";
+export class SearchTool implements AgentTool<typeof searchSchema, SearchToolDetails> {
+	readonly name = "search";
+	readonly label = "Search";
 	readonly description: string;
-	readonly parameters = grepSchema;
+	readonly parameters = searchSchema;
 	readonly strict = true;
 
 	constructor(private readonly session: ToolSession) {
 		const displayMode = resolveFileDisplayMode(session);
-		this.description = prompt.render(grepDescription, {
+		this.description = prompt.render(searchDescription, {
 			IS_HASHLINE_MODE: displayMode.hashLines,
 			IS_LINE_NUMBER_MODE: !displayMode.hashLines && displayMode.lineNumbers,
 		});
@@ -86,11 +88,11 @@ export class GrepTool implements AgentTool<typeof grepSchema, GrepToolDetails> {
 
 	async execute(
 		_toolCallId: string,
-		params: GrepParams,
+		params: SearchParams,
 		signal?: AbortSignal,
-		_onUpdate?: AgentToolUpdateCallback<GrepToolDetails>,
+		_onUpdate?: AgentToolUpdateCallback<SearchToolDetails>,
 		_toolContext?: AgentToolContext,
-	): Promise<AgentToolResult<GrepToolDetails>> {
+	): Promise<AgentToolResult<SearchToolDetails>> {
 		const { pattern, path: searchDir, i, gitignore, skip } = params;
 
 		return untilAborted(signal, async () => {
@@ -103,18 +105,15 @@ export class GrepTool implements AgentTool<typeof grepSchema, GrepToolDetails> {
 			if (normalizedSkip < 0 || !Number.isFinite(normalizedSkip)) {
 				throw new ToolError("Skip must be a non-negative number");
 			}
-			const normalizedContextBefore = this.session.settings.get("grep.contextBefore");
-			const normalizedContextAfter = this.session.settings.get("grep.contextAfter");
+			const normalizedContextBefore = this.session.settings.get("search.contextBefore");
+			const normalizedContextAfter = this.session.settings.get("search.contextAfter");
 			const ignoreCase = i ?? false;
 			const useGitignore = gitignore ?? true;
 			const patternHasNewline = normalizedPattern.includes("\n") || normalizedPattern.includes("\\n");
 			const effectiveMultiline = patternHasNewline;
 
 			const useHashLines = resolveFileDisplayMode(this.session).hashLines;
-			const formatScopePath = (targetPath: string): string => {
-				const relative = path.relative(this.session.cwd, targetPath).replace(/\\/g, "/");
-				return relative.length === 0 ? "." : relative;
-			};
+			const formatScopePath = (targetPath: string): string => formatPathRelativeToCwd(targetPath, this.session.cwd);
 			let searchPath: string;
 			let scopePath: string;
 			let exactFilePaths: string[] | undefined;
@@ -130,7 +129,7 @@ export class GrepTool implements AgentTool<typeof grepSchema, GrepToolDetails> {
 				}
 				const resource = await internalRouter.resolve(rawPath);
 				if (!resource.sourcePath) {
-					throw new ToolError(`Cannot grep internal URL without a backing file: ${rawPath}`);
+					throw new ToolError(`Cannot search internal URL without a backing file: ${rawPath}`);
 				}
 				searchPath = resource.sourcePath;
 				scopePath = formatScopePath(searchPath);
@@ -224,14 +223,8 @@ export class GrepTool implements AgentTool<typeof grepSchema, GrepToolDetails> {
 				throw err;
 			}
 
-			const formatPath = (filePath: string): string => {
-				// returns paths starting with / (the virtual root)
-				const cleanPath = filePath.startsWith("/") ? filePath.slice(1) : filePath;
-				if (isDirectory) {
-					return cleanPath.replace(/\\/g, "/");
-				}
-				return path.basename(cleanPath);
-			};
+			const formatPath = (filePath: string): string =>
+				formatResultPath(filePath, isDirectory, searchPath, this.session.cwd);
 
 			// Build output
 			const roundRobinSelect = (matches: GrepMatch[], limit: number): GrepMatch[] => {
@@ -272,7 +265,7 @@ export class GrepTool implements AgentTool<typeof grepSchema, GrepToolDetails> {
 			const { record: recordFile, list: fileList } = createFileRecorder();
 			const fileMatchCounts = new Map<string, number>();
 			if (selectedMatches.length === 0) {
-				const details: GrepToolDetails = {
+				const details: SearchToolDetails = {
 					scopePath,
 					matchCount: 0,
 					fileCount: 0,
@@ -283,7 +276,6 @@ export class GrepTool implements AgentTool<typeof grepSchema, GrepToolDetails> {
 			}
 			const outputLines: string[] = [];
 			let linesTruncated = false;
-			const hasContextLines = normalizedContextBefore > 0 || normalizedContextAfter > 0;
 			const matchesByFile = new Map<string, GrepMatch[]>();
 			for (const match of selectedMatches) {
 				const relativePath = formatPath(match.path);
@@ -332,46 +324,16 @@ export class GrepTool implements AgentTool<typeof grepSchema, GrepToolDetails> {
 				return { model: modelOut, display: displayOut };
 			};
 			if (isDirectory) {
-				const filesByDirectory = new Map<string, string[]>();
-				for (const relativePath of fileList) {
-					const directory = path.dirname(relativePath).replace(/\\/g, "/");
-					if (!filesByDirectory.has(directory)) {
-						filesByDirectory.set(directory, []);
-					}
-					filesByDirectory.get(directory)!.push(relativePath);
-				}
-				for (const [directory, directoryFiles] of filesByDirectory) {
-					if (directory === ".") {
-						for (const relativePath of directoryFiles) {
-							const rendered = renderMatchesForFile(relativePath);
-							if (rendered.model.length === 0) continue;
-							if (outputLines.length > 0) {
-								outputLines.push("");
-								displayLines.push("");
-							}
-							const header = `# ${path.basename(relativePath)}`;
-							outputLines.push(header, ...rendered.model);
-							displayLines.push(header, ...rendered.display);
-						}
-						continue;
-					}
-					const renderedFiles = directoryFiles
-						.map(relativePath => ({ relativePath, rendered: renderMatchesForFile(relativePath) }))
-						.filter(file => file.rendered.model.length > 0);
-					if (renderedFiles.length === 0) continue;
-					if (outputLines.length > 0) {
-						outputLines.push("");
-						displayLines.push("");
-					}
-					const dirHeader = `# ${directory}`;
-					outputLines.push(dirHeader);
-					displayLines.push(dirHeader);
-					for (const { relativePath, rendered } of renderedFiles) {
-						const fileHeader = `## └─ ${path.basename(relativePath)}`;
-						outputLines.push(fileHeader, ...rendered.model);
-						displayLines.push(fileHeader, ...rendered.display);
-					}
-				}
+				const grouped = formatGroupedFiles(fileList, relativePath => {
+					const rendered = renderMatchesForFile(relativePath);
+					return {
+						modelLines: rendered.model,
+						displayLines: rendered.display,
+						skip: rendered.model.length === 0,
+					};
+				});
+				outputLines.push(...grouped.model);
+				displayLines.push(...grouped.display);
 			} else {
 				for (const relativePath of fileList) {
 					const rendered = renderMatchesForFile(relativePath);
@@ -379,11 +341,6 @@ export class GrepTool implements AgentTool<typeof grepSchema, GrepToolDetails> {
 					displayLines.push(...rendered.display);
 				}
 			}
-			if (hasContextLines && outputLines.length > 0) {
-				outputLines.unshift(
-					"[grep] '*' marks match lines; leading space marks context. Anchor and content are separated by '|'.",
-				);
-			}
 			if (matchLimitReached || result.limitReached) {
 				outputLines.push("", limitMessage);
 			}
@@ -391,7 +348,7 @@ export class GrepTool implements AgentTool<typeof grepSchema, GrepToolDetails> {
 			const truncation = truncateHead(rawOutput, { maxLines: Number.MAX_SAFE_INTEGER });
 			const output = truncation.content;
 			const truncated = Boolean(matchLimitReached || result.limitReached || truncation.truncated || linesTruncated);
-			const details: GrepToolDetails = {
+			const details: SearchToolDetails = {
 				scopePath,
 				matchCount: selectedMatches.length,
 				fileCount: fileList.length,
@@ -422,7 +379,7 @@ export class GrepTool implements AgentTool<typeof grepSchema, GrepToolDetails> {
 // TUI Renderer
 // =============================================================================
 
-interface GrepRenderArgs {
+interface SearchRenderArgs {
 	pattern: string;
 	path?: string;
 	i?: boolean;
@@ -432,9 +389,9 @@ interface GrepRenderArgs {
 
 const COLLAPSED_TEXT_LIMIT = PREVIEW_LIMITS.COLLAPSED_LINES * 2;
 
-export const grepToolRenderer = {
+export const searchToolRenderer = {
 	inline: true,
-	renderCall(args: GrepRenderArgs, _options: RenderResultOptions, uiTheme: Theme): Component {
+	renderCall(args: SearchRenderArgs, _options: RenderResultOptions, uiTheme: Theme): Component {
 		const meta: string[] = [];
 		if (args.path) meta.push(`in ${args.path}`);
 		if (args.i) meta.push("case:insensitive");
@@ -442,17 +399,17 @@ export const grepToolRenderer = {
 		if (args.skip !== undefined && args.skip > 0) meta.push(`skip:${args.skip}`);
 
 		const text = renderStatusLine(
-			{ icon: "pending", title: "Grep", description: args.pattern || "?", meta },
+			{ icon: "pending", title: "Search", description: args.pattern || "?", meta },
 			uiTheme,
 		);
 		return new Text(text, 0, 0);
 	},
 
 	renderResult(
-		result: { content: Array<{ type: string; text?: string }>; details?: GrepToolDetails; isError?: boolean },
+		result: { content: Array<{ type: string; text?: string }>; details?: SearchToolDetails; isError?: boolean },
 		options: RenderResultOptions,
 		uiTheme: Theme,
-		args?: GrepRenderArgs,
+		args?: SearchRenderArgs,
 	): Component {
 		const details = result.details;
 
@@ -471,7 +428,7 @@ export const grepToolRenderer = {
 			const lines = textContent.split("\n").filter(line => line.trim() !== "");
 			const description = args?.pattern ?? undefined;
 			const header = renderStatusLine(
-				{ icon: "success", title: "Grep", description, meta: [formatCount("item", lines.length)] },
+				{ icon: "success", title: "Search", description, meta: [formatCount("item", lines.length)] },
 				uiTheme,
 			);
 			let cached: RenderCache | undefined;
@@ -511,7 +468,7 @@ export const grepToolRenderer = {
 
 		if (matchCount === 0) {
 			const header = renderStatusLine(
-				{ icon: "warning", title: "Grep", description: args?.pattern, meta: ["0 matches"] },
+				{ icon: "warning", title: "Search", description: args?.pattern, meta: ["0 matches"] },
 				uiTheme,
 			);
 			return new Text([header, formatEmptyMessage("No matches found", uiTheme)].join("\n"), 0, 0);
@@ -523,7 +480,7 @@ export const grepToolRenderer = {
 		if (truncated) meta.push(uiTheme.fg("warning", "truncated"));
 		const description = args?.pattern ?? undefined;
 		const header = renderStatusLine(
-			{ icon: truncated ? "warning" : "success", title: "Grep", description, meta },
+			{ icon: truncated ? "warning" : "success", title: "Search", description, meta },
 			uiTheme,
 		);
 

package/src/tools/todo-write.ts

@@ -717,7 +717,6 @@ export const todoWriteToolRenderer = {
 		const lines: string[] = [header];
 		for (let p = 0; p < phases.length; p++) {
 			const phase = phases[p];
-			if (p > 0) lines.push("");
 			if (phases.length > 1) {
 				lines.push(uiTheme.fg("accent", chalk.bold(`  ${phase.name}`)));
 			}

package/src/tools/write.ts

@@ -19,6 +19,7 @@ import { parseArchivePathCandidates } from "./archive-reader";
 import { assertEditableFile } from "./auto-generated-guard";
 import { invalidateFsScanAfterWrite } from "./fs-cache-invalidation";
 import { type OutputMeta, outputMeta } from "./output-meta";
+import { formatPathRelativeToCwd } from "./path-utils";
 import { enforcePlanModeWrite, resolvePlanPath } from "./plan-mode-guard";
 import {
 	formatDiagnostics,
@@ -212,7 +213,6 @@ export class WriteTool implements AgentTool<typeof writeSchema, WriteToolDetails
 	}
 
 	async #writeArchiveEntry(
-		displayPath: string,
 		content: string,
 		resolvedArchivePath: ResolvedArchiveWritePath,
 	): Promise<AgentToolResult<WriteToolDetails>> {
@@ -278,8 +278,11 @@ export class WriteTool implements AgentTool<typeof writeSchema, WriteToolDetails
 		}
 
 		invalidateFsScanAfterWrite(resolvedArchivePath.absolutePath);
+		const outputPath = `${formatPathRelativeToCwd(resolvedArchivePath.absolutePath, this.session.cwd)}:${
+			resolvedArchivePath.archiveSubPath
+		}`;
 		return {
-			content: [{ type: "text", text: `Successfully wrote ${content.length} bytes to ${displayPath}` }],
+			content: [{ type: "text", text: `Successfully wrote ${content.length} bytes to ${outputPath}` }],
 			details: {},
 		};
 	}
@@ -426,7 +429,7 @@ export class WriteTool implements AgentTool<typeof writeSchema, WriteToolDetails
 					op: resolvedArchivePath.exists ? "update" : "create",
 				});
 
-				const archiveResult = await this.#writeArchiveEntry(path, cleanContent, resolvedArchivePath);
+				const archiveResult = await this.#writeArchiveEntry(cleanContent, resolvedArchivePath);
 				if (stripped) {
 					const firstText = archiveResult.content.find(
 						(block): block is { type: "text"; text: string } =>
@@ -468,7 +471,8 @@ export class WriteTool implements AgentTool<typeof writeSchema, WriteToolDetails
 			const diagnostics = await this.#writethrough(absolutePath, cleanContent, signal, undefined, batchRequest);
 			invalidateFsScanAfterWrite(absolutePath);
 
-			let resultText = `Successfully wrote ${cleanContent.length} bytes to ${path}`;
+			const displayPath = formatPathRelativeToCwd(absolutePath, this.session.cwd);
+			let resultText = `Successfully wrote ${cleanContent.length} bytes to ${displayPath}`;
 			if (stripped) {
 				resultText += `\nNote: auto-stripped hashline display prefixes from content before writing.`;
 			}

package/src/web/search/index.ts

@@ -205,7 +205,7 @@ export async function runSearchQuery(
  * Supports Anthropic, Perplexity, Exa, Brave, Jina, Kimi, Gemini, Codex, Z.AI, SearXNG, and Synthetic providers with automatic fallback.
  * Session is accepted for interface consistency but not used.
  */
-export class SearchTool implements AgentTool<typeof webSearchSchema, SearchRenderDetails> {
+export class WebSearchTool implements AgentTool<typeof webSearchSchema, SearchRenderDetails> {
 	readonly name = "web_search";
 	readonly label = "Web Search";
 	readonly description: string;