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

package/src/modes/rpc/rpc-mode.ts

@@ -8,25 +8,35 @@
  * - Commands: JSON objects with `type` field, optional `id` for correlation
  * - Responses: JSON objects with `type: "response"`, `command`, `success`, and optional `data`/`error`
  * - Events: AgentSessionEvent objects streamed as they occur
- * - Hook UI: Hook UI requests are emitted, client responds with hook_ui_response
+ * - Extension UI: Extension UI requests are emitted, client responds with extension_ui_response
  */
 
-import { nanoid } from "nanoid";
 import type { AgentSession } from "../../core/agent-session";
-import type { HookUIContext } from "../../core/hooks/index";
-import { logger } from "../../core/logger";
+import type { ExtensionUIContext } from "../../core/extensions/index";
 import { theme } from "../interactive/theme/theme";
-import type { RpcCommand, RpcHookUIRequest, RpcHookUIResponse, RpcResponse, RpcSessionState } from "./rpc-types";
+import type {
+	RpcCommand,
+	RpcExtensionUIRequest,
+	RpcExtensionUIResponse,
+	RpcResponse,
+	RpcSessionState,
+} from "./rpc-types";
 
 // Re-export types for consumers
-export type { RpcCommand, RpcHookUIRequest, RpcHookUIResponse, RpcResponse, RpcSessionState } from "./rpc-types";
+export type {
+	RpcCommand,
+	RpcExtensionUIRequest,
+	RpcExtensionUIResponse,
+	RpcResponse,
+	RpcSessionState,
+} from "./rpc-types";
 
 /**
  * Run in RPC mode.
  * Listens for JSON commands on stdin, outputs events and responses on stdout.
  */
 export async function runRpcMode(session: AgentSession): Promise<never> {
-	const output = (obj: RpcResponse | RpcHookUIRequest | object) => {
+	const output = (obj: RpcResponse | RpcExtensionUIRequest | object) => {
 		console.log(JSON.stringify(obj));
 	};
 
@@ -45,18 +55,21 @@ export async function runRpcMode(session: AgentSession): Promise<never> {
 		return { id, type: "response", command, success: false, error: message };
 	};
 
-	// Pending hook UI requests waiting for response
-	const pendingHookRequests = new Map<string, { resolve: (value: any) => void; reject: (error: Error) => void }>();
+	// Pending extension UI requests waiting for response
+	const pendingExtensionRequests = new Map<
+		string,
+		{ resolve: (value: any) => void; reject: (error: Error) => void }
+	>();
 
 	/**
-	 * Create a hook UI context that uses the RPC protocol.
+	 * Create an extension UI context that uses the RPC protocol.
 	 */
-	const createHookUIContext = (): HookUIContext => ({
+	const createExtensionUIContext = (): ExtensionUIContext => ({
 		async select(title: string, options: string[]): Promise<string | undefined> {
-			const id = nanoid();
+			const id = globalThis.crypto.randomUUID();
 			return new Promise((resolve, reject) => {
-				pendingHookRequests.set(id, {
-					resolve: (response: RpcHookUIResponse) => {
+				pendingExtensionRequests.set(id, {
+					resolve: (response: RpcExtensionUIResponse) => {
 						if ("cancelled" in response && response.cancelled) {
 							resolve(undefined);
 						} else if ("value" in response) {
@@ -67,15 +80,15 @@ export async function runRpcMode(session: AgentSession): Promise<never> {
 					},
 					reject,
 				});
-				output({ type: "hook_ui_request", id, method: "select", title, options } as RpcHookUIRequest);
+				output({ type: "extension_ui_request", id, method: "select", title, options } as RpcExtensionUIRequest);
 			});
 		},
 
 		async confirm(title: string, message: string): Promise<boolean> {
-			const id = nanoid();
+			const id = globalThis.crypto.randomUUID();
 			return new Promise((resolve, reject) => {
-				pendingHookRequests.set(id, {
-					resolve: (response: RpcHookUIResponse) => {
+				pendingExtensionRequests.set(id, {
+					resolve: (response: RpcExtensionUIResponse) => {
 						if ("cancelled" in response && response.cancelled) {
 							resolve(false);
 						} else if ("confirmed" in response) {
@@ -86,15 +99,15 @@ export async function runRpcMode(session: AgentSession): Promise<never> {
 					},
 					reject,
 				});
-				output({ type: "hook_ui_request", id, method: "confirm", title, message } as RpcHookUIRequest);
+				output({ type: "extension_ui_request", id, method: "confirm", title, message } as RpcExtensionUIRequest);
 			});
 		},
 
 		async input(title: string, placeholder?: string): Promise<string | undefined> {
-			const id = nanoid();
+			const id = globalThis.crypto.randomUUID();
 			return new Promise((resolve, reject) => {
-				pendingHookRequests.set(id, {
-					resolve: (response: RpcHookUIResponse) => {
+				pendingExtensionRequests.set(id, {
+					resolve: (response: RpcExtensionUIResponse) => {
 						if ("cancelled" in response && response.cancelled) {
 							resolve(undefined);
 						} else if ("value" in response) {
@@ -105,30 +118,54 @@ export async function runRpcMode(session: AgentSession): Promise<never> {
 					},
 					reject,
 				});
-				output({ type: "hook_ui_request", id, method: "input", title, placeholder } as RpcHookUIRequest);
+				output({ type: "extension_ui_request", id, method: "input", title, placeholder } as RpcExtensionUIRequest);
 			});
 		},
 
 		notify(message: string, type?: "info" | "warning" | "error"): void {
 			// Fire and forget - no response needed
 			output({
-				type: "hook_ui_request",
-				id: nanoid(),
+				type: "extension_ui_request",
+				id: globalThis.crypto.randomUUID(),
 				method: "notify",
 				message,
 				notifyType: type,
-			} as RpcHookUIRequest);
+			} as RpcExtensionUIRequest);
 		},
 
 		setStatus(key: string, text: string | undefined): void {
 			// Fire and forget - no response needed
 			output({
-				type: "hook_ui_request",
-				id: nanoid(),
+				type: "extension_ui_request",
+				id: globalThis.crypto.randomUUID(),
 				method: "setStatus",
 				statusKey: key,
 				statusText: text,
-			} as RpcHookUIRequest);
+			} as RpcExtensionUIRequest);
+		},
+
+		setWidget(key: string, content: unknown): void {
+			// Only support string arrays in RPC mode - factory functions are ignored
+			if (content === undefined || Array.isArray(content)) {
+				output({
+					type: "extension_ui_request",
+					id: globalThis.crypto.randomUUID(),
+					method: "setWidget",
+					widgetKey: key,
+					widgetLines: content as string[] | undefined,
+				} as RpcExtensionUIRequest);
+			}
+			// Component factories are not supported in RPC mode - would need TUI access
+		},
+
+		setTitle(title: string): void {
+			// Fire and forget - host can implement terminal title control
+			output({
+				type: "extension_ui_request",
+				id: globalThis.crypto.randomUUID(),
+				method: "setTitle",
+				title,
+			} as RpcExtensionUIRequest);
 		},
 
 		async custom() {
@@ -139,11 +176,11 @@ export async function runRpcMode(session: AgentSession): Promise<never> {
 		setEditorText(text: string): void {
 			// Fire and forget - host can implement editor control
 			output({
-				type: "hook_ui_request",
-				id: nanoid(),
+				type: "extension_ui_request",
+				id: globalThis.crypto.randomUUID(),
 				method: "set_editor_text",
 				text,
-			} as RpcHookUIRequest);
+			} as RpcExtensionUIRequest);
 		},
 
 		getEditorText(): string {
@@ -153,10 +190,10 @@ export async function runRpcMode(session: AgentSession): Promise<never> {
 		},
 
 		async editor(title: string, prefill?: string): Promise<string | undefined> {
-			const id = nanoid();
+			const id = globalThis.crypto.randomUUID();
 			return new Promise((resolve, reject) => {
-				pendingHookRequests.set(id, {
-					resolve: (response: RpcHookUIResponse) => {
+				pendingExtensionRequests.set(id, {
+					resolve: (response: RpcExtensionUIResponse) => {
 						if ("cancelled" in response && response.cancelled) {
 							resolve(undefined);
 						} else if ("value" in response) {
@@ -167,7 +204,7 @@ export async function runRpcMode(session: AgentSession): Promise<never> {
 					},
 					reject,
 				});
-				output({ type: "hook_ui_request", id, method: "editor", title, prefill } as RpcHookUIRequest);
+				output({ type: "extension_ui_request", id, method: "editor", title, prefill } as RpcExtensionUIRequest);
 			});
 		},
 
@@ -176,66 +213,39 @@ export async function runRpcMode(session: AgentSession): Promise<never> {
 		},
 	});
 
-	// Set up hooks with RPC-based UI context
-	const hookRunner = session.hookRunner;
-	if (hookRunner) {
-		hookRunner.initialize({
+	// Set up extensions with RPC-based UI context
+	const extensionRunner = session.extensionRunner;
+	if (extensionRunner) {
+		extensionRunner.initialize({
 			getModel: () => session.agent.state.model,
-			sendMessageHandler: (message, triggerTurn) => {
-				session.sendHookMessage(message, triggerTurn).catch((e) => {
-					output(error(undefined, "hook_send", e.message));
+			sendMessageHandler: (message, options) => {
+				session.sendCustomMessage(message, options).catch((e) => {
+					output(error(undefined, "extension_send", e.message));
 				});
 			},
 			appendEntryHandler: (customType, data) => {
 				session.sessionManager.appendCustomEntry(customType, data);
 			},
-			uiContext: createHookUIContext(),
+			getActiveToolsHandler: () => session.getActiveToolNames(),
+			getAllToolsHandler: () => session.getAllToolNames(),
+			setActiveToolsHandler: (toolNames: string[]) => session.setActiveToolsByName(toolNames),
+			uiContext: createExtensionUIContext(),
 			hasUI: false,
 		});
-		hookRunner.onError((err) => {
-			output({ type: "hook_error", hookPath: err.hookPath, event: err.event, error: err.error });
+		extensionRunner.onError((err) => {
+			output({ type: "extension_error", extensionPath: err.extensionPath, event: err.event, error: err.error });
 		});
 		// Emit session_start event
-		await hookRunner.emit({
+		await extensionRunner.emit({
 			type: "session_start",
 		});
 	}
 
-	// Emit session start event to custom tools
-	// Note: Tools get no-op UI context in RPC mode (host handles UI via protocol)
-	for (const { tool } of session.customTools) {
-		if (tool.onSession) {
-			try {
-				await tool.onSession(
-					{
-						previousSessionFile: undefined,
-						reason: "start",
-					},
-					{
-						sessionManager: session.sessionManager,
-						modelRegistry: session.modelRegistry,
-						model: session.model,
-						isIdle: () => !session.isStreaming,
-						hasQueuedMessages: () => session.queuedMessageCount > 0,
-						abort: () => {
-							session.abort();
-						},
-					},
-				);
-			} catch (err) {
-				logger.warn("Tool onSession error", { error: String(err) });
-			}
-		}
-	}
-
 	// Output all agent events as JSON
 	session.subscribe((event) => {
 		output(event);
 	});
 
-	// Serialize prompt commands to prevent concurrent execution
-	let activePrompt: Promise<void> | null = null;
-
 	// Handle a single command
 	const handleCommand = async (command: RpcCommand): Promise<RpcResponse> => {
 		const id = command.id;
@@ -246,24 +256,26 @@ export async function runRpcMode(session: AgentSession): Promise<never> {
 			// =================================================================
 
 			case "prompt": {
-				// Serialize prompts to prevent concurrent execution
-				if (activePrompt) {
-					await activePrompt;
-				}
-				activePrompt = session
+				// Don't await - events will stream
+				// Extension commands are executed immediately, file prompt templates are expanded
+				// If streaming and streamingBehavior specified, queues via steer/followUp
+				session
 					.prompt(command.message, {
 						images: command.images,
+						streamingBehavior: command.streamingBehavior,
 					})
-					.catch((e) => output(error(id, "prompt", e.message)))
-					.finally(() => {
-						activePrompt = null;
-					});
+					.catch((e) => output(error(id, "prompt", e.message)));
 				return success(id, "prompt");
 			}
 
-			case "queue_message": {
-				await session.queueMessage(command.message);
-				return success(id, "queue_message");
+			case "steer": {
+				await session.steer(command.message);
+				return success(id, "steer");
+			}
+
+			case "follow_up": {
+				await session.followUp(command.message);
+				return success(id, "follow_up");
 			}
 
 			case "abort": {
@@ -287,7 +299,9 @@ export async function runRpcMode(session: AgentSession): Promise<never> {
 					thinkingLevel: session.thinkingLevel,
 					isStreaming: session.isStreaming,
 					isCompacting: session.isCompacting,
-					queueMode: session.queueMode,
+					steeringMode: session.steeringMode,
+					followUpMode: session.followUpMode,
+					interruptMode: session.interruptMode,
 					sessionFile: session.sessionFile,
 					sessionId: session.sessionId,
 					autoCompactionEnabled: session.autoCompactionEnabled,
@@ -302,7 +316,7 @@ export async function runRpcMode(session: AgentSession): Promise<never> {
 			// =================================================================
 
 			case "set_model": {
-				const models = await session.getAvailableModels();
+				const models = session.getAvailableModels();
 				const model = models.find((m) => m.provider === command.provider && m.id === command.modelId);
 				if (!model) {
 					return error(id, "set_model", `Model not found: ${command.provider}/${command.modelId}`);
@@ -320,7 +334,7 @@ export async function runRpcMode(session: AgentSession): Promise<never> {
 			}
 
 			case "get_available_models": {
-				const models = await session.getAvailableModels();
+				const models = session.getAvailableModels();
 				return success(id, "get_available_models", { models });
 			}
 
@@ -342,12 +356,22 @@ export async function runRpcMode(session: AgentSession): Promise<never> {
 			}
 
 			// =================================================================
-			// Queue Mode
+			// Queue Modes
 			// =================================================================
 
-			case "set_queue_mode": {
-				session.setQueueMode(command.mode);
-				return success(id, "set_queue_mode");
+			case "set_steering_mode": {
+				session.setSteeringMode(command.mode);
+				return success(id, "set_steering_mode");
+			}
+
+			case "set_follow_up_mode": {
+				session.setFollowUpMode(command.mode);
+				return success(id, "set_follow_up_mode");
+			}
+
+			case "set_interrupt_mode": {
+				session.setInterruptMode(command.mode);
+				return success(id, "set_interrupt_mode");
 			}
 
 			// =================================================================
@@ -441,42 +465,30 @@ export async function runRpcMode(session: AgentSession): Promise<never> {
 		}
 	};
 
-	// Listen for JSON input - use Bun's ReadableStream
-	const stdinReader = (Bun.stdin.stream() as ReadableStream<Uint8Array>)
-		.pipeThrough(new TextDecoderStream())
-		.pipeThrough(
-			new TransformStream({
-				transform(chunk, controller) {
-					const lines = chunk.split("\n");
-					for (const line of lines) {
-						if (line.trim()) {
-							controller.enqueue(line);
-						}
-					}
-				},
-			}),
-		)
-		.getReader();
+	// Listen for JSON input using Bun's stdin
+	const decoder = new TextDecoder();
+	let buffer = "";
+
+	for await (const chunk of Bun.stdin.stream()) {
+		buffer += decoder.decode(chunk, { stream: true });
+		const lines = buffer.split("\n");
+		buffer = lines.pop() || "";
 
-	// Process lines in background
-	(async () => {
-		while (true) {
-			const { done, value: line } = await stdinReader.read();
-			if (done) break;
+		for (const line of lines) {
+			if (!line.trim()) continue;
 
 			try {
 				const parsed = JSON.parse(line);
 
-				// Handle hook UI responses
-				if (parsed.type === "hook_ui_response") {
-					const response = parsed as RpcHookUIResponse;
-					const pending = pendingHookRequests.get(response.id);
+				// Handle extension UI responses
+				if (parsed.type === "extension_ui_response") {
+					const response = parsed as RpcExtensionUIResponse;
+					const pending = pendingExtensionRequests.get(response.id);
 					if (pending) {
-						// Atomic delete: remove before resolve to prevent double-resolution
-						pendingHookRequests.delete(response.id);
+						pendingExtensionRequests.delete(response.id);
 						pending.resolve(response);
 					}
-					return;
+					continue;
 				}
 
 				// Handle regular commands
@@ -487,7 +499,7 @@ export async function runRpcMode(session: AgentSession): Promise<never> {
 				output(error(undefined, "parse", `Failed to parse command: ${e.message}`));
 			}
 		}
-	})();
+	}
 
 	// Keep process alive forever
 	return new Promise(() => {});

package/src/modes/rpc/rpc-types.ts

@@ -17,8 +17,9 @@ import type { CompactionResult } from "../../core/compaction/index";
 
 export type RpcCommand =
 	// Prompting
-	| { id?: string; type: "prompt"; message: string; images?: ImageContent[] }
-	| { id?: string; type: "queue_message"; message: string }
+	| { id?: string; type: "prompt"; message: string; images?: ImageContent[]; streamingBehavior?: "steer" | "followUp" }
+	| { id?: string; type: "steer"; message: string }
+	| { id?: string; type: "follow_up"; message: string }
 	| { id?: string; type: "abort" }
 	| { id?: string; type: "new_session"; parentSession?: string }
 
@@ -34,8 +35,10 @@ export type RpcCommand =
 	| { id?: string; type: "set_thinking_level"; level: ThinkingLevel }
 	| { id?: string; type: "cycle_thinking_level" }
 
-	// Queue mode
-	| { id?: string; type: "set_queue_mode"; mode: "all" | "one-at-a-time" }
+	// Queue modes
+	| { id?: string; type: "set_steering_mode"; mode: "all" | "one-at-a-time" }
+	| { id?: string; type: "set_follow_up_mode"; mode: "all" | "one-at-a-time" }
+	| { id?: string; type: "set_interrupt_mode"; mode: "immediate" | "wait" }
 
 	// Compaction
 	| { id?: string; type: "compact"; customInstructions?: string }
@@ -69,7 +72,9 @@ export interface RpcSessionState {
 	thinkingLevel: ThinkingLevel;
 	isStreaming: boolean;
 	isCompacting: boolean;
-	queueMode: "all" | "one-at-a-time";
+	steeringMode: "all" | "one-at-a-time";
+	followUpMode: "all" | "one-at-a-time";
+	interruptMode: "immediate" | "wait";
 	sessionFile?: string;
 	sessionId: string;
 	autoCompactionEnabled: boolean;
@@ -85,7 +90,8 @@ export interface RpcSessionState {
 export type RpcResponse =
 	// Prompting (async - events follow)
 	| { id?: string; type: "response"; command: "prompt"; success: true }
-	| { id?: string; type: "response"; command: "queue_message"; success: true }
+	| { id?: string; type: "response"; command: "steer"; success: true }
+	| { id?: string; type: "response"; command: "follow_up"; success: true }
 	| { id?: string; type: "response"; command: "abort"; success: true }
 	| { id?: string; type: "response"; command: "new_session"; success: true; data: { cancelled: boolean } }
 
@@ -125,8 +131,10 @@ export type RpcResponse =
 			data: { level: ThinkingLevel } | null;
 	  }
 
-	// Queue mode
-	| { id?: string; type: "response"; command: "set_queue_mode"; success: true }
+	// Queue modes
+	| { id?: string; type: "response"; command: "set_steering_mode"; success: true }
+	| { id?: string; type: "response"; command: "set_follow_up_mode"; success: true }
+	| { id?: string; type: "response"; command: "set_interrupt_mode"; success: true }
 
 	// Compaction
 	| { id?: string; type: "response"; command: "compact"; success: true; data: CompactionResult }
@@ -167,34 +175,48 @@ export type RpcResponse =
 	| { id?: string; type: "response"; command: string; success: false; error: string };
 
 // ============================================================================
-// Hook UI Events (stdout)
+// Extension UI Events (stdout)
 // ============================================================================
 
-/** Emitted when a hook needs user input */
-export type RpcHookUIRequest =
-	| { type: "hook_ui_request"; id: string; method: "select"; title: string; options: string[] }
-	| { type: "hook_ui_request"; id: string; method: "confirm"; title: string; message: string }
-	| { type: "hook_ui_request"; id: string; method: "input"; title: string; placeholder?: string }
-	| { type: "hook_ui_request"; id: string; method: "editor"; title: string; prefill?: string }
+/** Emitted when an extension needs user input */
+export type RpcExtensionUIRequest =
+	| { type: "extension_ui_request"; id: string; method: "select"; title: string; options: string[] }
+	| { type: "extension_ui_request"; id: string; method: "confirm"; title: string; message: string }
+	| { type: "extension_ui_request"; id: string; method: "input"; title: string; placeholder?: string }
+	| { type: "extension_ui_request"; id: string; method: "editor"; title: string; prefill?: string }
 	| {
-			type: "hook_ui_request";
+			type: "extension_ui_request";
 			id: string;
 			method: "notify";
 			message: string;
 			notifyType?: "info" | "warning" | "error";
 	  }
-	| { type: "hook_ui_request"; id: string; method: "setStatus"; statusKey: string; statusText: string | undefined }
-	| { type: "hook_ui_request"; id: string; method: "set_editor_text"; text: string };
+	| {
+			type: "extension_ui_request";
+			id: string;
+			method: "setStatus";
+			statusKey: string;
+			statusText: string | undefined;
+	  }
+	| {
+			type: "extension_ui_request";
+			id: string;
+			method: "setWidget";
+			widgetKey: string;
+			widgetLines: string[] | undefined;
+	  }
+	| { type: "extension_ui_request"; id: string; method: "setTitle"; title: string }
+	| { type: "extension_ui_request"; id: string; method: "set_editor_text"; text: string };
 
 // ============================================================================
-// Hook UI Commands (stdin)
+// Extension UI Commands (stdin)
 // ============================================================================
 
-/** Response to a hook UI request */
-export type RpcHookUIResponse =
-	| { type: "hook_ui_response"; id: string; value: string }
-	| { type: "hook_ui_response"; id: string; confirmed: boolean }
-	| { type: "hook_ui_response"; id: string; cancelled: true };
+/** Response to an extension UI request */
+export type RpcExtensionUIResponse =
+	| { type: "extension_ui_response"; id: string; value: string }
+	| { type: "extension_ui_response"; id: string; confirmed: boolean }
+	| { type: "extension_ui_response"; id: string; cancelled: true };
 
 // ============================================================================
 // Helper type for extracting command types

package/src/prompts/task.md

@@ -23,6 +23,7 @@ Guidelines:
 - For file searches: Use grep/glob when you need to search broadly. Use read when you know the specific file path.
 - For analysis: Start broad and narrow down. Use multiple search strategies if the first doesn't yield results.
 - Be thorough: Check multiple locations, consider different naming conventions, look for related files.
+- When spawning subagents with the Task tool, include a short, user-facing `description` for each task (5-8 words) that summarizes the approach.
 - NEVER create files unless absolutely necessary. ALWAYS prefer editing existing files.
 - NEVER proactively create documentation files (\*.md) or README files unless explicitly requested.
 - Any file paths in your response MUST be absolute. Do NOT use relative paths.

package/src/prompts/tools/gemini-image.md

@@ -0,0 +1,4 @@
+Generate or edit images using Google Gemini image models ("Nano Banana").
+
+Provide a text prompt and optional input images. Use response modalities to request image-only output,
+set aspect ratio or image size, and choose the model explicitly when needed.

package/src/prompts/tools/git.md

@@ -0,0 +1,9 @@
+Structured Git operations with safety guards and typed output. Use this tool instead of raw git commands.
+
+Operations:
+- READ: status, diff, log, show, blame, branch
+- WRITE: add, restore, commit, checkout, merge, rebase, stash, cherry-pick
+- REMOTE: fetch, pull, push, tag
+- GITHUB: pr, issue, ci, release
+
+Returns structured data plus a rendered summary for display. Safety checks may block or require confirmation for destructive actions.

package/src/prompts/voice-summary.md

@@ -0,0 +1,12 @@
+You are a voice summarizer for a coding agent.
+
+Summarize the assistant response for spoken playback.
+
+Rules:
+- Output 1 to 3 sentences, maximum 50 words.
+- No markdown, no code blocks, no inline code, no URLs.
+- If the response already fits, return it unchanged.
+- Preserve the most important question if one is asked.
+- If a decision or missing info is required, ask one short question.
+
+Return only the spoken text.

package/src/utils/image-convert.ts

@@ -0,0 +1,26 @@
+/**
+ * Convert image to PNG format for terminal display.
+ * Kitty graphics protocol requires PNG format (f=100).
+ */
+export async function convertToPng(
+	base64Data: string,
+	mimeType: string,
+): Promise<{ data: string; mimeType: string } | null> {
+	// Already PNG, no conversion needed
+	if (mimeType === "image/png") {
+		return { data: base64Data, mimeType };
+	}
+
+	try {
+		const sharp = (await import("sharp")).default;
+		const buffer = Buffer.from(base64Data, "base64");
+		const pngBuffer = await sharp(buffer).png().toBuffer();
+		return {
+			data: pngBuffer.toString("base64"),
+			mimeType: "image/png",
+		};
+	} catch {
+		// Sharp not available or conversion failed
+		return null;
+	}
+}