@howaboua/pi-codex-conversion 1.0.0

package/src/tools/view-image-tool.ts

@@ -0,0 +1,171 @@
+import { stat } from "node:fs/promises";
+import { isAbsolute, resolve } from "node:path";
+import {
+	createReadTool,
+	type AgentToolResult,
+	type ExtensionAPI,
+	type ExtensionContext,
+	type ToolDefinition,
+} from "@mariozechner/pi-coding-agent";
+import { Type, type TSchema } from "@sinclair/typebox";
+import { Text } from "@mariozechner/pi-tui";
+
+const VIEW_IMAGE_UNSUPPORTED_MESSAGE = "view_image is not allowed because you do not support image inputs";
+const DETAIL_DESCRIPTION =
+	"Optional detail override. The only supported value is `original`; omit this field for default resized behavior. Use `original` to preserve the file's original resolution instead of resizing to fit. This is important when high-fidelity image perception or precise localization is needed, especially for CUA agents.";
+
+interface ViewImageParams {
+	path: string;
+	detail?: string;
+}
+
+interface ViewImageReader {
+	execute: (toolCallId: string, params: { path: string }, signal?: AbortSignal) => Promise<AgentToolResult<unknown>>;
+}
+
+interface ViewImageReaders {
+	resized: ViewImageReader;
+	original: ViewImageReader;
+}
+
+interface CreateViewImageToolOptions {
+	allowOriginalDetail?: boolean;
+	createReaders?: (cwd: string) => ViewImageReaders;
+}
+
+type ViewImageParameters = ReturnType<typeof createViewImageParameters>;
+
+function createViewImageParameters(allowOriginalDetail: boolean) {
+	const properties: Record<string, TSchema> = {
+		path: Type.String({ description: "Local filesystem path to an image file" }),
+	};
+	if (allowOriginalDetail) {
+		properties.detail = Type.Optional(Type.String({ description: DETAIL_DESCRIPTION }));
+	}
+	return Type.Object(properties);
+}
+
+export function parseViewImageParams(params: unknown): ViewImageParams {
+	if (!params || typeof params !== "object" || !("path" in params) || typeof params.path !== "string") {
+		throw new Error("view_image requires a string 'path' parameter");
+	}
+	let detail: string | undefined;
+	if ("detail" in params) {
+		const rawDetail = params.detail;
+		if (rawDetail === null || rawDetail === undefined) {
+			detail = undefined;
+		} else if (typeof rawDetail !== "string") {
+			throw new Error("view_image.detail must be a string when provided");
+		} else {
+			detail = rawDetail;
+		}
+	}
+	if (detail !== undefined && detail !== "original") {
+		throw new Error(
+			`view_image.detail only supports \`original\`; omit \`detail\` for default resized behavior, got \`${detail}\``,
+		);
+	}
+	return { path: params.path, detail };
+}
+
+function resolveViewImagePath(path: string, cwd: string): string {
+	return isAbsolute(path) ? path : resolve(cwd, path);
+}
+
+async function ensureViewImagePathIsFile(path: string, cwd: string): Promise<string> {
+	const absolutePath = resolveViewImagePath(path, cwd);
+	let metadata;
+	try {
+		metadata = await stat(absolutePath);
+	} catch (error) {
+		throw new Error(`unable to locate image at \`${absolutePath}\`: ${error instanceof Error ? error.message : String(error)}`);
+	}
+	if (!metadata.isFile()) {
+		throw new Error(`image path \`${absolutePath}\` is not a file`);
+	}
+	return absolutePath;
+}
+
+function normalizeViewImageResult(result: AgentToolResult<unknown>): AgentToolResult<unknown> {
+	const imageContent = result.content.find((item) => item.type === "image");
+	if (!imageContent || imageContent.type !== "image") {
+		throw new Error("view_image expected an image file. Use exec_command for text files.");
+	}
+	return {
+		...result,
+		content: [imageContent],
+	};
+}
+
+function createDefaultViewImageReaders(cwd: string): ViewImageReaders {
+	return {
+		resized: createReadTool(cwd),
+		original: createReadTool(cwd, { autoResizeImages: false }),
+	};
+}
+
+function supportsImageInputs(model: ExtensionContext["model"]): boolean {
+	return Array.isArray(model?.input) && model.input.includes("image");
+}
+
+// Pi exposes image input support on models, but not Codex's finer-grained
+// original-detail capability flag. Keep the heuristic narrow to image-capable
+// Codex-family models until Pi surfaces an explicit capability.
+export function supportsOriginalImageDetail(model: ExtensionContext["model"]): boolean {
+	const provider = (model?.provider ?? "").toLowerCase();
+	const api = (model?.api ?? "").toLowerCase();
+	const id = (model?.id ?? "").toLowerCase();
+	return supportsImageInputs(model) && (provider.includes("codex") || api.includes("codex") || id.includes("codex"));
+}
+
+export function createViewImageTool(options: CreateViewImageToolOptions = {}): ToolDefinition<ViewImageParameters> {
+	const allowOriginalDetail = options.allowOriginalDetail ?? false;
+	const parameters = createViewImageParameters(allowOriginalDetail);
+	const createReaders = options.createReaders ?? createDefaultViewImageReaders;
+
+	return {
+		name: "view_image",
+		label: "view_image",
+		description:
+			"View a local image from the filesystem (only use if given a full filepath by the user, and the image isn't already attached to the thread context within <image ...> tags).",
+		promptSnippet: "View a local image from the filesystem.",
+		promptGuidelines: ["Use view_image only for image files. Use exec_command for text-file inspection."],
+		parameters,
+		async execute(toolCallId, params, signal, _onUpdate, ctx) {
+			if (!supportsImageInputs(ctx.model)) {
+				throw new Error(VIEW_IMAGE_UNSUPPORTED_MESSAGE);
+			}
+			const typedParams = parseViewImageParams(params);
+			if (typedParams.detail === "original" && !allowOriginalDetail) {
+				throw new Error("view_image.detail is not available for the current model");
+			}
+			await ensureViewImagePathIsFile(typedParams.path, ctx.cwd);
+			const readers = createReaders(ctx.cwd);
+			const reader = typedParams.detail === "original" ? readers.original : readers.resized;
+			const result = await reader.execute(toolCallId, { path: typedParams.path }, signal);
+			return normalizeViewImageResult(result);
+		},
+		renderCall(args, theme) {
+			return new Text(
+				`${theme.fg("toolTitle", theme.bold("view_image"))} ${theme.fg("accent", typeof args.path === "string" ? args.path : "")}`,
+				0,
+				0,
+			);
+		},
+		renderResult(result, { isPartial, expanded }, theme) {
+			if (isPartial) {
+				return new Text(theme.fg("warning", "Loading image..."), 0, 0);
+			}
+			const textBlock = result.content.find((item) => item.type === "text");
+			let text = theme.fg("success", "Image loaded");
+			if (expanded && textBlock?.type === "text") {
+				text += `\n${theme.fg("dim", textBlock.text)}`;
+			}
+			return new Text(text, 0, 0);
+		},
+	};
+}
+
+export function registerViewImageTool(pi: ExtensionAPI, options: CreateViewImageToolOptions = {}): void {
+	pi.registerTool(createViewImageTool(options));
+}

