mcp-duojie-image 0.5.7 → 0.6.0

package/README.md

@@ -5,7 +5,9 @@ MCP server for image generation via duojie.games GPT image API.
 ## Features
 
 - Text-to-image generation with `gpt-image-2`
-- Reference image editing via local image paths
+- Reference image editing via local image paths, with optional image roles
+- Prompt structuring helpers for use case, asset type, constraints, and effective prompt echo
+- Optional chroma-key transparent background post-processing
 - Async submission with task status lookup
 - File saving with overwrite/conflict handling
 - Verified size templates for `1K`, `2K`, and `4K`
@@ -18,7 +20,6 @@ Required:
 |---|---|---|
 | `DUOJIE_API_KEY` | required | duojie.games API key |
 | `DUOJIE_BASE_URL` | `https://api.duojie.games` | API base URL |
-| `DUOJIE_IMAGE_MODEL` | `gpt-image-2` | Optional; only `gpt-image-2` is supported |
 
 ## Tool: `generate_image`
 
@@ -31,7 +32,6 @@ Required parameters:
 | `prompt` | string | Image prompt |
 | `output_dir` | string | Absolute output directory |
 | `output_filename` | string | Filename without extension |
-| `model` | `gpt-image-2` | Only supported model |
 
 Optional parameters:
 
@@ -39,12 +39,30 @@ Optional parameters:
 |---|---|---:|---|
 | `size` | `1K` \| `2K` \| `4K` | `1K` | Output size tier |
 | `aspect_ratio` | `1:1` \| `3:2` \| `2:3` \| `16:9` \| `9:16` | `1:1` | Verified ratio template |
-| `reference_images` | string[] | - | Local reference image paths |
-| `format` | string | `png` | Output format |
+| `reference_images` | string[] | - | Legacy local reference image paths |
+| `input_images` | object[] | - | Structured local image inputs with `path`, optional `role`, and optional `note` |
+| `use_case` | string | - | Prompt taxonomy slug, for example `product-mockup` or `background-extraction` |
+| `asset_type` | string | - | Where the asset will be used |
+| `constraints` | string | - | Must-keep or must-avoid constraints |
+| `transparent_background` | boolean | `false` | Add chroma-key prompt instructions and remove the flat key color locally; PNG only |
+| `transparent_key_color` | string | `#00ff00` | Chroma-key color for transparent background requests |
+| `format` | `png` \| `jpg` \| `jpeg` | `png` | Output format; content is encoded to match the extension |
 | `overwrite` | boolean | `false` | Overwrite existing file |
 | `negative_prompt` | string | - | Content to avoid |
+| `reference_max_side` | number | `1024` | Resize reference inputs to this max side before upload |
+| `preserve_reference_detail` | boolean | `false` | Upload reference inputs without resizing |
 | `silent` | boolean | `false` | Disable desktop notification |
 
+Supported `input_images.role` values:
+
+- `reference`
+- `edit_target`
+- `style_reference`
+- `composition_reference`
+- `insert_source`
+
+When both `input_images` and `reference_images` are provided, `input_images` takes precedence. `generate_image` returns `effective_prompt` so callers can diagnose the exact prompt sent upstream.
+
 Response:
 
 ```json
@@ -52,6 +70,7 @@ Response:
   "success": true,
   "status": "submitted",
   "task_id": "uuid",
+  "effective_prompt": "Primary request: ...",
   "message": "已提交异步生成；如需诊断失败原因，可调用 check_image_task"
 }
 ```
@@ -72,7 +91,7 @@ Done response:
   "task_id": "uuid",
   "status": "done",
   "saved_path": "D:/images/output.png",
