@oai404iao/pi-codex-imagegen 2.0.0 → 2.1.1

package/src/tools/image-generation/storage.ts

@@ -1,185 +0,0 @@
-import { loadSettings } from "@oai404iao/pi-codex-runtime/internal/settings";
-import { saveBase64Image } from "../../utils/images.js";
-import { type SavedGeneratedImage } from "./types.js";
-
-const OPENAI_CODEX_IMAGE_DIR = ".pi/openai-codex-images";
-
-const OPENAI_CODEX_LATEST_IMAGE_NAME = "latest.png";
-
-let fsPromisesPromise: Promise<typeof import("node:fs/promises")> | undefined;
-
-const workspaceRootCache = new Map<string, Promise<string>>();
-
-const PATH_SEPARATOR = "/";
-
-function sanitizeFilePart(value: string | undefined, fallback: string): string {
-	const trimmed = (value ?? "").trim();
-	if (!trimmed) return fallback;
-	return trimmed.replace(/[^a-zA-Z0-9._-]+/g, "-");
-}
-
-function shortenFilePart(value: string | undefined, fallback: string): string {
-	const safe = sanitizeFilePart(value, fallback);
-	const match = /^([a-zA-Z]+_)(.+)$/.exec(safe);
-	const prefix = match?.[1] ?? "";
-	const body = match?.[2] ?? safe;
-	if (body.length <= 12) return `${prefix}${body}`;
-	return `${prefix}${body.slice(0, 8)}-${body.slice(-4)}`;
-}
-
-export function normalizeImageOutputFormat(value: string | undefined): string {
-	const format = (value ?? "png").toLowerCase();
-	return format === "png" || format === "jpg" || format === "jpeg" || format === "webp" ? format : "png";
-}
-
-function normalizePath(value: string): string {
-	if (!value) return ".";
-	const normalized = value.replace(/\/+/g, PATH_SEPARATOR);
-	if (normalized === PATH_SEPARATOR) return normalized;
-	return normalized.replace(/\/+$/g, "") || PATH_SEPARATOR;
-}
-
-function joinPaths(...parts: string[]): string {
-	if (parts.length === 0) return ".";
-	let result = parts[0] ?? "";
-	for (let i = 1; i < parts.length; i++) {
-		const part = parts[i];
-		if (!part) continue;
-		if (!result || result.endsWith(PATH_SEPARATOR)) {
-			result += part.replace(/^\/+/, "");
-		} else {
-			result += `${PATH_SEPARATOR}${part.replace(/^\/+/, "")}`;
-		}
-	}
-	return normalizePath(result);
-}
-
-function dirnamePath(value: string): string {
-	const normalized = normalizePath(value);
-	if (normalized === PATH_SEPARATOR) return PATH_SEPARATOR;
-	const index = normalized.lastIndexOf(PATH_SEPARATOR);
-	if (index < 0) return ".";
-	if (index === 0) return PATH_SEPARATOR;
-	return normalized.slice(0, index);
-}
-
-function splitPathSegments(value: string): string[] {
-	const normalized = normalizePath(value);
-	if (normalized === PATH_SEPARATOR) return [];
-	return normalized.replace(/^\/+/, "").split(PATH_SEPARATOR).filter(Boolean);
-}
-
-function relativePath(from: string, to: string): string {
-	const normalizedFrom = normalizePath(from);
-	const normalizedTo = normalizePath(to);
-	if (normalizedFrom === normalizedTo) return "";
-	const fromSegments = splitPathSegments(normalizedFrom);
-	const toSegments = splitPathSegments(normalizedTo);
-	let shared = 0;
-	while (shared < fromSegments.length && shared < toSegments.length && fromSegments[shared] === toSegments[shared]) {
-		shared++;
-	}
-	const upSegments = new Array(fromSegments.length - shared).fill("..");
-	const downSegments = toSegments.slice(shared);
-	return [...upSegments, ...downSegments].join(PATH_SEPARATOR);
-}
-
-async function getNodeFsPromises(): Promise<typeof import("node:fs/promises")> {
-	if (!fsPromisesPromise) {
-		fsPromisesPromise = import("node:fs/promises");
-	}
-	return fsPromisesPromise;
-}
-
-async function pathExists(value: string): Promise<boolean> {
-	try {
-		const fs = await getNodeFsPromises();
-		await fs.access(value);
-		return true;
-	} catch {
-		return false;
-	}
-}
-
-async function resolveWorkspaceRoot(cwd: string): Promise<string> {
-	const normalizedCwd = normalizePath(cwd);
-	const cached = workspaceRootCache.get(normalizedCwd);
-	if (cached) return cached;
-
-	const promise = (async () => {
-		let current = normalizedCwd;
-		while (true) {
-			if (await pathExists(joinPaths(current, ".git"))) {
-				return current;
-			}
-			const parent = dirnamePath(current);
-			if (parent === current || parent === ".") {
-				return normalizedCwd;
-			}
-			current = parent;
-		}
-	})();
-
-	workspaceRootCache.set(normalizedCwd, promise);
-	return promise;
-}
-
-export function getOpenAICodexImageDirectory(cwd: string): string {
-	return joinPaths(cwd, OPENAI_CODEX_IMAGE_DIR);
-}
-
-export function getOpenAICodexImagePath(cwd: string, responseId: string | undefined, callId: string, outputFormat?: string): string {
-	const ext = normalizeImageOutputFormat(outputFormat);
-	const safeCallId = shortenFilePart(callId, "image");
-	const safeResponseId = shortenFilePart(responseId, "response");
-	return joinPaths(getOpenAICodexImageDirectory(cwd), `${safeCallId}-${safeResponseId}.${ext}`);
-}
-
-export function getOpenAICodexLatestImagePath(cwd: string): string {
-	return joinPaths(getOpenAICodexImageDirectory(cwd), OPENAI_CODEX_LATEST_IMAGE_NAME);
-}
-
-export function buildGeneratedImageDisplayText(savedImage: SavedGeneratedImage, options?: { expanded?: boolean }): string {
-	const lines: string[] = [];
-	if (options?.expanded && savedImage.revisedPrompt) {
-		lines.push(`Prompt: ${savedImage.revisedPrompt}`);
-	}
-	lines.push(`File: ${savedImage.relativePath}`);
-	return lines.join("\n");
-}
-
-export async function saveOpenAICodexGeneratedImage(
-	cwd: string,
-	image: { responseId?: string; callId: string; result: string; outputFormat?: string; imageModel?: string; revisedPrompt?: string },
-): Promise<SavedGeneratedImage> {
-	const workspaceRoot = await resolveWorkspaceRoot(cwd);
-	const outputFormat = normalizeImageOutputFormat(image.outputFormat);
-	const saved = await saveBase64Image({
-		base64: image.result,
-		callId: image.callId,
-		cwd,
-		format: outputFormat,
-		responseId: image.responseId,
-		settings: loadSettings(cwd),
-	});
-	const absolutePath = saved.path;
-	const latestAbsolutePath = saved.latestPath ?? getOpenAICodexLatestImagePath(workspaceRoot);
-
-	const relativeFilePath = relativePath(workspaceRoot, absolutePath);
-	const latestRelativeFilePath = relativePath(workspaceRoot, latestAbsolutePath);
-	const relativePathValue = relativeFilePath && !relativeFilePath.startsWith("..") ? relativeFilePath : absolutePath;
-	const latestRelativePathValue =
-		latestRelativeFilePath && !latestRelativeFilePath.startsWith("..") ? latestRelativeFilePath : latestAbsolutePath;
-
-	return {
-		absolutePath,
-		relativePath: relativePathValue,
-		latestAbsolutePath,
-		latestRelativePath: latestRelativePathValue,
-		responseId: image.responseId,
-		callId: image.callId,
-		outputFormat,
-		imageModel: image.imageModel,
-		revisedPrompt: image.revisedPrompt,
-	};
-}

