@astrofoundry/pi-astro 0.5.0 → 0.6.0

package/extensions/gemini-image/index.test.ts

@@ -0,0 +1,369 @@
+import { mkdtempSync, readdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+const generateContentMock = vi.fn();
+const generateImagesMock = vi.fn();
+
+vi.mock("@google/genai", () => {
+    class FakeGoogleGenAI {
+        models = {
+            generateContent: generateContentMock,
+            generateImages: generateImagesMock,
+        };
+    }
+    return { GoogleGenAI: FakeGoogleGenAI };
+});
+
+type ToolDef = {
+    name: string;
+    execute: (
+        id: string,
+        input: Record<string, unknown>,
+        signal: AbortSignal | undefined,
+        onUpdate: unknown,
+        ctx: {
+            cwd: string;
+            hasUI: boolean;
+            ui: {
+                notify: ReturnType<typeof vi.fn>;
+                confirm: ReturnType<typeof vi.fn>;
+                input: ReturnType<typeof vi.fn>;
+            };
+        },
+    ) => Promise<{ content: unknown[]; details: Record<string, unknown> }>;
+};
+
+function makePi(): { tools: ToolDef[]; registerTool: (t: ToolDef) => void } {
+    const tools: ToolDef[] = [];
+    return { tools, registerTool: (t) => tools.push(t) };
+}
+
+function makeCtx(override: Partial<{ hasUI: boolean; confirm: boolean; inputValue: string | undefined }> = {}): {
+    cwd: string;
+    hasUI: boolean;
+    ui: {
+        notify: ReturnType<typeof vi.fn>;
+        confirm: ReturnType<typeof vi.fn>;
+        input: ReturnType<typeof vi.fn>;
+    };
+} {
+    const hasUI = override.hasUI ?? true;
+    return {
+        cwd: "/tmp/cwd",
+        hasUI,
+        ui: {
+            notify: vi.fn(),
+            confirm: vi.fn().mockResolvedValue(override.confirm ?? true),
+            input: vi.fn().mockResolvedValue(override.inputValue ?? "abc-key-from-paste"),
+        },
+    };
+}
+
+describe("gemini-image extension", () => {
+    let fakeHome: string;
+    const originalHome = process.env.HOME;
+    const originalKey = process.env.GEMINI_API_KEY;
+
+    beforeEach(() => {
+        fakeHome = mkdtempSync(join(tmpdir(), "gem-ext-"));
+        process.env.HOME = fakeHome;
+        process.env.GEMINI_API_KEY = "test-key";
+        vi.resetModules();
+        generateContentMock.mockReset();
+        generateImagesMock.mockReset();
+    });
+
+    afterEach(() => {
+        rmSync(fakeHome, { recursive: true, force: true });
+        process.env.HOME = originalHome;
+        if (originalKey === undefined) delete process.env.GEMINI_API_KEY;
+        else process.env.GEMINI_API_KEY = originalKey;
+    });
+
+    async function load(): Promise<{ tool: ToolDef }> {
+        const mod = await import("./index.ts");
+        const pi = makePi();
+        mod.default(pi as unknown as Parameters<typeof mod.default>[0]);
+        return { tool: pi.tools[0] };
+    }
+
+    it("registers a tool named gemini_image", async () => {
+        const { tool } = await load();
+        expect(tool.name).toBe("gemini_image");
+    });
+
+    it("uses default model gemini-2.5-flash-image and calls generateContent", async () => {
+        generateContentMock.mockResolvedValue({
+            candidates: [
+                { content: { parts: [{ inlineData: { mimeType: "image/png", data: "BASE64DATA" } }] } },
+            ],
+        });
+        const { tool } = await load();
+        const ctx = makeCtx();
+        const res = await tool.execute("t", { prompt: "a cat" }, undefined, undefined, ctx);
+        expect(res.details.model).toBe("gemini-2.5-flash-image");
+        expect(res.content[0]).toMatchObject({ type: "image", data: "BASE64DATA" });
+    });
+
+    it("calls Imagen for imagen-4.0-generate-001 with numberOfImages", async () => {
+        generateImagesMock.mockResolvedValue({
+            generatedImages: [
+                { image: { imageBytes: "IMG1", mimeType: "image/png" } },
+                { image: { imageBytes: "IMG2", mimeType: "image/png" } },
+            ],
+        });
+        const { tool } = await load();
+        const ctx = makeCtx();
+        const res = await tool.execute(
+            "t",
+            {
+                prompt: "landscape",
+                model: "imagen-4.0-generate-001",
+                number_of_images: 2,
+            },
+            undefined,
+            undefined,
+            ctx,
+        );
+        expect(res.details.images).toBe(2);
+        const args = generateImagesMock.mock.calls[0][0];
+        expect(args.config.numberOfImages).toBe(2);
+    });
+
+    it("rejects unknown model", async () => {
+        const { tool } = await load();
+        await expect(
+            tool.execute("t", { prompt: "x", model: "bogus-model" }, undefined, undefined, makeCtx()),
+        ).rejects.toThrow(/Unknown model/);
+    });
+
+    it("rejects invalid aspect_ratio for Imagen (e.g. 21:9)", async () => {
+        const { tool } = await load();
+        await expect(
+            tool.execute(
+                "t",
+                { prompt: "x", model: "imagen-4.0-generate-001", aspect_ratio: "21:9" },
+                undefined,
+                undefined,
+                makeCtx(),
+            ),
+        ).rejects.toThrow(/aspect_ratio .* Imagen/);
+    });
+
+    it("rejects 4K image_size for Imagen", async () => {
+        const { tool } = await load();
+        await expect(
+            tool.execute(
+                "t",
+                { prompt: "x", model: "imagen-4.0-generate-001", image_size: "4K" },
+                undefined,
+                undefined,
+                makeCtx(),
+            ),
+        ).rejects.toThrow(/image_size .* Imagen/);
+    });
+
+    it("rejects input_images on Imagen", async () => {
+        const { tool } = await load();
+        await expect(
+            tool.execute(
+                "t",
+                {
+                    prompt: "x",
+                    model: "imagen-4.0-generate-001",
+                    input_images: ["/tmp/x.png"],
+                },
+                undefined,
+                undefined,
+                makeCtx(),
+            ),
+        ).rejects.toThrow(/input_images/);
+    });
+
+    it("rejects negative_prompt on Gemini native", async () => {
+        const { tool } = await load();
+        await expect(
+            tool.execute(
+                "t",
+                { prompt: "x", negative_prompt: "ugly" },
+                undefined,
+                undefined,
+                makeCtx(),
+            ),
+        ).rejects.toThrow(/negative_prompt/);
+    });
+
+    it("rejects seed on Gemini native", async () => {
+        const { tool } = await load();
+        await expect(
+            tool.execute("t", { prompt: "x", seed: 42 }, undefined, undefined, makeCtx()),
+        ).rejects.toThrow(/seed/);
+    });
+
+    it("rejects number_of_images > 1 on Gemini native", async () => {
+        const { tool } = await load();
+        await expect(
+            tool.execute("t", { prompt: "x", number_of_images: 3 }, undefined, undefined, makeCtx()),
+        ).rejects.toThrow(/number_of_images/);
+    });
+
+    it("prompts for API key when none configured and saves if confirmed", async () => {
+        delete process.env.GEMINI_API_KEY;
+        generateContentMock.mockResolvedValue({
+            candidates: [{ content: { parts: [{ inlineData: { mimeType: "image/png", data: "X" } }] } }],
+        });
+        const { tool } = await load();
+        const ctx = makeCtx({ inputValue: "pasted-key" });
+        await tool.execute("t", { prompt: "x" }, undefined, undefined, ctx);
+        expect(ctx.ui.input).toHaveBeenCalled();
+        // Confirm was called for both the save prompt and the cost confirmation
+        expect(ctx.ui.confirm.mock.calls.length).toBeGreaterThanOrEqual(1);
+    });
+
+    it("errors when API key missing and no UI available", async () => {
+        delete process.env.GEMINI_API_KEY;
+        const { tool } = await load();
+        const ctx = makeCtx({ hasUI: false });
+        await expect(tool.execute("t", { prompt: "x" }, undefined, undefined, ctx)).rejects.toThrow(/no interactive UI/);
+    });
+
+    it("errors when user provides empty key at prompt", async () => {
+        delete process.env.GEMINI_API_KEY;
+        const { tool } = await load();
+        const ctx = makeCtx({ inputValue: "   " });
+        await expect(tool.execute("t", { prompt: "x" }, undefined, undefined, ctx)).rejects.toThrow(/No API key/);
+    });
+
+    it("cost confirmation: throws when user rejects", async () => {
+        generateContentMock.mockResolvedValue({
+            candidates: [{ content: { parts: [{ inlineData: { mimeType: "image/png", data: "X" } }] } }],
+        });
+        const { tool } = await load();
+        const ctx = makeCtx({ confirm: false });
+        await expect(tool.execute("t", { prompt: "x" }, undefined, undefined, ctx)).rejects.toThrow(/User cancelled/);
+    });
+
+    it("skip_confirm bypasses cost prompt", async () => {
+        generateContentMock.mockResolvedValue({
+            candidates: [{ content: { parts: [{ inlineData: { mimeType: "image/png", data: "X" } }] } }],
+        });
+        const { tool } = await load();
+        const ctx = makeCtx();
+        await tool.execute("t", { prompt: "x", skip_confirm: true }, undefined, undefined, ctx);
+        // confirm should not be called for cost
+        expect(ctx.ui.confirm).not.toHaveBeenCalled();
+    });
+
+    it("save_to writes PNG files and reports paths", async () => {
+        generateImagesMock.mockResolvedValue({
+            generatedImages: [
+                { image: { imageBytes: Buffer.from("fakeimage").toString("base64"), mimeType: "image/png" } },
+            ],
+        });
+        const saveDir = mkdtempSync(join(tmpdir(), "gem-save-"));
+        const { tool } = await load();
+        const ctx = makeCtx();
+        const res = await tool.execute(
+            "t",
+            {
+                prompt: "a-landscape",
+                model: "imagen-4.0-fast-generate-001",
+                save_to: saveDir,
+            },
+            undefined,
+            undefined,
+            ctx,
+        );
+        const paths = res.details.savedPaths as string[];
+        expect(paths).toHaveLength(1);
+        expect(readdirSync(saveDir)).toHaveLength(1);
+        rmSync(saveDir, { recursive: true, force: true });
+    });
+
+    it("throws when model returns no images", async () => {
+        generateContentMock.mockResolvedValue({ candidates: [] });
+        const { tool } = await load();
+        await expect(tool.execute("t", { prompt: "x" }, undefined, undefined, makeCtx())).rejects.toThrow(/no images/);
+    });
+
+    it("input_images are read from disk and passed as inlineData", async () => {
+        const sourceDir = mkdtempSync(join(tmpdir(), "gem-input-"));
+        const imgPath = join(sourceDir, "input.png");
+        writeFileSync(imgPath, "binary-image");
+        generateContentMock.mockResolvedValue({
+            candidates: [{ content: { parts: [{ inlineData: { mimeType: "image/png", data: "OUT" } }] } }],
+        });
+        const { tool } = await load();
+        const ctx = makeCtx();
+        await tool.execute(
+            "t",
+            { prompt: "edit", input_images: [imgPath] },
+            undefined,
+            undefined,
+            ctx,
+        );
+        const callArgs = generateContentMock.mock.calls[0][0];
+        // First content is the text, subsequent are inlineData parts
+        expect(callArgs.contents.some((c: Record<string, unknown>) => "inlineData" in c)).toBe(true);
+        rmSync(sourceDir, { recursive: true, force: true });
+    });
+
+    it("passes aspect_ratio + image_size into imageConfig for Gemini native", async () => {
+        generateContentMock.mockResolvedValue({
+            candidates: [{ content: { parts: [{ inlineData: { mimeType: "image/png", data: "X" } }] } }],
+        });
+        const { tool } = await load();
+        await tool.execute(
+            "t",
+            { prompt: "x", aspect_ratio: "16:9", image_size: "2K" },
+            undefined,
+            undefined,
+            makeCtx(),
+        );
+        const cfg = generateContentMock.mock.calls[0][0].config;
+        expect(cfg.imageConfig.aspectRatio).toBe("16:9");
+        expect(cfg.imageConfig.imageSize).toBe("2K");
+    });
+
+    it("Imagen config: numberOfImages + negative_prompt + seed + person_generation all pass through", async () => {
+        generateImagesMock.mockResolvedValue({
+            generatedImages: [{ image: { imageBytes: "X", mimeType: "image/png" } }],
+        });
+        const { tool } = await load();
+        await tool.execute(
+            "t",
+            {
+                prompt: "x",
+                model: "imagen-4.0-ultra-generate-001",
+                number_of_images: 2,
+                negative_prompt: "blurry",
+                seed: 1337,
+                person_generation: "allow_adult",
+            },
+            undefined,
+            undefined,
+            makeCtx(),
+        );
+        const cfg = generateImagesMock.mock.calls[0][0].config;
+        expect(cfg.numberOfImages).toBe(2);
+        expect(cfg.negativePrompt).toBe("blurry");
+        expect(cfg.seed).toBe(1337);
+        expect(cfg.personGeneration).toBe("allow_adult");
+    });
+
+    it("rejects invalid Gemini aspect_ratio", async () => {
+        const { tool } = await load();
+        await expect(
+            tool.execute("t", { prompt: "x", aspect_ratio: "17:3" }, undefined, undefined, makeCtx()),
+        ).rejects.toThrow(/aspect_ratio .* Gemini native/);
+    });
+
+    it("rejects invalid Gemini image_size", async () => {
+        const { tool } = await load();
+        await expect(
+            tool.execute("t", { prompt: "x", image_size: "8K" as "4K" }, undefined, undefined, makeCtx()),
+        ).rejects.toThrow(/image_size/);
+    });
+});

package/extensions/gemini-image/index.ts

@@ -0,0 +1,313 @@
+import { readFileSync, writeFileSync } from "node:fs";
+import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
+import type { AgentToolResult } from "@mariozechner/pi-agent-core";
+import { GoogleGenAI } from "@google/genai";
+import { StringEnum } from "@mariozechner/pi-ai";
+import { Type } from "typebox";
+import { persistApiKey, resolveExistingApiKey } from "./credentials.ts";
+import {
+    ALL_MODELS,
+    DEFAULT_MODEL,
+    GEMINI_ASPECT_RATIOS,
+    GEMINI_IMAGE_SIZES,
+    IMAGEN_ASPECT_RATIOS,
+    IMAGEN_IMAGE_SIZES,
+    PERSON_GENERATION_VALUES,
+    isGeminiNative,
+    isImagen,
+    type ImageModel,
+} from "./models.ts";
+import { estimateCost, formatUsd, hasPricing } from "./pricing.ts";
+
+const params = Type.Object({
+    prompt: Type.String({ description: "Text prompt describing the image to generate." }),
+    model: Type.Optional(
+        StringEnum(ALL_MODELS as unknown as readonly [string, ...string[]], {
+            description: `Model. Default: ${DEFAULT_MODEL}.`,
+        }),
+    ),
+    aspect_ratio: Type.Optional(Type.String({ description: "Aspect ratio; validated per model family." })),
+    image_size: Type.Optional(
+        StringEnum(["1K", "2K", "4K"] as const, { description: "Output resolution. 4K is Gemini-native only." }),
+    ),
+    number_of_images: Type.Optional(
+        Type.Integer({ minimum: 1, maximum: 4, description: "Imagen only. 1-4." }),
+    ),
+    negative_prompt: Type.Optional(Type.String({ description: "Imagen only." })),
+    person_generation: Type.Optional(
+        StringEnum(PERSON_GENERATION_VALUES as unknown as readonly [string, ...string[]], {
+            description: "People policy: dont_allow | allow_adult | allow_all.",
+        }),
+    ),
+    seed: Type.Optional(Type.Integer({ description: "Imagen only. Reproducibility seed." })),
+    input_images: Type.Optional(
+        Type.Array(Type.String(), {
+            description: "Gemini native only. Absolute paths to images for editing.",
+        }),
+    ),
+    save_to: Type.Optional(Type.String({ description: "Optional directory to write generated PNG(s)." })),
+    skip_confirm: Type.Optional(Type.Boolean({ description: "Skip the cost confirmation prompt." })),
+});
+
+type Params = {
+    prompt: string;
+    model?: string;
+    aspect_ratio?: string;
+    image_size?: "1K" | "2K" | "4K";
+    number_of_images?: number;
+    negative_prompt?: string;
+    person_generation?: (typeof PERSON_GENERATION_VALUES)[number];
+    seed?: number;
+    input_images?: string[];
+    save_to?: string;
+    skip_confirm?: boolean;
+};
+
+async function ensureApiKey(ctx: ExtensionContext): Promise<string> {
+    const existing = resolveExistingApiKey();
+    if (existing) return existing;
+
+    if (!ctx.hasUI) {
+        throw new Error("Gemini API key is not configured and no interactive UI is available to ask for one.");
+    }
+
+    const pasted = await ctx.ui.input("Paste your Gemini API key:");
+    if (!pasted || !pasted.trim()) {
+        throw new Error("No API key provided.");
+    }
+    const key = pasted.trim();
+
+    const save = await ctx.ui.confirm("Save for future use?", "The key will be kept locally for later calls.");
+    if (save) {
+        persistApiKey(key);
+    }
+    return key;
+}
+
+function validateForModel(model: ImageModel, p: Params): void {
+    if (isImagen(model)) {
+        if (p.aspect_ratio && !(IMAGEN_ASPECT_RATIOS as readonly string[]).includes(p.aspect_ratio)) {
+            throw new Error(
+                `aspect_ratio "${p.aspect_ratio}" is not supported for Imagen. Valid: ${IMAGEN_ASPECT_RATIOS.join(", ")}.`,
+            );
+        }
+        if (p.image_size && !(IMAGEN_IMAGE_SIZES as readonly string[]).includes(p.image_size)) {
+            throw new Error(
+                `image_size "${p.image_size}" is not supported for Imagen. Valid: ${IMAGEN_IMAGE_SIZES.join(", ")}.`,
+            );
+        }
+        if (p.input_images && p.input_images.length > 0) {
+            throw new Error("Imagen does not support input_images (text-to-image only). Use a Gemini-native model.");
+        }
+    } else if (isGeminiNative(model)) {
+        if (p.aspect_ratio && !(GEMINI_ASPECT_RATIOS as readonly string[]).includes(p.aspect_ratio)) {
+            throw new Error(
+                `aspect_ratio "${p.aspect_ratio}" is not supported for Gemini native. Valid: ${GEMINI_ASPECT_RATIOS.join(", ")}.`,
+            );
+        }
+        if (p.image_size && !(GEMINI_IMAGE_SIZES as readonly string[]).includes(p.image_size)) {
+            throw new Error(
+                `image_size "${p.image_size}" is not supported for Gemini native. Valid: ${GEMINI_IMAGE_SIZES.join(", ")}.`,
+            );
+        }
+        if (p.number_of_images !== undefined && p.number_of_images !== 1) {
+            throw new Error("Gemini native produces a single image per call; number_of_images only applies to Imagen.");
+        }
+        if (p.negative_prompt) {
+            throw new Error("negative_prompt is Imagen-only.");
+        }
+        if (p.seed !== undefined) {
+            throw new Error("seed is Imagen-only.");
+        }
+    }
+}
+
+interface DecodedImage {
+    data: string; // base64
+    mimeType: string;
+}
+
+async function callGeminiNative(
+    ai: GoogleGenAI,
+    model: string,
+    p: Params,
+    signal: AbortSignal | undefined,
+): Promise<DecodedImage[]> {
+    const imageConfig: Record<string, string> = {};
+    if (p.aspect_ratio) imageConfig.aspectRatio = p.aspect_ratio;
+    if (p.image_size) imageConfig.imageSize = p.image_size;
+    if (p.person_generation) imageConfig.personGeneration = p.person_generation;
+
+    const contents: Array<Record<string, unknown>> = [{ text: p.prompt }];
+    for (const path of p.input_images ?? []) {
+        const buffer = readFileSync(path);
+        const mimeType = path.toLowerCase().endsWith(".jpg") || path.toLowerCase().endsWith(".jpeg")
+            ? "image/jpeg"
+            : path.toLowerCase().endsWith(".webp")
+            ? "image/webp"
+            : "image/png";
+        contents.push({
+            inlineData: {
+                mimeType,
+                data: buffer.toString("base64"),
+            },
+        });
+    }
+
+    const response = await ai.models.generateContent({
+        model,
+        contents,
+        config: {
+            responseModalities: ["Text", "Image"],
+            ...(Object.keys(imageConfig).length > 0 ? { imageConfig } : {}),
+            ...(signal ? { abortSignal: signal } : {}),
+        },
+    });
+
+    const images: DecodedImage[] = [];
+    for (const candidate of response.candidates ?? []) {
+        for (const part of candidate.content?.parts ?? []) {
+            if (part.inlineData?.data && part.inlineData.mimeType) {
+                images.push({ data: part.inlineData.data, mimeType: part.inlineData.mimeType });
+            }
+        }
+    }
+    return images;
+}
+
+async function callImagen(
+    ai: GoogleGenAI,
+    model: string,
+    p: Params,
+    signal: AbortSignal | undefined,
+): Promise<DecodedImage[]> {
+    const config: Record<string, unknown> = {};
+    if (p.aspect_ratio) config.aspectRatio = p.aspect_ratio;
+    if (p.image_size) config.imageSize = p.image_size;
+    if (p.number_of_images !== undefined) config.numberOfImages = p.number_of_images;
+    if (p.negative_prompt) config.negativePrompt = p.negative_prompt;
+    if (p.person_generation) config.personGeneration = p.person_generation;
+    if (p.seed !== undefined) config.seed = p.seed;
+    if (signal) config.abortSignal = signal;
+
+    const response = await ai.models.generateImages({
+        model,
+        prompt: p.prompt,
+        ...(Object.keys(config).length > 0 ? { config } : {}),
+    });
+
+    const images: DecodedImage[] = [];
+    for (const generated of response.generatedImages ?? []) {
+        if (generated.image?.imageBytes) {
+            images.push({
+                data: generated.image.imageBytes,
+                mimeType: generated.image.mimeType ?? "image/png",
+            });
+        }
+    }
+    return images;
+}
+
+function saveImages(images: DecodedImage[], dir: string, prompt: string): string[] {
+    const slug = prompt
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 40) || "image";
+    const ts = new Date().toISOString().replace(/[:.]/g, "-");
+    const paths: string[] = [];
+    for (let i = 0; i < images.length; i++) {
+        const ext = images[i].mimeType === "image/jpeg" ? "jpg" : "png";
+        const base = images.length > 1 ? `${slug}-${ts}-${i + 1}.${ext}` : `${slug}-${ts}.${ext}`;
+        const full = `${dir.replace(/\/$/, "")}/${base}`;
+        writeFileSync(full, Buffer.from(images[i].data, "base64"));
+        paths.push(full);
+    }
+    return paths;
+}
+
+export default function geminiImageExtension(pi: ExtensionAPI): void {
+    pi.registerTool({
+        name: "gemini_image",
+        label: "Gemini Image",
+        description:
+            "Generate or edit images via Google's Gemini (native) and Imagen models. Supports aspect ratios, resolutions, image editing, negative prompts, and seeds.",
+        promptGuidelines: [
+            "Use gemini-2.5-flash-image (default) for general-purpose generation.",
+            "Use gemini-3-pro-image-preview for studio-quality 4K, complex layouts, or precise text rendering.",
+            "Use imagen-4.0-*-generate-001 models for batch text-to-image (1-4 per call) or when negative_prompt / seed is needed.",
+            "Image editing (input_images) is only supported by Gemini native models.",
+            "4K output is only supported by Gemini native models.",
+        ],
+        parameters: params,
+        async execute(_toolCallId, input, signal, _onUpdate, ctx) {
+            const p = input as Params;
+            const model = (p.model as ImageModel | undefined) ?? DEFAULT_MODEL;
+
+            if (!(ALL_MODELS as readonly string[]).includes(model)) {
+                throw new Error(`Unknown model "${model}". Valid: ${ALL_MODELS.join(", ")}.`);
+            }
+
+            validateForModel(model, p);
+
+            const apiKey = await ensureApiKey(ctx);
+
+            const numImages = isImagen(model) ? p.number_of_images ?? 1 : 1;
+
+            if (!p.skip_confirm && hasPricing(model) && ctx.hasUI) {
+                const est = estimateCost({
+                    model,
+                    prompt: p.prompt,
+                    numberOfImages: numImages,
+                    imageSize: p.image_size,
+                });
+                const proceed = await ctx.ui.confirm(
+                    "Confirm image generation",
+                    `Model: ${model}\nImages: ${numImages}${p.image_size ? `\nSize: ${p.image_size}` : ""}\nEstimated: ~${formatUsd(est.estimatedUsd)} (${est.breakdown})`,
+                );
+                if (!proceed) {
+                    throw new Error("User cancelled image generation.");
+                }
+            }
+
+            const ai = new GoogleGenAI({ apiKey });
+
+            const images = isImagen(model)
+                ? await callImagen(ai, model, p, signal)
+                : await callGeminiNative(ai, model, p, signal);
+
+            if (images.length === 0) {
+                throw new Error("Model returned no images.");
+            }
+
+            const savedPaths = p.save_to ? saveImages(images, p.save_to, p.prompt) : [];
+
+            const summaryLines = [
+                `Generated ${images.length} image${images.length > 1 ? "s" : ""} with ${model}.`,
+                `Prompt: "${p.prompt}"`,
+            ];
+            if (p.aspect_ratio) summaryLines.push(`Aspect ratio: ${p.aspect_ratio}`);
+            if (p.image_size) summaryLines.push(`Size: ${p.image_size}`);
+            if (p.negative_prompt) summaryLines.push(`Negative: "${p.negative_prompt}"`);
+            if (p.person_generation) summaryLines.push(`People: ${p.person_generation}`);
+            if (p.seed !== undefined) summaryLines.push(`Seed: ${p.seed}`);
+            if (savedPaths.length > 0) summaryLines.push(`Saved to:\n  ${savedPaths.join("\n  ")}`);
+
+            const content: AgentToolResult<unknown>["content"] = images.map((img) => ({
+                type: "image",
+                data: img.data,
+                mimeType: img.mimeType,
+            }));
+            content.push({ type: "text", text: summaryLines.join("\n") });
+
+            return {
+                content,
+                details: {
+                    model,
+                    images: images.length,
+                    savedPaths,
+                },
+            };
+        },
+    });
+}