-  "model": "gpt-image-2"
+  "effective_prompt": "Primary request: ..."
 }
 ```
 
@@ -105,7 +124,9 @@ These templates were tested directly against `/v1/images/generations`; all retur
 ```text
 generate_image(
   prompt="A futuristic city at sunset",
-  model="gpt-image-2",
+  use_case="stylized-concept",
+  asset_type="website hero",
+  constraints="no text, no watermark",
   size="2K",
   aspect_ratio="16:9",
   output_dir="D:/ai-images",

package/dist/config.js

@@ -9,14 +9,9 @@ export function loadConfig(overrides) {
     if (!apiKey) {
         throw new AppError("E_CONFIG_MISSING_KEY", "DUOJIE_API_KEY is not set");
     }
-    const model = overrides?.model ?? process.env.DUOJIE_IMAGE_MODEL ?? "gpt-image-2";
-    if (model !== "gpt-image-2") {
-        throw new AppError("E_INPUT_INVALID", "Only gpt-image-2 is supported");
-    }
     return {
         apiKey,
         baseUrl: overrides?.baseUrl ?? process.env.DUOJIE_BASE_URL ?? "https://api.duojie.games",
-        model,
         timeoutMs: 300_000,
     };
 }

package/dist/image-processing.js

@@ -0,0 +1,84 @@
+import sharp from "sharp";
+import { AppError } from "./errors.js";
+export const OUTPUT_FORMATS = ["png", "jpg", "jpeg", "webp"];
+export function normalizeOutputFormat(format) {
+    const normalized = format.toLowerCase().replace(/^\./, "");
+    if (!OUTPUT_FORMATS.includes(normalized)) {
+        throw new AppError("E_INPUT_INVALID", `Unsupported output format: ${format}. Supported formats: ${OUTPUT_FORMATS.join(", ")}`);
+    }
+    return normalized;
+}
+function parseHexColor(color) {
+    const hex = color.trim().replace(/^#/, "");
+    if (!/^[0-9a-fA-F]{6}$/.test(hex)) {
+        throw new AppError("E_INPUT_INVALID", `Invalid transparent_key_color: ${color}`);
+    }
+    return {
+        r: Number.parseInt(hex.slice(0, 2), 16),
+        g: Number.parseInt(hex.slice(2, 4), 16),
+        b: Number.parseInt(hex.slice(4, 6), 16),
+    };
+}
+function distance(a, b) {
+    return Math.sqrt(Math.pow(a.r - b.r, 2) +
+        Math.pow(a.g - b.g, 2) +
+        Math.pow(a.b - b.b, 2));
+}
+export async function encodeImage(imageBuffer, format) {
+    if (format === "png") {
+        return imageBuffer;
+    }
+    try {
+        const image = sharp(imageBuffer);
+        if (format === "webp") {
+            return await image.webp({ quality: 90 }).toBuffer();
+        }
+        // jpg / jpeg
+        return await image.jpeg({ quality: 90 }).toBuffer();
+    }
+    catch (err) {
+        throw new AppError("E_SAVE_FAILED", `Cannot encode image as ${format}: ${err}`);
+    }
+}
+export async function removeChromaKey(imageBuffer, keyColor = "#00ff00") {
+    const key = parseHexColor(keyColor);
+    const image = sharp(imageBuffer, { failOn: "none" }).ensureAlpha();
+    let metadata;
+    try {
+        metadata = await image.metadata();
+    }
+    catch (err) {
+        throw new AppError("E_SAVE_FAILED", `Cannot read image for chroma-key removal: ${err}`);
+    }
+    const width = metadata.width;
+    const height = metadata.height;
+    if (!width || !height) {
+        throw new AppError("E_SAVE_FAILED", "Cannot read image dimensions for chroma-key removal");
+    }
+    const data = await image.raw().toBuffer();
+    let transparentPixels = 0;
+    const hardThreshold = 34;
+    const softThreshold = 96;
+    for (let offset = 0; offset < data.length; offset += 4) {
+        const pixel = {
+            r: data[offset],
+            g: data[offset + 1],
+            b: data[offset + 2],
+        };
+        const dist = distance(pixel, key);
+        if (dist <= hardThreshold) {
+            data[offset + 3] = 0;
+            transparentPixels++;
+        }
+        else if (dist <= softThreshold) {
+            const alpha = Math.round(((dist - hardThreshold) / (softThreshold - hardThreshold)) * 255);
+            data[offset + 3] = Math.min(data[offset + 3], alpha);
+            transparentPixels++;
+        }
+    }
+    const totalPixels = width * height;
+    if (transparentPixels < totalPixels * 0.01) {
+        throw new AppError("E_SAVE_FAILED", "Chroma-key removal did not find enough background pixels; try a simpler subject or a different transparent_key_color");
+    }
+    return sharp(data, { raw: { width, height, channels: 4 } }).png().toBuffer();
+}

package/dist/index.js

@@ -8,6 +8,8 @@ import { ASPECT_RATIOS, IMAGE_SIZES, generateImage } from "./provider.js";
 import { saveImage } from "./saver.js";
 import { AppError } from "./errors.js";
 import { createTask, getTask, updateTask } from "./task-queue.js";
+import { IMAGE_INPUT_ROLES, PROMPT_USE_CASES, preparePrompt } from "./prompt.js";
+import { OUTPUT_FORMATS, removeChromaKey } from "./image-processing.js";
 const require = createRequire(import.meta.url);
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 const notifier = require("node-notifier");
@@ -32,18 +34,29 @@ const server = new McpServer({
     version: "0.1.0",
 });
 server.registerTool("generate_image", {
-    description: "Generate image async. If user didn't specify model and no model was chosen in this conversation, ask once. Reuse that model later unless user changes it. Return after tool call; don't wait/check.",
+    description: "Generate image async with gpt-image-2. Return after tool call; don't wait/check.",
     inputSchema: z.object({
         prompt: z.string().min(1).describe("Prompt"),
         output_dir: z.string().describe("Absolute output dir"),
         output_filename: z.string().describe("Filename without ext"),
         reference_images: z.array(z.string()).optional().describe("Reference image paths"),
+        input_images: z.array(z.object({
+            path: z.string().min(1).describe("Local image path"),
+            role: z.enum(IMAGE_INPUT_ROLES).optional().describe("How this image should guide generation/editing"),
+            note: z.string().optional().describe("Short role-specific instruction"),
+        })).optional().describe("Structured image inputs with roles; supersedes reference_images when provided"),
+        use_case: z.enum(PROMPT_USE_CASES).optional().describe("Prompt taxonomy slug"),
+        asset_type: z.string().optional().describe("Where the image will be used"),
+        constraints: z.string().optional().describe("Must-keep or must-avoid constraints"),
+        transparent_background: z.boolean().optional().describe("Generate on a chroma-key background and remove it locally; PNG only"),
+        transparent_key_color: z.string().regex(/^#[0-9a-fA-F]{6}$/).optional().describe("Chroma-key color, default #00ff00"),
         size: z.enum(IMAGE_SIZES).optional().describe("Default 1K. Supported: 1K, 2K, 4K"),
         aspect_ratio: z.enum(ASPECT_RATIOS).optional().describe("Supported: 1:1, 3:2, 2:3, 16:9, 9:16"),
-        format: z.string().optional().describe("Default png"),
-        model: z.enum(["gpt-image-2"]).describe("Required; only gpt-image-2 is supported"),
+        format: z.enum(OUTPUT_FORMATS).optional().describe("Default png. Supported: png, jpg, jpeg"),
         overwrite: z.boolean().optional().describe("Default false"),
         negative_prompt: z.string().optional().describe("Avoid"),
+        reference_max_side: z.number().int().min(256).max(3840).optional().describe("Resize reference inputs to this max side; default 1024"),
+        preserve_reference_detail: z.boolean().optional().describe("Do not resize reference inputs before upload"),
         silent: z.boolean().optional().describe("No notification"),
     }),
 }, async (args) => {
@@ -56,30 +69,67 @@ server.registerTool("generate_image", {
         return { content: [{ type: "text", text: JSON.stringify({ success: false, error: code, message: String(err instanceof Error ? err.message : err) }) }], isError: true };
     }
     const silent = args.silent ?? false;
+    if (args.transparent_background) {
+        const filenameExt = args.output_filename.match(/\.([^.]+)$/)?.[1]?.toLowerCase();
+        if ((args.format && args.format !== "png") || (filenameExt && filenameExt !== "png")) {
+            return {
+                content: [{
+                        type: "text",
+                        text: JSON.stringify({
+                            success: false,
+                            error: "E_INPUT_INVALID",
+                            message: "transparent_background requires PNG output",
+                        }),
+                    }],
+                isError: true,
+            };
+        }
+    }
+    let preparedPrompt;
+    try {
+        preparedPrompt = preparePrompt({
+            prompt: args.prompt,
+            negativePrompt: args.negative_prompt,
+            useCase: args.use_case,
+            assetType: args.asset_type,
+            constraints: args.constraints,
+            inputImages: args.input_images,
+            referenceImages: args.reference_images,
+            transparentBackground: args.transparent_background,
+            transparentKeyColor: args.transparent_key_color,
+        });
+    }
+    catch (err) {
+        const code = err instanceof AppError ? err.code : "E_INPUT_INVALID";
+        return { content: [{ type: "text", text: JSON.stringify({ success: false, error: code, message: String(err instanceof Error ? err.message : err) }) }], isError: true };
+    }
     const task = createTask();
+    updateTask(task.id, { effectivePrompt: preparedPrompt.prompt });
     // Start background generation (don't await)
     (async () => {
         try {
             updateTask(task.id, { status: "running", startedAt: Date.now() });
-            const imageBuffer = await generateImage(config, {
-                prompt: args.prompt,
-                referenceImages: args.reference_images,
-                model: args.model,
-                negativePrompt: args.negative_prompt,
+            let imageBuffer = await generateImage(config, {
+                prompt: preparedPrompt.prompt,
+                referenceImages: preparedPrompt.imagePaths,
                 size: args.size ?? "1K",
                 aspectRatio: args.aspect_ratio,
+                referenceMaxSide: args.preserve_reference_detail ? false : args.reference_max_side,
             });
-            const savedPath = saveImage(imageBuffer, {
+            const outputFormat = args.transparent_background ? "png" : args.format;
+            if (args.transparent_background) {
+                imageBuffer = await removeChromaKey(imageBuffer, args.transparent_key_color);
+            }
+            const savedPath = await saveImage(imageBuffer, {
                 outputDir: args.output_dir,
                 outputFilename: args.output_filename,
-                format: args.format ?? "png",
+                format: outputFormat,
                 overwrite: args.overwrite ?? false,
             });
             updateTask(task.id, {
                 status: "done",
                 completedAt: Date.now(),
                 savedPath,
-                model: args.model,
             });
             await server.sendLoggingMessage({
                 level: "info",
@@ -118,6 +168,7 @@ server.registerTool("generate_image", {
                     success: true,
                     status: "submitted",
                     task_id: task.id,
+                    effective_prompt: preparedPrompt.prompt,
                     message: `已提交异步生成：${args.output_filename}；如需诊断失败原因，可调用 check_image_task`,
                 }),
             }],
@@ -147,7 +198,9 @@ server.registerTool("check_image_task", {
     };
     if (task.status === "done") {
         response.saved_path = task.savedPath;
-        response.model = task.model;
+    }
+    if (task.effectivePrompt) {
+        response.effective_prompt = task.effectivePrompt;
     }
     if (task.status === "failed") {
         response.error = task.errorCode;

package/dist/prompt.js

@@ -0,0 +1,87 @@
+import { AppError } from "./errors.js";
+export const IMAGE_INPUT_ROLES = [
+    "reference",
+    "edit_target",
+    "style_reference",
+    "composition_reference",
+    "insert_source",
+];
+export const PROMPT_USE_CASES = [
+    "photorealistic-natural",
+    "product-mockup",
+    "ui-mockup",
+    "infographic-diagram",
+    "scientific-educational",
+    "ads-marketing",
+    "productivity-visual",
+    "logo-brand",
+    "illustration-story",
+    "stylized-concept",
+    "historical-scene",
+    "text-localization",
+    "identity-preserve",
+    "precise-object-edit",
+    "lighting-weather",
+    "background-extraction",
+    "style-transfer",
+    "compositing",
+    "sketch-to-render",
+];
+const DEFAULT_KEY_COLOR = "#00ff00";
+function compactLines(lines) {
+    return lines.filter((line) => Boolean(line?.trim())).join("\n");
+}
+function validateImageInputs(inputImages) {
+    if (!inputImages)
+        return undefined;
+    for (const [index, image] of inputImages.entries()) {
+        if (!image.path?.trim()) {
+            throw new AppError("E_INPUT_INVALID", `input_images[${index}].path is required`);
+        }
+    }
+    return inputImages;
+}
+function imageRoleLabel(role) {
+    return role?.replace(/_/g, " ") ?? "reference";
+}
+function imageLines(inputImages) {
+    if (!inputImages?.length)
+        return undefined;
+    const lines = inputImages.map((image, index) => {
+        const note = image.note?.trim() ? `; ${image.note.trim()}` : "";
+        return `Image ${index + 1}: ${imageRoleLabel(image.role)}${note}`;
+    });
+    return `Input images: ${lines.join("; ")}`;
+}
+function legacyReferenceInputs(referenceImages) {
+    if (!referenceImages?.length)
+        return undefined;
+    return referenceImages.map((path) => ({ path, role: "reference" }));
+}
+function transparentPrompt(keyColor) {
+    return compactLines([
+        `Scene/backdrop: perfectly flat solid ${keyColor} chroma-key background for local background removal.`,
+        "Constraints: background must be one uniform color with no shadows, gradients, texture, reflections, floor plane, or lighting variation; keep the subject fully separated from the background with crisp edges and generous padding.",
+        `Avoid: do not use ${keyColor} anywhere in the subject; no cast shadow, no contact shadow, no reflection, no watermark, and no text unless explicitly requested.`,
+    ]);
+}
+export function preparePrompt(opts) {
+    const inputImages = validateImageInputs(opts.inputImages) ?? legacyReferenceInputs(opts.referenceImages);
+    const keyColor = opts.transparentKeyColor ?? DEFAULT_KEY_COLOR;
+    const negativePrompt = opts.negativePrompt?.trim()
+        ? `Avoid: ${opts.negativePrompt.trim()}`
+        : undefined;
+    const prompt = compactLines([
+        opts.useCase ? `Use case: ${opts.useCase}` : undefined,
+        opts.assetType ? `Asset type: ${opts.assetType}` : undefined,
+        imageLines(inputImages),
+        `Primary request: ${opts.prompt.trim()}`,
+        opts.constraints ? `Constraints: ${opts.constraints.trim()}` : undefined,
+        opts.transparentBackground ? transparentPrompt(keyColor) : undefined,
+        negativePrompt,
+    ]);
+    return {
+        prompt,
+        imagePaths: inputImages?.map((image) => image.path) ?? [],
+    };
+}

package/dist/provider.js

@@ -81,8 +81,7 @@ async function handleProviderError(res) {
     throw new AppError("E_PROVIDER_BAD_REQUEST", `Upstream error ${res.status}: ${text.slice(0, 200)}`);
 }
 async function generateOpenAIImage(config, opts) {
-    const model = opts.model ?? config.model;
-    const prompt = opts.negativePrompt ? `${opts.prompt}\n\nAvoid: ${opts.negativePrompt}` : opts.prompt;
+    const prompt = opts.prompt;
     const size = mapOpenAISize(opts.size, opts.aspectRatio);
     const hasReferenceImages = Boolean(opts.referenceImages?.length);
     const url = `${config.baseUrl}${hasReferenceImages ? "/v1/images/edits" : "/v1/images/generations"}`;
@@ -92,42 +91,40 @@ async function generateOpenAIImage(config, opts) {
     };
     if (hasReferenceImages) {
         const form = new FormData();
-        form.set("model", model);
+        form.set("model", GPT_IMAGE_MODEL);
         form.set("prompt", prompt);
         form.set("size", size);
         if (opts.aspectRatio) {
             form.set("aspect_ratio", opts.aspectRatio);
         }
         for (const [index, imgPath] of opts.referenceImages.entries()) {
-            const data = await resizeIfNeeded(imgPath);
+            const data = await resizeIfNeeded(imgPath, opts.referenceMaxSide);
             const bytes = data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
-            form.append("image", new Blob([bytes], { type: "image/png" }), `reference-${index}.png`);
+            form.append("image", new Blob([bytes], { type: "image/webp" }), `reference-${index}.webp`);
         }
         body = form;
     }
     else {
         headers = { ...headers, "Content-Type": "application/json" };
         body = JSON.stringify({
-            model,
+            model: GPT_IMAGE_MODEL,
             prompt,
             size,
             ...(opts.aspectRatio ? { aspect_ratio: opts.aspectRatio } : {}),
         });
     }
+    // 启用 2 次重试,应对上游偶发的 EOF / 524(Cloudflare 100s 超时)。
+    // retries=0 时所有偶发失败一次过即死,指数退避代码是死代码。
     const res = await fetchWithRetry(url, {
         method: "POST",
         headers,
         body,
-    }, config.timeoutMs);
+    }, config.timeoutMs, 2);
     if (!res.ok) {
         await handleProviderError(res);
     }
     return imageFromOpenAIResponse(res);
 }
 export async function generateImage(config, opts) {
-    const model = opts.model ?? config.model;
-    if (model !== GPT_IMAGE_MODEL) {
-        throw new AppError("E_PROVIDER_BAD_REQUEST", `Unsupported model: ${model}`);
-    }
     return generateOpenAIImage(config, opts);
 }

package/dist/resizer.js

@@ -1,17 +1,39 @@
-import { Jimp, JimpMime } from "jimp";
+import sharp from "sharp";
+import { existsSync } from "node:fs";
 import { AppError } from "./errors.js";
-const MAX_SIDE = 1024;
-export async function resizeIfNeeded(imgPath) {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    let image;
+export const DEFAULT_REFERENCE_MAX_SIDE = 1024;
+/**
+ * 读入垫图,按需缩放到 maxSide 内(保持比例不放大),
+ * 强制重编码为 WebP(quality 85)以满足 gpt-image-2 edits 端点的 1.5MB 甜点值约束。
+ * PNG 通道比 WebP 大 3~5 倍,改用 WebP 后体积大幅下降,避免上游 100s 超时。
+ */
+export async function resizeIfNeeded(imgPath, maxSide = DEFAULT_REFERENCE_MAX_SIDE) {
+    if (!existsSync(imgPath)) {
+        throw new AppError("E_REFERENCE_NOT_FOUND", `Cannot read reference image: ${imgPath}`);
+    }
+    let pipeline = sharp(imgPath, { failOn: "none" });
+    if (maxSide !== false) {
+        try {
+            const metadata = await pipeline.metadata();
+            if (metadata.width &&
+                metadata.height &&
+                (metadata.width > maxSide || metadata.height > maxSide)) {
+                pipeline = pipeline.resize({
+                    width: maxSide,
+                    height: maxSide,
+                    fit: "inside",
+                    withoutEnlargement: true,
+                });
+            }
+        }
+        catch (err) {
+            throw new AppError("E_REFERENCE_NOT_FOUND", `Cannot read reference image: ${imgPath}`);
+        }
+    }
     try {
-        image = await Jimp.read(imgPath);
+        return await pipeline.webp({ quality: 85 }).toBuffer();
     }
-    catch {
+    catch (err) {
         throw new AppError("E_REFERENCE_NOT_FOUND", `Cannot read reference image: ${imgPath}`);
     }
-    if (image.width > MAX_SIDE || image.height > MAX_SIDE) {
-        image.scaleToFit({ w: MAX_SIDE, h: MAX_SIDE });
-    }
-    return image.getBuffer(JimpMime.png);
 }

package/dist/saver.js

@@ -1,8 +1,21 @@
 import { mkdirSync, existsSync, writeFileSync } from "node:fs";
 import { resolve, join, extname, basename } from "node:path";
 import { AppError } from "./errors.js";
-export function saveImage(imageBuffer, opts) {
-    const { outputDir, outputFilename, format = "png", overwrite = false } = opts;
+import { encodeImage, normalizeOutputFormat } from "./image-processing.js";
+function resolveFormat(outputFilename, format) {
+    const filenameExt = extname(outputFilename).replace(/^\./, "");
+    const requested = normalizeOutputFormat(format ?? "png");
+    if (!filenameExt)
+        return requested;
+    const filenameFormat = normalizeOutputFormat(filenameExt);
+    if (format && filenameFormat !== requested) {
+        throw new AppError("E_INPUT_INVALID", `Filename extension .${filenameExt} does not match requested format ${format}`);
+    }
+    return filenameFormat;
+}
+export async function saveImage(imageBuffer, opts) {
+    const { outputDir, outputFilename, overwrite = false } = opts;
+    const outputFormat = resolveFormat(outputFilename, opts.format);
     const absDir = resolve(outputDir);
     try {
         mkdirSync(absDir, { recursive: true });
@@ -10,7 +23,7 @@ export function saveImage(imageBuffer, opts) {
     catch (err) {
         throw new AppError("E_SAVE_FAILED", `Cannot create directory: ${absDir} - ${err}`);
     }
-    const ext = extname(outputFilename) || `.${format}`;
+    const ext = extname(outputFilename) || `.${outputFormat}`;
     const base = extname(outputFilename) ? basename(outputFilename, ext) : outputFilename;
     let finalPath = join(absDir, `${base}${ext}`);
     if (!overwrite && existsSync(finalPath)) {
@@ -21,7 +34,7 @@ export function saveImage(imageBuffer, opts) {
         } while (existsSync(finalPath));
     }
     try {
-        writeFileSync(finalPath, imageBuffer);
+        writeFileSync(finalPath, await encodeImage(imageBuffer, outputFormat));
     }
     catch (err) {
         throw new AppError("E_SAVE_FAILED", `Cannot write file: ${finalPath} - ${err}`);

package/package.json

@@ -1,46 +1,46 @@
-{
-  "name": "mcp-duojie-image",
-  "version": "0.5.7",
-  "description": "MCP server for image generation via duojie.games",
-  "type": "module",
-  "main": "dist/index.js",
-  "bin": {
-    "mcp-duojie-image": "dist/index.js"
-  },
-  "scripts": {
-    "dev": "tsx src/index.ts",
-    "build": "tsc",
-    "start": "node dist/index.js",
-    "test": "vitest run",
-    "lint": "tsc --noEmit",
-    "prepublishOnly": "npm run build"
-  },
-  "keywords": [
-    "mcp",
-    "image-generation",
-    "gpt",
-    "openai",
-    "ai"
-  ],
-  "author": "",
-  "license": "MIT",
-  "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.12.0",
-    "jimp": "^1.6.0",
-    "node-notifier": "^10.0.1",
-    "zod": "^3.23.8"
-  },
-  "devDependencies": {
-    "@types/node": "^22.0.0",
-    "@types/node-notifier": "^8.0.5",
-    "tsx": "^4.19.0",
-    "typescript": "^5.5.0",
-    "vitest": "^2.0.0"
-  },
-  "engines": {
-    "node": ">=18.0.0"
-  },
-  "files": [
-    "dist"
-  ]
-}
+{
+  "name": "mcp-duojie-image",
+  "version": "0.6.0",
+  "description": "MCP server for image generation via duojie.games",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "mcp-duojie-image": "dist/index.js"
+  },
+  "scripts": {
+    "dev": "tsx src/index.ts",
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "test": "vitest run",
+    "lint": "tsc --noEmit",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "mcp",
+    "image-generation",
+    "gpt",
+    "openai",
+    "ai"
+  ],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.0",
+    "node-notifier": "^10.0.1",
+    "sharp": "^0.35.3",
+    "zod": "^3.23.8"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "@types/node-notifier": "^8.0.5",
+    "tsx": "^4.19.0",
+    "typescript": "^5.5.0",
+    "vitest": "^2.0.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "files": [
+    "dist"
+  ]
+}