@alonetech/gpt-image-mcp 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 alonetech
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,121 @@
+# @alonetech/gpt-image-mcp
+
+MCP stdio server and CLI for OpenAI-compatible image generation APIs.
+
+It supports:
+
+- Text-to-image: prompt only
+- Image-to-image: prompt plus one or more reference images
+- MCP stdio mode for MCP clients
+- Direct CLI mode for local testing
+
+## Requirements
+
+- Node.js 18.17 or newer
+- An OpenAI-compatible image API `base_url`
+- A bearer token for that API
+
+## CLI
+
+Show help:
+
+```bash
+npx @alonetech/gpt-image-mcp --help
+```
+
+Text-to-image:
+
+```bash
+npx @alonetech/gpt-image-mcp generate \
+  --base-url "https://api.openai.com/v1" \
+  --token "YOUR_TOKEN" \
+  --prompt "An orange cat wearing a space suit, movie poster style" \
+  --output "./cat.png" \
+  --size "1024x1024" \
+  --quality "high" \
+  --format "png"
+```
+
+Image-to-image:
+
+```bash
+npx @alonetech/gpt-image-mcp generate \
+  --base-url "https://api.openai.com/v1" \
+  --token "YOUR_TOKEN" \
+  --prompt "Turn the references into a clean product image" \
+  --image "./front.png" \
+  --image "./side.jpg" \
+  --output "./product.png"
+```
+
+On PowerShell, use backticks instead of backslashes for line continuation.
+
+## MCP Usage
+
+Example MCP server config:
+
+```json
+{
+  "mcpServers": {
+    "gpt-image": {
+      "command": "npx",
+      "args": [
+        "-y",
+        "@alonetech/gpt-image-mcp",
+        "--base-url",
+        "https://api.openai.com/v1",
+        "--token",
+        "YOUR_TOKEN"
+      ]
+    }
+  }
+}
+```
+
+For debugging client startup, add:
+
+```json
+"--debug-log",
+"D:\\tmp\\gpt-image-mcp-debug.log"
+```
+
+## MCP Tool
+
+Tool name:
+
+```text
+generate_image
+```
+
+Required arguments:
+
+- `prompt`: prompt describing the output image
+
+Optional arguments:
+
+- `images`: reference images as base64 strings or data URLs. Omit or pass an empty array for text-to-image mode.
+- `model`: defaults to `gpt-image-2`
+- `size`: defaults to `auto`
+- `quality`: `auto`, `low`, `medium`, or `high`
+- `background`: `auto`, `transparent`, or `opaque`
+
+`base_url` and `token` are server startup configuration, not per-tool-call arguments.
+
+## Development
+
+```bash
+npm test
+npm run pack:dry-run
+```
+
+Create a local package tarball:
+
+```bash
+npm pack
+```
+
+Test the tarball:
+
+```bash
+npx ./alonetech-gpt-image-mcp-0.1.0.tgz --help
+```

package/bin/gpt-image-mcp.js

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+import { runCli } from "../src/cli.js";
+import { runStdioServer } from "../src/mcp-server.js";
+
+if (process.argv[2] === "generate" || process.argv[2] === "--help" || process.argv[2] === "-h") {
+  const exitCode = await runCli(process.argv.slice(2));
+  process.exitCode = exitCode;
+} else {
+  runStdioServer().catch((error) => {
+    console.error(error instanceof Error ? error.stack || error.message : String(error));
+    process.exitCode = 1;
+  });
+}

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@alonetech/gpt-image-mcp",
+  "version": "0.1.0",
+  "description": "MCP stdio server and CLI for text-to-image and image-to-image generation.",
+  "type": "module",
+  "bin": {
+    "gpt-image-mcp": "./bin/gpt-image-mcp.js"
+  },
+  "scripts": {
+    "test": "node --test",
+    "pack:dry-run": "npm pack --dry-run"
+  },
+  "engines": {
+    "node": ">=18.17"
+  },
+  "files": [
+    "bin",
+    "src",
+    "README.md",
+    "LICENSE"
+  ],
+  "keywords": [
+    "mcp",
+    "gpt-image",
+    "image-generation",
+    "text-to-image",
+    "image-to-image"
+  ],
+  "author": "alonetech",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/alonetech/gpt-image-mcp.git"
+  },
+  "bugs": {
+    "url": "https://github.com/alonetech/gpt-image-mcp/issues"
+  },
+  "homepage": "https://github.com/alonetech/gpt-image-mcp#readme",
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/cli.js

