@oh-my-pi/pi-coding-agent 13.3.13 → 13.4.0

package/src/web/search/providers/gemini.ts

@@ -5,7 +5,12 @@
  * Requires OAuth credentials stored in agent.db for provider "google-gemini-cli" or "google-antigravity".
  * Returns synthesized answers with citations and source metadata from grounding chunks.
  */
-import { getAntigravityHeaders, getGeminiCliHeaders, refreshGoogleCloudToken } from "@oh-my-pi/pi-ai";
+import {
+	ANTIGRAVITY_SYSTEM_INSTRUCTION,
+	getAntigravityHeaders,
+	getGeminiCliHeaders,
+	refreshGoogleCloudToken,
+} from "@oh-my-pi/pi-ai";
 import { getAgentDbPath } from "@oh-my-pi/pi-utils";
 import { AgentStorage } from "../../../session/agent-storage";
 import type { SearchCitation, SearchResponse, SearchSource } from "../../../web/search/types";
@@ -14,10 +19,18 @@ import type { SearchParams } from "./base";
 import { SearchProvider } from "./base";
 
 const DEFAULT_ENDPOINT = "https://cloudcode-pa.googleapis.com";
-const ANTIGRAVITY_ENDPOINT = "https://daily-cloudcode-pa.sandbox.googleapis.com";
+const ANTIGRAVITY_DAILY_ENDPOINT = "https://daily-cloudcode-pa.googleapis.com";
+const ANTIGRAVITY_SANDBOX_ENDPOINT = "https://daily-cloudcode-pa.sandbox.googleapis.com";
+const ANTIGRAVITY_ENDPOINT_FALLBACKS = [ANTIGRAVITY_DAILY_ENDPOINT, ANTIGRAVITY_SANDBOX_ENDPOINT] as const;
 const DEFAULT_MODEL = "gemini-2.5-flash";
 
