@falldownthesystem/imagen-mcp 0.1.0 → 0.2.0

package/README.md

@@ -1,11 +1,13 @@
 # imagen-mcp
 
-Minimal MCP server for OpenAI GPT Image 2.5. Two tools, two models.
+Minimal MCP server for OpenAI GPT Image 2.5 and Krea 3. Generate and edit tools for each provider.
 
-| Alias | API model | Use |
+| Provider | Tools | Models |
 |---|---|---|
-| `flare` (default) | `gpt-image-2.5-flare` | Fast, general purpose |
-| `sunburst` | `gpt-image-2.5-sunburst` | Slower, higher precision |
+| OpenAI | `generate_image`, `edit_image` | `flare` (default, `gpt-image-2.5-flare`): fast, general purpose. `sunburst` (`gpt-image-2.5-sunburst`): slower, higher precision. |
+| Krea | `krea_generate_image`, `krea_edit_image` | Krea 3: fast, instruction-following editor. Early-access beta. |
+
+The server registers a provider's tools only when that provider's API key is set.
 
 ## Setup
 
@@ -22,7 +24,10 @@ npm install
 npm run build
 ```
 
-Set `OPENAI_API_KEY` in the environment, or put it in a `.env` file next to `package.json`.
+Set one or both API keys in the environment, or put them in a `.env` file next to `package.json`:
+
+- `OPENAI_API_KEY`: enables the OpenAI tools.
+- `KREA_API_KEY`: enables the Krea tools. Create a token at [krea.ai/settings/api-tokens](https://www.krea.ai/settings/api-tokens). The Krea 3 API is in early access; only workspaces in the beta can call it. Request access at sales@krea.ai.
 
 Optional environment variables:
 
@@ -41,6 +46,7 @@ Claude Code (`.mcp.json`) or Claude Desktop, using the npm package:
 			"args": ["-y", "@falldownthesystem/imagen-mcp"],
 			"env": {
 				"OPENAI_API_KEY": "sk-...",
+				"KREA_API_KEY": "...",
 				"IMAGEN_OUTPUT_DIR": "C:/Users/me/Pictures/imagen"
 			}
 		}
@@ -53,10 +59,10 @@ Or with a local build, use `"command": "node"` and `"args": ["path/to/imagen-mcp
 Claude Code one-liner:
 
 ```sh
-claude mcp add imagen -e OPENAI_API_KEY=sk-... -- npx -y @falldownthesystem/imagen-mcp
+claude mcp add imagen -e OPENAI_API_KEY=sk-... -e KREA_API_KEY=... -- npx -y @falldownthesystem/imagen-mcp
 ```
 
-## Tools
+## OpenAI tools
 
 ### `generate_image`
 
@@ -74,7 +80,8 @@ Reference images to image. Required: `prompt`, `images`. The model regenerates t
 |---|---|---|---|
 | `images` | 1 to 16 file paths | required | `png`, `jpeg`, or `webp`. The first image is the main subject; extra images supply elements to combine, such as a logo or a style reference. Relative paths resolve against the server working directory. |
 | `mask` | file path | none | PNG with an alpha channel, same width and height as the first image. Fully transparent pixels mark the region the model may repaint; opaque pixels mark what to keep. Use for inpainting one area or filling an extended canvas. It is guidance, not a hard pixel lock. |
-| `input_fidelity` | `high`, `low` | `low` | How closely exact details from the references are preserved. `low` keeps content and layout, but faces, text, logos, and textures may shift. `high` keeps them faithful and steadies the area outside a mask. It costs more input tokens per reference image. Use `high` for real people, brands, product shots, or spot edits. |
+
+There is no `input_fidelity` option. The GPT Image 2.5 models always process reference images at high fidelity, and the API rejects the parameter. Faces, logos, text, and textures from the references are preserved by default.
 
 ### Shared options
 
@@ -97,3 +104,48 @@ Only the options you set are sent to the API. The default column shows what appl
 | `return_image` | boolean | `false` | Also return each image inline as MCP image content, so the client shows it and the model can inspect it. Adds about 1.4 MB of context per 1024x1024 png. The file is saved to disk either way. |
 
 The result lists the saved file paths, the model, the size, and token usage.
+
+## Krea tools
+
+Both tools call `POST /generate/image/krea/krea-3`, poll the job every 2 seconds, and download the result. A job that does not finish in 5 minutes, or a tool call that the client cancels, is cancelled on Krea. Failed and cancelled jobs are not billed.
+
+### `krea_generate_image`
+
+Text to image. Required: `prompt`.
+
+### `krea_edit_image`
+
+Reference images to image. Required: `prompt`, `images`. Write the prompt as an instruction: lead with the change, then add one sentence about what stays the same. With several references, name each one by what it shows, for example "Put the sneaker from the second image on the person in the first image."
+
+| Option | Values | Default | Notes |
+|---|---|---|---|
+| `images` | 1 to 8 local paths or `https` URLs | required | Local files (`png`, `jpeg`, `webp`) are uploaded to Krea assets for the request and deleted after it. URLs are passed through. References over 4 MP are resized to 4 MP. With 5 or more references, each is resized to 1536 px on its long side, so send 4 or fewer for full detail. |
+| `regional_edit` | boolean | `false` | `true` regenerates only the parts that must change and keeps the rest pixel-exact. Use it for local edits (recolor, add or remove an object, change text) and for chained edits on the latest output. Leave it off for global edits (restyle, relight, reframe, combine images into a new scene), which re-render the whole picture. |
+
+There is no mask option. Krea 3 decides the edit region from the prompt.
+
+### Shared Krea options
+
+Only the options you set are sent, except `thinking_mode` and `resolution`, which are always sent with their defaults.
+
+| Option | Values | Default | Notes |
+|---|---|---|---|
+| `prompt` | text | required | |
+| `thinking_mode` | `fast`, `high` | `fast` | How much Krea 3 plans before it generates. `high` uses a stronger reasoning engine for complex or multi-step edits and for combining several references. It is slower and costs $0.02 more. |
+| `resolution` | `1K`, `2K` | `2K` | Output canvas size. 2K is the native resolution. |
+| `aspect_ratio` | `1:1`, `4:5`, `3:4`, `2:3`, `9:16`, `5:4`, `4:3`, `3:2`, `16:9`, `21:9` | none | Omit for automatic framing. |
+| `negative_prompt` | text, up to 1024 chars | none | What to avoid. |
+| `seed` | integer | random | With `n` greater than 1, variation `i` uses `seed + i`. The same seed does not guarantee the same image, because the prompt expansion step varies between runs. |
+| `n` | 1 to 4 | 1 | Each variation is a separate job, billed separately. If some jobs fail, the finished images are still saved and the failures are listed in `errors`. |
+| `output_dir`, `file_name`, `return_image` | | | Same as the OpenAI tools. |
+
+Pricing per image:
+
+| Component | 1K output | 2K output |
+|---|---|---|
+| Base price | $0.03 | $0.06 |
+| Each 1K reference image | +$0.02 | +$0.02 |
+| Each 2K reference image | +$0.07 | +$0.07 |
+| `high` thinking mode | +$0.02 | +$0.02 |
+
+The result lists the saved file paths, the model, the resolution, the aspect ratio, the thinking mode, and the Krea job IDs.

package/dist/index.js

@@ -1,11 +1,9 @@
 #!/usr/bin/env node
-import fs from "node:fs/promises";
 import path from "node:path";
 import { McpServer } from "@modelcontextprotocol/server";
 import { StdioServerTransport } from "@modelcontextprotocol/server/stdio";
-import OpenAI, { toFile } from "openai";
-import * as z from "zod/v4";
-import { commonInput, resolveModel, resolveSize } from "./params.js";
+import { registerKreaTools } from "./krea.js";
+import { registerOpenAITools } from "./openai.js";
 // A .env next to the project is a convenience for local runs; MCP client configs normally pass env directly.
 try {
     process.loadEnvFile(path.join(import.meta.dirname, "..", ".env"));
@@ -13,114 +11,16 @@ try {
 catch {
     // No .env file present; rely on the process environment.
 }
-const client = new OpenAI();
-const server = new McpServer({ name: "imagen-mcp", version: "0.1.0" });
-const MIME = { png: "image/png", jpeg: "image/jpeg", webp: "image/webp" };
-const outputSchema = z.object({
-    files: z.array(z.string()),
-    model: z.string(),
-    size: z.string(),
-    usage: z
-        .object({
-        input_tokens: z.number(),
-        output_tokens: z.number(),
-        total_tokens: z.number(),
-        input_tokens_details: z.object({ image_tokens: z.number(), text_tokens: z.number() }).optional(),
-        output_tokens_details: z.object({ image_tokens: z.number(), text_tokens: z.number() }).optional(),
-    })
-        .optional(),
-});
-const annotations = { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true };
-function slug(text) {
-    return text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 40) || "image";
+const openaiKey = process.env.OPENAI_API_KEY;
+const kreaKey = process.env.KREA_API_KEY;
+if (!openaiKey && !kreaKey) {
+    console.error("imagen-mcp: set OPENAI_API_KEY, KREA_API_KEY, or both.");
+    process.exit(1);
 }
-function apiParams(input) {
-    return {
-        model: resolveModel(input.model),
-        prompt: input.prompt,
-        size: resolveSize(input),
-        quality: input.quality,
-        background: input.background,
-        output_format: input.output_format,
-        output_compression: input.output_compression,
-        n: input.n,
-    };
-}
-async function saveImages(result, input, model, size) {
-    const images = result.data ?? [];
-    if (images.length === 0)
-        throw new Error("The API returned no images.");
-    const ext = input.output_format ?? "png";
-    const dir = path.resolve(input.output_dir ?? process.env.IMAGEN_OUTPUT_DIR ?? "output");
-    await fs.mkdir(dir, { recursive: true });
-    const base = input.file_name ?? `${new Date().toISOString().replace(/[:.]/g, "-")}-${slug(input.prompt)}`;
-    const files = [];
-    const content = [];
-    for (const [i, image] of images.entries()) {
-        if (!image.b64_json)
-            throw new Error(`Image ${i + 1} has no b64_json payload.`);
-        const file = path.join(dir, images.length > 1 ? `${base}-${i + 1}.${ext}` : `${base}.${ext}`);
-        await fs.writeFile(file, Buffer.from(image.b64_json, "base64"));
-        files.push(file);
-        if (input.return_image)
-            content.push({ type: "image", data: image.b64_json, mimeType: MIME[ext] });
-    }
-    const output = { files, model, size: size ?? "auto", usage: result.usage };
-    content.unshift({ type: "text", text: JSON.stringify(output, null, 2) });
-    return { content, structuredContent: output };
-}
-async function loadImage(file) {
-    const abs = path.resolve(file);
-    const ext = path.extname(abs).slice(1).toLowerCase();
-    const type = MIME[ext === "jpg" ? "jpeg" : ext] ?? "application/octet-stream";
-    return toFile(await fs.readFile(abs), path.basename(abs), { type });
-}
-server.registerTool("generate_image", {
-    title: "Generate image",
-    description: "Generate images from a text prompt with OpenAI GPT Image 2.5. Saves files to disk and returns paths and token usage.",
-    inputSchema: z.object({
-        ...commonInput,
-        moderation: z
-            .enum(["auto", "low"])
-            .optional()
-            .describe("OpenAI content filter. low refuses fewer borderline prompts. Default low."),
-    }),
-    outputSchema,
-    annotations,
-}, async (input) => {
-    const params = apiParams(input);
-    const result = await client.images.generate({ ...params, moderation: input.moderation ?? "low" });
-    return saveImages(result, input, params.model, params.size);
-});
-server.registerTool("edit_image", {
-    title: "Edit image",
-    description: "Edit, restyle, or combine 1-16 reference images with a text prompt using OpenAI GPT Image 2.5. The whole picture is regenerated; without a mask the prompt decides what changes. Saves files to disk and returns paths and token usage.",
-    inputSchema: z.object({
-        ...commonInput,
-        images: z
-            .array(z.string())
-            .min(1)
-            .max(16)
-            .describe("Paths of 1-16 reference images (png/jpeg/webp). First = main subject; others = elements to combine. Relative to server cwd."),
-        mask: z
-            .string()
-            .optional()
-            .describe("Path of a PNG with alpha, same size as first image. Transparent pixels = region to repaint (guidance, not a hard lock). Default none."),
-        input_fidelity: z
-            .enum(["high", "low"])
-            .optional()
-            .describe("high keeps faces, text, logos and unmasked areas faithful; costs more input tokens. Default low."),
-    }),
-    outputSchema,
-    annotations,
-}, async (input) => {
-    const params = apiParams(input);
-    const result = await client.images.edit({
-        ...params,
-        image: await Promise.all(input.images.map(loadImage)),
-        mask: input.mask ? await loadImage(input.mask) : undefined,
-        input_fidelity: input.input_fidelity,
-    });
-    return saveImages(result, input, params.model, params.size);
-});
+const server = new McpServer({ name: "imagen-mcp", version: "0.2.0" });
+// Tools are registered per configured provider so clients never see a tool that can only fail.
+if (openaiKey)
+    registerOpenAITools(server);
+if (kreaKey)
+    registerKreaTools(server, kreaKey);
 await server.connect(new StdioServerTransport());

package/dist/krea.js

@@ -0,0 +1,200 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { setTimeout as sleep } from "node:timers/promises";
+import * as z from "zod/v4";
+import { annotations, MIME, saveImages, outputInput } from "./output.js";
+const API = "https://api.krea.ai";
+const ENDPOINT = "/generate/image/krea/krea-3";
+const POLL_INTERVAL_MS = 2000;
+// Krea times out hosted jobs after 3 minutes; the extra margin covers queueing behind the concurrency limit.
+const JOB_TIMEOUT_MS = 5 * 60_000;
+const PENDING = new Set(["backlogged", "queued", "scheduled", "processing", "sampling", "intermediate-complete"]);
+const ASPECT_RATIOS = ["1:1", "4:5", "3:4", "2:3", "9:16", "5:4", "4:3", "3:2", "16:9", "21:9"];
+const kreaInput = {
+    prompt: z
+        .string()
+        .min(1)
+        .describe("Plain-language instruction. Lead with the change; end with one sentence on what to keep. Name multiple references by what they show."),
+    thinking_mode: z
+        .enum(["fast", "high"])
+        .optional()
+        .describe("Prompt planning before generation. high = stronger reasoning for complex or multi-reference edits, slower, +$0.02. Default fast."),
+    resolution: z.enum(["1K", "2K"]).optional().describe("Output canvas. 1K = $0.03, 2K = $0.06 base price. Default 2K."),
+    aspect_ratio: z.enum(ASPECT_RATIOS).optional().describe("Default none (automatic framing)."),
+    negative_prompt: z.string().max(1024).optional().describe("What to avoid. Default none."),
+    seed: z
+        .number()
+        .int()
+        .optional()
+        .describe("Fixed seed; with n > 1 each variation uses seed + index. Prompt expansion still varies between runs. Default random."),
+    n: z
+        .number()
+        .int()
+        .min(1)
+        .max(4)
+        .optional()
+        .describe("Number of variations; each is a separate paid job. Files get -1, -2 suffixes. Default 1."),
+    ...outputInput,
+};
+const outputSchema = z.object({
+    files: z.array(z.string()),
+    model: z.string(),
+    resolution: z.string(),
+    aspect_ratio: z.string(),
+    thinking_mode: z.string(),
+    job_ids: z.array(z.string()),
+    errors: z.array(z.string()).optional(),
+});
+function sniffExt(data, url) {
+    if (data.subarray(0, 8).equals(Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a])))
+        return "png";
+    if (data[0] === 0xff && data[1] === 0xd8 && data[2] === 0xff)
+        return "jpeg";
+    if (data.toString("ascii", 0, 4) === "RIFF" && data.toString("ascii", 8, 12) === "WEBP")
+        return "webp";
+    // An unknown format is still a paid result, so keep it under whatever extension the URL carries.
+    return path.extname(new URL(url).pathname).slice(1).toLowerCase() || "img";
+}
+function jobError(job) {
+    const detail = job.error?.message ?? job.error?.code ?? job.result?.error;
+    return `Krea job ${job.job_id} ${job.status}${detail ? `: ${typeof detail === "string" ? detail : JSON.stringify(detail)}` : ""}`;
+}
+function createClient(apiKey) {
+    async function request(pathname, init = {}) {
+        const res = await fetch(`${API}${pathname}`, {
+            ...init,
+            headers: { Authorization: `Bearer ${apiKey}`, ...init.headers },
+        });
+        const text = await res.text();
+        if (!res.ok) {
+            let message = text;
+            try {
+                message = JSON.parse(text).error ?? text;
+            }
+            catch {
+                // Non-JSON error body; report it verbatim.
+            }
+            throw new Error(`Krea ${init.method ?? "GET"} ${pathname} failed (${res.status}): ${message}`);
+        }
+        return (text ? JSON.parse(text) : undefined);
+    }
+    async function upload(file, signal) {
+        const abs = path.resolve(file);
+        const ext = path.extname(abs).slice(1).toLowerCase();
+        const type = MIME[ext === "jpg" ? "jpeg" : ext] ?? "application/octet-stream";
+        const form = new FormData();
+        form.append("file", new Blob([await fs.readFile(abs)], { type }), path.basename(abs));
+        return request("/assets", { method: "POST", body: form, signal });
+    }
+    async function cancel(jobId) {
+        await request(`/jobs/${jobId}`, { method: "DELETE" }).catch(() => { });
+    }
+    async function run(body, signal) {
+        const created = await request(ENDPOINT, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(body),
+            signal,
+        });
+        const deadline = Date.now() + JOB_TIMEOUT_MS;
+        let job = created;
+        try {
+            while (PENDING.has(job.status)) {
+                if (Date.now() > deadline)
+                    throw new Error(`Krea job ${job.job_id} still ${job.status} after ${JOB_TIMEOUT_MS / 1000}s.`);
+                await sleep(POLL_INTERVAL_MS, undefined, { signal });
+                job = await request(`/jobs/${job.job_id}`, { signal });
+            }
+        }
+        catch (error) {
+            // Failed and cancelled jobs are not billed, so stop work the caller will never receive.
+            await cancel(created.job_id);
+            throw error;
+        }
+        if (job.status !== "completed")
+            throw new Error(jobError(job));
+        const urls = job.result?.urls ?? [];
+        if (urls.length === 0)
+            throw new Error(`Krea job ${job.job_id} completed without output URLs.`);
+        const images = await Promise.all(urls.map(async (url) => {
+            const res = await fetch(url, { signal });
+            if (!res.ok)
+                throw new Error(`Download of ${url} failed (${res.status}).`);
+            const data = Buffer.from(await res.arrayBuffer());
+            return { data, ext: sniffExt(data, url) };
+        }));
+        return { jobId: job.job_id, images };
+    }
+    async function generate(input, signal) {
+        const uploaded = [];
+        try {
+            const imageUrls = input.images
+                ? await Promise.all(input.images.map(async (ref) => {
+                    if (/^https?:\/\//i.test(ref))
+                        return ref;
+                    const asset = await upload(ref, signal);
+                    uploaded.push(asset.id);
+                    return asset.image_url;
+                }))
+                : undefined;
+            const resolution = input.resolution ?? "2K";
+            const thinkingMode = input.thinking_mode ?? "fast";
+            const runs = await Promise.allSettled(Array.from({ length: input.n ?? 1 }, (_, i) => run({
+                prompt: input.prompt,
+                thinking_mode: thinkingMode,
+                resolution,
+                aspect_ratio: input.aspect_ratio,
+                negative_prompt: input.negative_prompt,
+                seed: input.seed === undefined ? undefined : input.seed + i,
+                image_urls: imageUrls,
+                regional_edit: input.regional_edit,
+            }, signal)));
+            const done = runs.flatMap((r) => (r.status === "fulfilled" ? [r.value] : []));
+            const errors = runs.flatMap((r) => (r.status === "rejected" ? [String(r.reason instanceof Error ? r.reason.message : r.reason)] : []));
+            // Completed variations are already billed, so save them even when siblings fail.
+            if (done.length === 0)
+                throw new Error(errors.join("\n"));
+            return saveImages(done.flatMap((d) => d.images), input, {
+                model: "krea-3",
+                resolution,
+                aspect_ratio: input.aspect_ratio ?? "auto",
+                thinking_mode: thinkingMode,
+                job_ids: done.map((d) => d.jobId),
+                ...(errors.length > 0 && { errors }),
+            });
+        }
+        finally {
+            // Reference uploads exist only for this request; keep them out of the user's Krea asset library.
+            await Promise.allSettled(uploaded.map((id) => request(`/assets/${id}`, { method: "DELETE" })));
+        }
+    }
+    return { generate };
+}
+export function registerKreaTools(server, apiKey) {
+    const krea = createClient(apiKey);
+    server.registerTool("krea_generate_image", {
+        title: "Generate image (Krea 3)",
+        description: "Generate images from a text prompt with Krea 3 (early-access beta). Saves files to disk and returns paths and Krea job IDs.",
+        inputSchema: z.object(kreaInput),
+        outputSchema,
+        annotations,
+    }, (input, ctx) => krea.generate(input, ctx.mcpReq.signal));
+    server.registerTool("krea_edit_image", {
+        title: "Edit image (Krea 3)",
+        description: "Edit or combine 1-8 reference images with a plain-language instruction using Krea 3 (early-access beta). Without regional_edit the whole picture is re-rendered. Saves files to disk and returns paths and Krea job IDs.",
+        inputSchema: z.object({
+            ...kreaInput,
+            images: z
+                .array(z.string())
+                .min(1)
+                .max(8)
+                .describe("1-8 reference images: local paths (png/jpeg/webp, relative to server cwd) or https URLs. Each costs +$0.02 (1K) or +$0.07 (2K). Over 4 refs are downscaled to 1536 px."),
+            regional_edit: z
+                .boolean()
+                .optional()
+                .describe("true = regenerate only what must change and keep the rest pixel-exact; use for local edits and chained edits. Omit for restyle, relight, reframe, or compositing. Default false."),
+        }),
+        outputSchema,
+        annotations,
+    }, (input, ctx) => krea.generate(input, ctx.mcpReq.signal));
+}

package/dist/openai.js

@@ -0,0 +1,93 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import OpenAI, { toFile } from "openai";
+import * as z from "zod/v4";
+import { annotations, MIME, saveImages } from "./output.js";
+import { commonInput, resolveModel, resolveSize } from "./params.js";
+const outputSchema = z.object({
+    files: z.array(z.string()),
+    model: z.string(),
+    size: z.string(),
+    usage: z
+        .object({
+        input_tokens: z.number(),
+        output_tokens: z.number(),
+        total_tokens: z.number(),
+        input_tokens_details: z.object({ image_tokens: z.number(), text_tokens: z.number() }).optional(),
+        output_tokens_details: z.object({ image_tokens: z.number(), text_tokens: z.number() }).optional(),
+    })
+        .optional(),
+});
+function apiParams(input) {
+    return {
+        model: resolveModel(input.model),
+        prompt: input.prompt,
+        size: resolveSize(input),
+        quality: input.quality,
+        background: input.background,
+        output_format: input.output_format,
+        output_compression: input.output_compression,
+        n: input.n,
+    };
+}
+function saveResult(result, input, model, size) {
+    const ext = input.output_format ?? "png";
+    const images = (result.data ?? []).map((image, i) => {
+        if (!image.b64_json)
+            throw new Error(`Image ${i + 1} has no b64_json payload.`);
+        return { data: Buffer.from(image.b64_json, "base64"), ext };
+    });
+    return saveImages(images, input, { model, size: size ?? "auto", usage: result.usage });
+}
+async function loadImage(file) {
+    const abs = path.resolve(file);
+    const ext = path.extname(abs).slice(1).toLowerCase();
+    const type = MIME[ext === "jpg" ? "jpeg" : ext] ?? "application/octet-stream";
+    return toFile(await fs.readFile(abs), path.basename(abs), { type });
+}
+export function registerOpenAITools(server) {
+    const client = new OpenAI();
+    server.registerTool("generate_image", {
+        title: "Generate image",
+        description: "Generate images from a text prompt with OpenAI GPT Image 2.5. Saves files to disk and returns paths and token usage.",
+        inputSchema: z.object({
+            ...commonInput,
+            moderation: z
+                .enum(["auto", "low"])
+                .optional()
+                .describe("OpenAI content filter. low refuses fewer borderline prompts. Default low."),
+        }),
+        outputSchema,
+        annotations,
+    }, async (input) => {
+        const params = apiParams(input);
+        const result = await client.images.generate({ ...params, moderation: input.moderation ?? "low" });
+        return saveResult(result, input, params.model, params.size);
+    });
+    server.registerTool("edit_image", {
+        title: "Edit image",
+        description: "Edit, restyle, or combine 1-16 reference images with a text prompt using OpenAI GPT Image 2.5. The whole picture is regenerated; without a mask the prompt decides what changes. Reference details are always kept at high fidelity (no input_fidelity option). Saves files to disk and returns paths and token usage.",
+        inputSchema: z.object({
+            ...commonInput,
+            images: z
+                .array(z.string())
+                .min(1)
+                .max(16)
+                .describe("Paths of 1-16 reference images (png/jpeg/webp). First = main subject; others = elements to combine. Relative to server cwd."),
+            mask: z
+                .string()
+                .optional()
+                .describe("Path of a PNG with alpha, same size as first image. Transparent pixels = region to repaint (guidance, not a hard lock). Default none."),
+        }),
+        outputSchema,
+        annotations,
+    }, async (input) => {
+        const params = apiParams(input);
+        const result = await client.images.edit({
+            ...params,
+            image: await Promise.all(input.images.map(loadImage)),
+            mask: input.mask ? await loadImage(input.mask) : undefined,
+        });
+        return saveResult(result, input, params.model, params.size);
+    });
+}

package/dist/output.js

@@ -0,0 +1,36 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import * as z from "zod/v4";
+export const MIME = { png: "image/png", jpeg: "image/jpeg", webp: "image/webp" };
+export const outputInput = {
+    output_dir: z.string().optional().describe("Save directory. Default IMAGEN_OUTPUT_DIR env or ./output (relative to server cwd)."),
+    file_name: z.string().optional().describe("Base name without extension. Default timestamp + prompt slug."),
+    return_image: z
+        .boolean()
+        .optional()
+        .describe("Also return the image inline (base64, ~1.4 MB per 1024x1024 png) so it can be viewed. File is saved either way. Default false."),
+};
+export const annotations = { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true };
+function slug(text) {
+    return text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 40) || "image";
+}
+export async function saveImages(images, options, meta) {
+    if (images.length === 0)
+        throw new Error("The API returned no images.");
+    const dir = path.resolve(options.output_dir ?? process.env.IMAGEN_OUTPUT_DIR ?? "output");
+    await fs.mkdir(dir, { recursive: true });
+    const base = options.file_name ?? `${new Date().toISOString().replace(/[:.]/g, "-")}-${slug(options.prompt)}`;
+    const files = [];
+    const content = [];
+    for (const [i, image] of images.entries()) {
+        const file = path.join(dir, images.length > 1 ? `${base}-${i + 1}.${image.ext}` : `${base}.${image.ext}`);
+        await fs.writeFile(file, image.data);
+        files.push(file);
+        const mimeType = MIME[image.ext];
+        if (options.return_image && mimeType)
+            content.push({ type: "image", data: image.data.toString("base64"), mimeType });
+    }
+    const output = { files, ...meta };
+    content.unshift({ type: "text", text: JSON.stringify(output, null, 2) });
+    return { content, structuredContent: output };
+}

