@alonetech/gpt-image-mcp 0.1.0 → 0.2.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.2.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

@@ -125,6 +125,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 +140,7 @@ export async function generateImage(input, config = {}) {
         "Content-Type": "application/json",
       },
       body: JSON.stringify(body),
+      signal,
     });
 
     if (!response.ok) {
@@ -169,6 +172,7 @@ export async function generateImage(input, config = {}) {
       Authorization: `Bearer ${token}`,
     },
     body: form,
+    signal,
   });
 
   if (!response.ok) {

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,