@falldownthesystem/imagen-mcp 0.1.1 → 0.3.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.6 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.6-flare`): fast, good layouts. `sunburst` (`gpt-image-2.6-sunburst`): more detail, more consistent across edits. |
+| 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,29 +59,33 @@ 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`
 
-Text to image. Required: `prompt`.
+Text to image, animated GIF, or SVG. Required: `prompt`.
 
 | Option | Values | Default | Notes |
 |---|---|---|---|
+| `output_format` | `png`, `jpeg`, `webp`, `gif`, `svg` | `png` | Also sets the file extension. `gif` is an animation: describe the subject, the motion, and how it loops, and `size` sets each frame. `svg` is a static vector file (paths, shapes, colors); it needs `n` = 1. `gif` and `svg` reject `output_compression`. |
+| `frame_count` | 2 to 16 | 9 | `gif` only. Frames, frame size, and `n` share one pixel budget, so use a small `size` for many frames. |
+| `frame_duration_ms` | 20 to 2000 | 200 | `gif` only. Delay per frame, rounded to 10 ms. |
 | `moderation` | `auto`, `low` | `low` | OpenAI content filter strictness. `low` refuses fewer borderline prompts; OpenAI usage policies still apply. The API default is `auto`; this tool sends `low` unless set. |
 
 ### `edit_image`
 
-Reference images to image. Required: `prompt`, `images`. The model regenerates the whole picture guided by the references and the prompt. Without a mask, the prompt alone decides what changes.
+Reference images to image. Required: `prompt`, `images`. The model regenerates the whole picture guided by the references and the prompt. Without a mask or markup, the prompt alone decides what changes. Output is `png`, `jpeg`, or `webp`; the edit endpoint does not make GIF or SVG.
 
 | Option | Values | Default | Notes |
 |---|---|---|---|
 | `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. |
+| `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. Cannot be combined with `markup`. |
+| `markup` | file path | none | Transparent PNG annotation layer, same width and height as the first image, at most 50 MB. Draw circles, arrows, or scribbles where the change goes, and say in the prompt what to change and to remove the marks. Applies to the first image; other images stay references. Cannot be combined with `mask`. |
 
-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.
+There is no `input_fidelity` option. The GPT Image 2.6 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
 
@@ -84,17 +94,63 @@ Only the options you set are sent to the API. The default column shows what appl
 | Option | Values | Default | Notes |
 |---|---|---|---|
 | `prompt` | text, up to 32000 chars | required | |
-| `model` | `flare`, `sunburst` | `flare` | `flare` (`gpt-image-2.5-flare`) is fast and general purpose. `sunburst` (`gpt-image-2.5-sunburst`) is slower with higher precision. Same token price. `IMAGEN_DEFAULT_MODEL` env changes the default. |
+| `model` | `flare`, `sunburst` | `flare` | `flare` (`gpt-image-2.6-flare`) is fast and lays out posters and product shots well. `sunburst` (`gpt-image-2.6-sunburst`) gives more detail and keeps characters and products more consistent across edits at `medium` or `high` quality. Same token price. `IMAGEN_DEFAULT_MODEL` env changes the default. |
 | `size` | `auto`, `1024x1024`, `1536x1024`, `1024x1536`, `WIDTHxHEIGHT` | `auto` | Custom sizes: multiples of 16, ratio 1:3 to 3:1, long edge up to 3840. Overrides `aspect_ratio`. |
 | `aspect_ratio` | `1:1`, `3:2`, `2:3`, `4:3`, `3:4`, `16:9`, `9:16`, `21:9`, `9:21` | none | Combined with `long_edge` to compute a size. |
 | `long_edge` | 256 to 3840 | 1536 | Only used with `aspect_ratio`. |
 | `quality` | `low`, `medium`, `high`, `xhigh`, `max`, `auto` | `auto` | Higher tiers add detail and cost more output tokens. `auto` lets the model choose and may pick an expensive tier. Set it explicitly to control cost. |
+| `complexity` | `low`, `medium`, `high` | `high` | How much the model plans the scene before it renders. Separate from `quality`, no extra fee. `low` is faster and suits focused edits such as a new background or sign. `high` helps with dense text, complex layouts, and many objects, but can add latency and unwanted changes. |
 | `background` | `transparent`, `opaque`, `auto` | `auto` | `transparent` gives an alpha background for stickers, logos, and cut-outs. Needs `png` or `webp`. |
-| `output_format` | `png`, `jpeg`, `webp` | `png` | Also sets the file extension. |
+| `output_format` | `png`, `jpeg`, `webp` | `png` | Also sets the file extension. `generate_image` also takes `gif` and `svg`. |
 | `output_compression` | 0 to 100 | 100 | `jpeg` and `webp` only. Works like JPEG quality: lower is smaller with more artifacts. |
 | `n` | 1 to 10 | 1 | Number of separate variations generated from the same prompt in one call. Each costs its own output tokens. |
 | `output_dir` | directory path | `IMAGEN_OUTPUT_DIR` env, else `./output` | Relative to the server working directory. |
 | `file_name` | base name without extension | timestamp plus a slug of the prompt | With `n` greater than 1, a `-1`, `-2` suffix is added. |