@@ -0,0 +1,188 @@
+import { readFile, writeFile } from "node:fs/promises";
+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]
+
+Options:
+  --image <path>       Optional input image. Repeat for image-to-image mode.
+  --output <path>      Output image path. Default: ${DEFAULT_OUTPUT}
+  --model <model>      Image model. Default: gpt-image-2
+  --size <size>        Image size. Default: auto
+  --quality <quality>  auto, low, medium, or high. Default: auto
+  --format <format>    png, jpeg, or webp. Default: png
+`;
+}
+
+function readOption(args, index) {
+  const value = args[index + 1];
+  if (value === undefined || value.startsWith("--")) {
+    throw new Error(`Missing value for ${args[index]}`);
+  }
+
+  return value;
+}
+
+function parseGenerateArgs(args) {
+  const options = {
+    images: [],
+    output: DEFAULT_OUTPUT,
+    output_format: "png",
+  };
+
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+
+    switch (arg) {
+      case "--base-url":
+        options.baseUrl = readOption(args, index);
+        index += 1;
+        break;
+      case "--token":
+        options.token = readOption(args, index);
+        index += 1;
+        break;
+      case "--prompt":
+        options.prompt = readOption(args, index);
+        index += 1;
+        break;
+      case "--image":
+        options.images.push(readOption(args, index));
+        index += 1;
+        break;
+      case "--output":
+        options.output = readOption(args, index);
+        index += 1;
+        break;
+      case "--model":
+        options.model = readOption(args, index);
+        index += 1;
+        break;
+      case "--size":
+        options.size = readOption(args, index);
+        index += 1;
+        break;
+      case "--quality":
+        options.quality = readOption(args, index);
+        index += 1;
+        break;
+      case "--format":
+        options.output_format = readOption(args, index);
+        index += 1;
+        break;
+      case "--help":
+      case "-h":
+        options.help = true;
+        break;
+      default:
+        throw new Error(`Unknown option: ${arg}`);
+    }
+  }
+
+  return options;
+}
+
+function requireOption(options, key, flagName) {
+  if (!options[key]) {
+    throw new Error(`Missing required option: ${flagName}`);
+  }
+}
+
+function mimeTypeForPath(path) {
+  const lower = path.toLowerCase();
+  if (lower.endsWith(".jpg") || lower.endsWith(".jpeg")) {
+    return "image/jpeg";
+  }
+  if (lower.endsWith(".webp")) {
+    return "image/webp";
+  }
+  if (lower.endsWith(".gif")) {
+    return "image/gif";
+  }
+  return "image/png";
+}
+
+async function imagesFromPaths(paths, readFileImpl) {
+  const images = [];
+
+  for (const path of paths) {
+    const bytes = await readFileImpl(path);
+    images.push({
+      data: Buffer.from(bytes).toString("base64"),
+      mime_type: mimeTypeForPath(path),
+      name: basename(path),
+    });
+  }
+
+  return images;
+}
+
+async function runGenerate(args, dependencies) {
+  const options = parseGenerateArgs(args);
+  const stdout = dependencies.stdout || process.stdout;
+
+  if (options.help) {
+    stdout.write(usage());
+    return 0;
+  }
+
+  requireOption(options, "baseUrl", "--base-url");
+  requireOption(options, "token", "--token");
+  requireOption(options, "prompt", "--prompt");
+
+  const input = {
+    prompt: options.prompt,
+    model: options.model,
+    size: options.size,
+    quality: options.quality,
+    output_format: options.output_format,
+  };
+
+  if (options.images.length > 0) {
+    input.images = await imagesFromPaths(options.images, dependencies.readFile || readFile);
+  }
+
+  for (const key of Object.keys(input)) {
+    if (input[key] === undefined) {
+      delete input[key];
+    }
+  }
+
+  const result = await (dependencies.generateImage || generateImage)(input, {
+    baseUrl: options.baseUrl,
+    token: options.token,
+  });
+
+  const bytes = Buffer.from(result.data, "base64");
+  await (dependencies.writeFile || writeFile)(options.output, bytes);
+  stdout.write(`Saved ${result.mode} image to ${options.output}\n`);
+  return 0;
+}
+
+export async function runCli(args = process.argv.slice(2), dependencies = {}) {
+  const stderr = dependencies.stderr || process.stderr;
+  const stdout = dependencies.stdout || process.stdout;
+  const [command, ...rest] = args;
+
+  try {
+    if (!command || command === "--help" || command === "-h") {
+      stdout.write(usage());
+      return 0;
+    }
+
+    if (command !== "generate") {
+      stderr.write(`Unknown command: ${command}\n${usage()}`);
+      return 2;
+    }
+
+    return await runGenerate(rest, dependencies);
+  } catch (error) {
+    stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+    return 2;
+  }
+}

package/src/image-api.js

@@ -0,0 +1,182 @@
+const DEFAULT_MODEL = "gpt-image-2";
+const DEFAULT_OUTPUT_FORMAT = "png";
+
+function requireString(value, fieldName) {
+  if (typeof value !== "string" || value.trim() === "") {
+    throw new Error(`${fieldName} is required`);
+  }
+
+  return value.trim();
+}
+
+function normalizeBase64Image(data) {
+  const match = data.match(/^data:(?<mime>image\/[a-z0-9.+-]+);base64,(?<body>.+)$/i);
+
+  if (match?.groups) {
+    return {
+      data: match.groups.body,
+      mimeType: match.groups.mime.toLowerCase(),
+    };
+  }
+
+  return {
+    data,
+    mimeType: undefined,
+  };
+}
+
+function extensionForMimeType(mimeType) {
+  if (mimeType === "image/jpeg") {
+    return "jpg";
+  }
+
+  return mimeType.split("/")[1] || "png";
+}
+
+function imageBlobFromInput(image, index) {
+  if (!image || typeof image !== "object") {
+    throw new Error(`images[${index}] must be an object`);
+  }
+
+  const rawData = requireString(image.data, `images[${index}].data`);
+  const normalized = normalizeBase64Image(rawData);
+  const mimeType = image.mime_type || image.mimeType || normalized.mimeType || "image/png";
+
+  if (!String(mimeType).startsWith("image/")) {
+    throw new Error(`images[${index}].mime_type must be an image MIME type`);
+  }
+
+  const buffer = Buffer.from(normalized.data, "base64");
+  if (buffer.length === 0) {
+    throw new Error(`images[${index}].data must contain base64 image bytes`);
+  }
+
+  const extension = extensionForMimeType(mimeType);
+  const filename = image.name || image.filename || `image-${index + 1}.${extension}`;
+
+  return {
+    blob: new Blob([buffer], { type: mimeType }),
+    filename,
+  };
+}
+
+function buildEndpoint(baseUrl, path) {
+  return new URL(path, baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`).toString();
+}
+
+function appendIfPresent(form, key, value) {
+  if (value !== undefined && value !== null && value !== "") {
+    form.set(key, String(value));
+  }
+}
+
+async function parseErrorResponse(response) {
+  const contentType = response.headers?.get?.("content-type") || "";
+
+  if (contentType.includes("application/json")) {
+    const body = await response.json().catch(() => undefined);
+    return body?.error?.message || body?.message || JSON.stringify(body);
+  }
+
+  return response.text ? response.text() : response.statusText;
+}
+
+function mimeTypeForOutputFormat(outputFormat) {
+  return `image/${outputFormat === "jpg" ? "jpeg" : outputFormat}`;
+}
+
+function commonOptions(input, outputFormat) {
+  return {
+    model: input.model || DEFAULT_MODEL,
+    prompt: requireString(input?.prompt, "prompt"),
+    n: 1,
+    size: input.size || "auto",
+    quality: input.quality || "auto",
+    output_format: outputFormat,
+    background: input.background,
+  };
+}
+
+function resultFromResponseBody(body, outputFormat, model, mode) {
+  const data = body?.data?.[0]?.b64_json;
+
+  if (!data) {
+    throw new Error("Image API response did not include base64 image data");
+  }
+
+  return {
+    data,
+    mimeType: mimeTypeForOutputFormat(outputFormat),
+    model,
+    mode,
+  };
+}
+
+export async function generateImage(input, config = {}) {
+  const fetchImpl = config.fetchImpl || globalThis.fetch;
+
+  if (typeof fetchImpl !== "function") {
+    throw new Error("fetch is not available in this Node runtime");
+  }
+
+  const baseUrl = requireString(config.baseUrl || config.base_url, "base_url");
+  const token = requireString(config.token, "token");
+  const images = input?.images;
+  const outputFormat = input.output_format || input.outputFormat || DEFAULT_OUTPUT_FORMAT;
+  const options = commonOptions(input, outputFormat);
+
+  if (!Array.isArray(images) || images.length === 0) {
+    const { background, ...body } = options;
+    if (background) {
+      body.background = background;
+    }
+
+    const response = await fetchImpl(buildEndpoint(baseUrl, "images/generations"), {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${token}`,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify(body),
+    });
+
+    if (!response.ok) {
+      const message = await parseErrorResponse(response);
+      throw new Error(`Image API request failed (${response.status} ${response.statusText}): ${message}`);
+    }
+
+    return resultFromResponseBody(await response.json(), outputFormat, options.model, "text");
+  }
+
+  const form = new FormData();
+
+  form.set("model", options.model);
+  form.set("prompt", options.prompt);
+  form.set("n", String(options.n));
+  appendIfPresent(form, "size", options.size);
+  appendIfPresent(form, "quality", options.quality);
+  appendIfPresent(form, "output_format", options.output_format);
+  appendIfPresent(form, "background", options.background);
+
+  images.forEach((image, index) => {
+    const { blob, filename } = imageBlobFromInput(image, index);
+    form.append("image", blob, filename);
+  });
+
+  const response = await fetchImpl(buildEndpoint(baseUrl, "images/edits"), {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${token}`,
+    },
+    body: form,
+  });
+
+  if (!response.ok) {
+    const message = await parseErrorResponse(response);
+    throw new Error(`Image API request failed (${response.status} ${response.statusText}): ${message}`);
+  }
+
+  return resultFromResponseBody(await response.json(), outputFormat, options.model, "edit");
+}
+
+export const generateEditedImage = generateImage;

