@ljoukov/llm 7.0.12 → 7.0.14

package/dist/index.js

@@ -15,6 +15,7 @@ import {
 } from "@google/genai";
 import { zodToJsonSchema } from "@alcyone-labs/zod-to-json-schema";
 import { z as z3 } from "zod";
+import { toFile } from "openai";
 
 // src/utils/asyncQueue.ts
 function createAsyncQueue() {
@@ -216,6 +217,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",
@@ -227,6 +307,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;
@@ -253,6 +334,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;
 }
@@ -298,6 +382,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;
@@ -325,6 +430,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) {
@@ -337,8 +445,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;
   }
@@ -400,6 +518,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
 import os2 from "os";
@@ -1554,6 +1706,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 = "";
@@ -1624,6 +1778,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;
@@ -1663,12 +1831,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,
@@ -4380,13 +4550,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);
@@ -4398,6 +4572,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",
@@ -4988,6 +5168,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",
@@ -4995,7 +5184,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");
@@ -6151,8 +6340,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,
@@ -6175,8 +6367,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),
@@ -6291,10 +6486,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) {
@@ -6306,8 +6513,12 @@ function extractOpenAiUsageTokens(usage) {
   }
   return {
     promptTokens,
+    promptTextTokens,
+    promptImageTokens,
     cachedTokens,
     responseTokens,
+    responseTextTokens,
+    responseImageTokens,
     thinkingTokens: reasoningTokens,
     totalTokens
   };
@@ -7783,6 +7994,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,
@@ -7869,6 +8083,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
@@ -10148,7 +10367,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 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: Buffer5.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: Buffer5.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) {
@@ -10162,7 +10692,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");
   }
@@ -13460,8 +13990,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),
@@ -14172,6 +14705,7 @@ async function runCandidateEvolution(options) {
   };
 }
 export {
+  CHATGPT_IMAGE_MODEL_IDS,
   CHATGPT_MODEL_IDS,
   CODEX_APPLY_PATCH_FREEFORM_TOOL_DESCRIPTION,
   CODEX_APPLY_PATCH_JSON_TOOL_DESCRIPTION,
@@ -14192,6 +14726,17 @@ export {
   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,
@@ -14232,6 +14777,7 @@ export {
   generateText,
   getChatGptAuthProfile,
   getCurrentToolCallContext,
+  isChatGptImageModelId,
   isChatGptModelId,
   isExperimentalChatGptModelId,
   isFireworksModelId,
@@ -14241,6 +14787,7 @@ export {
   isLlmImageModelId,
   isLlmModelId,
   isLlmTextModelId,
+  isOpenAiImageModelId,
   isOpenAiModelId,
   loadEnvFromFile,
   loadLocalEnv,
@@ -14248,6 +14795,7 @@ export {
   refreshChatGptOauthToken,
   resetModelConcurrencyConfig,
   resetTelemetry,
+  resolveChatGptImageProviderModel,
   resolveFilesystemToolProfile,
   resolveFireworksModelId,
   runAgentLoop,
@@ -14260,6 +14808,7 @@ export {
   streamToolLoop,
   stripCodexCitationMarkers,
   toGeminiJsonSchema,
-  tool
+  tool,
+  validateOpenAiGptImage2Resolution
 };
 //# sourceMappingURL=index.js.map