package/src/tools/write-stdin-tool.ts

@@ -0,0 +1,145 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { Type } from "@sinclair/typebox";
+import { Text } from "@mariozechner/pi-tui";
+import { renderWriteStdinCall } from "./codex-rendering.ts";
+import type { ExecSessionManager, UnifiedExecResult } from "./exec-session-manager.ts";
+import { formatUnifiedExecResult } from "./unified-exec-format.ts";
+
+const WRITE_STDIN_PARAMETERS = Type.Object({
+	session_id: Type.Number({ description: "Identifier of the running unified exec session." }),
+	chars: Type.Optional(Type.String({ description: "Bytes to write to stdin. May be empty to poll." })),
+	yield_time_ms: Type.Optional(Type.Number({ description: "How long to wait (in milliseconds) for output before yielding." })),
+	max_output_tokens: Type.Optional(Type.Number({ description: "Maximum number of tokens to return. Excess output will be truncated." })),
+});
+
+interface WriteStdinParams {
+	session_id: number;
+	chars?: string;
+	yield_time_ms?: number;
+	max_output_tokens?: number;
+}
+
+interface FormattedExecTranscript {
+	output: string;
+	sessionId?: number;
+	exitCode?: number;
+}
+
+function parseFormattedExecTranscript(text: string): FormattedExecTranscript {
+	const marker = "\nOutput:\n";
+	const markerIndex = text.indexOf(marker);
+	const output = markerIndex !== -1 ? text.slice(markerIndex + marker.length) : text;
+	const sessionMatch = text.match(/Process running with session ID (\d+)/);
+	const exitCodeMatch = text.match(/Process exited with code (-?\d+)/);
+	return {
+		output,
+		sessionId: sessionMatch ? Number(sessionMatch[1]) : undefined,
+		exitCode: exitCodeMatch ? Number(exitCodeMatch[1]) : undefined,
+	};
+}
+
+function renderTerminalText(text: string): string {
+	let committed = "";
+	let line: string[] = [];
+	let cursor = 0;
+
+	for (const char of text) {
+		switch (char) {
+			case "\r":
+				cursor = 0;
+				break;
+			case "\n":
+				committed += `${line.join("")}\n`;
+				line = [];
+				cursor = 0;
+				break;
+			case "\b":
+				cursor = Math.max(0, cursor - 1);
+				break;
+			default:
+				if (cursor > line.length) {
+					line.push(...Array.from({ length: cursor - line.length }, () => " "));
+				}
+				line[cursor] = char;
+				cursor += 1;
+				break;
+		}
+	}
+
+	return committed + line.join("");
+}
+
+function getResultState(result: { details?: unknown; content: Array<{ type: string; text?: string }> }): FormattedExecTranscript {
+	const details = isUnifiedExecResult(result.details) ? result.details : undefined;
+	const content = result.content.find((item) => item.type === "text");
+	if (details) {
+		return {
+			output: details.output,
+			sessionId: details.session_id,
+			exitCode: details.exit_code,
+		};
+	}
+	if (content?.type === "text") {
+		return parseFormattedExecTranscript(content.text ?? "");
+	}
+	return { output: "" };
+}
+
+function parseWriteStdinParams(params: unknown): WriteStdinParams {
+	if (!params || typeof params !== "object" || !("session_id" in params) || typeof params.session_id !== "number") {
+		throw new Error("write_stdin requires numeric 'session_id'");
+	}
+	const chars = "chars" in params && typeof params.chars === "string" ? params.chars : undefined;
+	const yield_time_ms = "yield_time_ms" in params && typeof params.yield_time_ms === "number" ? params.yield_time_ms : undefined;
+	const max_output_tokens =
+		"max_output_tokens" in params && typeof params.max_output_tokens === "number" ? params.max_output_tokens : undefined;
+	return { session_id: params.session_id, chars, yield_time_ms, max_output_tokens };
+}
+
+function isUnifiedExecResult(details: unknown): details is UnifiedExecResult {
+	return typeof details === "object" && details !== null;
+}
+
+export function registerWriteStdinTool(pi: ExtensionAPI, sessions: ExecSessionManager): void {
+	pi.registerTool({
+		name: "write_stdin",
+		label: "write_stdin",
+		description: "Writes characters to an existing unified exec session and returns recent output.",
+		promptSnippet: "Write to an exec session.",
+		parameters: WRITE_STDIN_PARAMETERS,
+		async execute(_toolCallId, params) {
+			const typed = parseWriteStdinParams(params);
+			const command = sessions.getSessionCommand(typed.session_id);
+			let result: UnifiedExecResult;
+			try {
+				result = await sessions.write(typed);
+			} catch (error) {
+				const message = error instanceof Error ? error.message : String(error);
+				throw new Error(`write_stdin failed: ${message}`);
+			}
+			return {
+				content: [{ type: "text", text: formatUnifiedExecResult(result, command) }],
+				details: result,
+			};
+		},
+		renderCall(args, theme) {
+			const sessionId = typeof args.session_id === "number" ? args.session_id : "?";
+			const input = typeof args.chars === "string" ? args.chars : undefined;
+			const command = typeof sessionId === "number" ? sessions.getSessionCommand(sessionId) : undefined;
+			return new Text(renderWriteStdinCall(sessionId, input, command, theme), 0, 0);
+		},
+		renderResult(result, { expanded, isPartial }, theme) {
+			if (isPartial || !expanded) return undefined;
+			const state = getResultState(result);
+			const output = renderTerminalText(state.output);
+			let text = theme.fg("dim", output || "(no output)");
+			if (state.sessionId !== undefined) {
+				text += `\n${theme.fg("accent", `Session ${state.sessionId} still running`)}`;
+			}
+			if (state.exitCode !== undefined) {
+				text += `\n${theme.fg("muted", `Exit code: ${state.exitCode}`)}`;
+			}
+			return new Text(text, 0, 0);
+		},
+	});
+}