package/src/tools/image-generation/types.ts

@@ -1,36 +0,0 @@
-export const IMAGE_SAVE_DISPLAY_MESSAGE_TYPE = "codex-image-generation-display";
-
-export interface SavedGeneratedImage {
-	absolutePath: string;
-	relativePath: string;
-	latestAbsolutePath: string;
-	latestRelativePath: string;
-	responseId: string | undefined;
-	callId: string;
-	outputFormat: string;
-	imageModel?: string;
-	revisedPrompt?: string;
-}
-
-export interface ImageDisplayMessageDetails {
-	savedImages: SavedGeneratedImage[];
-}
-
-interface PendingImageDisplay {
-	savedImage: SavedGeneratedImage;
-	imageData: { data: string; mimeType: string };
-}
-
-interface QueuedImageActivity extends PendingImageDisplay {
-	kind: "image";
-}
-
-export type PendingActivity = QueuedImageActivity;
-
-export interface CachedImagePreview {
-	data: string;
-	mimeType: string;
-	bytes: number;
-	widthPx?: number;
-	heightPx?: number;
-}

package/src/tools/image-generation.ts

@@ -1,210 +0,0 @@
-import { readFile } from "node:fs/promises";
-import { isAbsolute, resolve } from "node:path";
-import { buildSessionContext, detectSupportedImageMimeTypeFromFile, type SessionEntry } from "@earendil-works/pi-coding-agent";
-import { saveBase64Image } from "../utils/images.js";
-import { imageGenerationOutput, imageGenerationOutputSchema } from "./image-generation/output.js";
-import type { CodexMinimalToolsSettings } from "@oai404iao/pi-codex-runtime/internal/settings";
-import type { Api, Model, ProviderHeaders } from "@earendil-works/pi-ai";
-import { buildCodexJsonHeaders, hasCodexRequestAuth, resolveCodexApiEndpoint, withResolvedAuthBaseUrl } from "@oai404iao/pi-codex-runtime/internal/codex-http";
-import { loadModelSettings, type ResolvedCodexModelSettings } from "@oai404iao/pi-codex-runtime/internal/model-catalog/runtime";
-import { checkEndpointResponse, rememberResolvedEndpoint, requireEndpointCapability } from "@oai404iao/pi-codex-runtime/internal/endpoint-state";
-import { currentCodexTurn, uuidV7 } from "@oai404iao/pi-codex-runtime/internal/codex-wire-identity";
-import { fetchCodexJson } from "@oai404iao/pi-codex-runtime/internal/json-request";
-
-export interface ImageGenerationInput {
-	prompt?: string;
-	referenced_image_paths?: string[] | null;
-	num_last_images_to_include?: number | null;
-	transparent_background?: boolean;
-}
-
-export const imageGenerationToolSchema = {
-	type: "object",
-	additionalProperties: false,
-	properties: {
-		prompt: { type: "string", description: "Image generation or editing prompt." },
-		referenced_image_paths: {
-			type: ["array", "null"], maxItems: 5,
-			items: { type: "string", minLength: 1 },
-			description: "Local image paths to edit. PNG, JPEG, WebP, GIF and BMP are supported.",
-		},
-		num_last_images_to_include: {
-			type: ["integer", "null"], minimum: 1, maximum: 5,
-			description: "Use the newest conversation images when one or more targets have no local path.",
-		},
-		transparent_background: {
-			type: "boolean",
-			description: "Whether the output should have a transparent background. Defaults to false.",
-		},
-	},
-	required: ["prompt"],
-};
-
-interface ImageGenerationToolContext {
-	cwd: string;
-	model?: Model<Api>;
-	modelRegistry?: {
-		getApiKeyAndHeaders(model: Model<Api>): Promise<
-			| { ok: true; apiKey?: string; headers?: ProviderHeaders; baseUrl?: string }
-			| { ok: false; error: string }
-		>;
-	};
-	sessionManager?: {
-		getSessionId?(): string;
-		getBranch(): SessionEntry[];
-	};
-}
-
-export interface StandaloneImageGenerationInvocation {
-	callId?: string;
-	turnId?: string;
-}
-
-async function referencedImageUrls(cwd: string, paths: readonly string[]): Promise<Array<{ image_url: string }>> {
-	if (paths.length > 5) throw new Error("referenced_image_paths must contain at most 5 paths.");
-	return Promise.all(paths.map(async (rawPath) => {
-		const normalized = rawPath.replace(/^@/, "");
-		const path = isAbsolute(normalized) ? normalized : resolve(cwd, normalized);
-		const mimeType = await detectSupportedImageMimeTypeFromFile(path);
-		if (!mimeType) throw new Error(`Unsupported reference image type: ${rawPath}. Use PNG, JPEG, WebP, GIF, or BMP.`);
-		const data = await readFile(path);
-		if (mimeType === "image/gif" || mimeType === "image/bmp") {
-			// Codex Original mode normalizes unsupported source formats to PNG without resizing.
-			const { PhotonImage } = await import("@silvia-odwyer/photon-node");
-			const decoded = PhotonImage.new_from_byteslice(data);
-			try {
-				return { image_url: `data:image/png;base64,${Buffer.from(decoded.get_bytes()).toString("base64")}` };
-			} finally {
-				decoded.free();
-			}
-		}
-		return { image_url: `data:${mimeType};base64,${data.toString("base64")}` };
-	}));
-}
-
-function recentConversationImageUrls(ctx: ImageGenerationToolContext, count: number): Array<{ image_url: string }> {
-	if (!ctx.sessionManager) throw new Error("Conversation images are unavailable in this tool context; use referenced_image_paths.");
-	if (!Number.isSafeInteger(count) || count < 1 || count > 5) {
-		throw new Error("num_last_images_to_include must be an integer between 1 and 5.");
-	}
-	const messages = buildSessionContext(ctx.sessionManager.getBranch()).messages;
-	const images: string[] = [];
-	for (const message of messages) {
-		if (message.role === "user" || message.role === "toolResult") {
-			if (!Array.isArray(message.content)) continue;
-			for (const item of message.content) {
-				if (item.type === "image") images.push(`data:${item.mimeType};base64,${item.data}`);
-			}
-			continue;
-		}
-		if (message.role !== "assistant") continue;
-		for (const block of message.content as unknown[]) {
-			if (!block || typeof block !== "object") continue;
-			const candidate = block as { type?: unknown; item?: { result?: unknown } };
-			if (candidate.type === "image_generation_call" && typeof candidate.item?.result === "string" && candidate.item.result) {
-				images.push(`data:image/png;base64,${candidate.item.result}`);
-			}
-		}
-	}
-	if (images.length < count) throw new Error(`Requested the last ${count} conversation images, but only ${images.length} were available.`);
-	return images.slice(-count).map((image_url) => ({ image_url }));
-}
-
-export async function standaloneImageGeneration(
-	input: ImageGenerationInput,
-	ctx: ImageGenerationToolContext,
-	settings: ResolvedCodexModelSettings,
-	signal?: AbortSignal,
-	invocation: StandaloneImageGenerationInvocation = {},
-) {
-	signal?.throwIfAborted();
-	const callId = invocation.callId ?? "standalone";
-	const sessionId = ctx.sessionManager?.getSessionId?.();
-	const turnId = invocation.turnId ?? currentCodexTurn(sessionId)?.turnId ?? uuidV7();
-	const model = ctx.model;
-	if (!model || !ctx.modelRegistry) throw new Error("No active model is available for standalone image generation.");
-	if (!settings.enabled) throw new Error("pi-codex-minimal-tools is disabled.");
-	if (!settings.imageGeneration) throw new Error("Image generation is disabled by the global setting or current model profile.");
-	if (settings.imageGenerationImplementation !== "standalone") throw new Error("Image generation requires a standalone model profile.");
-	if (!input.prompt?.trim()) throw new Error("A prompt is required for standalone image generation.");
-	if (input.transparent_background !== undefined && typeof input.transparent_background !== "boolean") {
-		throw new Error("transparent_background must be a boolean.");
-	}
-	if (input.num_last_images_to_include != null && input.referenced_image_paths?.length) {
-		throw new Error("Provide only one of referenced_image_paths or num_last_images_to_include.");
-	}
-	// Capture the invocation's images and turn before auth can yield to another turn.
-	const images = input.num_last_images_to_include != null
-		? recentConversationImageUrls(ctx, input.num_last_images_to_include)
-		: await referencedImageUrls(ctx.cwd, input.referenced_image_paths ?? []);
-	const auth = await ctx.modelRegistry.getApiKeyAndHeaders(model);
-	signal?.throwIfAborted();
-	if (!auth.ok) throw new Error(auth.error);
-	const requestModel = withResolvedAuthBaseUrl(model, auth);
-	rememberResolvedEndpoint(model, requestModel, sessionId);
-	requireEndpointCapability(settings.endpoint_config, requestModel, sessionId, "imageGeneration.standalone");
-	if (!hasCodexRequestAuth({ modelHeaders: model.headers, auth })) {
-		throw new Error(`No request authentication for provider: ${model.provider}`);
-	}
-	const response = await fetchCodexJson(
-		resolveCodexApiEndpoint(auth.baseUrl ?? model.baseUrl, settings.responsesEndpoint, images.length ? "images/edits" : "images/generations"),
-		{
-			headers: buildCodexJsonHeaders({
-				codexRequestExtensions: settings.codexRequestExtensions,
-				modelHeaders: model.headers, auth, endpoint: settings.responsesEndpoint,
-				extraHeaders: settings.codexRequestExtensions ? { "x-codex-image-turn-id": turnId } : undefined,
-			}),
-			body: JSON.stringify({
-				model: settings.imageModel, prompt: input.prompt,
-				...(images.length ? { images } : {}),
-				background: input.transparent_background === true ? "transparent" : "opaque",
-				quality: "auto", size: "auto",
-			}),
-			signal,
-		},
-		["imageGeneration.standalone"],
-	);
-	signal?.throwIfAborted();
-	await checkEndpointResponse(response, requestModel, sessionId, ["imageGeneration.standalone"], signal);
-	const result = await response.json() as { data?: Array<{ b64_json?: string; generation_id?: string }> };
-	signal?.throwIfAborted();
-	const base64 = result.data?.[0]?.b64_json;
-	if (!base64) throw new Error("Standalone image generation returned no image data.");
-	const saved = await saveBase64Image({ base64, callId, cwd: ctx.cwd, format: "png", responseId: settings.imageModel, settings });
-	signal?.throwIfAborted();
-	return {
-		content: [
-			{ type: "image", data: base64, mimeType: "image/png" },
-			{ type: "text", text: `Generated image with ${settings.imageModel}; saved to ${saved.path}${saved.latestPath ? ` (latest: ${saved.latestPath})` : ""}.` },
-		],
-		details: {
-			saved, mode: "standalone-images-api",
-			requestId: response.headers.get("x-codex-imagegen-request-id") ?? undefined,
-			generationId: result.data?.[0]?.generation_id,
-		},
-		structuredContent: imageGenerationOutput(saved, base64),
-	};
-}
-
-export function createImageGenerationToolDefinition(options: {
-	loadSettings?: (cwd: string, model?: Model<Api>) => CodexMinimalToolsSettings | ResolvedCodexModelSettings;
-	getCurrentTurnId?: (sessionId: string | undefined) => string | undefined;
-} = {}) {
-	return {
-		name: "image_generation",
-		label: "Image Generation",
-		description: "Generate or edit images using the standalone Images API selected by the current model profile. Results are saved under imageOutputDir and mirrored to latest.png.",
-		promptSnippet: "Generate or edit images with the implementation selected by the current model profile.",
-		parameters: imageGenerationToolSchema,
-		outputSchema: imageGenerationOutputSchema,
-		async execute(toolCallId: string, params: ImageGenerationInput, signal: AbortSignal | undefined, _onUpdate: unknown, ctx: ImageGenerationToolContext) {
-			const cwd = ctx?.cwd ?? process.cwd();
-			const profileModel = ctx.model ? { ...ctx.model, baseUrl: "" } : undefined;
-			const settings = options.loadSettings?.(cwd, profileModel) ?? loadModelSettings(profileModel, cwd);
-			const resolved = "modelProfile" in settings ? settings as ResolvedCodexModelSettings : loadModelSettings(profileModel, cwd, settings);
-			return standaloneImageGeneration(params, { ...ctx, cwd }, resolved, signal, {
-				callId: toolCallId, turnId: options.getCurrentTurnId?.(ctx.sessionManager?.getSessionId?.()),
-			});
-		},
-	};
-}

