@ljoukov/llm 7.0.12 → 7.0.13

package/README.md

@@ -182,6 +182,42 @@ console.log(result.text);
 console.log(result.usage, result.costUsd);
 ```
 
+### Image Generation
+
+```ts
+import {
+  generateImages,
+  type LlmOpenAiImageResolution,
+  OPENAI_GPT_IMAGE_2_QUALITY_LEVELS,
+  OPENAI_GPT_IMAGE_2_RESOLUTIONS,
+  OPENAI_GPT_IMAGE_2_SIZE_CONSTRAINTS,
+} from "@ljoukov/llm";
+
+const customResolution = "1440x960" satisfies LlmOpenAiImageResolution;
+
+const images = await generateImages({
+  model: "gpt-image-2",
+  stylePrompt: "Warm amber desk light, deep blue night, cinematic laboratory mood.",
+  imagePrompts: ["A compact lab bench still life with glassware and an open notebook"],
+  imageResolution: customResolution,
+  imageQuality: "low",
+  numImages: 1,
+});
+
+console.log(OPENAI_GPT_IMAGE_2_RESOLUTIONS, OPENAI_GPT_IMAGE_2_QUALITY_LEVELS);
+console.log(OPENAI_GPT_IMAGE_2_SIZE_CONSTRAINTS);
+console.log(images[0]?.mimeType, images[0]?.data.byteLength);
+```
+
+`generateImages()` is typed as a discriminated union by `model`: `gpt-image-2` requests use
+`imageResolution`, while Gemini image requests use `imageSize` (`"1K" | "2K" | "4K"`). For
+`gpt-image-2`, `OPENAI_GPT_IMAGE_2_RESOLUTIONS` exposes the documented popular presets plus
+`"auto"`; custom literal `WIDTHxHEIGHT` resolutions are also accepted when they satisfy
+`OPENAI_GPT_IMAGE_2_SIZE_CONSTRAINTS`: each edge must be at most 3840px, each edge must be a
+multiple of 16px, the long edge must be at most 3:1 relative to the short edge, and total pixels
+must be between 655,360 and 8,294,400. Resolutions above 3,686,400 pixels are documented as
+experimental by OpenAI.
+
 ### Streaming (response + thoughts + usage)
 
 ```ts

package/dist/index.cjs

@@ -50,6 +50,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,
@@ -99,6 +110,7 @@ __export(index_exports, {
   isLlmImageModelId: () => isLlmImageModelId,
   isLlmModelId: () => isLlmModelId,
   isLlmTextModelId: () => isLlmTextModelId,
+  isOpenAiImageModelId: () => isOpenAiImageModelId,
   isOpenAiModelId: () => isOpenAiModelId,
   loadEnvFromFile: () => loadEnvFromFile,
   loadLocalEnv: () => loadLocalEnv,
@@ -118,7 +130,8 @@ __export(index_exports, {
   streamToolLoop: () => streamToolLoop,
   stripCodexCitationMarkers: () => stripCodexCitationMarkers,
   toGeminiJsonSchema: () => toGeminiJsonSchema,
-  tool: () => tool
+  tool: () => tool,
+  validateOpenAiGptImage2Resolution: () => validateOpenAiGptImage2Resolution
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -130,6 +143,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 +345,81 @@ 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 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",
@@ -413,6 +502,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 +550,9 @@ function getOpenAiPricing(modelId) {
   }
   return void 0;
 }
+function getOpenAiImagePricing(modelId) {
+  return isOpenAiImageModelId(modelId) ? OPENAI_GPT_IMAGE_2_PRICING : void 0;
+}
 
 // src/utils/cost.ts
 function resolveUsageNumber(value) {
@@ -452,8 +565,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 +638,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);
@@ -4495,13 +4652,13 @@ 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, ...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) || isGeminiImageModelId(value);
 }
 function isLlmModelId(value) {
   return isLlmTextModelId(value) || isLlmImageModelId(value);
@@ -4513,6 +4670,9 @@ var LlmJsonCallError = class extends Error {
     this.name = "LlmJsonCallError";
   }
 };
+function isOpenAiGenerateImagesRequest(request) {
+  return isOpenAiImageModelId(request.model);
+}
 function tool(options) {
   return {
     type: "function",
@@ -5103,6 +5263,9 @@ function resolveProvider(model) {
       return { provider: "fireworks", model: fireworksModel };
     }
   }
+  if (isOpenAiImageModelId(model)) {
+    return { provider: "openai", model };
+  }
   if (isOpenAiModelId(model)) {
     return {
       provider: "openai",
@@ -5110,7 +5273,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 +6429,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 +6456,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 +6575,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 +6602,12 @@ function extractOpenAiUsageTokens(usage) {
   }
   return {
     promptTokens,
+    promptTextTokens,
+    promptImageTokens,
     cachedTokens,
     responseTokens,
+    responseTextTokens,
+    responseImageTokens,
     thinkingTokens: reasoningTokens,
     totalTokens
   };
@@ -7898,6 +8083,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,
@@ -10263,7 +10451,184 @@ 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();
+  }
+}
 async function generateImages(request) {
+  if (isOpenAiGenerateImagesRequest(request)) {
+    return await generateImagesWithOpenAiImageApi(request);
+  }
   const maxAttempts = Math.max(1, Math.floor(request.maxAttempts ?? 4));
   const promptList = Array.from(request.imagePrompts);
   if (promptList.length === 0) {
@@ -10277,7 +10642,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 +13940,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),
@@ -14308,6 +14676,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,
@@ -14357,6 +14736,7 @@ async function runCandidateEvolution(options) {
   isLlmImageModelId,
   isLlmModelId,
   isLlmTextModelId,
+  isOpenAiImageModelId,
   isOpenAiModelId,
   loadEnvFromFile,
   loadLocalEnv,
@@ -14376,6 +14756,7 @@ async function runCandidateEvolution(options) {
   streamToolLoop,
   stripCodexCitationMarkers,
   toGeminiJsonSchema,
-  tool
+  tool,
+  validateOpenAiGptImage2Resolution
 });
 //# sourceMappingURL=index.cjs.map