@oai404iao/pi-codex-minimal-tools 1.4.0 → 2.0.0

package/src/tools/image-generation.ts

@@ -1,274 +1 @@
-import { randomUUID } from "node:crypto";
-import { readFile } from "node:fs/promises";
-import { extname, isAbsolute, resolve } from "node:path";
-import { buildSessionContext, type SessionEntry } from "@earendil-works/pi-coding-agent";
-import { saveBase64Image } from "../utils/images.js";
-import type { CodexMinimalToolsSettings } from "../settings.js";
-import type { Api, Model, ProviderHeaders } from "@earendil-works/pi-ai";
-import {
-	buildCodexJsonHeaders,
-	hasCodexRequestAuth,
-	resolveCodexApiEndpoint,
-} from "../codex-http.js";
-import { loadModelSettings, type ResolvedCodexModelSettings } from "../model-catalog/runtime.js";
-
-export interface ImageGenerationInput {
-	prompt?: string;
-	referenced_image_paths?: string[];
-	num_last_images_to_include?: number;
-	size?: "1024x1024" | "1024x1536" | "1536x1024" | "auto";
-	quality?: "low" | "medium" | "high" | "auto";
-	background?: "transparent" | "opaque" | "auto";
-	output_format?: "png" | "webp" | "jpeg";
-}
-
-export const imageGenerationToolSchema = {
-	type: "object",
-	additionalProperties: false,
-	properties: {
-		prompt: { type: "string", description: "Image generation or editing prompt." },
-		referenced_image_paths: {
-			type: "array",
-			maxItems: 5,
-			items: { type: "string", minLength: 1 },
-			description: "Local PNG, JPEG, or WebP paths to edit.",
-		},
-		num_last_images_to_include: {
-			type: "integer",
-			minimum: 1,
-			maximum: 5,
-			description: "Use the newest conversation images when one or more targets have no local path.",
-		},
-	},
-	required: ["prompt"],
-};
-
-async function urlToBase64(url: string, signal?: AbortSignal): Promise<string> {
-	const response = await fetch(url, { signal });
-	if (!response.ok) throw new Error(`Failed to download generated image: ${response.status} ${await response.text()}`);
-	const buffer = Buffer.from(await response.arrayBuffer());
-	return buffer.toString("base64");
-}
-
-export async function directImageGeneration(input: ImageGenerationInput, cwd: string, settings: CodexMinimalToolsSettings, signal?: AbortSignal) {
-	if (!settings.directImageApiFallback) throw new Error("Direct Images API fallback is disabled. Use native openai or openai-codex handling, or enable directImageApiFallback.");
-	const apiKey = process.env.OPENAI_API_KEY;
-	if (!apiKey) throw new Error("OPENAI_API_KEY is required for direct image_generation fallback.");
-	if (!input.prompt?.trim()) throw new Error("A prompt is required for direct image_generation fallback.");
-	const body: Record<string, unknown> = {
-		model: settings.imageModel,
-		prompt: input.prompt,
-	};
-	if (input.size && input.size !== "auto") body.size = input.size;
-	if (input.quality && input.quality !== "auto") body.quality = input.quality;
-	if (input.background && input.background !== "auto") body.background = input.background;
-	if (input.output_format) body.output_format = input.output_format;
-	const response = await fetch("https://api.openai.com/v1/images/generations", {
-		method: "POST",
-		headers: { Authorization: `Bearer ${apiKey}`, "content-type": "application/json" },
-		body: JSON.stringify(body),
-		signal,
-	});
-	if (!response.ok) throw new Error(`OpenAI Images API failed: ${response.status} ${await response.text()}`);
-	const json = await response.json() as { data?: Array<{ b64_json?: string; url?: string; revised_prompt?: string }> };
-	const first = json.data?.[0];
-	const base64 = first?.b64_json ?? (first?.url ? await urlToBase64(first.url, signal) : undefined);
-	if (!base64) throw new Error("OpenAI Images API returned no image data.");
-	const saved = await saveBase64Image({ base64, callId: "direct", cwd, format: input.output_format, responseId: settings.imageModel, settings });
-	return {
-		content: [{ type: "text", text: `Generated image with ${settings.imageModel}; saved to ${saved.path}${saved.latestPath ? ` (latest: ${saved.latestPath})` : ""}.` }],
-		details: { saved, revisedPrompt: first?.revised_prompt, mode: "direct-images-api" },
-	};
-}
-
-interface ImageGenerationToolContext {
-	cwd: string;
-	model?: Model<Api>;
-	modelRegistry?: {
-		getApiKeyAndHeaders(model: Model<Api>): Promise<
-			| { ok: true; apiKey?: string; headers?: ProviderHeaders }
-			| { 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 extension = extname(path).toLowerCase();
-		const mimeType = extension === ".png"
-			? "image/png"
-			: extension === ".jpg" || extension === ".jpeg"
-				? "image/jpeg"
-				: extension === ".webp"
-					? "image/webp"
-					: undefined;
-		if (!mimeType) throw new Error(`Unsupported reference image type: ${rawPath}. Use PNG, JPEG, or WebP.`);
-		const data = await readFile(path);
-		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.");
-	}
-	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 = {},
-) {
-	const callId = invocation.callId ?? "standalone";
-	const turnId = invocation.turnId ?? randomUUID();
-	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 (!input.prompt?.trim()) throw new Error("A prompt is required for standalone image generation.");
-	if (input.num_last_images_to_include !== undefined && input.referenced_image_paths?.length) {
-		throw new Error("Provide only one of referenced_image_paths or num_last_images_to_include.");
-	}
-	const auth = await ctx.modelRegistry.getApiKeyAndHeaders(model);
-	if (!auth.ok) throw new Error(auth.error);
-	if (!hasCodexRequestAuth({
-		modelHeaders: model.headers,
-		auth: { apiKey: auth.apiKey, headers: auth.headers },
-	})) {
-		throw new Error(`No request authentication for provider: ${model.provider}`);
-	}
-	const images = input.num_last_images_to_include !== undefined
-		? recentConversationImageUrls(ctx, input.num_last_images_to_include)
-		: await referencedImageUrls(ctx.cwd, input.referenced_image_paths ?? []);
-	const edit = images.length > 0;
-	const response = await fetch(
-		resolveCodexApiEndpoint(
-			model.baseUrl,
-			settings.apiKeyMode,
-			edit ? "images/edits" : "images/generations",
-		),
-		{
-			method: "POST",
-			headers: buildCodexJsonHeaders({
-				modelHeaders: model.headers,
-				auth: { apiKey: auth.apiKey, headers: auth.headers },
-				apiKeyMode: settings.apiKeyMode,
-				extraHeaders: {
-					"x-codex-image-turn-id": turnId,
-				},
-			}),
-			body: JSON.stringify({
-				model: settings.imageModel,
-				prompt: input.prompt.trim(),
-				...(edit ? { images } : {}),
-				background: "auto",
-				quality: "auto",
-				size: "auto",
-			}),
-			signal,
-		},
-	);
-	if (!response.ok) {
-		throw new Error(`Standalone image generation failed: HTTP ${response.status}: ${await response.text()}`);
-	}
-	const result = await response.json() as {
-		data?: Array<{ b64_json?: string }>;
-	};
-	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,
-	});
-	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" },
-	};
-}
-
-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 hosted or standalone implementation selected by the current model profile. Results are saved under imageOutputDir and mirrored to latest.<ext>.",
-		promptSnippet: "Generate or edit images with the implementation selected by the current model profile.",
-		parameters: imageGenerationToolSchema,
-		async execute(toolCallId: string, params: ImageGenerationInput, signal: AbortSignal | undefined, _onUpdate: unknown, ctx: ImageGenerationToolContext) {
-			const cwd = ctx?.cwd ?? process.cwd();
-			const settings = options.loadSettings?.(cwd, ctx.model) ?? loadModelSettings(ctx.model, cwd);
-			const resolvedSettings = "modelProfile" in settings
-				? settings as ResolvedCodexModelSettings
-				: loadModelSettings(ctx.model, cwd, settings);
-			if (resolvedSettings.imageGenerationImplementation === "standalone") {
-				const sessionId = ctx.sessionManager?.getSessionId?.();
-				return standaloneImageGeneration(params, ctx, resolvedSettings, signal, {
-					callId: toolCallId,
-					turnId: options.getCurrentTurnId?.(sessionId),
-				});
-			}
-			if (settings?.directImageApiFallback) return directImageGeneration(params, cwd, settings, signal);
-			return {
-				content: [{ type: "text", text: "image_generation should be handled by the current model profile. If no hosted or standalone implementation is configured, enable directImageApiFallback with OPENAI_API_KEY." }],
-				details: { phase: "native-provider", nativeTool: "image_generation" },
-			};
-		},
-	};
-}
+export * from "@oai404iao/pi-codex-imagegen/internal/tools/image-generation";

