@oh-my-pi/pi-coding-agent 3.20.1 → 3.24.0

package/src/core/tools/find.ts

@@ -1,12 +1,28 @@
 import { existsSync, type Stats, statSync } from "node:fs";
 import path 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 { globSync } from "glob";
+import { getLanguageFromPath, type Theme } from "../../modes/interactive/theme/theme";
 import findDescription from "../../prompts/tools/find.md" with { type: "text" };
 import { ensureTool } from "../../utils/tools-manager";
+import type { RenderResultOptions } from "../custom-tools/types";
 import { untilAborted } from "../utils";
+import type { ToolSession } from "./index";
 import { resolveToCwd } from "./path-utils";
+import {
+	formatCount,
+	formatEmptyMessage,
+	formatErrorMessage,
+	formatExpandHint,
+	formatMeta,
+	formatMoreItems,
+	formatScope,
+	formatTruncationSuffix,
+	PREVIEW_LIMITS,
+} from "./render-utils";
 import { DEFAULT_MAX_BYTES, formatSize, type TruncationResult, truncateHead } from "./truncate";
 
 const findSchema = Type.Object({
@@ -40,7 +56,7 @@ export interface FindToolDetails {
 	error?: string;
 }
 
-export function createFindTool(cwd: string): AgentTool<typeof findSchema> {
+export function createFindTool(session: ToolSession): AgentTool<typeof findSchema> {
 	return {
 		name: "find",
 		label: "Find",
@@ -72,9 +88,9 @@ export function createFindTool(cwd: string): AgentTool<typeof findSchema> {
 					throw new Error("fd is not available and could not be downloaded");
 				}
 
-				const searchPath = resolveToCwd(searchDir || ".", cwd);
+				const searchPath = resolveToCwd(searchDir || ".", session.cwd);
 				const scopePath = (() => {
-					const relative = path.relative(cwd, searchPath).replace(/\\/g, "/");
+					const relative = path.relative(session.cwd, searchPath).replace(/\\/g, "/");
 					return relative.length === 0 ? "." : relative;
 				})();
 				const effectiveLimit = limit ?? DEFAULT_LIMIT;
@@ -246,5 +262,133 @@ export function createFindTool(cwd: string): AgentTool<typeof findSchema> {
 	};
 }
 
-/** Default find tool using process.cwd() - for backwards compatibility */
-export const findTool = createFindTool(process.cwd());
+// =============================================================================
+// TUI Renderer
+// =============================================================================
+
+interface FindRenderArgs {
+	pattern: string;
+	path?: string;
+	type?: string;
+	hidden?: boolean;
+	sortByMtime?: boolean;
+	limit?: number;
+}
+
+const COLLAPSED_LIST_LIMIT = PREVIEW_LIMITS.COLLAPSED_ITEMS;
+
+export const findToolRenderer = {
+	renderCall(args: FindRenderArgs, uiTheme: Theme): Component {
+		const label = uiTheme.fg("toolTitle", uiTheme.bold("Find"));
+		let text = `${label} ${uiTheme.fg("accent", args.pattern || "*")}`;
+
+		const meta: string[] = [];
+		if (args.path) meta.push(`in ${args.path}`);
+		if (args.type && args.type !== "all") meta.push(`type:${args.type}`);
+		if (args.hidden) meta.push("hidden");
+		if (args.sortByMtime) meta.push("sort:mtime");
+		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?: FindToolDetails },
+		{ expanded }: RenderResultOptions,
+		uiTheme: Theme,
+	): Component {
+		const details = result.details;
+
+		if (details?.error) {
+			return new Text(formatErrorMessage(details.error, uiTheme), 0, 0);
+		}
+
+		const hasDetailedData = details?.fileCount !== undefined;
+		const textContent = result.content?.find((c) => c.type === "text")?.text;
+
+		if (!hasDetailedData) {
+			if (!textContent || textContent.includes("No files matching") || textContent.trim() === "") {
+				return new Text(formatEmptyMessage("No files found", uiTheme), 0, 0);
+			}
+
+			const lines = textContent.split("\n").filter((l) => l.trim());
+			const maxLines = expanded ? lines.length : Math.min(lines.length, COLLAPSED_LIST_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("file", 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("accent", displayLines[i])}`;
+			}
+			if (remaining > 0) {
+				text += `\n ${uiTheme.fg("dim", uiTheme.tree.last)} ${uiTheme.fg("muted", formatMoreItems(remaining, "file", uiTheme))}`;
+			}
+			return new Text(text, 0, 0);
+		}
+
+		const fileCount = details?.fileCount ?? 0;
+		const truncated = details?.truncated ?? details?.truncation?.truncated ?? false;
+		const files = details?.files ?? [];
+
+		if (fileCount === 0) {
+			return new Text(formatEmptyMessage("No files found", uiTheme), 0, 0);
+		}
+
+		const icon = uiTheme.styledSymbol("status.success", "success");
+		const summaryText = formatCount("file", fileCount);
+		const scopeLabel = formatScope(details?.scopePath, uiTheme);
+		const maxFiles = expanded ? files.length : Math.min(files.length, COLLAPSED_LIST_LIMIT);
+		const hasMoreFiles = files.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?.resultLimitReached) {
+			truncationReasons.push(`limit ${details.resultLimitReached} results`);
+		}
+		if (details?.truncation?.truncated) {
+			truncationReasons.push("size limit");
+		}
+
+		const hasTruncation = truncationReasons.length > 0;
+
+		if (files.length > 0) {
+			for (let i = 0; i < maxFiles; i++) {
+				const isLast = i === maxFiles - 1 && !hasMoreFiles && !hasTruncation;
+				const branch = isLast ? uiTheme.tree.last : uiTheme.tree.branch;
+				const entry = files[i];
+				const isDir = entry.endsWith("/");
+				const entryPath = isDir ? entry.slice(0, -1) : entry;
+				const lang = isDir ? undefined : getLanguageFromPath(entryPath);
+				const entryIcon = isDir
+					? uiTheme.fg("accent", uiTheme.icon.folder)
+					: uiTheme.fg("muted", uiTheme.getLangIcon(lang));
+				text += `\n ${uiTheme.fg("dim", branch)} ${entryIcon} ${uiTheme.fg("accent", entry)}`;
+			}
+
+			if (hasMoreFiles) {
+				const moreFilesBranch = hasTruncation ? uiTheme.tree.branch : uiTheme.tree.last;
+				text += `\n ${uiTheme.fg("dim", moreFilesBranch)} ${uiTheme.fg(
+					"muted",
+					formatMoreItems(files.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/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

@@ -2,6 +2,7 @@ import type { AgentTool } from "@oh-my-pi/pi-agent-core";
 import { type GitParams, gitTool as gitToolCore, type ToolResponse } from "@oh-my-pi/pi-git-tool";
 import { type Static, Type } from "@sinclair/typebox";
 import gitDescription from "../../prompts/tools/git.md" with { type: "text" };
+import type { ToolSession } from "./index";
 
 const gitSchema = Type.Object({
 	operation: Type.Union([
@@ -192,14 +193,21 @@ const gitSchema = Type.Object({
 
 export type GitToolDetails = ToolResponse<unknown>;
 
-export function createGitTool(cwd: string): AgentTool<typeof gitSchema, GitToolDetails> {
+export function createGitTool(session: ToolSession): AgentTool<typeof gitSchema, GitToolDetails> | null {
+	if (session.settings?.getGitToolEnabled() === false) {
+		return null;
+	}
 	return {
 		name: "git",
 		label: "Git",
 		description: gitDescription,
 		parameters: gitSchema,
 		execute: async (_toolCallId, params: Static<typeof gitSchema>, _signal?: AbortSignal) => {
-			const result = await gitToolCore(params as GitParams, cwd);
+			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, session.cwd);
 			if ("error" in result) {
 				const message = result._rendered ?? result.error;
 				return { content: [{ type: "text", text: message }], details: result };
@@ -213,4 +221,10 @@ export function createGitTool(cwd: string): AgentTool<typeof gitSchema, GitToolD
 	};
 }
 
-export const gitTool = createGitTool(process.cwd());
+export const gitTool = createGitTool({
+	cwd: process.cwd(),
+	hasUI: false,
+	rulebookRules: [],
+	getSessionFile: () => null,
+	getSessionSpawns: () => null,
+})!;