@ljoukov/llm 7.0.12 → 7.0.14

package/dist/index.cjs

@@ -30,6 +30,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  CHATGPT_IMAGE_MODEL_IDS: () => CHATGPT_IMAGE_MODEL_IDS,
   CHATGPT_MODEL_IDS: () => CHATGPT_MODEL_IDS,
   CODEX_APPLY_PATCH_FREEFORM_TOOL_DESCRIPTION: () => CODEX_APPLY_PATCH_FREEFORM_TOOL_DESCRIPTION,
   CODEX_APPLY_PATCH_JSON_TOOL_DESCRIPTION: () => CODEX_APPLY_PATCH_JSON_TOOL_DESCRIPTION,
@@ -50,6 +51,17 @@ __export(index_exports, {
   LLM_MODEL_IDS: () => LLM_MODEL_IDS,
   LLM_TEXT_MODEL_IDS: () => LLM_TEXT_MODEL_IDS,
   LlmJsonCallError: () => LlmJsonCallError,
+  OPENAI_GPT_IMAGE_2_AUTO_RESOLUTION: () => OPENAI_GPT_IMAGE_2_AUTO_RESOLUTION,
+  OPENAI_GPT_IMAGE_2_BACKGROUNDS: () => OPENAI_GPT_IMAGE_2_BACKGROUNDS,
+  OPENAI_GPT_IMAGE_2_MODERATION_LEVELS: () => OPENAI_GPT_IMAGE_2_MODERATION_LEVELS,
+  OPENAI_GPT_IMAGE_2_NUM_IMAGES: () => OPENAI_GPT_IMAGE_2_NUM_IMAGES,
+  OPENAI_GPT_IMAGE_2_OUTPUT_FORMATS: () => OPENAI_GPT_IMAGE_2_OUTPUT_FORMATS,
+  OPENAI_GPT_IMAGE_2_PARTIAL_IMAGE_COUNTS: () => OPENAI_GPT_IMAGE_2_PARTIAL_IMAGE_COUNTS,
+  OPENAI_GPT_IMAGE_2_POPULAR_RESOLUTIONS: () => OPENAI_GPT_IMAGE_2_POPULAR_RESOLUTIONS,
+  OPENAI_GPT_IMAGE_2_QUALITY_LEVELS: () => OPENAI_GPT_IMAGE_2_QUALITY_LEVELS,
+  OPENAI_GPT_IMAGE_2_RESOLUTIONS: () => OPENAI_GPT_IMAGE_2_RESOLUTIONS,
+  OPENAI_GPT_IMAGE_2_SIZE_CONSTRAINTS: () => OPENAI_GPT_IMAGE_2_SIZE_CONSTRAINTS,
+  OPENAI_IMAGE_MODEL_IDS: () => OPENAI_IMAGE_MODEL_IDS,
   OPENAI_MODEL_IDS: () => OPENAI_MODEL_IDS,
   appendMarkdownSourcesSection: () => appendMarkdownSourcesSection,
   applyPatch: () => applyPatch,
@@ -90,6 +102,7 @@ __export(index_exports, {
   generateText: () => generateText,
   getChatGptAuthProfile: () => getChatGptAuthProfile,
   getCurrentToolCallContext: () => getCurrentToolCallContext,
+  isChatGptImageModelId: () => isChatGptImageModelId,
   isChatGptModelId: () => isChatGptModelId,
   isExperimentalChatGptModelId: () => isExperimentalChatGptModelId,
   isFireworksModelId: () => isFireworksModelId,
@@ -99,6 +112,7 @@ __export(index_exports, {
   isLlmImageModelId: () => isLlmImageModelId,
   isLlmModelId: () => isLlmModelId,
   isLlmTextModelId: () => isLlmTextModelId,
+  isOpenAiImageModelId: () => isOpenAiImageModelId,
   isOpenAiModelId: () => isOpenAiModelId,
   loadEnvFromFile: () => loadEnvFromFile,
   loadLocalEnv: () => loadLocalEnv,
@@ -106,6 +120,7 @@ __export(index_exports, {
   refreshChatGptOauthToken: () => refreshChatGptOauthToken,
   resetModelConcurrencyConfig: () => resetModelConcurrencyConfig,
   resetTelemetry: () => resetTelemetry,
+  resolveChatGptImageProviderModel: () => resolveChatGptImageProviderModel,
   resolveFilesystemToolProfile: () => resolveFilesystemToolProfile,
   resolveFireworksModelId: () => resolveFireworksModelId,
   runAgentLoop: () => runAgentLoop,
@@ -118,7 +133,8 @@ __export(index_exports, {
   streamToolLoop: () => streamToolLoop,
   stripCodexCitationMarkers: () => stripCodexCitationMarkers,
   toGeminiJsonSchema: () => toGeminiJsonSchema,
-  tool: () => tool
+  tool: () => tool,
+  validateOpenAiGptImage2Resolution: () => validateOpenAiGptImage2Resolution
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -130,6 +146,7 @@ var import_node_path5 = __toESM(require("path"), 1);
 var import_genai2 = require("@google/genai");
 var import_zod_to_json_schema = require("@alcyone-labs/zod-to-json-schema");
 var import_zod3 = require("zod");
+var import_openai3 = require("openai");
 
 // src/utils/asyncQueue.ts
 function createAsyncQueue() {
@@ -331,6 +348,85 @@ var OPENAI_MODEL_IDS = [
 function isOpenAiModelId(value) {
   return OPENAI_MODEL_IDS.includes(value);
 }
+var OPENAI_IMAGE_MODEL_IDS = ["gpt-image-2"];
+function isOpenAiImageModelId(value) {
+  return OPENAI_IMAGE_MODEL_IDS.includes(value);
+}
+var CHATGPT_IMAGE_MODEL_IDS = ["chatgpt-gpt-image-2"];
+function isChatGptImageModelId(value) {
+  return CHATGPT_IMAGE_MODEL_IDS.includes(value);
+}
+var OPENAI_GPT_IMAGE_2_POPULAR_RESOLUTIONS = [
+  "1024x1024",
+  "1536x1024",
+  "1024x1536",
+  "2048x2048",
+  "2048x1152",
+  "3840x2160",
+  "2160x3840"
+];
+var OPENAI_GPT_IMAGE_2_AUTO_RESOLUTION = "auto";
+var OPENAI_GPT_IMAGE_2_RESOLUTIONS = [
+  ...OPENAI_GPT_IMAGE_2_POPULAR_RESOLUTIONS,
+  OPENAI_GPT_IMAGE_2_AUTO_RESOLUTION
+];
+var OPENAI_GPT_IMAGE_2_SIZE_CONSTRAINTS = {
+  maxEdgePixels: 3840,
+  edgeMultiplePixels: 16,
+  maxLongToShortEdgeRatio: 3,
+  minTotalPixels: 655360,
+  maxTotalPixels: 8294400,
+  experimentalTotalPixelsThreshold: 3686400
+};
+function validateOpenAiGptImage2Resolution(value) {
+  if (value === OPENAI_GPT_IMAGE_2_AUTO_RESOLUTION) {
+    return { valid: true };
+  }
+  const match = /^([1-9]\d*)x([1-9]\d*)$/.exec(value);
+  if (!match) {
+    return { valid: false, reason: 'Expected "auto" or a WIDTHxHEIGHT pixel string.' };
+  }
+  const width = Number(match[1]);
+  const height = Number(match[2]);
+  if (!Number.isSafeInteger(width) || !Number.isSafeInteger(height)) {
+    return { valid: false, reason: "Width and height must be safe integer pixel counts." };
+  }
+  const constraints = OPENAI_GPT_IMAGE_2_SIZE_CONSTRAINTS;
+  if (width > constraints.maxEdgePixels || height > constraints.maxEdgePixels) {
+    return {
+      valid: false,
+      reason: `Width and height must each be at most ${constraints.maxEdgePixels}px.`
+    };
+  }
+  if (width % constraints.edgeMultiplePixels !== 0 || height % constraints.edgeMultiplePixels !== 0) {
+    return {
+      valid: false,
+      reason: `Width and height must each be multiples of ${constraints.edgeMultiplePixels}px.`
+    };
+  }
+  const totalPixels = width * height;
+  if (totalPixels < constraints.minTotalPixels || totalPixels > constraints.maxTotalPixels) {
+    return {
+      valid: false,
+      reason: `Total pixels must be between ${constraints.minTotalPixels} and ${constraints.maxTotalPixels}.`
+    };
+  }
+  const longEdge = Math.max(width, height);
+  const shortEdge = Math.min(width, height);
+  if (longEdge / shortEdge > constraints.maxLongToShortEdgeRatio) {
+    return {
+      valid: false,
+      reason: `The long edge must be at most ${constraints.maxLongToShortEdgeRatio}:1 relative to the short edge.`
+    };
+  }
+  return { valid: true };
+}
+var OPENAI_GPT_IMAGE_2_QUALITY_LEVELS = ["low", "medium", "high", "auto"];
+var OPENAI_GPT_IMAGE_2_OUTPUT_FORMATS = ["png", "jpeg", "webp"];
+var OPENAI_GPT_IMAGE_2_BACKGROUNDS = ["opaque", "auto"];
+var OPENAI_GPT_IMAGE_2_MODERATION_LEVELS = ["low", "auto"];
+var OPENAI_GPT_IMAGE_2_PARTIAL_IMAGE_COUNTS = [0, 1, 2, 3];
+var OPENAI_GPT_IMAGE_2_NUM_IMAGES = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
 var CHATGPT_MODEL_IDS = [
   "chatgpt-gpt-5.5",
   "chatgpt-gpt-5.5-fast",
@@ -342,6 +438,7 @@ var CHATGPT_MODEL_IDS = [
 var FAST_MODEL_SUFFIX = "-fast";
 var OPENAI_PRIORITY_MODEL_IDS = ["gpt-5.5-fast"];
 var CHATGPT_PRIORITY_MODEL_IDS = ["chatgpt-gpt-5.5-fast", "chatgpt-gpt-5.4-fast"];
+var CHATGPT_IMAGE_GENERATION_PROVIDER_MODEL = "gpt-5.4";
 var EXPERIMENTAL_CHATGPT_MODEL_PREFIX = "experimental-chatgpt-";
 function isExperimentalChatGptModelId(value) {
   return value.startsWith(EXPERIMENTAL_CHATGPT_MODEL_PREFIX) && value.length > EXPERIMENTAL_CHATGPT_MODEL_PREFIX.length;
@@ -368,6 +465,9 @@ function resolveChatGptProviderModel(model) {
   const providerModel = stripChatGptPrefix(model);
   return CHATGPT_PRIORITY_MODEL_IDS.includes(model) ? stripFastSuffix(providerModel) : providerModel;
 }
+function resolveChatGptImageProviderModel(_model) {
+  return CHATGPT_IMAGE_GENERATION_PROVIDER_MODEL;
+}
 function resolveChatGptServiceTier(model) {
   return CHATGPT_PRIORITY_MODEL_IDS.includes(model) ? "priority" : void 0;
 }
@@ -413,6 +513,27 @@ var OPENAI_GPT_54_NANO_PRICING = {
   cachedRate: 5e-3 / 1e6,
   outputRate: 0.4 / 1e6
 };
+var OPENAI_GPT_IMAGE_2_PRICING = {
+  defaultQuality: "medium",
+  defaultResolution: "1024x1024",
+  imagePrices: {
+    low: {
+      "1024x1024": 6e-3,
+      "1024x1536": 5e-3,
+      "1536x1024": 5e-3
+    },
+    medium: {
+      "1024x1024": 0.053,
+      "1024x1536": 0.041,
+      "1536x1024": 0.041
+    },
+    high: {
+      "1024x1024": 0.211,
+      "1024x1536": 0.165,
+      "1536x1024": 0.165
+    }
+  }
+};
 function getOpenAiPricing(modelId) {
   if (isExperimentalChatGptModelId(modelId)) {
     return OPENAI_GPT_54_PRICING;
@@ -440,6 +561,9 @@ function getOpenAiPricing(modelId) {
   }
   return void 0;
 }
+function getOpenAiImagePricing(modelId) {
+  return isOpenAiImageModelId(modelId) || isChatGptImageModelId(modelId) ? OPENAI_GPT_IMAGE_2_PRICING : void 0;
+}
 
 // src/utils/cost.ts
 function resolveUsageNumber(value) {
@@ -452,8 +576,18 @@ function estimateCallCostUsd({
   modelId,
   tokens,
   responseImages,
-  imageSize
+  imageSize,
+  imageQuality
 }) {
+  const openAiImagePricing = getOpenAiImagePricing(modelId);
+  if (openAiImagePricing) {
+    return estimateOpenAiImageCostUsd({
+      pricing: openAiImagePricing,
+      responseImages,
+      imageSize,
+      imageQuality
+    });
+  }
   if (!tokens) {
     return 0;
   }
@@ -515,6 +649,40 @@ function estimateCallCostUsd({
   }
   return 0;
 }
+function estimateOpenAiImageCostUsd({
+  pricing,
+  responseImages,
+  imageSize,
+  imageQuality
+}) {
+  if (responseImages <= 0) {
+    return 0;
+  }
+  const quality = imageQuality === "low" || imageQuality === "medium" || imageQuality === "high" ? imageQuality : pricing.defaultQuality;
+  const resolution = resolveOpenAiImagePriceResolution(imageSize) ?? pricing.defaultResolution;
+  return responseImages * pricing.imagePrices[quality][resolution];
+}
+function resolveOpenAiImagePriceResolution(imageSize) {
+  if (imageSize === "1024x1024" || imageSize === "1024x1536" || imageSize === "1536x1024") {
+    return imageSize;
+  }
+  if (!imageSize || imageSize === "auto") {
+    return void 0;
+  }
+  const match = /^(\d+)x(\d+)$/.exec(imageSize);
+  if (!match) {
+    return void 0;
+  }
+  const width = Number(match[1]);
+  const height = Number(match[2]);
+  if (!Number.isFinite(width) || !Number.isFinite(height) || width <= 0 || height <= 0) {
+    return void 0;
+  }
+  if (width === height) {
+    return "1024x1024";
+  }
+  return width > height ? "1536x1024" : "1024x1536";
+}
 
 // src/openai/chatgpt-codex.ts
 var import_node_os2 = __toESM(require("os"), 1);
@@ -1669,6 +1837,8 @@ async function collectChatGptCodexStream(options) {
   const toolCallOrder = [];
   const webSearchCalls = /* @__PURE__ */ new Map();
   const webSearchCallOrder = [];
+  const imageGenerationCalls = /* @__PURE__ */ new Map();
+  const imageGenerationCallOrder = [];
   let text = "";
   const reasoningText = "";
   let reasoningSummaryText = "";
@@ -1739,6 +1909,20 @@ async function collectChatGptCodexStream(options) {
               action: item.action && typeof item.action === "object" ? item.action : void 0
             });
           }
+        } else if (item.type === "image_generation_call") {
+          const id = typeof item.id === "string" ? item.id : "";
+          const result = typeof item.result === "string" ? item.result : "";
+          if (id && result) {
+            if (!imageGenerationCalls.has(id)) {
+              imageGenerationCallOrder.push(id);
+            }
+            imageGenerationCalls.set(id, {
+              id,
+              status: typeof item.status === "string" ? item.status : void 0,
+              revisedPrompt: typeof item.revised_prompt === "string" ? item.revised_prompt : void 0,
+              result
+            });
+          }
         }
       }
       continue;
@@ -1778,12 +1962,14 @@ async function collectChatGptCodexStream(options) {
   }
   const orderedToolCalls = toolCallOrder.map((id) => toolCalls.get(id)).filter((call) => call !== void 0);
   const orderedWebSearchCalls = webSearchCallOrder.map((id) => webSearchCalls.get(id)).filter((call) => call !== void 0);
+  const orderedImageGenerationCalls = imageGenerationCallOrder.map((id) => imageGenerationCalls.get(id)).filter((call) => call !== void 0);
   return {
     text,
     reasoningText,
     reasoningSummaryText,
     toolCalls: orderedToolCalls,
     webSearchCalls: orderedWebSearchCalls,
+    imageGenerationCalls: orderedImageGenerationCalls,
     usage,
     id: responseId,
     model,
@@ -4495,13 +4681,17 @@ var LLM_TEXT_MODEL_IDS = [
   ...FIREWORKS_MODEL_IDS,
   ...GEMINI_TEXT_MODEL_IDS
 ];
-var LLM_IMAGE_MODEL_IDS = [...GEMINI_IMAGE_MODEL_IDS];
+var LLM_IMAGE_MODEL_IDS = [
+  ...OPENAI_IMAGE_MODEL_IDS,
+  ...CHATGPT_IMAGE_MODEL_IDS,
+  ...GEMINI_IMAGE_MODEL_IDS
+];
 var LLM_MODEL_IDS = [...LLM_TEXT_MODEL_IDS, ...LLM_IMAGE_MODEL_IDS];
 function isLlmTextModelId(value) {
   return isOpenAiModelId(value) || isChatGptModelId(value) || isFireworksModelId(value) || isGeminiTextModelId(value);
 }
 function isLlmImageModelId(value) {
-  return isGeminiImageModelId(value);
+  return isOpenAiImageModelId(value) || isChatGptImageModelId(value) || isGeminiImageModelId(value);
 }
 function isLlmModelId(value) {
   return isLlmTextModelId(value) || isLlmImageModelId(value);
@@ -4513,6 +4703,12 @@ var LlmJsonCallError = class extends Error {
     this.name = "LlmJsonCallError";
   }
 };
+function isOpenAiGenerateImagesRequest(request) {
+  return isOpenAiImageModelId(request.model);
+}
+function isChatGptGenerateImagesRequest(request) {
+  return isChatGptImageModelId(request.model);
+}
 function tool(options) {
   return {
     type: "function",
@@ -5103,6 +5299,15 @@ function resolveProvider(model) {
       return { provider: "fireworks", model: fireworksModel };
     }
   }
+  if (isOpenAiImageModelId(model)) {
+    return { provider: "openai", model };
+  }
+  if (isChatGptImageModelId(model)) {
+    return {
+      provider: "chatgpt",
+      model: resolveChatGptImageProviderModel(model)
+    };
+  }
   if (isOpenAiModelId(model)) {
     return {
       provider: "openai",
@@ -5110,7 +5315,7 @@ function resolveProvider(model) {
       serviceTier: resolveOpenAiServiceTier(model)
     };
   }
-  throw new Error(`Unsupported text model: ${model}`);
+  throw new Error(`Unsupported model: ${model}`);
 }
 function isOpenAiCodexModel(modelId) {
   return modelId.includes("codex");
@@ -6266,8 +6471,11 @@ function mergeTokenUpdates(current, next) {
   }
   return {
     promptTokens: next.promptTokens ?? current.promptTokens,
+    promptTextTokens: next.promptTextTokens ?? current.promptTextTokens,
+    promptImageTokens: next.promptImageTokens ?? current.promptImageTokens,
     cachedTokens: next.cachedTokens ?? current.cachedTokens,
     responseTokens: next.responseTokens ?? current.responseTokens,
+    responseTextTokens: next.responseTextTokens ?? current.responseTextTokens,
     responseImageTokens: next.responseImageTokens ?? current.responseImageTokens,
     thinkingTokens: next.thinkingTokens ?? current.thinkingTokens,
     totalTokens: next.totalTokens ?? current.totalTokens,
@@ -6290,8 +6498,11 @@ function sumUsageTokens(current, next) {
   }
   return {
     promptTokens: sumUsageValue(current?.promptTokens, next.promptTokens),
+    promptTextTokens: sumUsageValue(current?.promptTextTokens, next.promptTextTokens),
+    promptImageTokens: sumUsageValue(current?.promptImageTokens, next.promptImageTokens),
     cachedTokens: sumUsageValue(current?.cachedTokens, next.cachedTokens),
     responseTokens: sumUsageValue(current?.responseTokens, next.responseTokens),
+    responseTextTokens: sumUsageValue(current?.responseTextTokens, next.responseTextTokens),
     responseImageTokens: sumUsageValue(current?.responseImageTokens, next.responseImageTokens),
     thinkingTokens: sumUsageValue(current?.thinkingTokens, next.thinkingTokens),
     totalTokens: sumUsageValue(current?.totalTokens, next.totalTokens),
@@ -6406,10 +6617,22 @@ function extractOpenAiUsageTokens(usage) {
   const cachedTokens = toMaybeNumber(
     usage.input_tokens_details?.cached_tokens
   );
+  const promptTextTokens = toMaybeNumber(
+    usage.input_tokens_details?.text_tokens
+  );
+  const promptImageTokens = toMaybeNumber(
+    usage.input_tokens_details?.image_tokens
+  );
   const outputTokensRaw = toMaybeNumber(usage.output_tokens);
   const reasoningTokens = toMaybeNumber(
     usage.output_tokens_details?.reasoning_tokens
   );
+  const responseTextTokens = toMaybeNumber(
+    usage.output_tokens_details?.text_tokens
+  );
+  const responseImageTokens = toMaybeNumber(
+    usage.output_tokens_details?.image_tokens
+  );
   const totalTokens = toMaybeNumber(usage.total_tokens);
   let responseTokens;
   if (outputTokensRaw !== void 0) {
@@ -6421,8 +6644,12 @@ function extractOpenAiUsageTokens(usage) {
   }
   return {
     promptTokens,
+    promptTextTokens,
+    promptImageTokens,
     cachedTokens,
     responseTokens,
+    responseTextTokens,
+    responseImageTokens,
     thinkingTokens: reasoningTokens,
     totalTokens
   };
@@ -7898,6 +8125,9 @@ async function runTextCall(params) {
   const { result } = await collectFileUploadMetrics(async () => {
     try {
       if (provider === "openai") {
+        if (isOpenAiImageModelId(request.model)) {
+          throw new Error("gpt-image-2 is an image generation model; use generateImages().");
+        }
         const openAiInput = await maybePrepareOpenAiPromptInput(
           toOpenAiInput(contents, {
             defaultMediaResolution: request.mediaResolution,
@@ -7984,6 +8214,11 @@ async function runTextCall(params) {
           }
         }, modelForProvider);
       } else if (provider === "chatgpt") {
+        if (isChatGptImageModelId(request.model)) {
+          throw new Error(
+            "chatgpt-gpt-image-2 is an image generation model; use generateImages()."
+          );
+        }
         const chatGptInput = toChatGptInput(contents, {
           defaultMediaResolution: request.mediaResolution,
           model: request.model
@@ -10263,7 +10498,318 @@ async function gradeGeneratedImage(params) {
   });
   return { grade: value.grade, result };
 }
+function resolveOpenAiImageMimeType(outputFormat) {
+  switch (outputFormat) {
+    case "jpeg":
+      return "image/jpeg";
+    case "webp":
+      return "image/webp";
+    case "png":
+    case void 0:
+      return "image/png";
+  }
+}
+function buildOpenAiImagePrompt(params) {
+  return [
+    "Follow the requested visual style.",
+    "",
+    "Style:",
+    params.stylePrompt.trim(),
+    ...params.hasStyleImages ? [
+      "",
+      "Use the attached reference image or images for palette, lighting, mood, composition, and material feel."
+    ] : [],
+    "",
+    "Image:",
+    params.imagePrompt.trim()
+  ].filter((line) => line.length > 0).join("\n");
+}
+function resolveOpenAiImageRequestParams(request) {
+  if (request.partialImages !== void 0) {
+    throw new Error("partialImages is only supported for streaming image generation.");
+  }
+  if (request.outputCompression !== void 0 && (!Number.isInteger(request.outputCompression) || request.outputCompression < 0 || request.outputCompression > 100)) {
+    throw new Error("outputCompression must be an integer from 0 to 100.");
+  }
+  if (request.outputCompression !== void 0 && request.outputFormat !== "jpeg" && request.outputFormat !== "webp") {
+    throw new Error("outputCompression requires outputFormat to be jpeg or webp.");
+  }
+  const size = request.imageResolution ?? "auto";
+  const sizeValidation = validateOpenAiGptImage2Resolution(size);
+  if (!sizeValidation.valid) {
+    throw new Error(
+      `imageResolution ${JSON.stringify(size)} is not supported by gpt-image-2: ${sizeValidation.reason}`
+    );
+  }
+  return {
+    size,
+    quality: request.imageQuality ?? "auto",
+    outputFormat: request.outputFormat,
+    n: request.numImages ?? 1,
+    background: request.background,
+    moderation: request.moderation
+  };
+}
+async function createOpenAiStyleImageFiles(styleImages) {
+  if (!styleImages || styleImages.length === 0) {
+    return void 0;
+  }
+  return await Promise.all(
+    styleImages.map(async (image, index) => {
+      const mimeType = image.mimeType ?? "image/png";
+      const extension = resolveAttachmentExtension(mimeType);
+      return await (0, import_openai3.toFile)(image.data, `style-${index + 1}.${extension}`, { type: mimeType });
+    })
+  );
+}
+async function generateImagesWithOpenAiImageApi(request) {
+  const promptEntries = Array.from(request.imagePrompts, (rawPrompt, index) => {
+    const prompt = rawPrompt.trim();
+    if (!prompt) {
+      throw new Error(`imagePrompts[${index}] must be a non-empty string`);
+    }
+    return prompt;
+  });
+  if (promptEntries.length === 0) {
+    return [];
+  }
+  const provider = resolveProvider(request.model).provider;
+  const telemetry = createLlmTelemetryEmitter({
+    telemetry: request.telemetry,
+    operation: "generateImages",
+    provider,
+    model: request.model
+  });
+  const startedAtMs = Date.now();
+  const params = resolveOpenAiImageRequestParams(request);
+  const styleImages = await createOpenAiStyleImageFiles(request.styleImages);
+  const hasStyleImages = Boolean(styleImages && styleImages.length > 0);
+  const outputMimeType = resolveOpenAiImageMimeType(params.outputFormat);
+  let totalUsage;
+  let costUsd = 0;
+  let outputImages = 0;
+  telemetry.emit({
+    type: "llm.call.started",
+    imagePromptCount: promptEntries.length,
+    styleImageCount: request.styleImages?.length ?? 0,
+    numImagesPerPrompt: params.n
+  });
+  try {
+    const images = [];
+    for (const imagePrompt of promptEntries) {
+      const prompt = buildOpenAiImagePrompt({
+        stylePrompt: request.stylePrompt,
+        imagePrompt,
+        hasStyleImages
+      });
+      const response = await runOpenAiCall(async (client) => {
+        const payload = {
+          model: request.model,
+          prompt,
+          n: params.n,
+          size: params.size,
+          quality: params.quality,
+          ...params.outputFormat ? { output_format: params.outputFormat } : {},
+          ...request.outputCompression !== void 0 ? { output_compression: request.outputCompression } : {},
+          ...params.background ? { background: params.background } : {},
+          ...params.moderation ? { moderation: params.moderation } : {}
+        };
+        if (styleImages && styleImages.length > 0) {
+          return await client.images.edit(
+            {
+              ...payload,
+              image: styleImages
+            },
+            { signal: request.signal }
+          );
+        }
+        return await client.images.generate(payload, { signal: request.signal });
+      }, request.model);
+      const data = Array.isArray(response.data) ? response.data ?? [] : [];
+      for (const item of data) {
+        if (typeof item.b64_json !== "string" || item.b64_json.length === 0) {
+          continue;
+        }
+        images.push({
+          mimeType: outputMimeType,
+          data: import_node_buffer4.Buffer.from(item.b64_json, "base64")
+        });
+      }
+      outputImages = images.length;
+      const usage = extractOpenAiUsageTokens(response.usage);
+      totalUsage = sumUsageTokens(totalUsage, usage);
+      costUsd += estimateCallCostUsd({
+        modelId: request.model,
+        tokens: usage,
+        responseImages: data.length,
+        imageSize: params.size,
+        imageQuality: params.quality
+      });
+    }
+    telemetry.emit({
+      type: "llm.call.completed",
+      success: true,
+      durationMs: Math.max(0, Date.now() - startedAtMs),
+      usage: totalUsage,
+      costUsd,
+      imageCount: images.length,
+      attempts: promptEntries.length
+    });
+    return images;
+  } catch (error) {
+    const err = error instanceof Error ? error : new Error(String(error));
+    telemetry.emit({
+      type: "llm.call.completed",
+      success: false,
+      durationMs: Math.max(0, Date.now() - startedAtMs),
+      usage: totalUsage,
+      costUsd,
+      imageCount: outputImages,
+      error: err.message
+    });
+    throw err;
+  } finally {
+    await telemetry.flush();
+  }
+}
+function buildChatGptImageInputContent(params) {
+  const parts = [
+    {
+      type: "text",
+      text: params.prompt
+    }
+  ];
+  for (const [index, image] of (params.styleImages ?? []).entries()) {
+    const mimeType = image.mimeType ?? "image/png";
+    parts.push({
+      type: "inlineData",
+      data: image.data.toString("base64"),
+      mimeType,
+      filename: `style-${index + 1}.${resolveAttachmentExtension(mimeType)}`
+    });
+  }
+  return [{ role: "user", parts }];
+}
+async function generateImagesWithChatGptImageTool(request) {
+  const promptEntries = Array.from(request.imagePrompts, (rawPrompt, index) => {
+    const prompt = rawPrompt.trim();
+    if (!prompt) {
+      throw new Error(`imagePrompts[${index}] must be a non-empty string`);
+    }
+    return prompt;
+  });
+  if (promptEntries.length === 0) {
+    return [];
+  }
+  const providerInfo = resolveProvider(request.model);
+  const telemetry = createLlmTelemetryEmitter({
+    telemetry: request.telemetry,
+    operation: "generateImages",
+    provider: providerInfo.provider,
+    model: request.model
+  });
+  const startedAtMs = Date.now();
+  const numImagesPerPrompt = request.numImages ?? 1;
+  let totalUsage;
+  let costUsd = 0;
+  let outputImages = 0;
+  telemetry.emit({
+    type: "llm.call.started",
+    imagePromptCount: promptEntries.length,
+    styleImageCount: request.styleImages?.length ?? 0,
+    numImagesPerPrompt
+  });
+  try {
+    const images = [];
+    for (const imagePrompt of promptEntries) {
+      const prompt = buildOpenAiImagePrompt({
+        stylePrompt: request.stylePrompt,
+        imagePrompt,
+        hasStyleImages: Boolean(request.styleImages && request.styleImages.length > 0)
+      });
+      for (let imageIndex = 0; imageIndex < numImagesPerPrompt; imageIndex += 1) {
+        const chatGptInput = toChatGptInput(
+          buildChatGptImageInputContent({
+            prompt,
+            styleImages: request.styleImages
+          }),
+          { model: request.model }
+        );
+        const preparedInput = await maybePrepareOpenAiPromptInput(chatGptInput.input, {
+          model: request.model,
+          provider: "chatgpt"
+        });
+        const result = await collectChatGptCodexResponseWithRetry({
+          request: {
+            model: providerInfo.model,
+            store: false,
+            stream: true,
+            instructions: chatGptInput.instructions ?? "Use the image_generation tool to generate exactly one PNG image. Do not return prose instead of the image.",
+            input: preparedInput,
+            tool_choice: "required",
+            parallel_tool_calls: false,
+            tools: [{ type: "image_generation", output_format: "png" }]
+          },
+          signal: request.signal
+        });
+        if (result.status && result.status !== "completed") {
+          throw new Error(`ChatGPT image generation response status ${result.status}`);
+        }
+        if (result.imageGenerationCalls.length === 0) {
+          throw new Error("ChatGPT image generation returned no image_generation_call result.");
+        }
+        for (const call of result.imageGenerationCalls) {
+          images.push({
+            mimeType: "image/png",
+            data: import_node_buffer4.Buffer.from(call.result, "base64")
+          });
+        }
+        outputImages = images.length;
+        const usage = extractChatGptUsageTokens(result.usage);
+        totalUsage = sumUsageTokens(totalUsage, usage);
+        costUsd += estimateCallCostUsd({
+          modelId: request.model,
+          tokens: usage,
+          responseImages: result.imageGenerationCalls.length,
+          imageSize: "1024x1024",
+          imageQuality: "medium"
+        });
+      }
+    }
+    telemetry.emit({
+      type: "llm.call.completed",
+      success: true,
+      durationMs: Math.max(0, Date.now() - startedAtMs),
+      modelVersion: request.model,
+      usage: totalUsage,
+      costUsd,
+      imageCount: images.length,
+      attempts: promptEntries.length * numImagesPerPrompt
+    });
+    return images;
+  } catch (error) {
+    const err = error instanceof Error ? error : new Error(String(error));
+    telemetry.emit({
+      type: "llm.call.completed",
+      success: false,
+      durationMs: Math.max(0, Date.now() - startedAtMs),
+      usage: totalUsage,
+      costUsd,
+      imageCount: outputImages,
+      error: err.message
+    });
+    throw err;
+  } finally {
+    await telemetry.flush();
+  }
+}
 async function generateImages(request) {
+  if (isOpenAiGenerateImagesRequest(request)) {
+    return await generateImagesWithOpenAiImageApi(request);
+  }
+  if (isChatGptGenerateImagesRequest(request)) {
+    return await generateImagesWithChatGptImageTool(request);
+  }
   const maxAttempts = Math.max(1, Math.floor(request.maxAttempts ?? 4));
   const promptList = Array.from(request.imagePrompts);
   if (promptList.length === 0) {
@@ -10277,7 +10823,7 @@ async function generateImages(request) {
     }
     return { index: arrayIndex + 1, prompt: trimmedPrompt };
   });
-  const gradingPrompt = request.imageGradingPrompt.trim();
+  const gradingPrompt = request.imageGradingPrompt?.trim() ?? "";
   if (!gradingPrompt) {
     throw new Error("imageGradingPrompt must be a non-empty string");
   }
@@ -13575,8 +14121,11 @@ function summarizeResultUsage(result) {
     }
     summary = {
       promptTokens: sumUsageValue2(summary?.promptTokens, usage.promptTokens),
+      promptTextTokens: sumUsageValue2(summary?.promptTextTokens, usage.promptTextTokens),
+      promptImageTokens: sumUsageValue2(summary?.promptImageTokens, usage.promptImageTokens),
       cachedTokens: sumUsageValue2(summary?.cachedTokens, usage.cachedTokens),
       responseTokens: sumUsageValue2(summary?.responseTokens, usage.responseTokens),
+      responseTextTokens: sumUsageValue2(summary?.responseTextTokens, usage.responseTextTokens),
       responseImageTokens: sumUsageValue2(summary?.responseImageTokens, usage.responseImageTokens),
       thinkingTokens: sumUsageValue2(summary?.thinkingTokens, usage.thinkingTokens),
       totalTokens: sumUsageValue2(summary?.totalTokens, usage.totalTokens),
@@ -14288,6 +14837,7 @@ async function runCandidateEvolution(options) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  CHATGPT_IMAGE_MODEL_IDS,
   CHATGPT_MODEL_IDS,
   CODEX_APPLY_PATCH_FREEFORM_TOOL_DESCRIPTION,
   CODEX_APPLY_PATCH_JSON_TOOL_DESCRIPTION,
@@ -14308,6 +14858,17 @@ async function runCandidateEvolution(options) {
   LLM_MODEL_IDS,
   LLM_TEXT_MODEL_IDS,
   LlmJsonCallError,
+  OPENAI_GPT_IMAGE_2_AUTO_RESOLUTION,
+  OPENAI_GPT_IMAGE_2_BACKGROUNDS,
+  OPENAI_GPT_IMAGE_2_MODERATION_LEVELS,
+  OPENAI_GPT_IMAGE_2_NUM_IMAGES,
+  OPENAI_GPT_IMAGE_2_OUTPUT_FORMATS,
+  OPENAI_GPT_IMAGE_2_PARTIAL_IMAGE_COUNTS,
+  OPENAI_GPT_IMAGE_2_POPULAR_RESOLUTIONS,
+  OPENAI_GPT_IMAGE_2_QUALITY_LEVELS,
+  OPENAI_GPT_IMAGE_2_RESOLUTIONS,
+  OPENAI_GPT_IMAGE_2_SIZE_CONSTRAINTS,
+  OPENAI_IMAGE_MODEL_IDS,
   OPENAI_MODEL_IDS,
   appendMarkdownSourcesSection,
   applyPatch,
@@ -14348,6 +14909,7 @@ async function runCandidateEvolution(options) {
   generateText,
   getChatGptAuthProfile,
   getCurrentToolCallContext,
+  isChatGptImageModelId,
   isChatGptModelId,
   isExperimentalChatGptModelId,
   isFireworksModelId,
@@ -14357,6 +14919,7 @@ async function runCandidateEvolution(options) {
   isLlmImageModelId,
   isLlmModelId,
   isLlmTextModelId,
+  isOpenAiImageModelId,
   isOpenAiModelId,
   loadEnvFromFile,
   loadLocalEnv,
@@ -14364,6 +14927,7 @@ async function runCandidateEvolution(options) {
   refreshChatGptOauthToken,
   resetModelConcurrencyConfig,
   resetTelemetry,
+  resolveChatGptImageProviderModel,
   resolveFilesystemToolProfile,
   resolveFireworksModelId,
   runAgentLoop,
@@ -14376,6 +14940,7 @@ async function runCandidateEvolution(options) {
   streamToolLoop,
   stripCodexCitationMarkers,
   toGeminiJsonSchema,
-  tool
+  tool,
+  validateOpenAiGptImage2Resolution
 });
 //# sourceMappingURL=index.cjs.map