package/src/mcp-server.js

@@ -0,0 +1,416 @@
+import { appendFileSync } from "node:fs";
+
+import { generateImage } from "./image-api.js";
+
+export const TOOL_NAME = "generate_image";
+
+const JSONRPC_VERSION = "2.0";
+
+const TOOL_DEFINITION = {
+  name: TOOL_NAME,
+  description:
+    "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"],
+    properties: {
+      prompt: {
+        type: "string",
+        description: "Prompt describing the single output image to generate.",
+      },
+      images: {
+        type: "array",
+        minItems: 0,
+        description:
+          "Optional reference images as base64 strings or data URLs. Omit this field or pass an empty array for text-to-image mode; provide one or more images for image-to-image mode.",
+        items: {
+          type: "object",
+          required: ["data"],
+          properties: {
+            data: {
+              type: "string",
+              description: "Base64 image data, optionally as a data:image/...;base64,... URL.",
+            },
+            mime_type: {
+              type: "string",
+              description: "Image MIME type. Defaults to image/png when omitted.",
+            },
+            name: {
+              type: "string",
+              description: "Optional filename sent in the multipart request.",
+            },
+          },
+        },
+      },
+      model: {
+        type: "string",
+        default: "gpt-image-2",
+      },
+      size: {
+        type: "string",
+        default: "auto",
+      },
+      quality: {
+        type: "string",
+        enum: ["auto", "low", "medium", "high"],
+        default: "auto",
+      },
+      background: {
+        type: "string",
+        enum: ["auto", "transparent", "opaque"],
+      },
+    },
+  },
+};
+
+function success(id, result) {
+  return {
+    jsonrpc: JSONRPC_VERSION,
+    id,
+    result,
+  };
+}
+
+function failure(id, code, message) {
+  return {
+    jsonrpc: JSONRPC_VERSION,
+    id,
+    error: {
+      code,
+      message,
+    },
+  };
+}
+
+function valueAfterFlag(argv, flagName) {
+  const equalsPrefix = `${flagName}=`;
+  const inline = argv.find((value) => value.startsWith(equalsPrefix));
+  if (inline) {
+    return inline.slice(equalsPrefix.length);
+  }
+
+  const flagIndex = argv.indexOf(flagName);
+  if (flagIndex >= 0) {
+    return argv[flagIndex + 1];
+  }
+
+  return undefined;
+}
+
+export function createServerConfig({ argv = process.argv, env = process.env } = {}) {
+  const config = {
+    baseUrl:
+      valueAfterFlag(argv, "--base-url") ||
+      env.GPT_IMAGE_BASE_URL ||
+      env.GPT_IMAGE_BASEURL,
+    token: valueAfterFlag(argv, "--token") || env.GPT_IMAGE_TOKEN,
+  };
+  const debugLog = valueAfterFlag(argv, "--debug-log") || env.GPT_IMAGE_DEBUG_LOG;
+
+  if (debugLog) {
+    config.debugLog = debugLog;
+  }
+
+  return config;
+}
+
+function createDebugLogger(debugLog) {
+  if (!debugLog) {
+    return () => {};
+  }
+
+  return (event, data = {}) => {
+    const entry = {
+      time: new Date().toISOString(),
+      event,
+      ...data,
+    };
+    appendFileSync(debugLog, `${JSON.stringify(entry)}\n`, "utf8");
+  };
+}
+
+function framedMessage(message) {
+  const body = JSON.stringify(message);
+  return `Content-Length: ${Buffer.byteLength(body, "utf8")}\r\n\r\n${body}`;
+}
+
+function rawMessage(message) {
+  return `${JSON.stringify(message)}\n`;
+}
+
+function findHeaderSeparator(buffer) {
+  const crlfIndex = buffer.indexOf("\r\n\r\n");
+  if (crlfIndex >= 0) {
+    return {
+      index: crlfIndex,
+      length: 4,
+    };
+  }
+
+  const lfIndex = buffer.indexOf("\n\n");
+  if (lfIndex >= 0) {
+    return {
+      index: lfIndex,
+      length: 2,
+    };
+  }
+
+  return undefined;
+}
+
+function parseFirstRawJsonMessage(buffer) {
+  const text = buffer.toString("utf8");
+  const start = text.search(/\S/);
+
+  if (start < 0 || text[start] !== "{") {
+    return undefined;
+  }
+
+  let depth = 0;
+  let inString = false;
+  let escaped = false;
+
+  for (let index = start; index < text.length; index += 1) {
+    const char = text[index];
+
+    if (escaped) {
+      escaped = false;
+      continue;
+    }
+
+    if (char === "\\") {
+      escaped = true;
+      continue;
+    }
+
+    if (char === '"') {
+      inString = !inString;
+      continue;
+    }
+
+    if (inString) {
+      continue;
+    }
+
+    if (char === "{") {
+      depth += 1;
+    } else if (char === "}") {
+      depth -= 1;
+      if (depth === 0) {
+        const body = text.slice(start, index + 1);
+        return {
+          message: JSON.parse(body),
+          remaining: Buffer.from(text.slice(index + 1), "utf8"),
+        };
+      }
+    }
+  }
+
+  return undefined;
+}
+
+async function* readFramedMessages(input, debug = () => {}) {
+  let buffer = Buffer.alloc(0);
+
+  for await (const chunk of input) {
+    const chunkBuffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+    debug("stdin_chunk", {
+      bytes: chunkBuffer.length,
+    });
+    buffer = Buffer.concat([buffer, chunkBuffer]);
+
+    while (true) {
+      const separator = findHeaderSeparator(buffer);
+      if (!separator) {
+        const raw = parseFirstRawJsonMessage(buffer);
+        if (raw) {
+          debug("raw_json_complete", {
+            bufferedBytes: buffer.length,
+            remainingBytes: raw.remaining.length,
+          });
+          buffer = raw.remaining;
+          yield {
+            message: raw.message,
+            transport: "raw",
+          };
+          continue;
+        }
+
+        debug("frame_waiting_for_headers", {
+          bufferedBytes: buffer.length,
+        });
+        break;
+      }
+
+      const headers = buffer.slice(0, separator.index).toString("utf8");
+      debug("frame_headers", {
+        bytes: separator.index,
+        headers: headers.replaceAll("\r", "\\r").replaceAll("\n", "\\n"),
+      });
+      const lengthMatch = headers.match(/^Content-Length:\s*(\d+)$/im);
+
+      if (!lengthMatch) {
+        throw new Error("Missing Content-Length header");
+      }
+
+      const contentLength = Number.parseInt(lengthMatch[1], 10);
+      const bodyStart = separator.index + separator.length;
+      const bodyEnd = bodyStart + contentLength;
+
+      if (buffer.length < bodyEnd) {
+        debug("frame_waiting_for_body", {
+          contentLength,
+          bufferedBodyBytes: buffer.length - bodyStart,
+        });
+        break;
+      }
+
+      const body = buffer.slice(bodyStart, bodyEnd).toString("utf8");
+      buffer = buffer.slice(bodyEnd);
+      debug("frame_body_complete", {
+        contentLength,
+        remainingBytes: buffer.length,
+      });
+      yield {
+        message: JSON.parse(body),
+        transport: "framed",
+      };
+    }
+  }
+
+  const trailing = buffer.toString("utf8").trim();
+  if (trailing) {
+    debug("raw_json_fallback", {
+      bufferedBytes: buffer.length,
+    });
+
+    for (const line of trailing.split(/\r?\n/)) {
+      const trimmed = line.trim();
+      if (trimmed) {
+        yield {
+          message: JSON.parse(trimmed),
+          transport: "raw",
+        };
+      }
+    }
+  }
+}
+
+async function handleToolCall(message, dependencies) {
+  const name = message.params?.name;
+  if (name !== TOOL_NAME) {
+    return failure(message.id, -32602, `Unknown tool: ${name || ""}`);
+  }
+
+  try {
+    const image = await generateImage(
+      message.params?.arguments || {},
+      {
+        ...dependencies.config,
+        fetchImpl: dependencies.fetchImpl || globalThis.fetch,
+      },
+    );
+
+    return success(message.id, {
+      content: [
+        {
+          type: "image",
+          data: image.data,
+          mimeType: image.mimeType,
+        },
+        {
+          type: "text",
+          text: `Generated one image with ${image.model} using ${image.mode} mode.`,
+        },
+      ],
+      isError: false,
+    });
+  } catch (error) {
+    return success(message.id, {
+      content: [
+        {
+          type: "text",
+          text: error instanceof Error ? error.message : String(error),
+        },
+      ],
+      isError: true,
+    });
+  }
+}
+
+export async function handleJsonRpcMessage(message, dependencies = {}) {
+  if (!message || message.jsonrpc !== JSONRPC_VERSION || typeof message.method !== "string") {
+    return failure(message?.id ?? null, -32600, "Invalid JSON-RPC request");
+  }
+
+  const isNotification = message.id === undefined;
+
+  switch (message.method) {
+    case "initialize":
+      return success(message.id, {
+        protocolVersion: message.params?.protocolVersion || "2024-11-05",
+        capabilities: {
+          tools: {
+            listChanged: false,
+          },
+        },
+        serverInfo: {
+          name: "gpt-image-mcp",
+          version: "0.1.0",
+        },
+      });
+    case "notifications/initialized":
+      return undefined;
+    case "ping":
+      return success(message.id, {});
+    case "tools/list":
+      return success(message.id, {
+        tools: [TOOL_DEFINITION],
+      });
+    case "tools/call":
+      return handleToolCall(message, dependencies);
+    default:
+      if (isNotification) {
+        return undefined;
+      }
+      return failure(message.id, -32601, `Method not found: ${message.method}`);
+  }
+}
+
+export async function runStdioServer({
+  input = process.stdin,
+  output = process.stdout,
+  config = createServerConfig(),
+} = {}) {
+  const debug = createDebugLogger(config.debugLog);
+  debug("server_started", {
+    hasBaseUrl: Boolean(config.baseUrl),
+    hasToken: Boolean(config.token),
+  });
+
+  try {
+    for await (const { message, transport } of readFramedMessages(input, debug)) {
+      debug("message_received", {
+        id: message?.id,
+        method: message?.method,
+        transport,
+      });
+      const response = await handleJsonRpcMessage(message, { config });
+      if (response) {
+        debug("message_sent", {
+          id: response.id,
+          hasError: Boolean(response.error),
+          hasResult: Boolean(response.result),
+          transport,
+        });
+        output.write(transport === "raw" ? rawMessage(response) : framedMessage(response));
+      }
+    }
+    debug("input_closed");
+  } catch (error) {
+    debug("server_error", {
+      message: error instanceof Error ? error.message : String(error),
+    });
+    output.write(framedMessage(failure(null, -32700, "Parse error")));
+  }
+}