@oh-my-pi/pi-coding-agent 3.20.0 → 3.21.0

package/src/core/tools/gemini-image.ts

@@ -1,4 +1,7 @@
-import type { ImageContent, TextContent } from "@oh-my-pi/pi-ai";
+import * as crypto from "node:crypto";
+import * as fs from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 import { type Static, Type } from "@sinclair/typebox";
 import geminiImageDescription from "../../prompts/tools/gemini-image.md" with { type: "text" };
 import { detectSupportedImageMimeTypeFromFile } from "../../utils/mime";
@@ -7,10 +10,17 @@ import { untilAborted } from "../utils";
 import { resolveReadPath } from "./path-utils";
 import { getEnv } from "./web-search/auth";
 
-const DEFAULT_MODEL = "gemini-2.5-flash-image";
+const DEFAULT_MODEL = "gemini-3-pro-image-preview";
+const DEFAULT_OPENROUTER_MODEL = "google/gemini-3-pro-image-preview";
 const DEFAULT_TIMEOUT_SECONDS = 120;
 const MAX_IMAGE_SIZE = 20 * 1024 * 1024;
 
+type ImageProvider = "gemini" | "openrouter";
+interface ImageApiKey {
+	provider: ImageProvider;
+	apiKey: string;
+}
+
 const responseModalitySchema = Type.Union([Type.Literal("Image"), Type.Literal("Text")]);
 const aspectRatioSchema = Type.Union(
 	[Type.Literal("1:1"), Type.Literal("3:4"), Type.Literal("4:3"), Type.Literal("9:16"), Type.Literal("16:9")],
@@ -34,13 +44,7 @@ export const geminiImageSchema = Type.Object(
 		prompt: Type.String({ description: "Text prompt for image generation or editing." }),
 		model: Type.Optional(
 			Type.String({
-				description: `Gemini image model. Default: ${DEFAULT_MODEL} (Nano Banana).`,
-			}),
-		),
-		response_modalities: Type.Optional(
-			Type.Array(responseModalitySchema, {
-				description: 'Response modalities (default: ["Image"]).',
-				minItems: 1,
+				description: `Image model. Default: ${DEFAULT_MODEL} (direct Gemini) or ${DEFAULT_OPENROUTER_MODEL} (OpenRouter).`,
 			}),
 		),
 		aspect_ratio: Type.Optional(aspectRatioSchema),
@@ -100,9 +104,35 @@ interface GeminiGenerateContentResponse {
 	usageMetadata?: GeminiUsageMetadata;
 }
 
+interface OpenRouterImageUrl {
+	url: string;
+}
+
+interface OpenRouterContentPart {
+	type: "text" | "image_url";
+	text?: string;
+	image_url?: OpenRouterImageUrl;
+}
+
+interface OpenRouterMessage {
+	content?: string | OpenRouterContentPart[];
+	images?: Array<string | { image_url?: OpenRouterImageUrl }>;
+}
+
+interface OpenRouterChoice {
+	message?: OpenRouterMessage;
+}
+
+interface OpenRouterResponse {
+	choices?: OpenRouterChoice[];
+}
+
 interface GeminiImageToolDetails {
+	provider: ImageProvider;
 	model: string;
 	imageCount: number;
+	imagePaths: string[];
+	images: InlineImageData[];
 	responseText?: string;
 	promptFeedback?: GeminiPromptFeedback;
 	usage?: GeminiUsageMetadata;
@@ -125,12 +155,109 @@ function normalizeDataUrl(data: string): { data: string; mimeType?: string } {
 	return { data: match[2] ?? "", mimeType: match[1] };
 }
 
-async function findGeminiApiKey(): Promise<string | null> {
+function resolveOpenRouterModel(model: string): string {
+	return model.includes("/") ? model : `google/${model}`;
+}
+
+function toDataUrl(image: InlineImageData): string {
+	return `data:${image.mimeType};base64,${image.data}`;
+}
+
+async function loadImageFromUrl(imageUrl: string, signal?: AbortSignal): Promise<InlineImageData> {
+	if (imageUrl.startsWith("data:")) {
+		const normalized = normalizeDataUrl(imageUrl.trim());
+		if (!normalized.mimeType) {
+			throw new Error("mime_type is required when providing raw base64 data.");
+		}
+		if (!normalized.data) {
+			throw new Error("Image data is empty.");
+		}
+		return { data: normalized.data, mimeType: normalized.mimeType };
+	}
+
+	const response = await fetch(imageUrl, { signal });
+	if (!response.ok) {
+		const rawText = await response.text();
+		throw new Error(`Image download failed (${response.status}): ${rawText}`);
+	}
+	const contentType = response.headers.get("content-type")?.split(";")[0];
+	if (!contentType || !contentType.startsWith("image/")) {
+		throw new Error(`Unsupported image type from URL: ${imageUrl}`);
+	}
+	const buffer = Buffer.from(await response.arrayBuffer());
+	return { data: buffer.toString("base64"), mimeType: contentType };
+}
+
+function collectOpenRouterResponseText(message: OpenRouterMessage | undefined): string | undefined {
+	if (!message) return undefined;
+	if (typeof message.content === "string") {
+		const trimmed = message.content.trim();
+		return trimmed.length > 0 ? trimmed : undefined;
+	}
+	if (Array.isArray(message.content)) {
+		const texts = message.content
+			.filter((part) => part.type === "text")
+			.map((part) => part.text)
+			.filter((text): text is string => Boolean(text));
+		const combined = texts.join("\n").trim();
+		return combined.length > 0 ? combined : undefined;
+	}
+	return undefined;
+}
+
+function extractOpenRouterImageUrls(message: OpenRouterMessage | undefined): string[] {
+	const urls: string[] = [];
+	if (!message) return urls;
+	for (const image of message.images ?? []) {
+		if (typeof image === "string") {
+			urls.push(image);
+			continue;
+		}
+		if (image.image_url?.url) {
+			urls.push(image.image_url.url);
+		}
+	}
+	if (Array.isArray(message.content)) {
+		for (const part of message.content) {
+			if (part.type === "image_url" && part.image_url?.url) {
+				urls.push(part.image_url.url);
+			}
+		}
+	}
+	return urls;
+}
+
+/** Preferred provider set via settings (default: auto) */
+let preferredImageProvider: ImageProvider | "auto" = "auto";
+
+/** Set the preferred image provider from settings */
+export function setPreferredImageProvider(provider: ImageProvider | "auto"): void {
+	preferredImageProvider = provider;
+}
+
+async function findImageApiKey(): Promise<ImageApiKey | null> {
+	// If a specific provider is preferred, try it first
+	if (preferredImageProvider === "gemini") {
+		const geminiKey = await getEnv("GEMINI_API_KEY");
+		if (geminiKey) return { provider: "gemini", apiKey: geminiKey };
+		const googleKey = await getEnv("GOOGLE_API_KEY");
+		if (googleKey) return { provider: "gemini", apiKey: googleKey };
+		// Fall through to auto-detect if preferred provider key not found
+	} else if (preferredImageProvider === "openrouter") {
+		const openRouterKey = await getEnv("OPENROUTER_API_KEY");
+		if (openRouterKey) return { provider: "openrouter", apiKey: openRouterKey };
+		// Fall through to auto-detect if preferred provider key not found
+	}
+
+	// Auto-detect: OpenRouter takes priority
+	const openRouterKey = await getEnv("OPENROUTER_API_KEY");
+	if (openRouterKey) return { provider: "openrouter", apiKey: openRouterKey };
+
 	const geminiKey = await getEnv("GEMINI_API_KEY");
-	if (geminiKey) return geminiKey;
+	if (geminiKey) return { provider: "gemini", apiKey: geminiKey };
 
 	const googleKey = await getEnv("GOOGLE_API_KEY");
-	if (googleKey) return googleKey;
+	if (googleKey) return { provider: "gemini", apiKey: googleKey };
 
 	return null;
 }
@@ -174,8 +301,29 @@ async function resolveInputImage(input: ImageInput, cwd: string): Promise<Inline
 	throw new Error("input_images entries must include either path or data.");
 }
 
-function buildResponseSummary(model: string, imageCount: number, responseText: string | undefined): string {
-	const lines = [`Model: ${model}`, `Images: ${imageCount}`];
+function getExtensionForMime(mimeType: string): string {
+	const map: Record<string, string> = {
+		"image/png": "png",
+		"image/jpeg": "jpg",
+		"image/gif": "gif",
+		"image/webp": "webp",
+	};
+	return map[mimeType] ?? "png";
+}
+
+function saveImageToTemp(image: InlineImageData): string {
+	const ext = getExtensionForMime(image.mimeType);
+	const filename = `omp-image-${crypto.randomUUID()}.${ext}`;
+	const filepath = join(tmpdir(), filename);
+	fs.writeFileSync(filepath, Buffer.from(image.data, "base64"));
+	return filepath;
+}
+
+function buildResponseSummary(model: string, imagePaths: string[], responseText: string | undefined): string {
+	const lines = [`Model: ${model}`, `Generated ${imagePaths.length} image(s):`];
+	for (const p of imagePaths) {
+		lines.push(`  ${p}`);
+	}
 	if (responseText) {
 		lines.push("", responseText.trim());
 	}
@@ -232,60 +380,137 @@ function createAbortController(
 }
 
 export const geminiImageTool: CustomTool<typeof geminiImageSchema, GeminiImageToolDetails> = {
-	name: "gemini_image",
-	label: "Gemini Image",
+	name: "generate_image",
+	label: "GenerateImage",
 	description: geminiImageDescription,
 	parameters: geminiImageSchema,
 	async execute(_toolCallId, params, _onUpdate, ctx, signal) {
 		return untilAborted(signal, async () => {
-			const apiKey = await findGeminiApiKey();
+			const apiKey = await findImageApiKey();
 			if (!apiKey) {
-				throw new Error("GEMINI_API_KEY not found.");
+				throw new Error("OPENROUTER_API_KEY, GEMINI_API_KEY, or GOOGLE_API_KEY not found.");
 			}
 
-			const model = params.model ?? DEFAULT_MODEL;
-			const responseModalities = params.response_modalities ?? ["Image"];
+			const provider = apiKey.provider;
+			const model = params.model ?? (provider === "openrouter" ? DEFAULT_OPENROUTER_MODEL : DEFAULT_MODEL);
+			const resolvedModel = provider === "openrouter" ? resolveOpenRouterModel(model) : model;
 			const cwd = ctx.sessionManager.getCwd();
 
-			const parts = [] as Array<{ text?: string; inlineData?: InlineImageData }>;
+			const resolvedImages: InlineImageData[] = [];
 			if (params.input_images?.length) {
 				for (const input of params.input_images) {
-					const image = await resolveInputImage(input, cwd);
-					parts.push({ inlineData: image });
+					resolvedImages.push(await resolveInputImage(input, cwd));
 				}
 			}
-			parts.push({ text: params.prompt });
-
-			const generationConfig: {
-				responseModalities: GeminiResponseModality[];
-				imageConfig?: { aspectRatio?: string; imageSize?: string };
-			} = {
-				responseModalities,
-			};
-
-			if (params.aspect_ratio || params.image_size) {
-				generationConfig.imageConfig = {
-					aspectRatio: params.aspect_ratio,
-					imageSize: params.image_size,
-				};
-			}
-
-			const requestBody = {
-				contents: [{ role: "user" as const, parts }],
-				generationConfig,
-			};
 
 			const timeoutSeconds = params.timeout_seconds ?? DEFAULT_TIMEOUT_SECONDS;
 			const { controller, cleanup } = createAbortController(signal, timeoutSeconds);
 
 			try {
+				if (provider === "openrouter") {
+					const contentParts: OpenRouterContentPart[] = [{ type: "text", text: params.prompt }];
+					for (const image of resolvedImages) {
+						contentParts.push({ type: "image_url", image_url: { url: toDataUrl(image) } });
+					}
+
+					const requestBody = {
+						model: resolvedModel,
+						messages: [{ role: "user" as const, content: contentParts }],
+					};
+
+					const response = await fetch("https://openrouter.ai/api/v1/chat/completions", {
+						method: "POST",
+						headers: {
+							"Content-Type": "application/json",
+							Authorization: `Bearer ${apiKey.apiKey}`,
+						},
+						body: JSON.stringify(requestBody),
+						signal: controller.signal,
+					});
+
+					const rawText = await response.text();
+					if (!response.ok) {
+						let message = rawText;
+						try {
+							const parsed = JSON.parse(rawText) as { error?: { message?: string } };
+							message = parsed.error?.message ?? message;
+						} catch {
+							// Keep raw text.
+						}
+						throw new Error(`OpenRouter image request failed (${response.status}): ${message}`);
+					}
+
+					const data = JSON.parse(rawText) as OpenRouterResponse;
+					const message = data.choices?.[0]?.message;
+					const responseText = collectOpenRouterResponseText(message);
+					const imageUrls = extractOpenRouterImageUrls(message);
+					const inlineImages: InlineImageData[] = [];
+					for (const imageUrl of imageUrls) {
+						inlineImages.push(await loadImageFromUrl(imageUrl, controller.signal));
+					}
+
+					if (inlineImages.length === 0) {
+						const messageText = responseText ? `\n\n${responseText}` : "";
+						return {
+							content: [{ type: "text", text: `No image data returned.${messageText}` }],
+							details: {
+								provider,
+								model: resolvedModel,
+								imageCount: 0,
+								imagePaths: [],
+								images: [],
+								responseText,
+							},
+						};
+					}
+
+					const imagePaths = inlineImages.map(saveImageToTemp);
+
+					return {
+						content: [{ type: "text", text: buildResponseSummary(resolvedModel, imagePaths, responseText) }],
+						details: {
+							provider,
+							model: resolvedModel,
+							imageCount: inlineImages.length,
+							imagePaths,
+							images: inlineImages,
+							responseText,
+						},
+					};
+				}
+
+				const parts = [] as Array<{ text?: string; inlineData?: InlineImageData }>;
+				for (const image of resolvedImages) {
+					parts.push({ inlineData: image });
+				}
+				parts.push({ text: params.prompt });
+
+				const generationConfig: {
+					responseModalities: GeminiResponseModality[];
+					imageConfig?: { aspectRatio?: string; imageSize?: string };
+				} = {
+					responseModalities: ["Image"],
+				};
+
+				if (params.aspect_ratio || params.image_size) {
+					generationConfig.imageConfig = {
+						aspectRatio: params.aspect_ratio,
+						imageSize: params.image_size,
+					};
+				}
+
+				const requestBody = {
+					contents: [{ role: "user" as const, parts }],
+					generationConfig,
+				};
+
 				const response = await fetch(
 					`https://generativelanguage.googleapis.com/v1beta/models/${encodeURIComponent(model)}:generateContent`,
 					{
 						method: "POST",
 						headers: {
 							"Content-Type": "application/json",
-							"x-goog-api-key": apiKey,
+							"x-goog-api-key": apiKey.apiKey,
 						},
 						body: JSON.stringify(requestBody),
 						signal: controller.signal,
@@ -308,18 +533,19 @@ export const geminiImageTool: CustomTool<typeof geminiImageSchema, GeminiImageTo
 				const responseParts = combineParts(data);
 				const responseText = collectResponseText(responseParts);
 				const inlineImages = collectInlineImages(responseParts);
-				const content: Array<TextContent | ImageContent> = [];
 
 				if (inlineImages.length === 0) {
 					const blocked = data.promptFeedback?.blockReason
 						? `Blocked: ${data.promptFeedback.blockReason}`
 						: "No image data returned.";
-					content.push({ type: "text", text: `${blocked}${responseText ? `\n\n${responseText}` : ""}` });
 					return {
-						content,
+						content: [{ type: "text", text: `${blocked}${responseText ? `\n\n${responseText}` : ""}` }],
 						details: {
+							provider,
 							model,
 							imageCount: 0,
+							imagePaths: [],
+							images: [],
 							responseText,
 							promptFeedback: data.promptFeedback,
 							usage: data.usageMetadata,
@@ -327,19 +553,16 @@ export const geminiImageTool: CustomTool<typeof geminiImageSchema, GeminiImageTo
 					};
 				}
 
-				content.push({
-					type: "text",
-					text: buildResponseSummary(model, inlineImages.length, responseText),
-				});
-				for (const image of inlineImages) {
-					content.push({ type: "image", data: image.data, mimeType: image.mimeType });
-				}
+				const imagePaths = inlineImages.map(saveImageToTemp);
 
 				return {
-					content,
+					content: [{ type: "text", text: buildResponseSummary(model, imagePaths, responseText) }],
 					details: {
+						provider,
 						model,
 						imageCount: inlineImages.length,
+						imagePaths,
+						images: inlineImages,
 						responseText,
 						promptFeedback: data.promptFeedback,
 						usage: data.usageMetadata,
@@ -355,7 +578,7 @@ export const geminiImageTool: CustomTool<typeof geminiImageSchema, GeminiImageTo
 export async function getGeminiImageTools(): Promise<
 	Array<CustomTool<typeof geminiImageSchema, GeminiImageToolDetails>>
 > {
-	const apiKey = await findGeminiApiKey();
+	const apiKey = await findImageApiKey();
 	if (!apiKey) return [];
 	return [geminiImageTool];
 }

package/src/core/tools/git.ts

@@ -199,6 +199,10 @@ export function createGitTool(cwd: string): AgentTool<typeof gitSchema, GitToolD
 		description: gitDescription,
 		parameters: gitSchema,
 		execute: async (_toolCallId, params: Static<typeof gitSchema>, _signal?: AbortSignal) => {
+			if (params.operation === "commit" && !params.message) {
+				throw new Error("Git commit requires a message to avoid an interactive editor. Provide `message`.");
+			}
+
 			const result = await gitToolCore(params as GitParams, cwd);
 			if ("error" in result) {
 				const message = result._rendered ?? result.error;

package/src/core/tools/grep.ts

@@ -1,11 +1,26 @@
 import { readFileSync, type Stats, statSync } from "node:fs";
 import nodePath from "node:path";
 import type { AgentTool } from "@oh-my-pi/pi-agent-core";
+import type { Component } from "@oh-my-pi/pi-tui";
+import { Text } from "@oh-my-pi/pi-tui";
 import { Type } from "@sinclair/typebox";
 import type { Subprocess } from "bun";
+import { getLanguageFromPath, type Theme } from "../../modes/interactive/theme/theme";
 import grepDescription from "../../prompts/tools/grep.md" with { type: "text" };
 import { ensureTool } from "../../utils/tools-manager";
+import type { RenderResultOptions } from "../custom-tools/types";
 import { resolveToCwd } from "./path-utils";
+import {
+	formatCount,
+	formatEmptyMessage,
+	formatErrorMessage,
+	formatExpandHint,
+	formatMeta,
+	formatMoreItems,
+	formatScope,
+	formatTruncationSuffix,
+	PREVIEW_LIMITS,
+} from "./render-utils";
 import {
 	DEFAULT_MAX_BYTES,
 	formatSize,
@@ -582,3 +597,179 @@ export function createGrepTool(cwd: string): AgentTool<typeof grepSchema> {
 
 /** Default grep tool using process.cwd() - for backwards compatibility */
 export const grepTool = createGrepTool(process.cwd());
+
+// =============================================================================
+// TUI Renderer
+// =============================================================================
+
+interface GrepRenderArgs {
+	pattern: string;
+	path?: string;
+	glob?: string;
+	type?: string;
+	ignoreCase?: boolean;
+	caseSensitive?: boolean;
+	literal?: boolean;
+	multiline?: boolean;
+	context?: number;
+	limit?: number;
+	outputMode?: string;
+}
+
+const COLLAPSED_LIST_LIMIT = PREVIEW_LIMITS.COLLAPSED_ITEMS;
+const COLLAPSED_TEXT_LIMIT = PREVIEW_LIMITS.COLLAPSED_LINES * 2;
+
+export const grepToolRenderer = {
+	renderCall(args: GrepRenderArgs, uiTheme: Theme): Component {
+		const label = uiTheme.fg("toolTitle", uiTheme.bold("Grep"));
+		let text = `${label} ${uiTheme.fg("accent", args.pattern || "?")}`;
+
+		const meta: string[] = [];
+		if (args.path) meta.push(`in ${args.path}`);
+		if (args.glob) meta.push(`glob:${args.glob}`);
+		if (args.type) meta.push(`type:${args.type}`);
+		if (args.outputMode && args.outputMode !== "files_with_matches") meta.push(`mode:${args.outputMode}`);
+		if (args.caseSensitive) {
+			meta.push("case:sensitive");
+		} else if (args.ignoreCase) {
+			meta.push("case:insensitive");
+		}
+		if (args.literal) meta.push("literal");
+		if (args.multiline) meta.push("multiline");
+		if (args.context !== undefined) meta.push(`context:${args.context}`);
+		if (args.limit !== undefined) meta.push(`limit:${args.limit}`);
+
+		text += formatMeta(meta, uiTheme);
+
+		return new Text(text, 0, 0);
+	},
+
+	renderResult(
+		result: { content: Array<{ type: string; text?: string }>; details?: GrepToolDetails },
+		{ expanded }: RenderResultOptions,
+		uiTheme: Theme,
+	): Component {
+		const details = result.details;
+
+		if (details?.error) {
+			return new Text(formatErrorMessage(details.error, uiTheme), 0, 0);
+		}
+
+		const hasDetailedData = details?.matchCount !== undefined || details?.fileCount !== undefined;
+
+		if (!hasDetailedData) {
+			const textContent = result.content?.find((c) => c.type === "text")?.text;
+			if (!textContent || textContent === "No matches found") {
+				return new Text(formatEmptyMessage("No matches found", uiTheme), 0, 0);
+			}
+
+			const lines = textContent.split("\n").filter((line) => line.trim() !== "");
+			const maxLines = expanded ? lines.length : Math.min(lines.length, COLLAPSED_TEXT_LIMIT);
+			const displayLines = lines.slice(0, maxLines);
+			const remaining = lines.length - maxLines;
+			const hasMore = remaining > 0;
+
+			const icon = uiTheme.styledSymbol("status.success", "success");
+			const summary = formatCount("item", lines.length);
+			const expandHint = formatExpandHint(expanded, hasMore, uiTheme);
+			let text = `${icon} ${uiTheme.fg("dim", summary)}${expandHint}`;
+
+			for (let i = 0; i < displayLines.length; i++) {
+				const isLast = i === displayLines.length - 1 && remaining === 0;
+				const branch = isLast ? uiTheme.tree.last : uiTheme.tree.branch;
+				text += `\n ${uiTheme.fg("dim", branch)} ${uiTheme.fg("toolOutput", displayLines[i])}`;
+			}
+
+			if (remaining > 0) {
+				text += `\n ${uiTheme.fg("dim", uiTheme.tree.last)} ${uiTheme.fg(
+					"muted",
+					formatMoreItems(remaining, "item", uiTheme),
+				)}`;
+			}
+
+			return new Text(text, 0, 0);
+		}
+
+		const matchCount = details?.matchCount ?? 0;
+		const fileCount = details?.fileCount ?? 0;
+		const mode = details?.mode ?? "files_with_matches";
+		const truncated = details?.truncated ?? details?.truncation?.truncated ?? false;
+		const files = details?.files ?? [];
+
+		if (matchCount === 0) {
+			return new Text(formatEmptyMessage("No matches found", uiTheme), 0, 0);
+		}
+
+		const icon = uiTheme.styledSymbol("status.success", "success");
+		const summaryParts =
+			mode === "files_with_matches"
+				? [formatCount("file", fileCount)]
+				: [formatCount("match", matchCount), formatCount("file", fileCount)];
+		const summaryText = summaryParts.join(uiTheme.sep.dot);
+		const scopeLabel = formatScope(details?.scopePath, uiTheme);
+
+		const fileEntries: Array<{ path: string; count?: number }> = details?.fileMatches?.length
+			? details.fileMatches.map((entry) => ({ path: entry.path, count: entry.count }))
+			: files.map((path) => ({ path }));
+		const maxFiles = expanded ? fileEntries.length : Math.min(fileEntries.length, COLLAPSED_LIST_LIMIT);
+		const hasMoreFiles = fileEntries.length > maxFiles;
+		const expandHint = formatExpandHint(expanded, hasMoreFiles, uiTheme);
+
+		let text = `${icon} ${uiTheme.fg("dim", summaryText)}${formatTruncationSuffix(
+			truncated,
+			uiTheme,
+		)}${scopeLabel}${expandHint}`;
+
+		const truncationReasons: string[] = [];
+		if (details?.matchLimitReached) {
+			truncationReasons.push(`limit ${details.matchLimitReached} matches`);
+		}
+		if (details?.headLimitReached) {
+			truncationReasons.push(`head limit ${details.headLimitReached}`);
+		}
+		if (details?.truncation?.truncated) {
+			truncationReasons.push("size limit");
+		}
+		if (details?.linesTruncated) {
+			truncationReasons.push("line length");
+		}
+
+		const hasTruncation = truncationReasons.length > 0;
+
+		if (fileEntries.length > 0) {
+			for (let i = 0; i < maxFiles; i++) {
+				const entry = fileEntries[i];
+				const isLast = i === maxFiles - 1 && !hasMoreFiles && !hasTruncation;
+				const branch = isLast ? uiTheme.tree.last : uiTheme.tree.branch;
+				const isDir = entry.path.endsWith("/");
+				const entryPath = isDir ? entry.path.slice(0, -1) : entry.path;
+				const lang = isDir ? undefined : getLanguageFromPath(entryPath);
+				const entryIcon = isDir
+					? uiTheme.fg("accent", uiTheme.icon.folder)
+					: uiTheme.fg("muted", uiTheme.getLangIcon(lang));
+				const countLabel =
+					entry.count !== undefined
+						? ` ${uiTheme.fg("dim", `(${entry.count} match${entry.count !== 1 ? "es" : ""})`)}`
+						: "";
+				text += `\n ${uiTheme.fg("dim", branch)} ${entryIcon} ${uiTheme.fg("accent", entry.path)}${countLabel}`;
+			}
+
+			if (hasMoreFiles) {
+				const moreFilesBranch = hasTruncation ? uiTheme.tree.branch : uiTheme.tree.last;
+				text += `\n ${uiTheme.fg("dim", moreFilesBranch)} ${uiTheme.fg(
+					"muted",
+					formatMoreItems(fileEntries.length - maxFiles, "file", uiTheme),
+				)}`;
+			}
+		}
+
+		if (hasTruncation) {
+			text += `\n ${uiTheme.fg("dim", uiTheme.tree.last)} ${uiTheme.fg(
+				"warning",
+				`truncated: ${truncationReasons.join(", ")}`,
+			)}`;
+		}
+
+		return new Text(text, 0, 0);
+	},
+};

package/src/core/tools/index.ts

@@ -5,6 +5,7 @@ export { createEditTool, type EditToolOptions, editTool } from "./edit";
 export { exaTools } from "./exa/index";
 export type { ExaRenderDetails, ExaSearchResponse, ExaSearchResult } from "./exa/types";
 export { createFindTool, type FindToolDetails, findTool } from "./find";
+export { setPreferredImageProvider } from "./gemini-image";
 export { createGitTool, type GitToolDetails, gitTool } from "./git";
 export { createGrepTool, type GrepToolDetails, grepTool } from "./grep";
 export { createLsTool, type LsToolDetails, lsTool } from "./ls";
@@ -23,12 +24,7 @@ export { createNotebookTool, type NotebookToolDetails, notebookTool } from "./no
 export { createOutputTool, type OutputToolDetails, outputTool } from "./output";
 export { createReadTool, type ReadToolDetails, type ReadToolOptions, readTool } from "./read";
 export { createReportFindingTool, createSubmitReviewTool, reportFindingTool, submitReviewTool } from "./review";
-export {
-	createRulebookTool,
-	filterRulebookRules,
-	formatRulesForPrompt,
-	type RulebookToolDetails,
-} from "./rulebook";
+export { createRulebookTool, filterRulebookRules, formatRulesForPrompt, type RulebookToolDetails } from "./rulebook";
 export { BUNDLED_AGENTS, createTaskTool, taskTool } from "./task/index";
 export type { TruncationResult } from "./truncate";
 export { createWebFetchTool, type WebFetchToolDetails, webFetchCustomTool, webFetchTool } from "./web-fetch";
@@ -39,6 +35,7 @@ export {
 	getWebSearchTools,
 	hasExaWebSearch,
 	linkedinWebSearchTools,
+	setPreferredWebSearchProvider,
 	type WebSearchProvider,
 	type WebSearchResponse,
 	type WebSearchToolsOptions,