package/dist/params.js

@@ -1,4 +1,5 @@
 import * as z from "zod/v4";
+import { outputInput } from "./output.js";
 export const MODELS = {
     flare: "gpt-image-2.5-flare",
     sunburst: "gpt-image-2.5-sunburst",
@@ -68,12 +69,7 @@ export const commonInput = {
         .max(10)
         .optional()
         .describe("Number of variations to generate; each costs output tokens. Files get -1, -2 suffixes. Default 1."),
-    output_dir: z.string().optional().describe("Save directory. Default IMAGEN_OUTPUT_DIR env or ./output (relative to server cwd)."),
-    file_name: z.string().optional().describe("Base name without extension. Default timestamp + prompt slug."),
-    return_image: z
-        .boolean()
-        .optional()
-        .describe("Also return the image inline (base64, ~1.4 MB per 1024x1024 png) so it can be viewed. File is saved either way. Default false."),
+    ...outputInput,
 };
 export function resolveModel(alias) {
     const fallback = process.env.IMAGEN_DEFAULT_MODEL;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@falldownthesystem/imagen-mcp",
-	"version": "0.1.0",
-	"description": "Minimal MCP server for OpenAI GPT Image 2.5 (flare and sunburst): generate and edit images",
+	"version": "0.2.0",
+	"description": "Minimal MCP server for OpenAI GPT Image 2.5 (flare and sunburst) and Krea 3: generate and edit images",
 	"type": "module",
 	"bin": {
 		"imagen-mcp": "dist/index.js"
@@ -23,6 +23,7 @@
 		"model-context-protocol",
 		"openai",
 		"gpt-image",
+		"krea",
 		"image-generation"
 	],
 	"author": "FallDownTheSystem",
@@ -36,12 +37,12 @@
 		"access": "public"
 	},
 	"dependencies": {
-		"@modelcontextprotocol/server": "^2.0.0",
-		"openai": "^7.13.0",
-		"zod": "^4.5.4"
+		"@modelcontextprotocol/server": "^2.3.1",
+		"openai": "^7.34.0",
+		"zod": "^4.6.7"
 	},
 	"devDependencies": {
-		"@types/node": "^26.5.0",
+		"@types/node": "^26.6.5",
 		"typescript": "^7.0.2"
 	}
 }