@alonetech/gpt-image-mcp 0.1.0 → 0.3.0

package/README.md

@@ -90,6 +90,7 @@ generate_image
 Required arguments:
 
 - `prompt`: prompt describing the output image
+- `output`: filesystem path where the generated image will be saved
 
 Optional arguments:
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alonetech/gpt-image-mcp",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "description": "MCP stdio server and CLI for text-to-image and image-to-image generation.",
   "type": "module",
   "bin": {

package/src/cli.js

@@ -3,15 +3,13 @@ import { basename } from "node:path";
 
 import { generateImage } from "./image-api.js";
 
-const DEFAULT_OUTPUT = "output.png";
-
 function usage() {
   return `Usage:
-  gpt-image-mcp generate --base-url <url> --token <token> --prompt <text> [options]
+  gpt-image-mcp generate --base-url <url> --token <token> --prompt <text> --output <path> [options]
 
 Options:
   --image <path>       Optional input image. Repeat for image-to-image mode.
-  --output <path>      Output image path. Default: ${DEFAULT_OUTPUT}
+  --output <path>      Required output image path.
   --model <model>      Image model. Default: gpt-image-2
   --size <size>        Image size. Default: auto
   --quality <quality>  auto, low, medium, or high. Default: auto
@@ -31,7 +29,6 @@ function readOption(args, index) {
 function parseGenerateArgs(args) {
   const options = {
     images: [],
-    output: DEFAULT_OUTPUT,
     output_format: "png",
   };
 
@@ -134,6 +131,7 @@ async function runGenerate(args, dependencies) {
   requireOption(options, "baseUrl", "--base-url");
   requireOption(options, "token", "--token");
   requireOption(options, "prompt", "--prompt");
+  requireOption(options, "output", "--output");
 
   const input = {
     prompt: options.prompt,

package/src/image-api.js

@@ -97,19 +97,50 @@ function commonOptions(input, outputFormat) {
   };
 }
 
-function resultFromResponseBody(body, outputFormat, model, mode) {
-  const data = body?.data?.[0]?.b64_json;
+async function resultFromResponseBody(body, outputFormat, model, mode, fetchImpl) {
+  const firstResult = body?.data?.[0];
 
-  if (!data) {
-    throw new Error("Image API response did not include base64 image data");
+  // Try b64_json first
+  const b64Data = firstResult?.b64_json;
+  if (b64Data) {
+    return {
+      data: b64Data,
+      mimeType: mimeTypeForOutputFormat(outputFormat),
+      model,
+      mode,
+    };
   }
 
-  return {
-    data,
-    mimeType: mimeTypeForOutputFormat(outputFormat),
-    model,
-    mode,
+  // Try url - fetch image from URL and convert to base64
+  const url = firstResult?.url;
+  if (url) {
+    // Use globalThis.fetch for fetching image URLs (not fetchImpl which may have API-specific headers)
+    const response = await globalThis.fetch(url);
+    if (!response.ok) {
+      throw new Error(`Failed to fetch image from URL: ${response.status} ${response.statusText}`);
+    }
+    const arrayBuffer = await response.arrayBuffer();
+    const base64 = Buffer.from(arrayBuffer).toString('base64');
+    // Get correct mimeType from response Content-Type
+    const contentType = response.headers.get('content-type') || '';
+    const actualMimeType = contentType.startsWith('image/') ? contentType : mimeTypeForOutputFormat(outputFormat);
+    return {
+      data: base64,
+      mimeType: actualMimeType,
+      model,
+      mode,
+    };
+  }
+
+  // Debug: include response info in error message
+  const responseSummary = {
+    bodyKeys: Object.keys(body || {}),
+    dataType: typeof body?.data,
+    dataLength: body?.data?.length,
+    firstResultKeys: firstResult ? Object.keys(firstResult) : null,
+    bodyPreview: JSON.stringify(body).substring(0, 500)
   };
+  throw new Error(`Image API response did not include base64 image data or URL. Response summary: ${JSON.stringify(responseSummary)}`);
 }
 
 export async function generateImage(input, config = {}) {
@@ -125,6 +156,8 @@ export async function generateImage(input, config = {}) {
   const outputFormat = input.output_format || input.outputFormat || DEFAULT_OUTPUT_FORMAT;
   const options = commonOptions(input, outputFormat);
 
+  const signal = config.signal;
+
   if (!Array.isArray(images) || images.length === 0) {
     const { background, ...body } = options;
     if (background) {
@@ -138,6 +171,7 @@ export async function generateImage(input, config = {}) {
         "Content-Type": "application/json",
       },
       body: JSON.stringify(body),
+      signal,
     });
 
     if (!response.ok) {
@@ -145,7 +179,7 @@ export async function generateImage(input, config = {}) {
       throw new Error(`Image API request failed (${response.status} ${response.statusText}): ${message}`);
     }
 
-    return resultFromResponseBody(await response.json(), outputFormat, options.model, "text");
+    return resultFromResponseBody(await response.json(), outputFormat, options.model, "text", fetchImpl);
   }
 
   const form = new FormData();
@@ -169,6 +203,7 @@ export async function generateImage(input, config = {}) {
       Authorization: `Bearer ${token}`,
     },
     body: form,
+    signal,
   });
 
   if (!response.ok) {
@@ -176,7 +211,7 @@ export async function generateImage(input, config = {}) {
     throw new Error(`Image API request failed (${response.status} ${response.statusText}): ${message}`);
   }
 
-  return resultFromResponseBody(await response.json(), outputFormat, options.model, "edit");
+  return resultFromResponseBody(await response.json(), outputFormat, options.model, "edit", fetchImpl);
 }
 
 export const generateEditedImage = generateImage;

package/src/mcp-server.js

@@ -1,4 +1,5 @@
 import { appendFileSync } from "node:fs";
+import { writeFile } from "node:fs/promises";
 
 import { generateImage } from "./image-api.js";
 
@@ -12,12 +13,16 @@ const TOOL_DEFINITION = {
     "Generate one image in text-to-image mode from a prompt only, or in image-to-image mode from a prompt plus optional reference images.",
   inputSchema: {
     type: "object",
-    required: ["prompt"],
+    required: ["prompt", "output"],
     properties: {
       prompt: {
         type: "string",
         description: "Prompt describing the single output image to generate.",
       },
+      output: {
+        type: "string",
+        description: "Required filesystem path where the generated image will be saved.",
+      },
       images: {
         type: "array",
         minItems: 0,
@@ -111,6 +116,15 @@ export function createServerConfig({ argv = process.argv, env = process.env } =
     config.debugLog = debugLog;
   }
 
+  const timeoutStr = valueAfterFlag(argv, "--timeout") || env.GPT_IMAGE_TIMEOUT;
+  if (timeoutStr) {
+    const timeoutMs = Number.parseInt(timeoutStr, 10);
+    if (Number.isNaN(timeoutMs) || timeoutMs <= 0) {
+      throw new Error(`Invalid timeout value: ${timeoutStr}`);
+    }
+    config.timeoutMs = timeoutMs;
+  }
+
   return config;
 }
 
@@ -302,15 +316,36 @@ async function handleToolCall(message, dependencies) {
     return failure(message.id, -32602, `Unknown tool: ${name || ""}`);
   }
 
+  const requestId = message.id;
+  const pendingRequests = dependencies.pendingRequests;
+  const timeoutMs = dependencies.config?.timeoutMs ?? 300000; // default 5 minutes
+  const controller = new AbortController();
+  const timeoutTimer = setTimeout(() => {
+    controller.abort(new Error(`Tool call timed out after ${timeoutMs}ms`));
+  }, timeoutMs);
+
+  if (pendingRequests && requestId !== undefined && requestId !== null) {
+    pendingRequests.set(requestId, { controller, timer: timeoutTimer });
+  }
+
   try {
+    const args = message.params?.arguments || {};
+    const outputPath = args.output;
+    if (typeof outputPath !== "string" || outputPath.trim() === "") {
+      throw new Error("output is required");
+    }
+
     const image = await generateImage(
-      message.params?.arguments || {},
+      args,
       {
         ...dependencies.config,
         fetchImpl: dependencies.fetchImpl || globalThis.fetch,
+        signal: controller.signal,
       },
     );
 
+    await (dependencies.writeFile || writeFile)(outputPath, Buffer.from(image.data, "base64"));
+
     return success(message.id, {
       content: [
         {
@@ -326,15 +361,23 @@ async function handleToolCall(message, dependencies) {
       isError: false,
     });
   } catch (error) {
+    const isAborted = error instanceof Error && error.name === "AbortError";
     return success(message.id, {
       content: [
         {
           type: "text",
-          text: error instanceof Error ? error.message : String(error),
+          text: isAborted
+            ? `Image generation was cancelled or timed out: ${error.message}`
+            : error instanceof Error ? error.message : String(error),
         },
       ],
       isError: true,
     });
+  } finally {
+    clearTimeout(timeoutTimer);
+    if (pendingRequests && requestId !== undefined && requestId !== null) {
+      pendingRequests.delete(requestId);
+    }
   }
 }
 
@@ -361,6 +404,19 @@ export async function handleJsonRpcMessage(message, dependencies = {}) {
       });
     case "notifications/initialized":
       return undefined;
+    case "notifications/cancelled": {
+      const pendingRequests = dependencies.pendingRequests;
+      if (pendingRequests) {
+        const requestId = message.params?.requestId;
+        const pending = pendingRequests.get(requestId);
+        if (pending) {
+          clearTimeout(pending.timer);
+          pending.controller.abort(new Error("Request cancelled by client"));
+          pendingRequests.delete(requestId);
+        }
+      }
+      return undefined;
+    }
     case "ping":
       return success(message.id, {});
     case "tools/list":
@@ -386,8 +442,11 @@ export async function runStdioServer({
   debug("server_started", {
     hasBaseUrl: Boolean(config.baseUrl),
     hasToken: Boolean(config.token),
+    timeoutMs: config.timeoutMs || 300000,
   });
 
+  const pendingRequests = new Map();
+
   try {
     for await (const { message, transport } of readFramedMessages(input, debug)) {
       debug("message_received", {
@@ -395,7 +454,7 @@ export async function runStdioServer({
         method: message?.method,
         transport,
       });
-      const response = await handleJsonRpcMessage(message, { config });
+      const response = await handleJsonRpcMessage(message, { config, pendingRequests });
       if (response) {
         debug("message_sent", {
           id: response.id,