package/src/utils/images.ts

@@ -1,73 +0,0 @@
-import { copyFile, mkdir, writeFile } from "node:fs/promises";
-import { existsSync } from "node:fs";
-import { randomUUID } from "node:crypto";
-import { dirname, extname, isAbsolute, join, resolve } from "node:path";
-import type { CodexMinimalToolsSettings } from "@oai404iao/pi-codex-runtime/internal/settings";
-
-export interface SavedImageInfo {
-	path: string;
-	latestPath?: string;
-	mimeType: string;
-	format: string;
-	bytes: number;
-}
-
-export function projectRoot(cwd: string): string {
-	let current = resolve(cwd);
-	while (true) {
-		if (existsSync(join(current, ".git")) || existsSync(join(current, ".pi"))) return current;
-		const parent = dirname(current);
-		if (parent === current) return resolve(cwd);
-		current = parent;
-	}
-}
-
-export function imageOutputDir(cwd: string, settings: Pick<CodexMinimalToolsSettings, "imageOutputDir">): string {
-	const configured = settings.imageOutputDir || ".pi/openai-codex-images";
-	return isAbsolute(configured) ? resolve(configured) : resolve(projectRoot(cwd), configured);
-}
-
-export function imageFormatToMime(format: string | undefined): string {
-	const normalized = (format || "png").toLowerCase().replace(/^\./, "");
-	if (normalized === "jpg" || normalized === "jpeg") return "image/jpeg";
-	if (normalized === "webp") return "image/webp";
-	return "image/png";
-}
-
-export function extensionForMime(mimeType: string): string {
-	if (mimeType === "image/jpeg") return "jpeg";
-	if (mimeType === "image/webp") return "webp";
-	return "png";
-}
-
-export function inferImageFormat(value: unknown, fallback = "png"): string {
-	if (typeof value !== "string") return fallback;
-	const lower = value.toLowerCase();
-	if (lower.includes("jpeg") || lower.includes("jpg")) return "jpeg";
-	if (lower.includes("webp")) return "webp";
-	if (lower.includes("png")) return "png";
-	const ext = extname(lower).replace(/^\./, "");
-	return ext || fallback;
-}
-
-export async function saveBase64Image(options: {
-	base64: string;
-	callId?: string;
-	cwd: string;
-	format?: string;
-	responseId?: string;
-	settings: Pick<CodexMinimalToolsSettings, "imageOutputDir">;
-}): Promise<SavedImageInfo> {
-	const format = inferImageFormat(options.format, "png");
-	const mimeType = imageFormatToMime(format);
-	const ext = extensionForMime(mimeType);
-	const dir = imageOutputDir(options.cwd, options.settings);
-	await mkdir(dir, { recursive: true });
-	const unique = randomUUID().slice(0, 8);
-	const filePath = join(dir, `${new Date().toISOString().replace(/[:.]/g, "-")}-${unique}.${ext}`);
-	const data = Buffer.from(options.base64, "base64");
-	await writeFile(filePath, data, { mode: 0o600 });
-	const latestPath = join(dir, `latest.${ext}`);
-	await copyFile(filePath, latestPath);
-	return { bytes: data.byteLength, format: ext, latestPath, mimeType, path: filePath };
-}