-export interface GeminiSearchParams {
+interface GeminiToolParams {
+	google_search?: Record<string, unknown>;
+	code_execution?: Record<string, unknown>;
+	url_context?: Record<string, unknown>;
+}
+
+export interface GeminiSearchParams extends GeminiToolParams {
 	query: string;
 	system_prompt?: string;
 	num_results?: number;
@@ -27,6 +40,17 @@ export interface GeminiSearchParams {
 	temperature?: number;
 }
 
+export function buildGeminiRequestTools(params: GeminiToolParams): Array<Record<string, Record<string, unknown>>> {
+	const tools: Array<Record<string, Record<string, unknown>>> = [{ googleSearch: params.google_search ?? {} }];
+	if (params.code_execution !== undefined) {
+		tools.push({ codeExecution: params.code_execution });
+	}
+	if (params.url_context !== undefined) {
+		tools.push({ urlContext: params.url_context });
+	}
+	return tools;
+}
+
 /** OAuth credential stored in agent.db */
 interface GeminiOAuthCredential {
 	type: "oauth";
@@ -48,15 +72,15 @@ interface GeminiAuth {
 
 /**
  * Finds valid Gemini OAuth credentials from agent.db.
- * Checks google-antigravity first (daily sandbox, more quota), then google-gemini-cli (prod).
+ * Checks google-gemini-cli first (stable prod), then google-antigravity (daily sandbox).
  * @returns OAuth credential with access token and project ID, or null if none found
  */
 export async function findGeminiAuth(): Promise<GeminiAuth | null> {
 	const expiryBuffer = 5 * 60 * 1000; // 5 minutes
 	const now = Date.now();
 
-	// Try providers in order: antigravity first (more quota), then gemini-cli
-	const providers = ["google-antigravity", "google-gemini-cli"] as const;
+	// Try providers in deterministic order: gemini-cli first, then antigravity
+	const providers = ["google-gemini-cli", "google-antigravity"] as const;
 
 	try {
 		const storage = await AgentStorage.open(getAgentDbPath());
@@ -180,6 +204,7 @@ async function callGeminiSearch(
 	systemPrompt?: string,
 	maxOutputTokens?: number,
 	temperature?: number,
+	toolParams: GeminiToolParams = {},
 ): Promise<{
 	answer: string;
 	sources: SearchSource[];
@@ -188,10 +213,31 @@ async function callGeminiSearch(
 	model: string;
 	usage?: { inputTokens: number; outputTokens: number; totalTokens: number };
 }> {
-	const endpoint = auth.isAntigravity ? ANTIGRAVITY_ENDPOINT : DEFAULT_ENDPOINT;
-	const url = `${endpoint}/v1internal:streamGenerateContent?alt=sse`;
+	const endpoints = auth.isAntigravity ? ANTIGRAVITY_ENDPOINT_FALLBACKS : [DEFAULT_ENDPOINT];
 	const headers = auth.isAntigravity ? getAntigravityHeaders() : getGeminiCliHeaders();
 
+	const requestMetadata = auth.isAntigravity
+		? {
+				requestType: "agent",
+				userAgent: "antigravity",
+				requestId: `agent-${crypto.randomUUID()}`,
+			}
+		: {
+				userAgent: "pi-coding-agent",
+				requestId: `pi-${Date.now()}-${Math.random().toString(36).slice(2, 11)}`,
+			};
+
+	const normalizedSystemPrompt = systemPrompt?.toWellFormed();
+	const systemInstructionParts: Array<{ text: string }> = [
+		...(auth.isAntigravity
+			? [
+					{ text: ANTIGRAVITY_SYSTEM_INSTRUCTION },
+					{ text: `Please ignore following [ignore]${ANTIGRAVITY_SYSTEM_INSTRUCTION}[/ignore]` },
+				]
+			: []),
+		...(normalizedSystemPrompt ? [{ text: normalizedSystemPrompt }] : []),
+	];
+
 	const requestBody: Record<string, unknown> = {
 		project: auth.projectId,
 		model: DEFAULT_MODEL,
@@ -202,16 +248,15 @@ async function callGeminiSearch(
 					parts: [{ text: query }],
 				},
 			],
-			// Add googleSearch tool for grounding
-			tools: [{ googleSearch: {} }],
-			...(systemPrompt && {
+			tools: buildGeminiRequestTools(toolParams),
+			...(systemInstructionParts.length > 0 && {
 				systemInstruction: {
-					parts: [{ text: systemPrompt }],
+					...(auth.isAntigravity ? { role: "user" } : {}),
+					parts: systemInstructionParts,
 				},
 			}),
 		},
-		userAgent: "pi-web-search",
-		requestId: `search-${Date.now()}-${Math.random().toString(36).slice(2, 11)}`,
+		...requestMetadata,
 	};
 
 	if (maxOutputTokens !== undefined || temperature !== undefined) {
@@ -224,17 +269,52 @@ async function callGeminiSearch(
 		}
 		(requestBody.request as Record<string, unknown>).generationConfig = generationConfig;
 	}
+	let response: Response | undefined;
+	for (let endpointIndex = 0; endpointIndex < endpoints.length; endpointIndex++) {
+		const url = `${endpoints[endpointIndex]}/v1internal:streamGenerateContent?alt=sse`;
+		try {
+			response = await fetch(url, {
+				method: "POST",
+				headers: {
+					Authorization: `Bearer ${auth.accessToken}`,
+					"Content-Type": "application/json",
+					Accept: "text/event-stream",
+					...headers,
+				},
+				body: JSON.stringify(requestBody),
+			});
+		} catch (error) {
+			if (auth.isAntigravity && endpointIndex < endpoints.length - 1) {
+				continue;
+			}
+			throw error;
+		}
 
-	const response = await fetch(url, {
-		method: "POST",
-		headers: {
-			Authorization: `Bearer ${auth.accessToken}`,
-			"Content-Type": "application/json",
-			Accept: "text/event-stream",
-			...headers,
-		},
-		body: JSON.stringify(requestBody),
-	});
+		if (response.ok) {
+			break;
+		}
+
+		const errorText = await response.text();
+		const isRetryableStatus =
+			response.status === 429 ||
+			response.status === 500 ||
+			response.status === 502 ||
+			response.status === 503 ||
+			response.status === 504;
+		if (auth.isAntigravity && isRetryableStatus && endpointIndex < endpoints.length - 1) {
+			continue;
+		}
+
+		throw new SearchProviderError(
+			"gemini",
+			`Gemini Cloud Code API error (${response.status}): ${errorText}`,
+			response.status,
+		);
+	}
+
+	if (!response) {
+		throw new SearchProviderError("gemini", "Gemini API request failed", 500);
+	}
 
 	if (!response.ok) {
 		const errorText = await response.text();
@@ -396,6 +476,11 @@ export async function searchGemini(params: GeminiSearchParams): Promise<SearchRe
 		params.system_prompt,
 		params.max_output_tokens,
 		params.temperature,
+		{
+			google_search: params.google_search,
+			code_execution: params.code_execution,
+			url_context: params.url_context,
+		},
 	);
 
 	let sources = result.sources;
@@ -432,6 +517,9 @@ export class GeminiProvider extends SearchProvider {
 			num_results: params.numSearchResults ?? params.limit,
 			max_output_tokens: params.maxOutputTokens,
 			temperature: params.temperature,
+			google_search: params.googleSearch,
+			code_execution: params.codeExecution,
+			url_context: params.urlContext,
 		});
 	}
 }

package/src/patch/normative.ts

@@ -1,72 +0,0 @@
-/**
- * Normalize applied patch output into a canonical edit tool payload.
- */
-import { generateUnifiedDiffString } from "./diff";
-import { normalizeToLF, stripBom } from "./normalize";
-import { parseHunks } from "./parser";
-import type { PatchInput } from "./types";
-
-export interface NormativePatchOptions {
-	path: string;
-	rename?: string;
-	oldContent: string;
-	newContent: string;
-	contextLines?: number;
-	anchor?: string | string[];
-}
-
-/** Normative patch input is the MongoDB-style update variant */
-
-function applyAnchors(diff: string, anchors: Array<string | undefined> | undefined): string {
-	if (!anchors || anchors.length === 0) {
-		return diff;
-	}
-	const lines = diff.split("\n");
-	let anchorIndex = 0;
-	for (let i = 0; i < lines.length; i++) {
-		if (!lines[i].startsWith("@@")) continue;
-		const anchor = anchors[anchorIndex];
-		if (anchor !== undefined) {
-			lines[i] = anchor.trim().length === 0 ? "@@" : `@@ ${anchor}`;
-		}
-		anchorIndex++;
-	}
-	return lines.join("\n");
-}
-
-function deriveAnchors(diff: string): Array<string | undefined> {
-	const hunks = parseHunks(diff);
-	return hunks.map(hunk => {
-		if (hunk.oldLines.length === 0 || hunk.newLines.length === 0) {
-			return undefined;
-		}
-		const newLines = new Set(hunk.newLines);
-		for (const line of hunk.oldLines) {
-			const trimmed = line.trim();
-			if (trimmed.length === 0) continue;
-			if (!/[A-Za-z0-9_]/.test(trimmed)) continue;
-			if (newLines.has(line)) {
-				return trimmed;
-			}
-		}
-		return undefined;
-	});
-}
-
-export function buildNormativeUpdateInput(options: NormativePatchOptions): PatchInput {
-	const normalizedOld = normalizeToLF(stripBom(options.oldContent).text);
-	const normalizedNew = normalizeToLF(stripBom(options.newContent).text);
-	const diffResult = generateUnifiedDiffString(normalizedOld, normalizedNew, options.contextLines ?? 3);
-	let anchors: Array<string | undefined> | undefined =
-		typeof options.anchor === "string" ? [options.anchor] : options.anchor;
-	if (!anchors) {
-		anchors = deriveAnchors(diffResult.diff);
-	}
-	const diff = applyAnchors(diffResult.diff, anchors);
-	return {
-		path: options.path,
-		op: "update",
-		rename: options.rename,
-		diff,
-	};
-}

package/src/prompts/tools/ast-find.md

@@ -1,20 +0,0 @@
-Performs structural code search using AST matching via native ast-grep.
-
-<instruction>
-- Use this when syntax shape matters more than raw text (calls, declarations, specific language constructs)
-- Prefer a precise `path` scope to keep results targeted and deterministic (`path` accepts files, directories, or glob patterns)
-- `pattern` is required; `lang` is optional (`lang` is inferred per file extension when omitted)
-- Use `selector` only for contextual pattern mode; otherwise provide a direct pattern
-- Enable `include_meta` when metavariable captures are needed in output
-</instruction>
-
-<output>
-- Returns grouped matches with file path, byte range, and line/column ranges
-- Includes summary counts (`totalMatches`, `filesWithMatches`, `filesSearched`) and parse issues when present
-</output>
-
-<critical>
-- `pattern` is required
-- Set `lang` explicitly to constrain matching when path pattern spans mixed-language trees
-- If exploration is broad/open-ended across subsystems, use Task tool with explore subagent first
-</critical>

package/src/prompts/tools/ast-replace.md

@@ -1,21 +0,0 @@
-Performs structural AST-aware rewrites via native ast-grep.
-
-<instruction>
-- Use for codemods and structural rewrites where plain text replace is unsafe
-- Narrow scope with `path` before replacing (`path` accepts files, directories, or glob patterns)
-- `pattern` + `rewrite` are required; `lang` is optional only when all matched files resolve to a single language
-- Keep `dry_run` enabled unless explicit apply intent is clear
-- Use `max_files` and `max_replacements` as safety caps on broad rewrites
-</instruction>
-
-<output>
-- Returns replacement summary, per-file replacement counts, and change previews
-- Reports whether changes were applied or only previewed
-- Includes parse issues when files cannot be processed
-</output>
-
-<critical>
-- `pattern` + `rewrite` are required
-- If the path pattern spans multiple languages, set `lang` explicitly for deterministic rewrites
-- For one-off local text edits, prefer the Edit tool instead of AST replace
-</critical>

package/src/tools/ast-find.ts

@@ -1,316 +0,0 @@
-import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
-import { type AstFindResult, astFind } from "@oh-my-pi/pi-natives";
-import type { Component } from "@oh-my-pi/pi-tui";
-import { Text } from "@oh-my-pi/pi-tui";
-import { untilAborted } from "@oh-my-pi/pi-utils";
-import { type Static, Type } from "@sinclair/typebox";
-import { renderPromptTemplate } from "../config/prompt-templates";
-import type { RenderResultOptions } from "../extensibility/custom-tools/types";
-import type { Theme } from "../modes/theme/theme";
-import astFindDescription from "../prompts/tools/ast-find.md" with { type: "text" };
-import { Ellipsis, Hasher, type RenderCache, renderStatusLine, renderTreeList, truncateToWidth } from "../tui";
-import type { ToolSession } from ".";
-import type { OutputMeta } from "./output-meta";
-import { hasGlobPathChars, parseSearchPath, resolveToCwd } from "./path-utils";
-import { formatCount, formatEmptyMessage, formatErrorMessage, PREVIEW_LIMITS } from "./render-utils";
-import { ToolError } from "./tool-errors";
-import { toolResult } from "./tool-result";
-
-const astFindSchema = Type.Object({
-	pattern: Type.String({ description: "AST pattern, e.g. 'foo($A)'" }),
-	lang: Type.Optional(Type.String({ description: "Language override" })),
-	path: Type.Optional(Type.String({ description: "File, directory, or glob pattern to search (default: cwd)" })),
-	selector: Type.Optional(Type.String({ description: "Optional selector for contextual pattern mode" })),
-	limit: Type.Optional(Type.Number({ description: "Max matches (default: 50)" })),
-	offset: Type.Optional(Type.Number({ description: "Skip first N matches (default: 0)" })),
-	context: Type.Optional(Type.Number({ description: "Context lines around each match" })),
-	include_meta: Type.Optional(Type.Boolean({ description: "Include metavariable captures" })),
-});
-
-export interface AstFindToolDetails {
-	matchCount: number;
-	fileCount: number;
-	filesSearched: number;
-	limitReached: boolean;
-	parseErrors?: string[];
-	meta?: OutputMeta;
-}
-
-export class AstFindTool implements AgentTool<typeof astFindSchema, AstFindToolDetails> {
-	readonly name = "ast_find";
-	readonly label = "AST Find";
-	readonly description: string;
-	readonly parameters = astFindSchema;
-	readonly strict = true;
-
-	constructor(private readonly session: ToolSession) {
-		this.description = renderPromptTemplate(astFindDescription);
-	}
-
-	async execute(
-		_toolCallId: string,
-		params: Static<typeof astFindSchema>,
-		signal?: AbortSignal,
-		_onUpdate?: AgentToolUpdateCallback<AstFindToolDetails>,
-		_context?: AgentToolContext,
-	): Promise<AgentToolResult<AstFindToolDetails>> {
-		return untilAborted(signal, async () => {
-			const pattern = params.pattern?.trim();
-			if (!pattern) {
-				throw new ToolError("`pattern` is required");
-			}
-			const limit = params.limit === undefined ? 50 : Math.floor(params.limit);
-			if (!Number.isFinite(limit) || limit < 1) {
-				throw new ToolError("Limit must be a positive number");
-			}
-			const offset = params.offset === undefined ? 0 : Math.floor(params.offset);
-			if (!Number.isFinite(offset) || offset < 0) {
-				throw new ToolError("Offset must be a non-negative number");
-			}
-			const context = params.context === undefined ? undefined : Math.floor(params.context);
-			if (context !== undefined && (!Number.isFinite(context) || context < 0)) {
-				throw new ToolError("Context must be a non-negative number");
-			}
-
-			let searchPath: string | undefined;
-			let globFilter: string | undefined;
-			const rawPath = params.path?.trim();
-			if (rawPath) {
-				const internalRouter = this.session.internalRouter;
-				if (internalRouter?.canHandle(rawPath)) {
-					if (hasGlobPathChars(rawPath)) {
-						throw new ToolError(`Glob patterns are not supported for internal URLs: ${rawPath}`);
-					}
-					const resource = await internalRouter.resolve(rawPath);
-					if (!resource.sourcePath) {
-						throw new ToolError(`Cannot search internal URL without backing file: ${rawPath}`);
-					}
-					searchPath = resource.sourcePath;
-				} else {
-					const parsedPath = parseSearchPath(rawPath);
-					searchPath = resolveToCwd(parsedPath.basePath, this.session.cwd);
-					globFilter = parsedPath.glob;
-				}
-			}
-
-			const result = await astFind({
-				pattern,
-				lang: params.lang?.trim(),
-				path: searchPath,
-				glob: globFilter,
-				selector: params.selector?.trim(),
-				limit,
-				offset,
-				context,
-				includeMeta: params.include_meta,
-				signal,
-			});
-
-			const details: AstFindToolDetails = {
-				matchCount: result.totalMatches,
-				fileCount: result.filesWithMatches,
-				filesSearched: result.filesSearched,
-				limitReached: result.limitReached,
-				parseErrors: result.parseErrors,
-			};
-
-			if (result.matches.length === 0) {
-				const parseMessage = result.parseErrors?.length
-					? `\nParse issues:\n${result.parseErrors.map(err => `- ${err}`).join("\n")}`
-					: "";
-				return toolResult(details).text(`No matches found${parseMessage}`).done();
-			}
-
-			const lines: string[] = [
-				`${result.totalMatches} matches in ${result.filesWithMatches} files (searched ${result.filesSearched})`,
-			];
-			const grouped = new Map<string, AstFindResult["matches"]>();
-			for (const match of result.matches) {
-				const entry = grouped.get(match.path);
-				if (entry) {
-					entry.push(match);
-				} else {
-					grouped.set(match.path, [match]);
-				}
-			}
-			for (const [filePath, matches] of grouped) {
-				lines.push("", `# ${filePath}`);
-				for (const match of matches) {
-					const firstLine = match.text.split("\n", 1)[0] ?? "";
-					const preview = firstLine.length > 140 ? `${firstLine.slice(0, 137)}...` : firstLine;
-					lines.push(`${match.startLine}:${match.startColumn}-${match.endLine}:${match.endColumn}: ${preview}`);
-					if (match.metaVariables && Object.keys(match.metaVariables).length > 0) {
-						const serializedMeta = Object.entries(match.metaVariables)
-							.sort(([left], [right]) => left.localeCompare(right))
-							.map(([key, value]) => `${key}=${value}`)
-							.join(", ");
-						lines.push(`  meta: ${serializedMeta}`);
-					}
-				}
-			}
-			if (result.limitReached) {
-				lines.push("", "Result limit reached; narrow path pattern or increase limit.");
-			}
-			if (result.parseErrors?.length) {
-				lines.push("", "Parse issues:", ...result.parseErrors.map(err => `- ${err}`));
-			}
-
-			const output = lines.join("\n");
-			return toolResult(details).text(output).done();
-		});
-	}
-}
-
-// =============================================================================
-// TUI Renderer
-// =============================================================================
-
-interface AstFindRenderArgs {
-	pattern?: string;
-	lang?: string;
-	path?: string;
-	selector?: string;
-	limit?: number;
-	offset?: number;
-	context?: number;
-	include_meta?: boolean;
-}
-
-const COLLAPSED_MATCH_LIMIT = PREVIEW_LIMITS.COLLAPSED_LINES * 2;
-
-export const astFindToolRenderer = {
-	inline: true,
-	renderCall(args: AstFindRenderArgs, _options: RenderResultOptions, uiTheme: Theme): Component {
-		const meta: string[] = [];
-		if (args.lang) meta.push(`lang:${args.lang}`);
-		if (args.path) meta.push(`in ${args.path}`);
-		if (args.selector) meta.push("selector");
-		if (args.limit !== undefined && args.limit > 0) meta.push(`limit:${args.limit}`);
-		if (args.offset !== undefined && args.offset > 0) meta.push(`offset:${args.offset}`);
-		if (args.context !== undefined) meta.push(`context:${args.context}`);
-		if (args.include_meta) meta.push("meta");
-
-		const description = args.pattern || "?";
-		const text = renderStatusLine({ icon: "pending", title: "AST Find", description, meta }, uiTheme);
-		return new Text(text, 0, 0);
-	},
-
-	renderResult(
-		result: { content: Array<{ type: string; text?: string }>; details?: AstFindToolDetails; isError?: boolean },
-		options: RenderResultOptions,
-		uiTheme: Theme,
-		args?: AstFindRenderArgs,
-	): Component {
-		const details = result.details;
-
-		if (result.isError) {
-			const errorText = result.content?.find(c => c.type === "text")?.text || "Unknown error";
-			return new Text(formatErrorMessage(errorText, uiTheme), 0, 0);
-		}
-
-		const matchCount = details?.matchCount ?? 0;
-		const fileCount = details?.fileCount ?? 0;
-		const filesSearched = details?.filesSearched ?? 0;
-		const limitReached = details?.limitReached ?? false;
-
-		if (matchCount === 0) {
-			const description = args?.pattern;
-			const meta = ["0 matches"];
-			if (filesSearched > 0) meta.push(`searched ${filesSearched}`);
-			const header = renderStatusLine({ icon: "warning", title: "AST Find", description, meta }, uiTheme);
-			const lines = [header, formatEmptyMessage("No matches found", uiTheme)];
-			if (details?.parseErrors?.length) {
-				for (const err of details.parseErrors) {
-					lines.push(uiTheme.fg("warning", `  - ${err}`));
-				}
-			}
-			return new Text(lines.join("\n"), 0, 0);
-		}
-
-		const summaryParts = [formatCount("match", matchCount), formatCount("file", fileCount)];
-		const meta = [...summaryParts, `searched ${filesSearched}`];
-		if (limitReached) meta.push(uiTheme.fg("warning", "limit reached"));
-		const description = args?.pattern;
-		const header = renderStatusLine(
-			{ icon: limitReached ? "warning" : "success", title: "AST Find", description, meta },
-			uiTheme,
-		);
-
-		// Parse text content into match groups (grouped by file, separated by blank lines)
-		const textContent = result.content?.find(c => c.type === "text")?.text ?? "";
-		const rawLines = textContent.split("\n");
-		// Skip the summary line and group by blank-line separators
-		const contentLines = rawLines.slice(1);
-		const allGroups: string[][] = [];
-		let current: string[] = [];
-		for (const line of contentLines) {
-			if (line.trim().length === 0) {
-				if (current.length > 0) {
-					allGroups.push(current);
-					current = [];
-				}
-				continue;
-			}
-			current.push(line);
-		}
-		if (current.length > 0) allGroups.push(current);
-
-		// Keep only file match groups (starting with "# ")
-		const matchGroups = allGroups.filter(group => group[0]?.startsWith("# "));
-
-		const getCollapsedMatchLimit = (groups: string[][], maxLines: number): number => {
-			if (groups.length === 0) return 0;
-			let usedLines = 0;
-			let count = 0;
-			for (const group of groups) {
-				if (count > 0 && usedLines + group.length > maxLines) break;
-				usedLines += group.length;
-				count += 1;
-				if (usedLines >= maxLines) break;
-			}
-			return count;
-		};
-
-		const extraLines: string[] = [];
-		if (limitReached) {
-			extraLines.push(uiTheme.fg("warning", "limit reached; narrow path pattern or increase limit"));
-		}
-		if (details?.parseErrors?.length) {
-			extraLines.push(uiTheme.fg("warning", `${details.parseErrors.length} parse issue(s)`));
-		}
-
-		let cached: RenderCache | undefined;
-		return {
-			render(width: number): string[] {
-				const { expanded } = options;
-				const key = new Hasher().bool(expanded).u32(width).digest();
-				if (cached?.key === key) return cached.lines;
-				const maxCollapsed = expanded
-					? matchGroups.length
-					: getCollapsedMatchLimit(matchGroups, COLLAPSED_MATCH_LIMIT);
-				const matchLines = renderTreeList(
-					{
-						items: matchGroups,
-						expanded,
-						maxCollapsed,
-						itemType: "match",
-						renderItem: group =>
-							group.map(line => {
-								if (line.startsWith("# ")) return uiTheme.fg("accent", line);
-								if (line.startsWith("  meta:")) return uiTheme.fg("dim", line);
-								return uiTheme.fg("toolOutput", line);
-							}),
-					},
-					uiTheme,
-				);
-				const result = [header, ...matchLines, ...extraLines].map(l => truncateToWidth(l, width, Ellipsis.Omit));
-				cached = { key, lines: result };
-				return result;
-			},
-			invalidate() {
-				cached = undefined;
-			},
-		};
-	},
-	mergeCallAndResult: true,
-};