@takeshijuan/ideogram-mcp-server 1.0.0

package/dist/index.js

@@ -0,0 +1,3607 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/config/constants.ts
+var API_BASE_URL, API_ENDPOINTS, API_KEY_HEADER, DEFAULTS, VALIDATION, CREDITS_PER_IMAGE, EDIT_CREDITS_PER_IMAGE, USD_PER_CREDIT, HTTP_STATUS, RETRYABLE_STATUS_CODES, RETRY_CONFIG, TIMEOUTS, SERVER_INFO, PREDICTION_QUEUE, ERROR_CODES;
+var init_constants = __esm({
+  "src/config/constants.ts"() {
+    "use strict";
+    API_BASE_URL = "https://api.ideogram.ai";
+    API_ENDPOINTS = {
+      /** V3 Generate endpoint */
+      GENERATE_V3: "/v1/ideogram-v3/generate",
+      /** Legacy Edit endpoint (inpainting only) */
+      EDIT_LEGACY: "/edit",
+      /** Legacy V2 Generate endpoint */
+      GENERATE_LEGACY: "/generate"
+    };
+    API_KEY_HEADER = "Api-Key";
+    DEFAULTS = {
+      /** Default aspect ratio */
+      ASPECT_RATIO: "1x1",
+      /** Default number of images to generate */
+      NUM_IMAGES: 1,
+      /** Default rendering speed */
+      RENDERING_SPEED: "DEFAULT",
+      /** Default magic prompt setting */
+      MAGIC_PROMPT: "AUTO",
+      /** Default style type */
+      STYLE_TYPE: "AUTO",
+      /** Default save locally option */
+      SAVE_LOCALLY: true
+    };
+    VALIDATION = {
+      /** Prompt constraints */
+      PROMPT: {
+        MIN_LENGTH: 1,
+        MAX_LENGTH: 1e4
+      },
+      /** Number of images constraints */
+      NUM_IMAGES: {
+        MIN: 1,
+        MAX: 8
+      },
+      /** Seed constraints */
+      SEED: {
+        MIN: 0,
+        MAX: 2147483647
+      },
+      /** Expand pixels constraints for outpainting */
+      EXPAND_PIXELS: {
+        MIN: 1,
+        MAX: 1024
+      },
+      /** Image file constraints */
+      IMAGE: {
+        /** Maximum file size in bytes (10MB) */
+        MAX_SIZE_BYTES: 10 * 1024 * 1024,
+        /** Supported image formats */
+        SUPPORTED_FORMATS: ["image/png", "image/jpeg", "image/webp"]
+      }
+    };
+    CREDITS_PER_IMAGE = {
+      FLASH: 0.04,
+      TURBO: 0.08,
+      DEFAULT: 0.1,
+      QUALITY: 0.2
+    };
+    EDIT_CREDITS_PER_IMAGE = {
+      FLASH: 0.06,
+      TURBO: 0.1,
+      DEFAULT: 0.12,
+      QUALITY: 0.24
+    };
+    USD_PER_CREDIT = 0.05;
+    HTTP_STATUS = {
+      OK: 200,
+      CREATED: 201,
+      BAD_REQUEST: 400,
+      UNAUTHORIZED: 401,
+      FORBIDDEN: 403,
+      NOT_FOUND: 404,
+      TOO_MANY_REQUESTS: 429,
+      INTERNAL_SERVER_ERROR: 500,
+      SERVICE_UNAVAILABLE: 503
+    };
+    RETRYABLE_STATUS_CODES = [
+      HTTP_STATUS.TOO_MANY_REQUESTS,
+      HTTP_STATUS.INTERNAL_SERVER_ERROR,
+      HTTP_STATUS.SERVICE_UNAVAILABLE
+    ];
+    RETRY_CONFIG = {
+      /** Maximum number of retry attempts */
+      MAX_ATTEMPTS: 3,
+      /** Initial delay in milliseconds */
+      INITIAL_DELAY_MS: 1e3,
+      /** Maximum delay in milliseconds */
+      MAX_DELAY_MS: 1e4,
+      /** Backoff multiplier for exponential backoff */
+      BACKOFF_MULTIPLIER: 2
+    };
+    TIMEOUTS = {
+      /** Default API request timeout */
+      DEFAULT_REQUEST_MS: 3e4,
+      /** Long-running request timeout (for quality rendering) */
+      LONG_REQUEST_MS: 12e4,
+      /** Image download timeout */
+      IMAGE_DOWNLOAD_MS: 6e4
+    };
+    SERVER_INFO = {
+      NAME: "ideogram-mcp-server",
+      VERSION: "1.0.0",
+      DESCRIPTION: "Production-grade Ideogram AI image generation MCP server"
+    };
+    PREDICTION_QUEUE = {
+      /** Maximum number of queued predictions */
+      MAX_QUEUE_SIZE: 100,
+      /** Prediction timeout in milliseconds */
+      PREDICTION_TIMEOUT_MS: 3e5,
+      /** Time before prediction records are cleaned up (24 hours) */
+      CLEANUP_AGE_MS: 24 * 60 * 60 * 1e3
+    };
+    ERROR_CODES = {
+      // Authentication errors
+      INVALID_API_KEY: "INVALID_API_KEY",
+      MISSING_API_KEY: "MISSING_API_KEY",
+      // Validation errors
+      VALIDATION_ERROR: "VALIDATION_ERROR",
+      INVALID_PROMPT: "INVALID_PROMPT",
+      INVALID_ASPECT_RATIO: "INVALID_ASPECT_RATIO",
+      INVALID_IMAGE: "INVALID_IMAGE",
+      INVALID_MASK: "INVALID_MASK",
+      IMAGE_TOO_LARGE: "IMAGE_TOO_LARGE",
+      // API errors
+      API_ERROR: "API_ERROR",
+      RATE_LIMITED: "RATE_LIMITED",
+      INSUFFICIENT_CREDITS: "INSUFFICIENT_CREDITS",
+      // Network errors
+      NETWORK_ERROR: "NETWORK_ERROR",
+      TIMEOUT: "TIMEOUT",
+      // Prediction errors
+      PREDICTION_NOT_FOUND: "PREDICTION_NOT_FOUND",
+      PREDICTION_ALREADY_COMPLETED: "PREDICTION_ALREADY_COMPLETED",
+      PREDICTION_FAILED: "PREDICTION_FAILED",
+      // Storage errors
+      STORAGE_ERROR: "STORAGE_ERROR",
+      DOWNLOAD_FAILED: "DOWNLOAD_FAILED",
+      // General errors
+      INTERNAL_ERROR: "INTERNAL_ERROR",
+      UNKNOWN_ERROR: "UNKNOWN_ERROR"
+    };
+  }
+});
+
+// src/utils/error.handler.ts
+function createInvalidApiKeyError(details) {
+  return new IdeogramMCPError(
+    ERROR_CODES.INVALID_API_KEY,
+    "Invalid or missing Ideogram API key",
+    "Your API key is invalid or has been revoked. Please check your IDEOGRAM_API_KEY environment variable and ensure it is a valid API key from https://ideogram.ai/manage-api",
+    HTTP_STATUS.UNAUTHORIZED,
+    false,
+    details
+  );
+}
+function createMissingApiKeyError() {
+  return new IdeogramMCPError(
+    ERROR_CODES.MISSING_API_KEY,
+    "Ideogram API key not configured",
+    "No API key found. Please set the IDEOGRAM_API_KEY environment variable with your API key from https://ideogram.ai/manage-api",
+    HTTP_STATUS.UNAUTHORIZED,
+    false
+  );
+}
+function createRateLimitError(retryAfterSeconds) {
+  const retryMessage = retryAfterSeconds ? ` Please wait ${retryAfterSeconds} seconds before retrying.` : " Please wait a moment and try again.";
+  return new IdeogramMCPError(
+    ERROR_CODES.RATE_LIMITED,
+    `Rate limit exceeded${retryAfterSeconds ? ` (retry after ${retryAfterSeconds}s)` : ""}`,
+    `Too many requests.${retryMessage}`,
+    HTTP_STATUS.TOO_MANY_REQUESTS,
+    true,
+    retryAfterSeconds ? { retry_after_seconds: retryAfterSeconds } : void 0
+  );
+}
+function createInsufficientCreditsError(requiredCredits, availableCredits) {
+  const details = {};
+  if (requiredCredits !== void 0) {
+    details["required_credits"] = requiredCredits;
+  }
+  if (availableCredits !== void 0) {
+    details["available_credits"] = availableCredits;
+  }
+  return new IdeogramMCPError(
+    ERROR_CODES.INSUFFICIENT_CREDITS,
+    "Insufficient credits to complete the request",
+    "You do not have enough credits to complete this request. Please purchase more credits at https://ideogram.ai",
+    HTTP_STATUS.FORBIDDEN,
+    false,
+    Object.keys(details).length > 0 ? details : void 0
+  );
+}
+function createInvalidImageError(reason) {
+  return new IdeogramMCPError(
+    ERROR_CODES.INVALID_IMAGE,
+    `Invalid image: ${reason}`,
+    `There was a problem with the provided image: ${reason}`,
+    HTTP_STATUS.BAD_REQUEST,
+    false,
+    { field: "image" }
+  );
+}
+function createImageTooLargeError(sizeBytes, maxSizeBytes) {
+  const sizeMB = (sizeBytes / (1024 * 1024)).toFixed(2);
+  const maxSizeMB = (maxSizeBytes / (1024 * 1024)).toFixed(0);
+  return new IdeogramMCPError(
+    ERROR_CODES.IMAGE_TOO_LARGE,
+    `Image size ${sizeMB}MB exceeds maximum ${maxSizeMB}MB`,
+    `The image is too large (${sizeMB}MB). Maximum allowed size is ${maxSizeMB}MB.`,
+    HTTP_STATUS.BAD_REQUEST,
+    false,
+    { size_bytes: sizeBytes, max_size_bytes: maxSizeBytes }
+  );
+}
+function createNetworkError(reason, originalError) {
+  return new IdeogramMCPError(
+    ERROR_CODES.NETWORK_ERROR,
+    `Network error: ${reason}`,
+    "A network error occurred. Please check your internet connection and try again.",
+    0,
+    true,
+    originalError ? { original_error: originalError.message } : void 0
+  );
+}
+function createTimeoutError(timeoutMs) {
+  return new IdeogramMCPError(
+    ERROR_CODES.TIMEOUT,
+    `Request timed out after ${timeoutMs}ms`,
+    "The request took too long to complete. Please try again.",
+    0,
+    true,
+    { timeout_ms: timeoutMs }
+  );
+}
+function createPredictionNotFoundError(predictionId) {
+  return new IdeogramMCPError(
+    ERROR_CODES.PREDICTION_NOT_FOUND,
+    `Prediction not found: ${predictionId}`,
+    "The requested prediction was not found. It may have expired or never existed.",
+    HTTP_STATUS.NOT_FOUND,
+    false,
+    { prediction_id: predictionId }
+  );
+}
+function createStorageError(operation, reason) {
+  return new IdeogramMCPError(
+    ERROR_CODES.STORAGE_ERROR,
+    `Storage error during ${operation}: ${reason}`,
+    `Failed to save image: ${reason}`,
+    0,
+    true,
+    { operation }
+  );
+}
+function createDownloadFailedError(url, reason) {
+  return new IdeogramMCPError(
+    ERROR_CODES.DOWNLOAD_FAILED,
+    `Failed to download image from ${url}: ${reason}`,
+    "Failed to download the generated image. The URL may have expired.",
+    0,
+    true,
+    { url }
+  );
+}
+function createInternalError(reason, details) {
+  return new IdeogramMCPError(
+    ERROR_CODES.INTERNAL_ERROR,
+    `Internal error: ${reason}`,
+    "An unexpected error occurred. Please try again.",
+    HTTP_STATUS.INTERNAL_SERVER_ERROR,
+    true,
+    details
+  );
+}
+function createApiError(statusCode, message, details) {
+  const retryable = RETRYABLE_STATUS_CODES.includes(statusCode);
+  return new IdeogramMCPError(
+    ERROR_CODES.API_ERROR,
+    `API error (${statusCode}): ${message}`,
+    getApiErrorUserMessage(statusCode, message),
+    statusCode,
+    retryable,
+    details
+  );
+}
+function fromApiErrorResponse(statusCode, response) {
+  if (statusCode === HTTP_STATUS.UNAUTHORIZED) {
+    return createInvalidApiKeyError(response.details);
+  }
+  if (statusCode === HTTP_STATUS.TOO_MANY_REQUESTS) {
+    return createRateLimitError();
+  }
+  if (statusCode === HTTP_STATUS.FORBIDDEN) {
+    if (response.message.toLowerCase().includes("credit") || response.message.toLowerCase().includes("balance")) {
+      return createInsufficientCreditsError();
+    }
+  }
+  return createApiError(statusCode, response.message, response.details);
+}
+function fromAxiosError(error) {
+  if (!error.response) {
+    if (error.code === "ECONNABORTED" || error.code === "ETIMEDOUT") {
+      return createTimeoutError(3e4);
+    }
+    return createNetworkError(error.message);
+  }
+  const { status, data } = error.response;
+  if (data && typeof data === "object" && "message" in data) {
+    return fromApiErrorResponse(status, data);
+  }
+  const message = typeof data === "string" ? data : error.message;
+  return createApiError(status, message);
+}
+function wrapError(error) {
+  if (error instanceof IdeogramMCPError) {
+    return error;
+  }
+  if (error instanceof Error) {
+    return createInternalError(error.message, { original_error: error.name });
+  }
+  if (typeof error === "string") {
+    return createInternalError(error);
+  }
+  return createInternalError("An unknown error occurred");
+}
+function isIdeogramMCPError(error) {
+  return error instanceof IdeogramMCPError;
+}
+function isRetryableError(error) {
+  if (isIdeogramMCPError(error)) {
+    return error.retryable;
+  }
+  return false;
+}
+function getApiErrorUserMessage(statusCode, apiMessage) {
+  switch (statusCode) {
+    case HTTP_STATUS.BAD_REQUEST:
+      return `Invalid request: ${apiMessage}`;
+    case HTTP_STATUS.UNAUTHORIZED:
+      return "Authentication failed. Please check your API key.";
+    case HTTP_STATUS.FORBIDDEN:
+      return "Access denied. You may not have permission for this operation.";
+    case HTTP_STATUS.NOT_FOUND:
+      return "The requested resource was not found.";
+    case HTTP_STATUS.TOO_MANY_REQUESTS:
+      return "Too many requests. Please wait before trying again.";
+    case HTTP_STATUS.INTERNAL_SERVER_ERROR:
+      return "The Ideogram API encountered an error. Please try again.";
+    case HTTP_STATUS.SERVICE_UNAVAILABLE:
+      return "The Ideogram API is temporarily unavailable. Please try again later.";
+    default:
+      return `An error occurred: ${apiMessage}`;
+  }
+}
+function extractRetryAfter(headers) {
+  if (!headers)
+    return void 0;
+  const retryAfter = headers["retry-after"] || headers["Retry-After"];
+  if (!retryAfter)
+    return void 0;
+  const seconds = parseInt(retryAfter, 10);
+  if (!isNaN(seconds))
+    return seconds;
+  const date = new Date(retryAfter);
+  if (!isNaN(date.getTime())) {
+    const nowMs = Date.now();
+    const retryMs = date.getTime();
+    return Math.max(0, Math.ceil((retryMs - nowMs) / 1e3));
+  }
+  return void 0;
+}
+var IdeogramMCPError;
+var init_error_handler = __esm({
+  "src/utils/error.handler.ts"() {
+    "use strict";
+    init_constants();
+    IdeogramMCPError = class _IdeogramMCPError extends Error {
+      /**
+       * Creates a new IdeogramMCPError instance.
+       *
+       * @param code - Error code for programmatic handling
+       * @param message - Technical error message for debugging
+       * @param userMessage - User-friendly message suitable for display
+       * @param statusCode - HTTP status code (or 0 for non-HTTP errors)
+       * @param retryable - Whether the operation can be safely retried
+       * @param details - Additional error context for debugging
+       */
+      constructor(code, message, userMessage, statusCode, retryable, details) {
+        super(message);
+        this.code = code;
+        this.userMessage = userMessage;
+        this.statusCode = statusCode;
+        this.retryable = retryable;
+        this.details = details;
+        Object.setPrototypeOf(this, _IdeogramMCPError.prototype);
+        if (Error.captureStackTrace) {
+          Error.captureStackTrace(this, _IdeogramMCPError);
+        }
+      }
+      /**
+       * The error name for stack traces
+       */
+      name = "IdeogramMCPError";
+      /**
+       * Converts the error to a ToolErrorOutput format for MCP tool responses.
+       */
+      toToolError() {
+        const base = {
+          success: false,
+          error_code: this.code,
+          error: this.message,
+          user_message: this.userMessage,
+          retryable: this.retryable
+        };
+        if (this.details !== void 0) {
+          return { ...base, details: this.details };
+        }
+        return base;
+      }
+      /**
+       * Creates a JSON-serializable representation of the error.
+       */
+      toJSON() {
+        return {
+          name: this.name,
+          code: this.code,
+          message: this.message,
+          userMessage: this.userMessage,
+          statusCode: this.statusCode,
+          retryable: this.retryable,
+          details: this.details,
+          stack: this.stack
+        };
+      }
+    };
+  }
+});
+
+// src/config/config.ts
+import { config as dotenvConfig } from "dotenv";
+import { z } from "zod";
+function parseBoolean(value, defaultValue) {
+  if (value === void 0 || value === "") {
+    return defaultValue;
+  }
+  const normalized = value.toLowerCase().trim();
+  if (["true", "1", "yes", "on"].includes(normalized)) {
+    return true;
+  }
+  if (["false", "0", "no", "off"].includes(normalized)) {
+    return false;
+  }
+  return defaultValue;
+}
+function parseInteger(value, defaultValue) {
+  if (value === void 0 || value === "") {
+    return defaultValue;
+  }
+  const parsed = parseInt(value, 10);
+  if (Number.isNaN(parsed)) {
+    return defaultValue;
+  }
+  return parsed;
+}
+function loadConfig() {
+  const result = ConfigSchema.safeParse(rawConfig);
+  if (!result.success) {
+    const errorMessages = result.error.issues.map((issue) => {
+      const path2 = issue.path.join(".");
+      return `  - ${path2}: ${issue.message}`;
+    }).join("\n");
+    throw new Error(
+      `Configuration validation failed:
+${errorMessages}
+
+Please check your environment variables or .env file.`
+    );
+  }
+  return result.data;
+}
+function isConfigValid() {
+  return ConfigSchema.safeParse(rawConfig).success;
+}
+function getConfigErrors() {
+  const result = ConfigSchema.safeParse(rawConfig);
+  if (result.success) {
+    return [];
+  }
+  return result.error.issues.map((issue) => {
+    const path2 = issue.path.join(".");
+    return `${path2}: ${issue.message}`;
+  });
+}
+var LOG_LEVELS, ConfigSchema, rawConfig, config;
+var init_config = __esm({
+  "src/config/config.ts"() {
+    "use strict";
+    init_constants();
+    dotenvConfig();
+    LOG_LEVELS = ["debug", "info", "warn", "error"];
+    ConfigSchema = z.object({
+      /**
+       * Ideogram API key (required)
+       */
+      ideogramApiKey: z.string({
+        required_error: "IDEOGRAM_API_KEY is required. Get your API key from https://ideogram.ai/manage-api"
+      }).min(1, {
+        message: "IDEOGRAM_API_KEY cannot be empty. Get your API key from https://ideogram.ai/manage-api"
+      }),
+      /**
+       * Logging level
+       */
+      logLevel: z.enum(LOG_LEVELS).default("info"),
+      /**
+       * Directory for local image storage
+       */
+      localSaveDir: z.string().default("./ideogram_images"),
+      /**
+       * Enable automatic local saving of images
+       */
+      enableLocalSave: z.boolean().default(true),
+      /**
+       * Maximum concurrent API requests
+       */
+      maxConcurrentRequests: z.number().int().min(1, { message: "MAX_CONCURRENT_REQUESTS must be at least 1" }).max(10, {
+        message: "MAX_CONCURRENT_REQUESTS cannot exceed 10 to prevent rate limiting"
+      }).default(3),
+      /**
+       * API request timeout in milliseconds
+       */
+      requestTimeoutMs: z.number().int().min(1e3, { message: "REQUEST_TIMEOUT_MS must be at least 1000ms" }).max(3e5, { message: "REQUEST_TIMEOUT_MS cannot exceed 300000ms (5 minutes)" }).default(TIMEOUTS.DEFAULT_REQUEST_MS)
+    });
+    rawConfig = {
+      ideogramApiKey: process.env["IDEOGRAM_API_KEY"],
+      logLevel: process.env["LOG_LEVEL"],
+      localSaveDir: process.env["LOCAL_SAVE_DIR"],
+      enableLocalSave: parseBoolean(process.env["ENABLE_LOCAL_SAVE"], DEFAULTS.SAVE_LOCALLY),
+      maxConcurrentRequests: parseInteger(process.env["MAX_CONCURRENT_REQUESTS"], 3),
+      requestTimeoutMs: parseInteger(
+        process.env["REQUEST_TIMEOUT_MS"],
+        TIMEOUTS.DEFAULT_REQUEST_MS
+      )
+    };
+    config = loadConfig();
+  }
+});
+
+// src/utils/logger.ts
+import { pino } from "pino";
+function isDevelopment() {
+  const nodeEnv = process.env["NODE_ENV"];
+  return nodeEnv === "development" || nodeEnv === void 0;
+}
+function shouldPrettyPrint() {
+  const prettyPrint = process.env["LOG_PRETTY"];
+  if (prettyPrint === "true" || prettyPrint === "1") {
+    return true;
+  }
+  if (prettyPrint === "false" || prettyPrint === "0") {
+    return false;
+  }
+  return isDevelopment();
+}
+function createLoggerOptions() {
+  const level = LOG_LEVEL_MAP[config.logLevel];
+  const baseOptions = {
+    name: SERVER_INFO.NAME,
+    level,
+    // Base context included in all log entries
+    base: {
+      service: SERVER_INFO.NAME,
+      version: SERVER_INFO.VERSION
+    },
+    // Custom timestamp format
+    timestamp: pino.stdTimeFunctions.isoTime,
+    // Customize error serialization
+    serializers: {
+      err: pino.stdSerializers.err,
+      error: pino.stdSerializers.err,
+      req: serializeRequest,
+      res: serializeResponse
+    },
+    // Format options for structured output
+    formatters: {
+      level: (label) => ({ level: label }),
+      bindings: (bindings) => ({
+        pid: bindings["pid"],
+        hostname: bindings["hostname"],
+        service: bindings["service"],
+        version: bindings["version"]
+      })
+    }
+  };
+  if (shouldPrettyPrint()) {
+    return {
+      ...baseOptions,
+      transport: {
+        target: "pino-pretty",
+        options: {
+          colorize: true,
+          translateTime: "SYS:standard",
+          ignore: "pid,hostname"
+        }
+      }
+    };
+  }
+  return baseOptions;
+}
+function serializeRequest(req) {
+  if (!req || typeof req !== "object") {
+    return {};
+  }
+  const serialized = {};
+  if ("method" in req)
+    serialized["method"] = req["method"];
+  if ("url" in req)
+    serialized["url"] = req["url"];
+  if ("endpoint" in req)
+    serialized["endpoint"] = req["endpoint"];
+  if ("headers" in req && typeof req["headers"] === "object" && req["headers"] !== null) {
+    const headers = req["headers"];
+    const sanitizedHeaders = {};
+    for (const [key, value] of Object.entries(headers)) {
+      const lowerKey = key.toLowerCase();
+      if (lowerKey === "authorization" || lowerKey === "api-key" || lowerKey === "x-api-key" || lowerKey === "cookie") {
+        sanitizedHeaders[key] = "[REDACTED]";
+      } else {
+        sanitizedHeaders[key] = value;
+      }
+    }
+    serialized["headers"] = sanitizedHeaders;
+  }
+  return serialized;
+}
+function serializeResponse(res) {
+  if (!res || typeof res !== "object") {
+    return {};
+  }
+  const serialized = {};
+  if ("status" in res)
+    serialized["status"] = res["status"];
+  if ("statusCode" in res)
+    serialized["statusCode"] = res["statusCode"];
+  if ("duration" in res)
+    serialized["duration"] = res["duration"];
+  return serialized;
+}
+function createChildLogger(component) {
+  return logger.child({ component });
+}
+function logApiRequest(log, context) {
+  log.debug(
+    {
+      req: {
+        method: context.method,
+        endpoint: context.endpoint
+      },
+      hasImage: context.hasImage,
+      hasMask: context.hasMask
+    },
+    "Ideogram API request"
+  );
+}
+function logApiResponse(log, context) {
+  const level = context.statusCode >= 400 ? "warn" : "debug";
+  log[level](
+    {
+      res: {
+        statusCode: context.statusCode,
+        duration: context.durationMs
+      },
+      endpoint: context.endpoint,
+      imageCount: context.imageCount
+    },
+    "Ideogram API response"
+  );
+}
+function logToolInvocation(log, context) {
+  const sanitizedParams = sanitizeToolParams(context.params);
+  log.info(
+    { tool: context.tool, params: sanitizedParams },
+    "Tool invoked"
+  );
+}
+function logToolResult(log, context) {
+  const level = context.success ? "info" : "warn";
+  log[level](
+    {
+      tool: context.tool,
+      success: context.success,
+      durationMs: context.durationMs,
+      errorCode: context.errorCode
+    },
+    context.success ? "Tool completed" : "Tool failed"
+  );
+}
+function logError(log, error, message, context) {
+  if (error instanceof Error) {
+    log.error(
+      {
+        err: error,
+        ...context
+      },
+      message
+    );
+  } else {
+    log.error(
+      {
+        error: String(error),
+        ...context
+      },
+      message
+    );
+  }
+}
+function sanitizeToolParams(params) {
+  const sanitized = {};
+  const maxStringLength = 200;
+  for (const [key, value] of Object.entries(params)) {
+    const lowerKey = key.toLowerCase();
+    if (lowerKey.includes("key") || lowerKey.includes("secret") || lowerKey.includes("token") || lowerKey.includes("password")) {
+      sanitized[key] = "[REDACTED]";
+      continue;
+    }
+    if (typeof value === "string" && value.length > maxStringLength) {
+      sanitized[key] = `${value.substring(0, maxStringLength)}... (${value.length} chars)`;
+      continue;
+    }
+    sanitized[key] = value;
+  }
+  return sanitized;
+}
+var LOG_LEVEL_MAP, logger;
+var init_logger = __esm({
+  "src/utils/logger.ts"() {
+    "use strict";
+    init_config();
+    init_constants();
+    LOG_LEVEL_MAP = {
+      debug: "debug",
+      info: "info",
+      warn: "warn",
+      error: "error"
+    };
+    logger = pino(createLoggerOptions());
+  }
+});
+
+// src/services/prediction.store.ts
+import { randomUUID } from "crypto";
+function createPredictionStore(options) {
+  return new PredictionStore(options);
+}
+function formatPredictionStatus(status) {
+  const statusLabels = {
+    queued: "Queued",
+    processing: "Processing",
+    completed: "Completed",
+    failed: "Failed",
+    cancelled: "Cancelled"
+  };
+  return statusLabels[status];
+}
+var PredictionStore;
+var init_prediction_store = __esm({
+  "src/services/prediction.store.ts"() {
+    "use strict";
+    init_constants();
+    init_error_handler();
+    init_logger();
+    PredictionStore = class {
+      predictions = /* @__PURE__ */ new Map();
+      maxQueueSize;
+      predictionTimeoutMs;
+      cleanupAgeMs;
+      enableAutoCleanup;
+      cleanupIntervalMs;
+      log;
+      cleanupTimer = null;
+      processor = null;
+      processingQueue = false;
+      /**
+       * Creates a new PredictionStore instance.
+       *
+       * @param options - Store configuration options
+       */
+      constructor(options = {}) {
+        this.maxQueueSize = options.maxQueueSize ?? PREDICTION_QUEUE.MAX_QUEUE_SIZE;
+        this.predictionTimeoutMs = options.predictionTimeoutMs ?? PREDICTION_QUEUE.PREDICTION_TIMEOUT_MS;
+        this.cleanupAgeMs = options.cleanupAgeMs ?? PREDICTION_QUEUE.CLEANUP_AGE_MS;
+        this.enableAutoCleanup = options.enableAutoCleanup ?? true;
+        this.cleanupIntervalMs = options.cleanupIntervalMs ?? 60 * 60 * 1e3;
+        this.log = options.logger ?? createChildLogger("prediction-store");
+        if (this.enableAutoCleanup) {
+          this.startAutoCleanup();
+        }
+        this.log.debug(
+          {
+            maxQueueSize: this.maxQueueSize,
+            predictionTimeoutMs: this.predictionTimeoutMs,
+            cleanupAgeMs: this.cleanupAgeMs
+          },
+          "PredictionStore initialized"
+        );
+      }
+      // ===========================================================================
+      // Public Methods - CRUD Operations
+      // ===========================================================================
+      /**
+       * Creates a new prediction and adds it to the queue.
+       *
+       * @param options - Prediction creation options
+       * @returns The created prediction
+       * @throws {IdeogramMCPError} If the queue is full
+       *
+       * @example
+       * ```typescript
+       * const prediction = store.create({
+       *   request: {
+       *     prompt: 'A serene mountain landscape',
+       *     num_images: 2,
+       *   },
+       *   type: 'generate',
+       * });
+       * console.log(`Prediction ID: ${prediction.id}`);
+       * ```
+       */
+      create(options) {
+        const queuedCount = this.getQueuedCount();
+        if (queuedCount >= this.maxQueueSize) {
+          throw createInternalError(
+            `Queue is full (max ${this.maxQueueSize} predictions). Try again later.`
+          );
+        }
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        const id = this.generatePredictionId();
+        const prediction = {
+          id,
+          status: "queued",
+          request: options.request,
+          type: options.type,
+          created_at: now,
+          progress: 0,
+          eta_seconds: this.estimateEta(options.request)
+        };
+        this.predictions.set(id, prediction);
+        this.log.info(
+          { predictionId: id, type: options.type },
+          "Prediction created and queued"
+        );
+        this.processNextIfIdle();
+        return prediction;
+      }
+      /**
+       * Gets a prediction by ID.
+       *
+       * @param id - The prediction ID
+       * @returns The prediction or undefined if not found
+       *
+       * @example
+       * ```typescript
+       * const prediction = store.get('pred_abc123');
+       * if (prediction) {
+       *   console.log(`Status: ${prediction.status}`);
+       * }
+       * ```
+       */
+      get(id) {
+        return this.predictions.get(id);
+      }
+      /**
+       * Gets a prediction by ID, throwing an error if not found.
+       *
+       * @param id - The prediction ID
+       * @returns The prediction
+       * @throws {IdeogramMCPError} If the prediction is not found
+       */
+      getOrThrow(id) {
+        const prediction = this.get(id);
+        if (!prediction) {
+          throw createPredictionNotFoundError(id);
+        }
+        return prediction;
+      }
+      /**
+       * Updates a prediction with new data.
+       *
+       * @param id - The prediction ID
+       * @param updates - Fields to update
+       * @returns The updated prediction
+       * @throws {IdeogramMCPError} If the prediction is not found
+       *
+       * @example
+       * ```typescript
+       * const updated = store.update('pred_abc123', {
+       *   status: 'processing',
+       *   progress: 50,
+       *   etaSeconds: 15,
+       * });
+       * ```
+       */
+      update(id, updates) {
+        const prediction = this.getOrThrow(id);
+        if (updates.status !== void 0) {
+          prediction.status = updates.status;
+          if (updates.status === "processing" && !prediction.started_at) {
+            prediction.started_at = (/* @__PURE__ */ new Date()).toISOString();
+          }
+          if (updates.status === "completed" || updates.status === "failed" || updates.status === "cancelled") {
+            prediction.completed_at = (/* @__PURE__ */ new Date()).toISOString();
+          }
+        }
+        if (updates.progress !== void 0) {
+          prediction.progress = Math.min(100, Math.max(0, updates.progress));
+        }
+        if (updates.etaSeconds !== void 0) {
+          prediction.eta_seconds = updates.etaSeconds;
+        }
+        if (updates.result !== void 0) {
+          prediction.result = updates.result;
+          prediction.status = "completed";
+          prediction.progress = 100;
+          prediction.eta_seconds = 0;
+          prediction.completed_at = (/* @__PURE__ */ new Date()).toISOString();
+        }
+        if (updates.error !== void 0) {
+          prediction.error = updates.error;
+          prediction.status = "failed";
+          prediction.completed_at = (/* @__PURE__ */ new Date()).toISOString();
+        }
+        this.predictions.set(id, prediction);
+        this.log.debug(
+          { predictionId: id, status: prediction.status, progress: prediction.progress },
+          "Prediction updated"
+        );
+        return prediction;
+      }
+      /**
+       * Marks a prediction as processing.
+       *
+       * @param id - The prediction ID
+       * @returns The updated prediction
+       */
+      markProcessing(id) {
+        return this.update(id, { status: "processing", progress: 10 });
+      }
+      /**
+       * Marks a prediction as completed with results.
+       *
+       * @param id - The prediction ID
+       * @param result - The generation/edit result
+       * @returns The updated prediction
+       */
+      markCompleted(id, result) {
+        const prediction = this.update(id, { result });
+        this.log.info(
+          { predictionId: id, imageCount: result.data.length },
+          "Prediction completed successfully"
+        );
+        this.processNextIfIdle();
+        return prediction;
+      }
+      /**
+       * Marks a prediction as failed with error information.
+       *
+       * @param id - The prediction ID
+       * @param error - Error information
+       * @returns The updated prediction
+       */
+      markFailed(id, error) {
+        const prediction = this.update(id, { error });
+        this.log.warn(
+          { predictionId: id, errorCode: error.code, errorMessage: error.message },
+          "Prediction failed"
+        );
+        this.processNextIfIdle();
+        return prediction;
+      }
+      /**
+       * Cancels a prediction if it's still queued.
+       * Predictions already processing or completed cannot be cancelled.
+       *
+       * @param id - The prediction ID
+       * @returns Object indicating success and current status
+       * @throws {IdeogramMCPError} If the prediction is not found
+       *
+       * @example
+       * ```typescript
+       * const result = store.cancel('pred_abc123');
+       * if (result.success) {
+       *   console.log('Prediction cancelled');
+       * } else {
+       *   console.log(`Cannot cancel: ${result.status}`);
+       * }
+       * ```
+       */
+      cancel(id) {
+        const prediction = this.getOrThrow(id);
+        if (prediction.status !== "queued") {
+          const statusMessages = {
+            queued: "Prediction is queued",
+            processing: "Prediction is already being processed by the Ideogram API",
+            completed: "Prediction has already completed",
+            failed: "Prediction has already failed",
+            cancelled: "Prediction was already cancelled"
+          };
+          return {
+            success: false,
+            status: prediction.status,
+            message: statusMessages[prediction.status]
+          };
+        }
+        prediction.status = "cancelled";
+        prediction.completed_at = (/* @__PURE__ */ new Date()).toISOString();
+        this.predictions.set(id, prediction);
+        this.log.info({ predictionId: id }, "Prediction cancelled");
+        return {
+          success: true,
+          status: "cancelled",
+          message: "Prediction successfully cancelled"
+        };
+      }
+      /**
+       * Deletes a prediction from the store.
+       *
+       * @param id - The prediction ID
+       * @returns True if deleted, false if not found
+       */
+      delete(id) {
+        const existed = this.predictions.has(id);
+        this.predictions.delete(id);
+        if (existed) {
+          this.log.debug({ predictionId: id }, "Prediction deleted");
+        }
+        return existed;
+      }
+      // ===========================================================================
+      // Public Methods - Query Operations
+      // ===========================================================================
+      /**
+       * Gets all predictions.
+       *
+       * @returns Array of all predictions
+       */
+      getAll() {
+        return Array.from(this.predictions.values());
+      }
+      /**
+       * Gets predictions by status.
+       *
+       * @param status - The status to filter by
+       * @returns Array of matching predictions
+       */
+      getByStatus(status) {
+        return this.getAll().filter((p) => p.status === status);
+      }
+      /**
+       * Gets the next queued prediction (FIFO).
+       *
+       * @returns The oldest queued prediction or undefined
+       */
+      getNextQueued() {
+        const queued = this.getByStatus("queued");
+        if (queued.length === 0) {
+          return void 0;
+        }
+        return queued.sort(
+          (a, b) => new Date(a.created_at).getTime() - new Date(b.created_at).getTime()
+        )[0];
+      }
+      /**
+       * Gets store statistics.
+       *
+       * @returns Statistics about the store contents
+       *
+       * @example
+       * ```typescript
+       * const stats = store.getStats();
+       * console.log(`Queued: ${stats.queued}, Processing: ${stats.processing}`);
+       * ```
+       */
+      getStats() {
+        const all = this.getAll();
+        return {
+          total: all.length,
+          queued: all.filter((p) => p.status === "queued").length,
+          processing: all.filter((p) => p.status === "processing").length,
+          completed: all.filter((p) => p.status === "completed").length,
+          failed: all.filter((p) => p.status === "failed").length,
+          cancelled: all.filter((p) => p.status === "cancelled").length
+        };
+      }
+      /**
+       * Checks if a prediction exists.
+       *
+       * @param id - The prediction ID
+       * @returns True if the prediction exists
+       */
+      has(id) {
+        return this.predictions.has(id);
+      }
+      /**
+       * Gets the count of queued predictions.
+       */
+      getQueuedCount() {
+        return this.getByStatus("queued").length;
+      }
+      /**
+       * Gets the count of processing predictions.
+       */
+      getProcessingCount() {
+        return this.getByStatus("processing").length;
+      }
+      // ===========================================================================
+      // Public Methods - Processing
+      // ===========================================================================
+      /**
+       * Registers a processor function for handling predictions.
+       * When a processor is registered, queued predictions will be processed automatically.
+       *
+       * @param processor - Function that processes a prediction and returns the result
+       *
+       * @example
+       * ```typescript
+       * store.setProcessor(async (prediction) => {
+       *   // Call Ideogram API here
+       *   return await client.generate(prediction.request);
+       * });
+       * ```
+       */
+      setProcessor(processor) {
+        this.processor = processor;
+        this.log.debug("Processor registered");
+        this.processNextIfIdle();
+      }
+      /**
+       * Processes the next queued prediction if one is available and not already processing.
+       * This is called automatically when predictions are created or completed.
+       */
+      async processNextIfIdle() {
+        if (!this.processor || this.processingQueue) {
+          return;
+        }
+        const next = this.getNextQueued();
+        if (!next) {
+          return;
+        }
+        this.processingQueue = true;
+        try {
+          await this.processOne(next);
+        } finally {
+          this.processingQueue = false;
+          if (this.getQueuedCount() > 0) {
+            setImmediate(() => this.processNextIfIdle());
+          }
+        }
+      }
+      // ===========================================================================
+      // Public Methods - Cleanup
+      // ===========================================================================
+      /**
+       * Cleans up old completed/failed/cancelled predictions.
+       *
+       * @returns Number of predictions removed
+       */
+      cleanup() {
+        const now = Date.now();
+        const cutoff = now - this.cleanupAgeMs;
+        let removed = 0;
+        for (const [id, prediction] of this.predictions) {
+          if (prediction.status !== "completed" && prediction.status !== "failed" && prediction.status !== "cancelled") {
+            continue;
+          }
+          const completedAt = prediction.completed_at ? new Date(prediction.completed_at).getTime() : 0;
+          if (completedAt < cutoff) {
+            this.predictions.delete(id);
+            removed++;
+          }
+        }
+        if (removed > 0) {
+          this.log.info({ removedCount: removed }, "Cleaned up old predictions");
+        }
+        return removed;
+      }
+      /**
+       * Clears all predictions from the store.
+       */
+      clear() {
+        const count = this.predictions.size;
+        this.predictions.clear();
+        this.log.info({ count }, "All predictions cleared");
+      }
+      /**
+       * Stops the automatic cleanup timer.
+       */
+      stopAutoCleanup() {
+        if (this.cleanupTimer) {
+          clearInterval(this.cleanupTimer);
+          this.cleanupTimer = null;
+          this.log.debug("Auto cleanup stopped");
+        }
+      }
+      /**
+       * Disposes the store, stopping timers and clearing data.
+       */
+      dispose() {
+        this.stopAutoCleanup();
+        this.clear();
+        this.processor = null;
+        this.log.debug("PredictionStore disposed");
+      }
+      // ===========================================================================
+      // Private Methods
+      // ===========================================================================
+      /**
+       * Generates a unique prediction ID.
+       */
+      generatePredictionId() {
+        return `pred_${randomUUID().replace(/-/g, "").slice(0, 16)}`;
+      }
+      /**
+       * Estimates the ETA for a prediction based on request parameters.
+       */
+      estimateEta(request) {
+        let eta = 30;
+        const numImages = request.num_images ?? 1;
+        eta += (numImages - 1) * 10;
+        const renderingSpeed = request.rendering_speed ?? "DEFAULT";
+        const speedMultipliers = {
+          FLASH: 0.5,
+          TURBO: 0.75,
+          DEFAULT: 1,
+          QUALITY: 2
+        };
+        eta *= speedMultipliers[renderingSpeed] ?? 1;
+        return Math.round(eta);
+      }
+      /**
+       * Processes a single prediction.
+       */
+      async processOne(prediction) {
+        if (!this.processor) {
+          return;
+        }
+        const { id } = prediction;
+        try {
+          this.markProcessing(id);
+          const progressInterval = setInterval(() => {
+            const current = this.get(id);
+            if (current && current.status === "processing" && (current.progress ?? 0) < 90) {
+              this.update(id, { progress: (current.progress ?? 0) + 20 });
+            }
+          }, 5e3);
+          try {
+            const result = await this.processor(prediction);
+            this.markCompleted(id, result);
+          } finally {
+            clearInterval(progressInterval);
+          }
+        } catch (error) {
+          const errorInfo = this.extractErrorInfo(error);
+          this.markFailed(id, errorInfo);
+        }
+      }
+      /**
+       * Extracts error information from an unknown error.
+       */
+      extractErrorInfo(error) {
+        if (error instanceof IdeogramMCPError) {
+          return {
+            code: error.code,
+            message: error.userMessage,
+            retryable: error.retryable
+          };
+        }
+        if (error instanceof Error) {
+          return {
+            code: "PROCESSING_ERROR",
+            message: error.message,
+            retryable: false
+          };
+        }
+        return {
+          code: "UNKNOWN_ERROR",
+          message: "An unexpected error occurred",
+          retryable: false
+        };
+      }
+      /**
+       * Starts the automatic cleanup timer.
+       */
+      startAutoCleanup() {
+        this.cleanupTimer = setInterval(() => {
+          this.cleanup();
+        }, this.cleanupIntervalMs);
+        if (this.cleanupTimer.unref) {
+          this.cleanupTimer.unref();
+        }
+        this.log.debug(
+          { intervalMs: this.cleanupIntervalMs },
+          "Auto cleanup started"
+        );
+      }
+    };
+  }
+});
+
+// src/types/tool.types.ts
+import { z as z2 } from "zod";
+var AspectRatioSchema, RenderingSpeedSchema, MagicPromptSchema, StyleTypeSchema, ModelSchema, PredictionStatusSchema, GenerateInputSchema, GenerateAsyncInputSchema, EditInputSchema, GetPredictionInputSchema, CancelPredictionInputSchema;
+var init_tool_types = __esm({
+  "src/types/tool.types.ts"() {
+    "use strict";
+    AspectRatioSchema = z2.enum([
+      "1x1",
+      "16x9",
+      "9x16",
+      "4x3",
+      "3x4",
+      "3x2",
+      "2x3",
+      "4x5",
+      "5x4",
+      "1x2",
+      "2x1",
+      "1x3",
+      "3x1",
+      "10x16",
+      "16x10"
+    ]);
+    RenderingSpeedSchema = z2.enum([
+      "FLASH",
+      "TURBO",
+      "DEFAULT",
+      "QUALITY"
+    ]);
+    MagicPromptSchema = z2.enum(["AUTO", "ON", "OFF"]);
+    StyleTypeSchema = z2.enum([
+      "AUTO",
+      "GENERAL",
+      "REALISTIC",
+      "DESIGN",
+      "FICTION",
+      "RENDER_3D",
+      "ANIME"
+    ]);
+    ModelSchema = z2.enum(["V_2", "V_2_TURBO"]);
+    PredictionStatusSchema = z2.enum([
+      "queued",
+      "processing",
+      "completed",
+      "failed",
+      "cancelled"
+    ]);
+    GenerateInputSchema = z2.object({
+      /** Text prompt describing the desired image (1-10000 characters) */
+      prompt: z2.string().min(1, "Prompt is required").max(1e4, "Prompt must be 10000 characters or less"),
+      /** Negative prompt to guide what not to include */
+      negative_prompt: z2.string().max(1e4, "Negative prompt must be 10000 characters or less").optional(),
+      /** Aspect ratio for the generated image */
+      aspect_ratio: AspectRatioSchema.optional().default("1x1"),
+      /** Number of images to generate (1-8) */
+      num_images: z2.number().int("Number of images must be an integer").min(1, "Must generate at least 1 image").max(8, "Cannot generate more than 8 images").optional().default(1),
+      /** Random seed for reproducible generation (0-2147483647) */
+      seed: z2.number().int("Seed must be an integer").min(0, "Seed must be non-negative").max(2147483647, "Seed must be at most 2147483647").optional(),
+      /** Rendering speed/quality tradeoff */
+      rendering_speed: RenderingSpeedSchema.optional().default("DEFAULT"),
+      /** Magic prompt enhancement option */
+      magic_prompt: MagicPromptSchema.optional().default("AUTO"),
+      /** Style type for the image */
+      style_type: StyleTypeSchema.optional().default("AUTO"),
+      /** Whether to save generated images locally */
+      save_locally: z2.boolean().optional().default(true)
+    });
+    GenerateAsyncInputSchema = GenerateInputSchema.extend({
+      /** Optional webhook URL for completion notification (reserved for future use) */
+      webhook_url: z2.string().url("Invalid webhook URL").optional()
+    });
+    EditInputSchema = z2.object({
+      /** Text prompt describing the desired changes */
+      prompt: z2.string().min(1, "Prompt is required").max(1e4, "Prompt must be 10000 characters or less"),
+      /** Source image: URL, file path, or base64 data URL */
+      image: z2.string().min(1, "Image is required"),
+      /**
+       * Mask image for inpainting: black=edit, white=preserve
+       * REQUIRED for inpainting
+       */
+      mask: z2.string().min(1, "Mask is required"),
+      /** Model to use for editing (V_2 or V_2_TURBO) */
+      model: ModelSchema.optional().default("V_2"),
+      /** Number of images to generate (1-8) */
+      num_images: z2.number().int("Number of images must be an integer").min(1, "Must generate at least 1 image").max(8, "Cannot generate more than 8 images").optional().default(1),
+      /** Random seed for reproducible generation (0-2147483647) */
+      seed: z2.number().int("Seed must be an integer").min(0, "Seed must be non-negative").max(2147483647, "Seed must be at most 2147483647").optional(),
+      /** Magic prompt enhancement option */
+      magic_prompt: MagicPromptSchema.optional().default("AUTO"),
+      /** Style type for the image */
+      style_type: StyleTypeSchema.optional().default("AUTO"),
+      /** Whether to save generated images locally */
+      save_locally: z2.boolean().optional().default(true)
+    });
+    GetPredictionInputSchema = z2.object({
+      /** Unique prediction ID returned from ideogram_generate_async */
+      prediction_id: z2.string().min(1, "Prediction ID is required")
+    });
+    CancelPredictionInputSchema = z2.object({
+      /** Unique prediction ID to cancel */
+      prediction_id: z2.string().min(1, "Prediction ID is required")
+    });
+  }
+});
+
+// src/utils/retry.ts
+function exponentialBackoff(attempt, options = {}) {
+  const {
+    initialDelayMs = RETRY_CONFIG.INITIAL_DELAY_MS,
+    maxDelayMs = RETRY_CONFIG.MAX_DELAY_MS,
+    backoffMultiplier = RETRY_CONFIG.BACKOFF_MULTIPLIER,
+    jitter = true
+  } = options;
+  const baseDelay = initialDelayMs * Math.pow(backoffMultiplier, attempt);
+  let delay = baseDelay;
+  if (jitter) {
+    const jitterFactor = 0.75 + Math.random() * 0.5;
+    delay = baseDelay * jitterFactor;
+  }
+  return Math.min(Math.round(delay), maxDelayMs);
+}
+function calculateRetryDelay(attempt, headers, options = {}) {
+  const retryAfterSeconds = extractRetryAfter(headers);
+  if (retryAfterSeconds !== void 0 && retryAfterSeconds > 0) {
+    const retryAfterMs = retryAfterSeconds * 1e3;
+    const maxDelayMs = options.maxDelayMs ?? RETRY_CONFIG.MAX_DELAY_MS;
+    return Math.min(retryAfterMs, maxDelayMs);
+  }
+  return exponentialBackoff(attempt, options);
+}
+async function withRetry(operation, options = {}) {
+  const {
+    maxAttempts = RETRY_CONFIG.MAX_ATTEMPTS,
+    initialDelayMs = RETRY_CONFIG.INITIAL_DELAY_MS,
+    maxDelayMs = RETRY_CONFIG.MAX_DELAY_MS,
+    backoffMultiplier = RETRY_CONFIG.BACKOFF_MULTIPLIER,
+    jitter = true,
+    shouldRetry = defaultShouldRetry,
+    logger: customLogger,
+    onRetry,
+    operationName = "operation"
+  } = options;
+  const log = customLogger ?? createChildLogger("ideogram-client");
+  const totalAttempts = maxAttempts + 1;
+  let lastError;
+  let lastHeaders;
+  for (let attempt = 1; attempt <= totalAttempts; attempt++) {
+    const context = {
+      attempt,
+      maxAttempts: totalAttempts,
+      isRetry: attempt > 1
+    };
+    try {
+      const result = await operation(context);
+      if (attempt > 1) {
+        log.info(
+          { operation: operationName, attempt, totalAttempts },
+          "Operation succeeded after retry"
+        );
+      }
+      return result;
+    } catch (error) {
+      lastError = error;
+      lastHeaders = extractHeadersFromError(error);
+      const canRetry = attempt < totalAttempts && shouldRetry(error, attempt);
+      if (!canRetry) {
+        log.warn(
+          {
+            operation: operationName,
+            attempt,
+            totalAttempts,
+            error: formatErrorForLog(error),
+            willRetry: false
+          },
+          `Operation failed after ${attempt} attempt(s)`
+        );
+        throw error;
+      }
+      const delayMs = calculateRetryDelay(attempt - 1, lastHeaders, {
+        initialDelayMs,
+        maxDelayMs,
+        backoffMultiplier,
+        jitter
+      });
+      log.debug(
+        {
+          operation: operationName,
+          attempt,
+          totalAttempts,
+          error: formatErrorForLog(error),
+          delayMs,
+          willRetry: true
+        },
+        `Retrying ${operationName} after ${delayMs}ms`
+      );
+      if (onRetry) {
+        onRetry(error, attempt, delayMs);
+      }
+      await sleep(delayMs);
+    }
+  }
+  throw lastError;
+}
+function defaultShouldRetry(error, _attempt) {
+  if (isRetryableError(error)) {
+    return true;
+  }
+  if (typeof error === "object" && error !== null) {
+    const err = error;
+    if ("response" in err && err["response"] === void 0) {
+      const code = "code" in err ? err["code"] : void 0;
+      if (code === "ECONNRESET" || code === "ECONNREFUSED" || code === "ETIMEDOUT" || code === "ENOTFOUND" || code === "EAI_AGAIN") {
+        return true;
+      }
+    }
+    if ("response" in err && typeof err["response"] === "object" && err["response"] !== null) {
+      const response = err["response"];
+      const status = response["status"];
+      if (typeof status === "number" && RETRYABLE_STATUS_CODES.includes(status)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function extractHeadersFromError(error) {
+  if (typeof error !== "object" || error === null) {
+    return void 0;
+  }
+  const err = error;
+  if ("response" in err && typeof err["response"] === "object" && err["response"] !== null) {
+    const response = err["response"];
+    if ("headers" in response && typeof response["headers"] === "object") {
+      return response["headers"];
+    }
+  }
+  if (isIdeogramMCPError(error) && error.details) {
+    if ("headers" in error.details && typeof error.details["headers"] === "object") {
+      return error.details["headers"];
+    }
+  }
+  return void 0;
+}
+function formatErrorForLog(error) {
+  if (isIdeogramMCPError(error)) {
+    return {
+      code: error.code,
+      message: error.message,
+      statusCode: error.statusCode,
+      retryable: error.retryable
+    };
+  }
+  if (error instanceof Error) {
+    return {
+      name: error.name,
+      message: error.message
+    };
+  }
+  return { error: String(error) };
+}
+function sleep(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+var init_retry = __esm({
+  "src/utils/retry.ts"() {
+    "use strict";
+    init_constants();
+    init_error_handler();
+    init_logger();
+  }
+});
+
+// src/services/ideogram.client.ts
+import axios from "axios";
+import FormData from "form-data";
+function createIdeogramClient(options) {
+  return new IdeogramClient(options);
+}
+var IdeogramClient;
+var init_ideogram_client = __esm({
+  "src/services/ideogram.client.ts"() {
+    "use strict";
+    init_constants();
+    init_config();
+    init_error_handler();
+    init_retry();
+    init_logger();
+    IdeogramClient = class {
+      apiKey;
+      baseUrl;
+      timeoutMs;
+      longTimeoutMs;
+      retryOptions;
+      log;
+      httpClient;
+      /**
+       * Creates a new IdeogramClient instance.
+       *
+       * @param options - Client configuration options
+       * @throws {IdeogramMCPError} If no API key is provided or found in environment
+       */
+      constructor(options = {}) {
+        const apiKey = options.apiKey ?? config.ideogramApiKey;
+        if (!apiKey) {
+          throw createMissingApiKeyError();
+        }
+        this.apiKey = apiKey;
+        this.baseUrl = options.baseUrl ?? API_BASE_URL;
+        this.timeoutMs = options.timeoutMs ?? config.requestTimeoutMs ?? TIMEOUTS.DEFAULT_REQUEST_MS;
+        this.longTimeoutMs = options.longTimeoutMs ?? TIMEOUTS.LONG_REQUEST_MS;
+        this.retryOptions = options.retryOptions ?? {};
+        this.log = options.logger ?? createChildLogger("ideogram-client");
+        this.httpClient = axios.create({
+          baseURL: this.baseUrl,
+          timeout: this.timeoutMs,
+          validateStatus: (status) => status >= 200 && status < 300
+        });
+        this.log.debug(
+          { baseUrl: this.baseUrl, timeoutMs: this.timeoutMs },
+          "IdeogramClient initialized"
+        );
+      }
+      // ===========================================================================
+      // Public Methods
+      // ===========================================================================
+      /**
+       * Generates images from a text prompt using Ideogram V3.
+       *
+       * @param params - Generation parameters
+       * @returns Promise resolving to the generation response with image URLs
+       * @throws {IdeogramMCPError} On validation errors, API errors, or network failures
+       *
+       * @example
+       * ```typescript
+       * const result = await client.generate({
+       *   prompt: 'A cute cat wearing a wizard hat',
+       *   aspectRatio: '1x1',
+       *   numImages: 2,
+       *   renderingSpeed: 'QUALITY',
+       * });
+       *
+       * console.log(result.data[0].url); // Temporary URL to generated image
+       * ```
+       */
+      async generate(params) {
+        const endpoint = API_ENDPOINTS.GENERATE_V3;
+        const startTime = Date.now();
+        const imageRequest = {
+          prompt: params.prompt,
+          num_images: params.numImages ?? DEFAULTS.NUM_IMAGES,
+          rendering_speed: params.renderingSpeed ?? DEFAULTS.RENDERING_SPEED,
+          magic_prompt: params.magicPrompt ?? DEFAULTS.MAGIC_PROMPT,
+          style_type: params.styleType ?? DEFAULTS.STYLE_TYPE
+        };
+        const normalizedAspectRatio = this.normalizeAspectRatio(params.aspectRatio);
+        if (normalizedAspectRatio !== void 0) {
+          imageRequest.aspect_ratio = normalizedAspectRatio;
+        }
+        if (params.negativePrompt !== void 0) {
+          imageRequest.negative_prompt = params.negativePrompt;
+        }
+        if (params.seed !== void 0) {
+          imageRequest.seed = params.seed;
+        }
+        const requestBody = imageRequest;
+        const requestContext = {
+          endpoint,
+          method: "POST",
+          hasImage: false,
+          hasMask: false
+        };
+        logApiRequest(this.log, requestContext);
+        const timeout = this.getTimeoutForRenderingSpeed(params.renderingSpeed);
+        const response = await this.executeWithRetry(
+          endpoint,
+          requestBody,
+          timeout,
+          "generate"
+        );
+        const responseContext = {
+          endpoint,
+          statusCode: 200,
+          durationMs: Date.now() - startTime,
+          imageCount: response.data.length
+        };
+        logApiResponse(this.log, responseContext);
+        return response;
+      }
+      /**
+       * Edits an existing image using inpainting.
+       *
+       * Inpainting uses a mask to define which areas to edit:
+       * - Black pixels in mask = areas to modify
+       * - White pixels in mask = areas to preserve
+       *
+       * @param params - Edit parameters including image, mask, and prompt
+       * @returns Promise resolving to the edit response with image URLs
+       * @throws {IdeogramMCPError} On validation errors, API errors, or network failures
+       *
+       * @example
+       * ```typescript
+       * const result = await client.edit({
+       *   prompt: 'Add a red balloon in the sky',
+       *   image: 'https://example.com/photo.jpg',
+       *   mask: maskBuffer, // Black=edit, white=preserve
+       *   model: 'V_2',
+       *   magicPrompt: 'AUTO',
+       * });
+       *
+       * console.log(result.data[0].url); // Edited image URL
+       * ```
+       */
+      async edit(params) {
+        const endpoint = API_ENDPOINTS.EDIT_LEGACY;
+        const startTime = Date.now();
+        const preparedImage = await this.prepareImage(params.image, "image");
+        const preparedMask = await this.prepareImage(params.mask, "mask");
+        const formData = new FormData();
+        formData.append("prompt", params.prompt);
+        formData.append("model", params.model ?? "V_2");
+        formData.append("magic_prompt_option", params.magicPrompt ?? DEFAULTS.MAGIC_PROMPT);
+        formData.append("num_images", String(params.numImages ?? DEFAULTS.NUM_IMAGES));
+        if (params.seed !== void 0) {
+          formData.append("seed", String(params.seed));
+        }
+        if (params.styleType !== void 0) {
+          formData.append("style_type", params.styleType);
+        }
+        formData.append("image_file", preparedImage.data, {
+          contentType: preparedImage.contentType,
+          filename: preparedImage.filename
+        });
+        formData.append("mask", preparedMask.data, {
+          contentType: preparedMask.contentType,
+          filename: preparedMask.filename
+        });
+        const requestContext = {
+          endpoint,
+          method: "POST",
+          hasImage: true,
+          hasMask: true
+        };
+        logApiRequest(this.log, requestContext);
+        const timeout = TIMEOUTS.LONG_REQUEST_MS;
+        const response = await this.executeWithRetry(
+          endpoint,
+          formData,
+          timeout,
+          "edit"
+        );
+        const responseContext = {
+          endpoint,
+          statusCode: 200,
+          durationMs: Date.now() - startTime,
+          imageCount: response.data.length
+        };
+        logApiResponse(this.log, responseContext);
+        return response;
+      }
+      /**
+       * Gets the current API key (masked for security).
+       */
+      getMaskedApiKey() {
+        if (this.apiKey.length <= 8) {
+          return "****";
+        }
+        return `${this.apiKey.slice(0, 4)}...${this.apiKey.slice(-4)}`;
+      }
+      /**
+       * Tests the API connection by checking if the API key is valid.
+       * Makes a minimal request to verify authentication.
+       *
+       * @returns Promise resolving to true if the connection is valid
+       * @throws {IdeogramMCPError} If the API key is invalid or there's a network error
+       */
+      async testConnection() {
+        try {
+          await this.generate({
+            prompt: "test",
+            numImages: 1,
+            renderingSpeed: "FLASH"
+          });
+          return true;
+        } catch (error) {
+          throw wrapError(error);
+        }
+      }
+      // ===========================================================================
+      // Private Methods
+      // ===========================================================================
+      /**
+       * Executes an API request with automatic retry on transient failures.
+       * Supports both JSON payloads (for generate) and FormData (for edit with images).
+       */
+      async executeWithRetry(endpoint, data, timeout, operationName) {
+        return withRetry(
+          async () => {
+            try {
+              const headers = {
+                [API_KEY_HEADER]: this.apiKey
+              };
+              if (data instanceof FormData) {
+                Object.assign(headers, data.getHeaders());
+              } else {
+                headers["Content-Type"] = "application/json";
+              }
+              const response = await this.httpClient.post(endpoint, data, {
+                headers,
+                timeout
+              });
+              return response.data;
+            } catch (error) {
+              if (axios.isAxiosError(error)) {
+                throw fromAxiosError(this.createAxiosErrorInfo(error));
+              }
+              throw wrapError(error);
+            }
+          },
+          {
+            ...this.retryOptions,
+            operationName,
+            logger: this.log
+          }
+        );
+      }
+      /**
+       * Converts an Axios error to the format expected by fromAxiosError.
+       */
+      createAxiosErrorInfo(error) {
+        const result = {
+          message: error.message
+        };
+        if (error.code !== void 0) {
+          result.code = error.code;
+        }
+        if (error.response) {
+          const responseData = error.response.data;
+          result.response = {
+            status: error.response.status
+          };
+          if (responseData !== void 0) {
+            result.response.data = responseData;
+          }
+        }
+        return result;
+      }
+      /**
+       * Prepares an image input for form upload.
+       * Handles URLs, base64 data URLs, and Buffers.
+       */
+      async prepareImage(input, fieldName) {
+        if (Buffer.isBuffer(input)) {
+          return this.prepareBufferImage(input, fieldName);
+        }
+        if (input.startsWith("data:")) {
+          return this.prepareBase64Image(input, fieldName);
+        }
+        if (input.startsWith("http://") || input.startsWith("https://")) {
+          return this.prepareUrlImage(input, fieldName);
+        }
+        throw createInvalidImageError(
+          `Unsupported image input format for ${fieldName}. Provide a URL, base64 data URL, or Buffer.`
+        );
+      }
+      /**
+       * Prepares a Buffer image for upload.
+       */
+      prepareBufferImage(buffer, fieldName) {
+        const contentType = this.detectImageType(buffer);
+        const extension = this.getExtensionForContentType(contentType);
+        this.validateImageSize(buffer.length);
+        return {
+          data: buffer,
+          contentType,
+          filename: `${fieldName}.${extension}`
+        };
+      }
+      /**
+       * Prepares a base64 data URL image for upload.
+       */
+      prepareBase64Image(dataUrl, fieldName) {
+        const matches = dataUrl.match(/^data:([^;]+);base64,(.+)$/);
+        if (!matches) {
+          throw createInvalidImageError(`Invalid base64 data URL format for ${fieldName}`);
+        }
+        const contentType = matches[1] ?? "image/png";
+        const base64Data = matches[2] ?? "";
+        const buffer = Buffer.from(base64Data, "base64");
+        this.validateImageSize(buffer.length);
+        const extension = this.getExtensionForContentType(contentType);
+        return {
+          data: buffer,
+          contentType,
+          filename: `${fieldName}.${extension}`
+        };
+      }
+      /**
+       * Prepares a URL image for upload by downloading it.
+       */
+      async prepareUrlImage(url, fieldName) {
+        try {
+          const response = await axios.get(url, {
+            responseType: "arraybuffer",
+            timeout: TIMEOUTS.IMAGE_DOWNLOAD_MS
+          });
+          const buffer = Buffer.from(response.data);
+          this.validateImageSize(buffer.length);
+          let contentType = response.headers["content-type"]?.toString().split(";")[0];
+          if (!contentType || !contentType.startsWith("image/")) {
+            contentType = this.detectImageType(buffer);
+          }
+          const extension = this.getExtensionForContentType(contentType);
+          return {
+            data: buffer,
+            contentType,
+            filename: `${fieldName}.${extension}`
+          };
+        } catch (error) {
+          if (axios.isAxiosError(error)) {
+            throw createNetworkError(
+              `Failed to download image from URL: ${error.message}`,
+              error
+            );
+          }
+          throw wrapError(error);
+        }
+      }
+      /**
+       * Validates that the image size is within limits.
+       */
+      validateImageSize(sizeBytes) {
+        const maxSize = 10 * 1024 * 1024;
+        if (sizeBytes > maxSize) {
+          throw createImageTooLargeError(sizeBytes, maxSize);
+        }
+      }
+      /**
+       * Detects the image type from the first few bytes (magic numbers).
+       */
+      detectImageType(buffer) {
+        if (buffer.length < 4) {
+          return "image/png";
+        }
+        if (buffer[0] === 137 && buffer[1] === 80 && buffer[2] === 78 && buffer[3] === 71) {
+          return "image/png";
+        }
+        if (buffer[0] === 255 && buffer[1] === 216 && buffer[2] === 255) {
+          return "image/jpeg";
+        }
+        if (buffer[0] === 82 && buffer[1] === 73 && buffer[2] === 70 && buffer[3] === 70 && buffer.length >= 12 && buffer[8] === 87 && buffer[9] === 69 && buffer[10] === 66 && buffer[11] === 80) {
+          return "image/webp";
+        }
+        return "image/png";
+      }
+      /**
+       * Gets the file extension for a content type.
+       */
+      getExtensionForContentType(contentType) {
+        const extensions = {
+          "image/png": "png",
+          "image/jpeg": "jpg",
+          "image/webp": "webp"
+        };
+        return extensions[contentType] ?? "png";
+      }
+      /**
+       * Normalizes aspect ratio input to the API format.
+       * Converts "16:9" format to "16x9" format if needed.
+       */
+      normalizeAspectRatio(ratio) {
+        if (!ratio) {
+          return void 0;
+        }
+        return ratio.replace(":", "x");
+      }
+      /**
+       * Gets the appropriate timeout based on rendering speed.
+       * Quality rendering may take longer.
+       */
+      getTimeoutForRenderingSpeed(speed) {
+        if (speed === "QUALITY") {
+          return this.longTimeoutMs;
+        }
+        return this.timeoutMs;
+      }
+    };
+  }
+});
+
+// src/services/cost.calculator.ts
+function calculateCost(params = {}) {
+  const numImages = params.numImages ?? DEFAULTS.NUM_IMAGES;
+  const renderingSpeed = params.renderingSpeed ?? DEFAULTS.RENDERING_SPEED;
+  const creditsPerImage = CREDITS_PER_IMAGE[renderingSpeed];
+  const creditsUsed = creditsPerImage * numImages;
+  const estimatedUsd = creditsUsed * USD_PER_CREDIT;
+  return {
+    credits_used: roundCredits(creditsUsed),
+    estimated_usd: roundUsd(estimatedUsd),
+    pricing_tier: renderingSpeed,
+    num_images: numImages
+  };
+}
+function calculateEditCost(params = {}) {
+  const numImages = params.numImages ?? DEFAULTS.NUM_IMAGES;
+  const renderingSpeed = params.renderingSpeed ?? DEFAULTS.RENDERING_SPEED;
+  const creditsPerImage = EDIT_CREDITS_PER_IMAGE[renderingSpeed];
+  const creditsUsed = creditsPerImage * numImages;
+  const estimatedUsd = creditsUsed * USD_PER_CREDIT;
+  return {
+    credits_used: roundCredits(creditsUsed),
+    estimated_usd: roundUsd(estimatedUsd),
+    pricing_tier: renderingSpeed,
+    num_images: numImages
+  };
+}
+function toCostEstimateOutput(cost) {
+  return {
+    credits_used: cost.credits_used,
+    estimated_usd: cost.estimated_usd,
+    pricing_tier: cost.pricing_tier,
+    num_images: cost.num_images
+  };
+}
+function roundCredits(credits) {
+  return Math.round(credits * 100) / 100;
+}
+function roundUsd(usd) {
+  return Math.round(usd * 1e4) / 1e4;
+}
+var init_cost_calculator = __esm({
+  "src/services/cost.calculator.ts"() {
+    "use strict";
+    init_constants();
+  }
+});
+
+// src/services/storage.service.ts
+import axios2 from "axios";
+import * as fs from "fs";
+import * as path from "path";
+import { randomUUID as randomUUID2 } from "crypto";
+function createStorageService(options) {
+  return new StorageService(options);
+}
+var StorageService;
+var init_storage_service = __esm({
+  "src/services/storage.service.ts"() {
+    "use strict";
+    init_config();
+    init_constants();
+    init_error_handler();
+    init_logger();
+    StorageService = class {
+      storageDir;
+      enabled;
+      downloadTimeoutMs;
+      log;
+      initialized = false;
+      /**
+       * Creates a new StorageService instance.
+       *
+       * @param options - Service configuration options
+       */
+      constructor(options = {}) {
+        this.storageDir = options.storageDir ?? config.localSaveDir ?? "./ideogram_images";
+        this.enabled = options.enabled ?? config.enableLocalSave ?? true;
+        this.downloadTimeoutMs = options.downloadTimeoutMs ?? TIMEOUTS.IMAGE_DOWNLOAD_MS;
+        this.log = options.logger ?? createChildLogger("storage");
+        this.log.debug(
+          { storageDir: this.storageDir, enabled: this.enabled },
+          "StorageService initialized"
+        );
+      }
+      // ===========================================================================
+      // Public Methods
+      // ===========================================================================
+      /**
+       * Downloads an image from a URL and saves it locally.
+       *
+       * @param url - The URL to download the image from
+       * @param options - Download options
+       * @returns Promise resolving to saved image information
+       * @throws {IdeogramMCPError} If download or save fails
+       *
+       * @example
+       * ```typescript
+       * const result = await storage.downloadImage(
+       *   'https://api.ideogram.ai/temp/image.png',
+       *   { prefix: 'generated' }
+       * );
+       * console.log(`Saved: ${result.filename}`);
+       * ```
+       */
+      async downloadImage(url, options = {}) {
+        if (!this.enabled) {
+          throw createStorageError("download", "Local storage is disabled");
+        }
+        await this.ensureStorageDirectory(options.subdir);
+        const startTime = Date.now();
+        this.log.debug({ url }, "Downloading image");
+        try {
+          const response = await axios2.get(url, {
+            responseType: "arraybuffer",
+            timeout: this.downloadTimeoutMs,
+            validateStatus: (status) => status >= 200 && status < 300
+          });
+          const buffer = Buffer.from(response.data);
+          if (buffer.length > VALIDATION.IMAGE.MAX_SIZE_BYTES) {
+            throw createStorageError(
+              "download",
+              `Image size ${(buffer.length / (1024 * 1024)).toFixed(2)}MB exceeds maximum 10MB`
+            );
+          }
+          const mimeType = this.detectImageType(buffer);
+          const extension = this.getExtensionForMimeType(mimeType);
+          const filename = this.generateFilename(options, extension);
+          const targetDir = options.subdir ? path.join(this.storageDir, options.subdir) : this.storageDir;
+          const filePath = path.resolve(targetDir, filename);
+          await this.saveFile(filePath, buffer);
+          const durationMs = Date.now() - startTime;
+          this.log.info(
+            { filename, sizeBytes: buffer.length, durationMs },
+            "Image saved successfully"
+          );
+          return {
+            filePath,
+            filename,
+            originalUrl: url,
+            sizeBytes: buffer.length,
+            mimeType
+          };
+        } catch (error) {
+          if (error instanceof IdeogramMCPError) {
+            throw error;
+          }
+          if (axios2.isAxiosError(error)) {
+            const message = error.response ? `HTTP ${error.response.status}: ${error.message}` : error.message;
+            throw createDownloadFailedError(url, message);
+          }
+          throw wrapError(error);
+        }
+      }
+      /**
+       * Downloads multiple images in parallel.
+       *
+       * @param urls - Array of URLs to download
+       * @param options - Download options applied to all images
+       * @returns Promise resolving to batch save result
+       *
+       * @example
+       * ```typescript
+       * const results = await storage.downloadImages(
+       *   ['https://...', 'https://...'],
+       *   { prefix: 'batch' }
+       * );
+       * if (results.failureCount > 0) {
+       *   console.warn(`${results.failureCount} images failed to download`);
+       * }
+       * ```
+       */
+      async downloadImages(urls, options = {}) {
+        if (!this.enabled) {
+          return {
+            saved: [],
+            failed: urls.map((url) => ({ url, error: "Local storage is disabled" })),
+            total: urls.length,
+            successCount: 0,
+            failureCount: urls.length
+          };
+        }
+        const results = {
+          saved: [],
+          failed: [],
+          total: urls.length,
+          successCount: 0,
+          failureCount: 0
+        };
+        const downloadPromises = urls.map(async (url, index) => {
+          try {
+            const imageOptions = {
+              ...options,
+              // Add index to prefix if multiple images
+              prefix: options.prefix ? `${options.prefix}_${index + 1}` : `image_${index + 1}`
+            };
+            const saved = await this.downloadImage(url, imageOptions);
+            return { success: true, url, saved };
+          } catch (error) {
+            const errorMessage = error instanceof Error ? error.message : "Unknown error";
+            return { success: false, url, error: errorMessage };
+          }
+        });
+        const downloadResults = await Promise.all(downloadPromises);
+        for (const result of downloadResults) {
+          if (result.success) {
+            results.saved.push(result.saved);
+            results.successCount++;
+          } else {
+            results.failed.push({ url: result.url, error: result.error });
+            results.failureCount++;
+          }
+        }
+        this.log.info(
+          {
+            total: results.total,
+            success: results.successCount,
+            failed: results.failureCount
+          },
+          "Batch download completed"
+        );
+        return results;
+      }
+      /**
+       * Saves raw image data to a file.
+       *
+       * @param data - Image data as Buffer or base64 string
+       * @param options - Save options
+       * @returns Promise resolving to saved image information
+       * @throws {IdeogramMCPError} If save fails
+       *
+       * @example
+       * ```typescript
+       * const imageBuffer = Buffer.from(base64Data, 'base64');
+       * const result = await storage.saveImage(imageBuffer, { prefix: 'edited' });
+       * ```
+       */
+      async saveImage(data, options = {}) {
+        if (!this.enabled) {
+          throw createStorageError("save", "Local storage is disabled");
+        }
+        await this.ensureStorageDirectory(options.subdir);
+        const buffer = typeof data === "string" ? Buffer.from(data, "base64") : data;
+        if (buffer.length > VALIDATION.IMAGE.MAX_SIZE_BYTES) {
+          throw createStorageError(
+            "save",
+            `Image size ${(buffer.length / (1024 * 1024)).toFixed(2)}MB exceeds maximum 10MB`
+          );
+        }
+        const mimeType = this.detectImageType(buffer);
+        const extension = this.getExtensionForMimeType(mimeType);
+        const filename = this.generateFilename(options, extension);
+        const targetDir = options.subdir ? path.join(this.storageDir, options.subdir) : this.storageDir;
+        const filePath = path.resolve(targetDir, filename);
+        await this.saveFile(filePath, buffer);
+        this.log.info({ filename, sizeBytes: buffer.length }, "Image saved");
+        return {
+          filePath,
+          filename,
+          originalUrl: "local",
+          sizeBytes: buffer.length,
+          mimeType
+        };
+      }
+      /**
+       * Checks if local storage is enabled.
+       */
+      isEnabled() {
+        return this.enabled;
+      }
+      /**
+       * Gets the configured storage directory.
+       */
+      getStorageDir() {
+        return path.resolve(this.storageDir);
+      }
+      /**
+       * Checks if a file exists in the storage directory.
+       *
+       * @param filename - The filename to check
+       * @param subdir - Optional subdirectory
+       */
+      async fileExists(filename, subdir) {
+        const targetDir = subdir ? path.join(this.storageDir, subdir) : this.storageDir;
+        const filePath = path.resolve(targetDir, filename);
+        try {
+          await fs.promises.access(filePath, fs.constants.F_OK);
+          return true;
+        } catch {
+          return false;
+        }
+      }
+      /**
+       * Deletes a file from the storage directory.
+       *
+       * @param filename - The filename to delete
+       * @param subdir - Optional subdirectory
+       * @returns True if deleted, false if file didn't exist
+       */
+      async deleteFile(filename, subdir) {
+        const targetDir = subdir ? path.join(this.storageDir, subdir) : this.storageDir;
+        const filePath = path.resolve(targetDir, filename);
+        try {
+          await fs.promises.unlink(filePath);
+          this.log.debug({ filename }, "File deleted");
+          return true;
+        } catch (error) {
+          if (error.code === "ENOENT") {
+            return false;
+          }
+          throw createStorageError("delete", `Failed to delete file: ${filename}`);
+        }
+      }
+      /**
+       * Lists files in the storage directory.
+       *
+       * @param subdir - Optional subdirectory
+       * @returns Array of filenames
+       */
+      async listFiles(subdir) {
+        const targetDir = subdir ? path.join(this.storageDir, subdir) : this.storageDir;
+        const resolvedDir = path.resolve(targetDir);
+        try {
+          const entries = await fs.promises.readdir(resolvedDir, { withFileTypes: true });
+          return entries.filter((entry) => entry.isFile()).map((entry) => entry.name);
+        } catch (error) {
+          if (error.code === "ENOENT") {
+            return [];
+          }
+          throw createStorageError("list", "Failed to list storage directory");
+        }
+      }
+      /**
+       * Gets the total size of files in the storage directory.
+       *
+       * @param subdir - Optional subdirectory
+       * @returns Total size in bytes
+       */
+      async getStorageSize(subdir) {
+        const targetDir = subdir ? path.join(this.storageDir, subdir) : this.storageDir;
+        const resolvedDir = path.resolve(targetDir);
+        try {
+          const entries = await fs.promises.readdir(resolvedDir, { withFileTypes: true });
+          let totalSize = 0;
+          for (const entry of entries) {
+            if (entry.isFile()) {
+              const filePath = path.join(resolvedDir, entry.name);
+              const stats = await fs.promises.stat(filePath);
+              totalSize += stats.size;
+            }
+          }
+          return totalSize;
+        } catch (error) {
+          if (error.code === "ENOENT") {
+            return 0;
+          }
+          throw createStorageError("size", "Failed to calculate storage size");
+        }
+      }
+      // ===========================================================================
+      // Private Methods
+      // ===========================================================================
+      /**
+       * Ensures the storage directory exists, creating it if necessary.
+       */
+      async ensureStorageDirectory(subdir) {
+        const targetDir = subdir ? path.join(this.storageDir, subdir) : this.storageDir;
+        const resolvedDir = path.resolve(targetDir);
+        if (this.initialized && !subdir) {
+          return;
+        }
+        try {
+          await fs.promises.mkdir(resolvedDir, { recursive: true });
+          if (!subdir) {
+            this.initialized = true;
+          }
+          this.log.debug({ dir: resolvedDir }, "Storage directory ready");
+        } catch (error) {
+          throw createStorageError(
+            "init",
+            `Failed to create storage directory: ${error.message}`
+          );
+        }
+      }
+      /**
+       * Saves data to a file.
+       */
+      async saveFile(filePath, data) {
+        try {
+          await fs.promises.writeFile(filePath, data);
+        } catch (error) {
+          throw createStorageError(
+            "write",
+            `Failed to write file: ${error.message}`
+          );
+        }
+      }
+      /**
+       * Generates a unique filename for an image.
+       */
+      generateFilename(options, extension) {
+        if (options.filename) {
+          return `${options.filename}.${extension}`;
+        }
+        const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+        const uuid = randomUUID2().slice(0, 8);
+        if (options.prefix) {
+          return `${options.prefix}_${timestamp}_${uuid}.${extension}`;
+        }
+        return `ideogram_${timestamp}_${uuid}.${extension}`;
+      }
+      /**
+       * Detects the image type from the first few bytes (magic numbers).
+       */
+      detectImageType(buffer) {
+        if (buffer.length < 4) {
+          return "image/png";
+        }
+        if (buffer[0] === 137 && buffer[1] === 80 && buffer[2] === 78 && buffer[3] === 71) {
+          return "image/png";
+        }
+        if (buffer[0] === 255 && buffer[1] === 216 && buffer[2] === 255) {
+          return "image/jpeg";
+        }
+        if (buffer[0] === 82 && buffer[1] === 73 && buffer[2] === 70 && buffer[3] === 70 && buffer.length >= 12 && buffer[8] === 87 && buffer[9] === 69 && buffer[10] === 66 && buffer[11] === 80) {
+          return "image/webp";
+        }
+        if (buffer[0] === 71 && buffer[1] === 73 && buffer[2] === 70 && buffer[3] === 56) {
+          return "image/gif";
+        }
+        return "image/png";
+      }
+      /**
+       * Gets the file extension for a MIME type.
+       */
+      getExtensionForMimeType(mimeType) {
+        const extensions = {
+          "image/png": "png",
+          "image/jpeg": "jpg",
+          "image/webp": "webp",
+          "image/gif": "gif"
+        };
+        return extensions[mimeType] ?? "png";
+      }
+    };
+  }
+});
+
+// src/tools/generate.ts
+function createGenerateHandler(options = {}) {
+  const log = options.logger ?? createChildLogger("tool:generate");
+  const client = options.client ?? createIdeogramClient(options.clientOptions);
+  const storage = options.storage ?? createStorageService(options.storageOptions);
+  return async function ideogramGenerateHandler(input) {
+    const startTime = Date.now();
+    logToolInvocation(log, {
+      tool: TOOL_NAME,
+      params: {
+        prompt: input.prompt,
+        aspect_ratio: input.aspect_ratio,
+        num_images: input.num_images,
+        rendering_speed: input.rendering_speed,
+        magic_prompt: input.magic_prompt,
+        style_type: input.style_type,
+        save_locally: input.save_locally
+      }
+    });
+    try {
+      const generateParams = {
+        prompt: input.prompt
+      };
+      if (input.negative_prompt !== void 0) {
+        generateParams.negativePrompt = input.negative_prompt;
+      }
+      if (input.aspect_ratio !== void 0) {
+        generateParams.aspectRatio = input.aspect_ratio;
+      }
+      if (input.num_images !== void 0) {
+        generateParams.numImages = input.num_images;
+      }
+      if (input.seed !== void 0) {
+        generateParams.seed = input.seed;
+      }
+      if (input.rendering_speed !== void 0) {
+        generateParams.renderingSpeed = input.rendering_speed;
+      }
+      if (input.magic_prompt !== void 0) {
+        generateParams.magicPrompt = input.magic_prompt;
+      }
+      if (input.style_type !== void 0) {
+        generateParams.styleType = input.style_type;
+      }
+      const response = await client.generate(generateParams);
+      const cost = calculateCost({
+        numImages: response.data.length,
+        renderingSpeed: input.rendering_speed
+      });
+      const images = [];
+      const shouldSaveLocally = input.save_locally && storage.isEnabled();
+      if (shouldSaveLocally) {
+        const urls = response.data.map((img) => img.url);
+        const saveResult = await storage.downloadImages(urls, {
+          prefix: "generated"
+        });
+        for (let i = 0; i < response.data.length; i++) {
+          const apiImage = response.data[i];
+          if (!apiImage)
+            continue;
+          const savedImage = saveResult.saved.find(
+            (s) => s.originalUrl === apiImage.url
+          );
+          const outputImage = {
+            url: apiImage.url,
+            seed: apiImage.seed,
+            is_image_safe: apiImage.is_image_safe
+          };
+          if (savedImage) {
+            outputImage.local_path = savedImage.filePath;
+          }
+          if (apiImage.prompt !== void 0) {
+            outputImage.prompt = apiImage.prompt;
+          }
+          if (apiImage.resolution !== void 0) {
+            outputImage.resolution = apiImage.resolution;
+          }
+          images.push(outputImage);
+        }
+        if (saveResult.failureCount > 0) {
+          log.warn(
+            { failedCount: saveResult.failureCount },
+            "Some images failed to save locally"
+          );
+        }
+      } else {
+        for (const apiImage of response.data) {
+          const outputImage = {
+            url: apiImage.url,
+            seed: apiImage.seed,
+            is_image_safe: apiImage.is_image_safe
+          };
+          if (apiImage.prompt !== void 0) {
+            outputImage.prompt = apiImage.prompt;
+          }
+          if (apiImage.resolution !== void 0) {
+            outputImage.resolution = apiImage.resolution;
+          }
+          images.push(outputImage);
+        }
+      }
+      const result = {
+        success: true,
+        created: response.created,
+        images,
+        total_cost: toCostEstimateOutput(cost),
+        num_images: images.length
+      };
+      const durationMs = Date.now() - startTime;
+      logToolResult(log, {
+        tool: TOOL_NAME,
+        success: true,
+        durationMs
+      });
+      log.debug(
+        {
+          numImages: result.num_images,
+          creditsUsed: result.total_cost.credits_used,
+          durationMs
+        },
+        "Generation completed successfully"
+      );
+      return result;
+    } catch (error) {
+      const mcpError = error instanceof IdeogramMCPError ? error : wrapError(error);
+      const durationMs = Date.now() - startTime;
+      logError(log, mcpError, "Generation failed", {
+        tool: TOOL_NAME,
+        durationMs
+      });
+      logToolResult(log, {
+        tool: TOOL_NAME,
+        success: false,
+        durationMs,
+        errorCode: mcpError.code
+      });
+      return mcpError.toToolError();
+    }
+  };
+}
+function getDefaultHandler() {
+  if (!defaultHandler) {
+    defaultHandler = createGenerateHandler();
+  }
+  return defaultHandler;
+}
+async function ideogramGenerate(input) {
+  return getDefaultHandler()(input);
+}
+var TOOL_NAME, TOOL_DESCRIPTION, TOOL_SCHEMA, defaultHandler, ideogramGenerateTool;
+var init_generate = __esm({
+  "src/tools/generate.ts"() {
+    "use strict";
+    init_tool_types();
+    init_ideogram_client();
+    init_cost_calculator();
+    init_storage_service();
+    init_error_handler();
+    init_logger();
+    TOOL_NAME = "ideogram_generate";
+    TOOL_DESCRIPTION = `Generate images from text prompts using Ideogram AI v3.
+
+Creates high-quality AI-generated images based on text descriptions. Supports various aspect ratios, rendering quality levels, and style options.
+
+Features:
+- 15 aspect ratio options (1x1, 16x9, 9x16, 4x3, 3x4, 3x2, 2x3, 4x5, 5x4, 1x2, 2x1, 1x3, 3x1, 10x16, 16x10)
+- Rendering speed options: FLASH (fastest), TURBO (fast), DEFAULT (balanced), QUALITY (best quality)
+- Magic prompt enhancement to automatically improve prompts
+- Style types: AUTO, GENERAL, REALISTIC, DESIGN, FICTION
+- Generate 1-8 images per request
+- Optional local saving of generated images
+- Cost tracking for usage monitoring
+
+Returns image URLs, seeds for reproducibility, and cost estimates.`;
+    TOOL_SCHEMA = GenerateInputSchema;
+    defaultHandler = null;
+    ideogramGenerateTool = {
+      name: TOOL_NAME,
+      description: TOOL_DESCRIPTION,
+      schema: TOOL_SCHEMA,
+      handler: ideogramGenerate
+    };
+  }
+});
+
+// src/tools/edit.ts
+function createEditHandler(options = {}) {
+  const log = options.logger ?? createChildLogger("tool:edit");
+  const client = options.client ?? createIdeogramClient(options.clientOptions);
+  const storage = options.storage ?? createStorageService(options.storageOptions);
+  return async function ideogramEditHandler(input) {
+    const startTime = Date.now();
+    logToolInvocation(log, {
+      tool: TOOL_NAME2,
+      params: {
+        prompt: input.prompt,
+        hasImage: !!input.image,
+        hasMask: !!input.mask,
+        model: input.model,
+        num_images: input.num_images,
+        magic_prompt: input.magic_prompt,
+        style_type: input.style_type,
+        save_locally: input.save_locally
+      }
+    });
+    try {
+      const editParams = {
+        prompt: input.prompt,
+        image: input.image,
+        mask: input.mask
+      };
+      if (input.model !== void 0) {
+        editParams.model = input.model;
+      }
+      if (input.num_images !== void 0) {
+        editParams.numImages = input.num_images;
+      }
+      if (input.seed !== void 0) {
+        editParams.seed = input.seed;
+      }
+      if (input.magic_prompt !== void 0) {
+        editParams.magicPrompt = input.magic_prompt;
+      }
+      if (input.style_type !== void 0) {
+        editParams.styleType = input.style_type;
+      }
+      const response = await client.edit(editParams);
+      const cost = calculateEditCost({
+        numImages: response.data.length,
+        renderingSpeed: "DEFAULT"
+      });
+      const images = [];
+      const shouldSaveLocally = input.save_locally && storage.isEnabled();
+      if (shouldSaveLocally) {
+        const urls = response.data.map((img) => img.url);
+        const saveResult = await storage.downloadImages(urls, {
+          prefix: "edited"
+        });
+        for (let i = 0; i < response.data.length; i++) {
+          const apiImage = response.data[i];
+          if (!apiImage)
+            continue;
+          const savedImage = saveResult.saved.find(
+            (s) => s.originalUrl === apiImage.url
+          );
+          const outputImage = {
+            url: apiImage.url,
+            seed: apiImage.seed,
+            is_image_safe: apiImage.is_image_safe
+          };
+          if (savedImage) {
+            outputImage.local_path = savedImage.filePath;
+          }
+          if (apiImage.prompt !== void 0) {
+            outputImage.prompt = apiImage.prompt;
+          }
+          if (apiImage.resolution !== void 0) {
+            outputImage.resolution = apiImage.resolution;
+          }
+          images.push(outputImage);
+        }
+        if (saveResult.failureCount > 0) {
+          log.warn(
+            { failedCount: saveResult.failureCount },
+            "Some images failed to save locally"
+          );
+        }
+      } else {
+        for (const apiImage of response.data) {
+          const outputImage = {
+            url: apiImage.url,
+            seed: apiImage.seed,
+            is_image_safe: apiImage.is_image_safe
+          };
+          if (apiImage.prompt !== void 0) {
+            outputImage.prompt = apiImage.prompt;
+          }
+          if (apiImage.resolution !== void 0) {
+            outputImage.resolution = apiImage.resolution;
+          }
+          images.push(outputImage);
+        }
+      }
+      const result = {
+        success: true,
+        created: response.created,
+        images,
+        total_cost: toCostEstimateOutput(cost),
+        num_images: images.length
+      };
+      const durationMs = Date.now() - startTime;
+      logToolResult(log, {
+        tool: TOOL_NAME2,
+        success: true,
+        durationMs
+      });
+      log.debug(
+        {
+          numImages: result.num_images,
+          creditsUsed: result.total_cost.credits_used,
+          durationMs
+        },
+        "Inpainting completed successfully"
+      );
+      return result;
+    } catch (error) {
+      const mcpError = error instanceof IdeogramMCPError ? error : wrapError(error);
+      const durationMs = Date.now() - startTime;
+      logError(log, mcpError, "Edit failed", {
+        tool: TOOL_NAME2,
+        durationMs
+      });
+      logToolResult(log, {
+        tool: TOOL_NAME2,
+        success: false,
+        durationMs,
+        errorCode: mcpError.code
+      });
+      return mcpError.toToolError();
+    }
+  };
+}
+function getDefaultHandler2() {
+  if (!defaultHandler2) {
+    defaultHandler2 = createEditHandler();
+  }
+  return defaultHandler2;
+}
+async function ideogramEdit(input) {
+  return getDefaultHandler2()(input);
+}
+var TOOL_NAME2, TOOL_DESCRIPTION2, TOOL_SCHEMA2, defaultHandler2, ideogramEditTool;
+var init_edit = __esm({
+  "src/tools/edit.ts"() {
+    "use strict";
+    init_tool_types();
+    init_ideogram_client();
+    init_cost_calculator();
+    init_storage_service();
+    init_error_handler();
+    init_logger();
+    TOOL_NAME2 = "ideogram_edit";
+    TOOL_DESCRIPTION2 = `Edit specific parts of an existing image using inpainting with Ideogram AI.
+
+Inpainting uses a mask to define which areas to modify:
+- Black pixels in mask = areas to edit/regenerate
+- White pixels in mask = areas to preserve unchanged
+
+The mask must be the same dimensions as the source image and contain only black and white pixels.
+
+Features:
+- Mask-based selective editing
+- Magic prompt enhancement to automatically improve prompts
+- Style types: AUTO, GENERAL, REALISTIC, DESIGN, FICTION, RENDER_3D, ANIME
+- Model selection: V_2 (default) or V_2_TURBO (faster)
+- Generate 1-8 variations per edit operation
+- Optional local saving of edited images
+- Cost tracking for usage monitoring
+
+Input image and mask can be provided as URLs, file paths, or base64 data URLs.
+
+Returns edited image URLs, seeds for reproducibility, and cost estimates.`;
+    TOOL_SCHEMA2 = EditInputSchema;
+    defaultHandler2 = null;
+    ideogramEditTool = {
+      name: TOOL_NAME2,
+      description: TOOL_DESCRIPTION2,
+      schema: TOOL_SCHEMA2,
+      handler: ideogramEdit
+    };
+  }
+});
+
+// src/tools/generate-async.ts
+function createGenerateAsyncHandler(options = {}) {
+  const log = options.logger ?? createChildLogger("tool:generate-async");
+  const store = options.store ?? createPredictionStore(options.storeOptions);
+  return async function ideogramGenerateAsyncHandler(input) {
+    const startTime = Date.now();
+    logToolInvocation(log, {
+      tool: TOOL_NAME3,
+      params: {
+        prompt: input.prompt,
+        aspect_ratio: input.aspect_ratio,
+        num_images: input.num_images,
+        rendering_speed: input.rendering_speed,
+        magic_prompt: input.magic_prompt,
+        style_type: input.style_type,
+        save_locally: input.save_locally,
+        webhook_url: input.webhook_url
+      }
+    });
+    try {
+      const generateRequest = {
+        prompt: input.prompt
+      };
+      if (input.negative_prompt !== void 0) {
+        generateRequest.negative_prompt = input.negative_prompt;
+      }
+      if (input.aspect_ratio !== void 0) {
+        generateRequest.aspect_ratio = input.aspect_ratio;
+      }
+      if (input.num_images !== void 0) {
+        generateRequest.num_images = input.num_images;
+      }
+      if (input.seed !== void 0) {
+        generateRequest.seed = input.seed;
+      }
+      if (input.rendering_speed !== void 0) {
+        generateRequest.rendering_speed = input.rendering_speed;
+      }
+      if (input.magic_prompt !== void 0) {
+        generateRequest.magic_prompt = input.magic_prompt;
+      }
+      if (input.style_type !== void 0) {
+        generateRequest.style_type = input.style_type;
+      }
+      const createOptions = {
+        request: generateRequest,
+        type: "generate"
+      };
+      if (input.webhook_url !== void 0) {
+        createOptions.webhookUrl = input.webhook_url;
+      }
+      const prediction = store.create(createOptions);
+      const result = {
+        success: true,
+        prediction_id: prediction.id,
+        status: "queued",
+        eta_seconds: prediction.eta_seconds ?? 30,
+        message: `Image generation queued successfully. Use ideogram_get_prediction with prediction_id "${prediction.id}" to check status and retrieve results.`
+      };
+      const durationMs = Date.now() - startTime;
+      logToolResult(log, {
+        tool: TOOL_NAME3,
+        success: true,
+        durationMs
+      });
+      log.debug(
+        {
+          predictionId: prediction.id,
+          etaSeconds: result.eta_seconds,
+          durationMs
+        },
+        "Async generation queued successfully"
+      );
+      return result;
+    } catch (error) {
+      const mcpError = error instanceof IdeogramMCPError ? error : wrapError(error);
+      const durationMs = Date.now() - startTime;
+      logError(log, mcpError, "Async generation queueing failed", {
+        tool: TOOL_NAME3,
+        durationMs
+      });
+      logToolResult(log, {
+        tool: TOOL_NAME3,
+        success: false,
+        durationMs,
+        errorCode: mcpError.code
+      });
+      return mcpError.toToolError();
+    }
+  };
+}
+function getDefaultStore() {
+  if (!defaultStore) {
+    defaultStore = createPredictionStore();
+  }
+  return defaultStore;
+}
+function getDefaultHandler3() {
+  if (!defaultHandler3) {
+    defaultHandler3 = createGenerateAsyncHandler({
+      store: getDefaultStore()
+    });
+  }
+  return defaultHandler3;
+}
+async function ideogramGenerateAsync(input) {
+  return getDefaultHandler3()(input);
+}
+var TOOL_NAME3, TOOL_DESCRIPTION3, TOOL_SCHEMA3, defaultHandler3, defaultStore, ideogramGenerateAsyncTool;
+var init_generate_async = __esm({
+  "src/tools/generate-async.ts"() {
+    "use strict";
+    init_tool_types();
+    init_prediction_store();
+    init_error_handler();
+    init_logger();
+    TOOL_NAME3 = "ideogram_generate_async";
+    TOOL_DESCRIPTION3 = `Queue an image generation request for background processing.
+
+Returns immediately with a prediction_id that can be used to poll for status and results using ideogram_get_prediction.
+
+This is a LOCAL async implementation since the Ideogram API is synchronous only. Jobs are queued internally and processed in order. Use this when you want to:
+- Queue multiple generations without waiting
+- Continue working while images generate in the background
+- Have more control over the generation workflow
+
+Parameters are the same as ideogram_generate:
+- prompt: Text description of the desired image (required)
+- aspect_ratio: Image dimensions (1x1, 16x9, etc.)
+- num_images: Number of images to generate (1-8)
+- rendering_speed: FLASH (fastest), TURBO, DEFAULT, or QUALITY (best)
+- magic_prompt: AUTO, ON, or OFF for prompt enhancement
+- style_type: AUTO, GENERAL, REALISTIC, DESIGN, or FICTION
+
+Returns:
+- prediction_id: Unique ID for polling
+- status: 'queued'
+- eta_seconds: Estimated time to completion
+- message: Status message
+
+After calling this, use ideogram_get_prediction to check status and retrieve results.`;
+    TOOL_SCHEMA3 = GenerateAsyncInputSchema;
+    defaultHandler3 = null;
+    defaultStore = null;
+    ideogramGenerateAsyncTool = {
+      name: TOOL_NAME3,
+      description: TOOL_DESCRIPTION3,
+      schema: TOOL_SCHEMA3,
+      handler: ideogramGenerateAsync
+    };
+  }
+});
+
+// src/tools/get-prediction.ts
+var get_prediction_exports = {};
+__export(get_prediction_exports, {
+  TOOL_DESCRIPTION: () => TOOL_DESCRIPTION4,
+  TOOL_NAME: () => TOOL_NAME4,
+  TOOL_SCHEMA: () => TOOL_SCHEMA4,
+  createGetPredictionHandler: () => createGetPredictionHandler,
+  getDefaultHandler: () => getDefaultHandler4,
+  getDefaultStore: () => getDefaultStore2,
+  ideogramGetPrediction: () => ideogramGetPrediction,
+  ideogramGetPredictionTool: () => ideogramGetPredictionTool,
+  resetDefaultHandler: () => resetDefaultHandler,
+  setDefaultStore: () => setDefaultStore
+});
+function createGetPredictionHandler(options = {}) {
+  const log = options.logger ?? createChildLogger("tool:get-prediction");
+  const store = options.store ?? createPredictionStore(options.storeOptions);
+  return async function ideogramGetPredictionHandler(input) {
+    const startTime = Date.now();
+    logToolInvocation(log, {
+      tool: TOOL_NAME4,
+      params: {
+        prediction_id: input.prediction_id
+      }
+    });
+    try {
+      const prediction = store.getOrThrow(input.prediction_id);
+      let result;
+      switch (prediction.status) {
+        case "queued":
+        case "processing": {
+          const processingResult = {
+            success: true,
+            prediction_id: prediction.id,
+            status: prediction.status,
+            message: `Prediction is ${formatPredictionStatus(prediction.status).toLowerCase()}. Please poll again in a few seconds.`
+          };
+          if (prediction.eta_seconds !== void 0) {
+            processingResult.eta_seconds = prediction.eta_seconds;
+          }
+          if (prediction.progress !== void 0) {
+            processingResult.progress = prediction.progress;
+          }
+          result = processingResult;
+          break;
+        }
+        case "completed": {
+          const images = [];
+          const apiResult = prediction.result;
+          if (apiResult?.data) {
+            for (const apiImage of apiResult.data) {
+              const outputImage = {
+                url: apiImage.url,
+                seed: apiImage.seed,
+                is_image_safe: apiImage.is_image_safe
+              };
+              if (apiImage.prompt !== void 0) {
+                outputImage.prompt = apiImage.prompt;
+              }
+              if (apiImage.resolution !== void 0) {
+                outputImage.resolution = apiImage.resolution;
+              }
+              images.push(outputImage);
+            }
+          }
+          const renderingSpeed = prediction.request.rendering_speed ?? "DEFAULT";
+          const numImages = images.length || prediction.request.num_images || 1;
+          const cost = prediction.type === "edit" ? calculateEditCost({ numImages, renderingSpeed }) : calculateCost({ numImages, renderingSpeed });
+          const completedResult = {
+            success: true,
+            prediction_id: prediction.id,
+            status: "completed",
+            created: prediction.created_at,
+            images,
+            total_cost: toCostEstimateOutput(cost),
+            num_images: images.length
+          };
+          result = completedResult;
+          break;
+        }
+        case "failed":
+        case "cancelled": {
+          const failedResult = {
+            success: false,
+            prediction_id: prediction.id,
+            status: prediction.status,
+            error: prediction.error ?? {
+              code: prediction.status === "cancelled" ? "CANCELLED" : "UNKNOWN_ERROR",
+              message: prediction.status === "cancelled" ? "Prediction was cancelled by user" : "Prediction failed with an unknown error",
+              retryable: false
+            },
+            message: prediction.status === "cancelled" ? "This prediction was cancelled. Create a new async generation request to try again." : `Prediction failed: ${prediction.error?.message ?? "Unknown error"}. ${prediction.error?.retryable ? "This error may be retryable." : "Please check your input and try again."}`
+          };
+          result = failedResult;
+          break;
+        }
+        default: {
+          const unknownResult = {
+            success: false,
+            prediction_id: prediction.id,
+            status: "failed",
+            error: {
+              code: "UNKNOWN_STATUS",
+              message: `Unknown prediction status: ${prediction.status}`,
+              retryable: false
+            },
+            message: "Prediction has an unknown status. Please contact support."
+          };
+          result = unknownResult;
+        }
+      }
+      const durationMs = Date.now() - startTime;
+      logToolResult(log, {
+        tool: TOOL_NAME4,
+        success: true,
+        durationMs
+      });
+      log.debug(
+        {
+          predictionId: prediction.id,
+          status: prediction.status,
+          durationMs
+        },
+        "Prediction status retrieved successfully"
+      );
+      return result;
+    } catch (error) {
+      const mcpError = error instanceof IdeogramMCPError ? error : wrapError(error);
+      const durationMs = Date.now() - startTime;
+      logError(log, mcpError, "Get prediction failed", {
+        tool: TOOL_NAME4,
+        predictionId: input.prediction_id,
+        durationMs
+      });
+      logToolResult(log, {
+        tool: TOOL_NAME4,
+        success: false,
+        durationMs,
+        errorCode: mcpError.code
+      });
+      return mcpError.toToolError();
+    }
+  };
+}
+function setDefaultStore(store) {
+  defaultStore2 = store;
+  defaultHandler4 = null;
+}
+function getDefaultStore2() {
+  if (!defaultStore2) {
+    defaultStore2 = createPredictionStore();
+  }
+  return defaultStore2;
+}
+function getDefaultHandler4() {
+  if (!defaultHandler4) {
+    defaultHandler4 = createGetPredictionHandler({
+      store: getDefaultStore2()
+    });
+  }
+  return defaultHandler4;
+}
+function resetDefaultHandler() {
+  if (defaultStore2) {
+    defaultStore2.dispose();
+    defaultStore2 = null;
+  }
+  defaultHandler4 = null;
+}
+async function ideogramGetPrediction(input) {
+  return getDefaultHandler4()(input);
+}
+var TOOL_NAME4, TOOL_DESCRIPTION4, TOOL_SCHEMA4, defaultHandler4, defaultStore2, ideogramGetPredictionTool;
+var init_get_prediction = __esm({
+  "src/tools/get-prediction.ts"() {
+    "use strict";
+    init_tool_types();
+    init_prediction_store();
+    init_cost_calculator();
+    init_error_handler();
+    init_logger();
+    TOOL_NAME4 = "ideogram_get_prediction";
+    TOOL_DESCRIPTION4 = `Check the status of an async image generation request.
+
+This tool polls the local job queue to check the status of a prediction created with ideogram_generate_async. Use it to:
+- Monitor progress of queued or processing jobs
+- Retrieve completed results including generated images and cost estimates
+- Check if a job has failed and get error information
+
+This is a LOCAL implementation since the Ideogram API is synchronous only. The prediction state is managed by the local job queue.
+
+Parameters:
+- prediction_id: The unique ID returned from ideogram_generate_async (required)
+
+Returns one of:
+1. **Processing** (status: 'queued' or 'processing'):
+   - progress: Percentage complete (0-100)
+   - eta_seconds: Estimated time remaining
+   - message: Status description
+
+2. **Completed** (status: 'completed'):
+   - images: Array of generated images with URLs, seeds, etc.
+   - total_cost: Estimated credits and USD cost
+   - num_images: Count of generated images
+
+3. **Failed** (status: 'failed' or 'cancelled'):
+   - error: { code, message, retryable }
+   - message: Description of what went wrong
+
+Typical workflow:
+1. Call ideogram_generate_async to queue a request
+2. Poll with ideogram_get_prediction until status is 'completed' or 'failed'
+3. Process the results or handle the error`;
+    TOOL_SCHEMA4 = GetPredictionInputSchema;
+    defaultHandler4 = null;
+    defaultStore2 = null;
+    ideogramGetPredictionTool = {
+      name: TOOL_NAME4,
+      description: TOOL_DESCRIPTION4,
+      schema: TOOL_SCHEMA4,
+      handler: ideogramGetPrediction
+    };
+  }
+});
+
+// src/tools/cancel-prediction.ts
+var cancel_prediction_exports = {};
+__export(cancel_prediction_exports, {
+  TOOL_DESCRIPTION: () => TOOL_DESCRIPTION5,
+  TOOL_NAME: () => TOOL_NAME5,
+  TOOL_SCHEMA: () => TOOL_SCHEMA5,
+  createCancelPredictionHandler: () => createCancelPredictionHandler,
+  getDefaultHandler: () => getDefaultHandler5,
+  getDefaultStore: () => getDefaultStore3,
+  ideogramCancelPrediction: () => ideogramCancelPrediction,
+  ideogramCancelPredictionTool: () => ideogramCancelPredictionTool,
+  resetDefaultHandler: () => resetDefaultHandler2,
+  setDefaultStore: () => setDefaultStore2
+});
+function createCancelPredictionHandler(options = {}) {
+  const log = options.logger ?? createChildLogger("tool:cancel-prediction");
+  const store = options.store ?? createPredictionStore(options.storeOptions);
+  return async function ideogramCancelPredictionHandler(input) {
+    const startTime = Date.now();
+    logToolInvocation(log, {
+      tool: TOOL_NAME5,
+      params: {
+        prediction_id: input.prediction_id
+      }
+    });
+    try {
+      const cancelResult = store.cancel(input.prediction_id);
+      let result;
+      if (cancelResult.success) {
+        const successResult = {
+          success: true,
+          prediction_id: input.prediction_id,
+          status: "cancelled",
+          message: "Prediction successfully cancelled. No credits will be used."
+        };
+        result = successResult;
+      } else {
+        const statusLabels = {
+          queued: "is still queued",
+          processing: "is already being processed by the Ideogram API and cannot be stopped",
+          completed: "has already completed successfully",
+          failed: "has already failed",
+          cancelled: "was already cancelled"
+        };
+        const reasonMessages = {
+          queued: "Prediction is queued but cancellation failed unexpectedly",
+          processing: "Cannot cancel - prediction is already being processed",
+          completed: "Cannot cancel - prediction already completed",
+          failed: "Cannot cancel - prediction already failed",
+          cancelled: "Prediction was already cancelled"
+        };
+        const failedResult = {
+          success: false,
+          prediction_id: input.prediction_id,
+          status: cancelResult.status === "cancelled" ? "failed" : cancelResult.status,
+          reason: reasonMessages[cancelResult.status],
+          message: `Cannot cancel this prediction because it ${statusLabels[cancelResult.status]}. ${cancelResult.status === "processing" ? "The job was already sent to the Ideogram API." : cancelResult.status === "completed" ? "Use ideogram_get_prediction to retrieve the results." : ""}`.trim()
+        };
+        result = failedResult;
+      }
+      const durationMs = Date.now() - startTime;
+      logToolResult(log, {
+        tool: TOOL_NAME5,
+        success: true,
+        durationMs
+      });
+      log.debug(
+        {
+          predictionId: input.prediction_id,
+          cancelled: cancelResult.success,
+          status: cancelResult.status,
+          durationMs
+        },
+        "Cancel prediction request processed"
+      );
+      return result;
+    } catch (error) {
+      const mcpError = error instanceof IdeogramMCPError ? error : wrapError(error);
+      const durationMs = Date.now() - startTime;
+      logError(log, mcpError, "Cancel prediction failed", {
+        tool: TOOL_NAME5,
+        predictionId: input.prediction_id,
+        durationMs
+      });
+      logToolResult(log, {
+        tool: TOOL_NAME5,
+        success: false,
+        durationMs,
+        errorCode: mcpError.code
+      });
+      return mcpError.toToolError();
+    }
+  };
+}
+function setDefaultStore2(store) {
+  defaultStore3 = store;
+  defaultHandler5 = null;
+}
+function getDefaultStore3() {
+  if (!defaultStore3) {
+    defaultStore3 = createPredictionStore();
+  }
+  return defaultStore3;
+}
+function getDefaultHandler5() {
+  if (!defaultHandler5) {
+    defaultHandler5 = createCancelPredictionHandler({
+      store: getDefaultStore3()
+    });
+  }
+  return defaultHandler5;
+}
+function resetDefaultHandler2() {
+  if (defaultStore3) {
+    defaultStore3.dispose();
+    defaultStore3 = null;
+  }
+  defaultHandler5 = null;
+}
+async function ideogramCancelPrediction(input) {
+  return getDefaultHandler5()(input);
+}
+var TOOL_NAME5, TOOL_DESCRIPTION5, TOOL_SCHEMA5, defaultHandler5, defaultStore3, ideogramCancelPredictionTool;
+var init_cancel_prediction = __esm({
+  "src/tools/cancel-prediction.ts"() {
+    "use strict";
+    init_tool_types();
+    init_prediction_store();
+    init_error_handler();
+    init_logger();
+    TOOL_NAME5 = "ideogram_cancel_prediction";
+    TOOL_DESCRIPTION5 = `Cancel a queued async image generation request.
+
+This tool cancels a prediction that was created with ideogram_generate_async. It only works for predictions that are still in the queue - once a prediction starts processing (submitted to the Ideogram API), it cannot be cancelled.
+
+This is a LOCAL implementation since the Ideogram API is synchronous only. Cancellation is managed by the local job queue.
+
+Parameters:
+- prediction_id: The unique ID returned from ideogram_generate_async (required)
+
+Returns one of:
+1. **Success** (status: 'cancelled'):
+   - The prediction was successfully cancelled
+   - It will not be processed and no credits will be used
+
+2. **Failed** (status: 'processing' | 'completed' | 'failed'):
+   - Cannot cancel because the prediction is already processing or completed
+   - If 'processing': The job was already sent to the Ideogram API
+   - If 'completed': The job finished successfully
+   - If 'failed': The job already failed
+
+Note: You can only cancel predictions that are in 'queued' status. Once processing begins, the Ideogram API call is in progress and cannot be stopped.
+
+Typical workflow:
+1. Call ideogram_generate_async to queue a request
+2. If you change your mind, call ideogram_cancel_prediction before it starts processing
+3. Use ideogram_get_prediction to verify the cancellation`;
+    TOOL_SCHEMA5 = CancelPredictionInputSchema;
+    defaultHandler5 = null;
+    defaultStore3 = null;
+    ideogramCancelPredictionTool = {
+      name: TOOL_NAME5,
+      description: TOOL_DESCRIPTION5,
+      schema: TOOL_SCHEMA5,
+      handler: ideogramCancelPrediction
+    };
+  }
+});
+
+// src/index.ts
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/server.ts
+init_constants();
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+
+// src/tools/index.ts
+init_prediction_store();
+init_generate();
+init_edit();
+init_generate_async();
+init_get_prediction();
+init_cancel_prediction();
+init_generate();
+init_edit();
+init_generate_async();
+init_get_prediction();
+init_cancel_prediction();
+import "zod";
+var allTools = [
+  ideogramGenerateTool,
+  ideogramEditTool,
+  ideogramGenerateAsyncTool,
+  ideogramGetPredictionTool,
+  ideogramCancelPredictionTool
+];
+var sharedPredictionStore = null;
+function initializeSharedStore(options) {
+  if (!sharedPredictionStore) {
+    sharedPredictionStore = createPredictionStore(options);
+    Promise.resolve().then(() => (init_get_prediction(), get_prediction_exports)).then(({ setDefaultStore: setDefaultStore3 }) => {
+      if (sharedPredictionStore) {
+        setDefaultStore3(sharedPredictionStore);
+      }
+    });
+    Promise.resolve().then(() => (init_cancel_prediction(), cancel_prediction_exports)).then(({ setDefaultStore: setDefaultStore3 }) => {
+      if (sharedPredictionStore) {
+        setDefaultStore3(sharedPredictionStore);
+      }
+    });
+  }
+  return sharedPredictionStore;
+}
+function disposeSharedStore() {
+  if (sharedPredictionStore) {
+    sharedPredictionStore.dispose();
+    sharedPredictionStore = null;
+  }
+}
+
+// src/server.ts
+init_logger();
+init_constants();
+var serverLogger = createChildLogger("server");
+function createServer(options = {}) {
+  const {
+    name = SERVER_INFO.NAME,
+    version = SERVER_INFO.VERSION,
+    toolOptions = {}
+  } = options;
+  serverLogger.info({ name, version }, "Creating MCP server");
+  const server = new McpServer({
+    name,
+    version
+  });
+  const { initializeStore = true, storeOptions } = toolOptions;
+  if (initializeStore) {
+    initializeSharedStore(storeOptions);
+  }
+  serverLogger.debug("Registering tools with server.tool()");
+  for (const tool of allTools) {
+    server.tool(
+      tool.name,
+      tool.description,
+      // Schema is passed as the Zod schema object
+      tool.schema,
+      // Handler wrapper to format response for MCP
+      async (input) => {
+        const handler = tool.handler;
+        const result = await handler(input);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(result, null, 2)
+            }
+          ]
+        };
+      }
+    );
+    serverLogger.debug({ toolName: tool.name }, "Registered tool");
+  }
+  serverLogger.info(
+    {
+      name,
+      version,
+      toolCount: allTools.length,
+      tools: allTools.map((t) => t.name)
+    },
+    "MCP server created with tools registered"
+  );
+  return server;
+}
+async function startServer(transport, options = {}) {
+  const server = createServer(options);
+  serverLogger.info("Connecting transport");
+  try {
+    await server.connect(transport);
+    serverLogger.info("Server connected and ready");
+  } catch (error) {
+    serverLogger.error({ err: error }, "Failed to connect transport");
+    throw error;
+  }
+  const shutdown = async () => {
+    serverLogger.info("Shutting down server");
+    try {
+      disposeSharedStore();
+      await server.close();
+      serverLogger.info("Server shutdown complete");
+    } catch (error) {
+      serverLogger.error({ err: error }, "Error during shutdown");
+      throw error;
+    }
+  };
+  return { server, shutdown };
+}
+
+// src/index.ts
+init_logger();
+init_config();
+var entryLogger = createChildLogger("entry");
+function validateConfiguration() {
+  if (!isConfigValid()) {
+    const errors = getConfigErrors();
+    entryLogger.error(
+      { errors },
+      "Invalid configuration. Please check your environment variables."
+    );
+    process.stderr.write(
+      `Configuration Error: ${errors.join(", ")}
+
+Required environment variables:
+  IDEOGRAM_API_KEY - Your Ideogram API key (get one at https://ideogram.ai)
+
+Optional environment variables:
+  LOG_LEVEL - Logging level (debug, info, warn, error). Default: info
+  LOCAL_SAVE_DIR - Directory for saving images. Default: ./ideogram_images
+  ENABLE_LOCAL_SAVE - Enable local image saving. Default: true
+  MAX_CONCURRENT_REQUESTS - Rate limiting. Default: 3
+  REQUEST_TIMEOUT_MS - API timeout in milliseconds. Default: 30000
+`
+    );
+    process.exit(1);
+  }
+  entryLogger.debug("Configuration validated successfully");
+}
+function setupSignalHandlers(shutdown) {
+  process.on("SIGINT", async () => {
+    entryLogger.info("Received SIGINT, shutting down gracefully...");
+    try {
+      await shutdown();
+      process.exit(0);
+    } catch {
+      entryLogger.error("Error during shutdown");
+      process.exit(1);
+    }
+  });
+  process.on("SIGTERM", async () => {
+    entryLogger.info("Received SIGTERM, shutting down gracefully...");
+    try {
+      await shutdown();
+      process.exit(0);
+    } catch {
+      entryLogger.error("Error during shutdown");
+      process.exit(1);
+    }
+  });
+  process.on("uncaughtException", async (error) => {
+    entryLogger.error({ err: error }, "Uncaught exception");
+    try {
+      await shutdown();
+    } finally {
+      process.exit(1);
+    }
+  });
+  process.on("unhandledRejection", async (reason) => {
+    entryLogger.error({ reason }, "Unhandled promise rejection");
+    try {
+      await shutdown();
+    } finally {
+      process.exit(1);
+    }
+  });
+}
+async function main() {
+  entryLogger.info(
+    { name: SERVER_INFO.NAME, version: SERVER_INFO.VERSION },
+    "Starting Ideogram MCP Server"
+  );
+  validateConfiguration();
+  const transport = new StdioServerTransport();
+  entryLogger.debug("Created StdioServerTransport");
+  try {
+    const { shutdown } = await startServer(transport);
+    setupSignalHandlers(shutdown);
+    entryLogger.info(
+      {
+        name: SERVER_INFO.NAME,
+        version: SERVER_INFO.VERSION,
+        logLevel: config.logLevel,
+        localSaveEnabled: config.enableLocalSave,
+        localSaveDir: config.localSaveDir
+      },
+      "Ideogram MCP Server started and ready to accept connections"
+    );
+  } catch (error) {
+    entryLogger.error({ err: error }, "Failed to start server");
+    process.exit(1);
+  }
+}
+main().catch((error) => {
+  process.stderr.write(`Fatal error: ${error}
+`);
+  process.exit(1);
+});