package/src/tools/view-image.ts

@@ -1,98 +1 @@
-import { stat, readFile, realpath } from "node:fs/promises";
-import { extname, isAbsolute, relative, resolve } from "node:path";
-
-export type ImageDetail = "auto" | "low" | "high" | "original";
-
-export interface ViewImageInput {
-	path: string;
-	detail?: ImageDetail;
-}
-
-export interface ViewImageOptions {
-	workspaceOnly?: boolean;
-}
-
-export interface ValidatedImage {
-	absolutePath: string;
-	displayPath: string;
-	mimeType: string;
-	sizeBytes: number;
-	detail: ImageDetail;
-}
-
-const IMAGE_MIME_BY_EXT: Record<string, string> = {
-	".png": "image/png",
-	".jpg": "image/jpeg",
-	".jpeg": "image/jpeg",
-	".gif": "image/gif",
-	".webp": "image/webp",
-	".bmp": "image/bmp",
-	".tif": "image/tiff",
-	".tiff": "image/tiff",
-	".svg": "image/svg+xml",
-};
-
-function assertWithinCwd(absolutePath: string, cwd: string, displayPath: string): void {
-	const cwdAbsolute = resolve(cwd);
-	const rel = relative(cwdAbsolute, absolutePath);
-	if (rel === "" || (!rel.startsWith("..") && !isAbsolute(rel))) return;
-	throw new Error(`view_image path escapes the workspace: ${displayPath}`);
-}
-
-export function normalizeImagePath(pathValue: string, cwd: string, options?: ViewImageOptions): { absolutePath: string; displayPath: string } {
-	let cleaned = pathValue.trim();
-	if ((cleaned.startsWith('"') && cleaned.endsWith('"')) || (cleaned.startsWith("'") && cleaned.endsWith("'"))) cleaned = cleaned.slice(1, -1);
-	if (cleaned.startsWith("@")) cleaned = cleaned.slice(1);
-	const absolutePath = resolve(cwd, cleaned);
-	if (options?.workspaceOnly) assertWithinCwd(absolutePath, cwd, cleaned);
-	return { absolutePath, displayPath: cleaned };
-}
-
-export function mimeTypeForImagePath(path: string): string | undefined {
-	return IMAGE_MIME_BY_EXT[extname(path).toLowerCase()];
-}
-
-export async function validateImagePath(input: ViewImageInput, cwd: string, options?: ViewImageOptions): Promise<ValidatedImage> {
-	if (!input || typeof input.path !== "string" || input.path.trim().length === 0) throw new Error("view_image requires a non-empty path.");
-	const detail = input.detail ?? "auto";
-	if (!["auto", "low", "high", "original"].includes(detail)) throw new Error(`Unsupported image detail: ${String(input.detail)}`);
-	const normalized = normalizeImagePath(input.path, cwd, options);
-	let fileStat;
-	try {
-		fileStat = await stat(normalized.absolutePath);
-	} catch {
-		throw new Error(`Image not found: ${normalized.displayPath}`);
-	}
-	if (fileStat.isDirectory()) throw new Error(`view_image expected a file but got a directory: ${normalized.displayPath}`);
-	if (!fileStat.isFile()) throw new Error(`view_image expected a regular image file: ${normalized.displayPath}`);
-	if (options?.workspaceOnly) {
-		try {
-			assertWithinCwd(await realpath(normalized.absolutePath), await realpath(cwd), normalized.displayPath);
-		} catch (error) {
-			if (error instanceof Error && error.message.includes("escapes the workspace")) throw error;
-			throw new Error(`Unable to validate image path: ${normalized.displayPath}`);
-		}
-	}
-	const mimeType = mimeTypeForImagePath(normalized.absolutePath);
-	if (!mimeType) throw new Error(`Unsupported image file type for view_image: ${normalized.displayPath}`);
-	return { ...normalized, detail, mimeType, sizeBytes: fileStat.size };
-}
-
-export async function viewImage(input: ViewImageInput, cwd: string, options?: ViewImageOptions) {
-	const image = await validateImagePath(input, cwd, options);
-	const data = await readFile(image.absolutePath, "base64");
-	return {
-		content: [{ type: "image", data, mimeType: image.mimeType, detail: image.detail }],
-		details: image,
-	};
-}
-
-export const viewImageToolSchema = {
-	type: "object",
-	additionalProperties: false,
-	properties: {
-		path: { type: "string", description: "Path to the local image file. Relative paths resolve against ctx.cwd; a leading @ is accepted and stripped." },
-		detail: { type: "string", enum: ["auto", "low", "high", "original"], description: "Image detail hint. Defaults to auto." },
-	},
-	required: ["path"],
-};
+export * from "@oai404iao/pi-codex-core/internal/tools/view-image";

package/src/tools/web-search/activity.ts

@@ -0,0 +1 @@
+export * from "@oai404iao/pi-codex-web-search/internal/tools/web-search/activity";

package/src/tools/web-search/capture.ts

@@ -0,0 +1 @@
+export * from "@oai404iao/pi-codex-web-search/internal/tools/web-search/capture";

package/src/tools/web-search/render.ts

@@ -0,0 +1 @@
+export * from "@oai404iao/pi-codex-web-search/internal/tools/web-search/render";