-| `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. |
+| `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. SVG files are never returned inline. 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,109 +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.1" });
-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. 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 saveImages(result, input, params.model, params.size);
-});
+const server = new McpServer({ name: "imagen-mcp", version: "0.3.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,133 @@
+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(),
+});
+const generateInput = {
+    ...commonInput,
+    output_format: z
+        .enum(["png", "jpeg", "webp", "gif", "svg"])
+        .optional()
+        .describe("Also the file extension. gif = animation (size is per frame). svg = static vector (n must be 1). gif/svg ignore output_compression. Default png."),
+    frame_count: z.number().int().min(2).max(16).optional().describe("gif only: frames per animation. Keep size small for many frames. Default 9."),
+    frame_duration_ms: z
+        .number()
+        .int()
+        .min(20)
+        .max(2000)
+        .optional()
+        .describe("gif only: delay per frame in ms, rounded to 10. Default 200."),
+    moderation: z
+        .enum(["auto", "low"])
+        .optional()
+        .describe("OpenAI content filter. low refuses fewer borderline prompts. Default low."),
+};
+function apiParams(input) {
+    return {
+        model: resolveModel(input.model),
+        prompt: input.prompt,
+        size: resolveSize(input),
+        quality: input.quality,
+        complexity: input.complexity,
+        background: input.background,
+        output_compression: input.output_compression,
+        n: input.n,
+    };
+}
+// The API rejects these combinations, so fail before spending a request on them.
+function checkGenerateFormat(input) {
+    const format = input.output_format ?? "png";
+    if (format !== "gif" && (input.frame_count !== undefined || input.frame_duration_ms !== undefined)) {
+        throw new Error("frame_count and frame_duration_ms need output_format gif.");
+    }
+    if ((format === "gif" || format === "svg") && input.output_compression !== undefined) {
+        throw new Error(`output_compression is not supported with output_format ${format}.`);
+    }
+    if (format === "svg" && (input.n ?? 1) !== 1) {
+        throw new Error("output_format svg needs n = 1.");
+    }
+}
+function saveResult(result, input, ext, model, size) {
+    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, animated GIFs, or SVG vector graphics from a text prompt with OpenAI GPT Image 2.6. For a GIF, describe the subject, the motion, and how it loops. Saves files to disk and returns paths and token usage.",
+        inputSchema: z.object(generateInput),
+        outputSchema,
+        annotations,
+    }, async (input) => {
+        checkGenerateFormat(input);
+        const params = apiParams(input);
+        const result = await client.images.generate({
+            ...params,
+            output_format: input.output_format,
+            frame_count: input.frame_count,
+            frame_duration_ms: input.frame_duration_ms,
+            moderation: input.moderation ?? "low",
+        });
+        return saveResult(result, input, input.output_format ?? "png", 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.6. The whole picture is regenerated; without a mask or markup the prompt decides what changes. Reference details are always kept at high fidelity (no input_fidelity option). Output is png, jpeg, or webp only. 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). Not with markup. Default none."),
+            markup: z
+                .string()
+                .optional()
+                .describe("Path of a transparent PNG annotation layer, same size as first image, with circles, arrows, or scribbles that mark where to change. The prompt says what to change and to remove the marks. Max 50 MB. Not with mask. Default none."),
+        }),
+        outputSchema,
+        annotations,
+    }, async (input) => {
+        if (input.mask && input.markup)
+            throw new Error("Use mask or markup, not both.");
+        const params = apiParams(input);
+        const result = await client.images.edit({
+            ...params,
+            output_format: input.output_format,
+            image: await Promise.all(input.images.map(loadImage)),
+            mask: input.mask ? await loadImage(input.mask) : undefined,
+            markup: input.markup ? await loadImage(input.markup) : undefined,
+        });
+        return saveResult(result, input, input.output_format ?? "png", params.model, params.size);
+    });
+}

package/dist/output.js

@@ -0,0 +1,37 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import * as z from "zod/v4";
+// svg is left out on purpose: MCP image content is raster, so saved SVGs are returned as file paths only.
+export const MIME = { png: "image/png", jpeg: "image/jpeg", webp: "image/webp", gif: "image/gif" };
+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,7 +1,8 @@
 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",
+    flare: "gpt-image-2.6-flare",
+    sunburst: "gpt-image-2.6-sunburst",
 };
 const ASPECT_RATIOS = {
     "1:1": 1,
@@ -28,7 +29,7 @@ export const commonInput = {
     model: z
         .enum(["flare", "sunburst"])
         .optional()
-        .describe("flare = fast, general purpose. sunburst = slower, higher precision. Same price. Default flare."),
+        .describe("flare = fast, good layouts. sunburst = more detail, more consistent across edits at medium/high quality. Same price. Default flare."),
     size: z
         .string()
         .regex(/^(auto|\d+x\d+)$/)
@@ -49,6 +50,10 @@ export const commonInput = {
         .enum(["low", "medium", "high", "xhigh", "max", "auto"])
         .optional()
         .describe("Higher = more detail, more output tokens. auto lets the model choose (may be costly). Default auto."),
+    complexity: z
+        .enum(["low", "medium", "high"])
+        .optional()
+        .describe("How much the model plans the scene before rendering; separate from quality, no extra fee. low = faster, suits focused edits. high = dense text, complex layouts, many objects. Default high."),
     background: z
         .enum(["transparent", "opaque", "auto"])
         .optional()
@@ -68,12 +73,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.1",
-	"description": "Minimal MCP server for OpenAI GPT Image 2.5 (flare and sunburst): generate and edit images",
+	"version": "0.3.0",
+	"description": "Minimal MCP server for OpenAI GPT Image 2.6 (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.51.0",
+		"zod": "^4.6.7"
 	},
 	"devDependencies": {
-		"@types/node": "^26.5.0",
+		"@types/node": "^26.6.5",
 		"typescript": "^7.0.2"
 	}
 }