@ljoukov/llm 7.0.11 → 7.0.13

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,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",
@@ -298,6 +374,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 +422,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) {
@@ -337,8 +437,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 +510,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";
@@ -4380,13 +4524,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);
@@ -4398,6 +4542,9 @@ var LlmJsonCallError = class extends Error {
     this.name = "LlmJsonCallError";
   }
 };
+function isOpenAiGenerateImagesRequest(request) {
+  return isOpenAiImageModelId(request.model);
+}
 function tool(options) {
   return {
     type: "function",
@@ -4988,6 +5135,9 @@ function resolveProvider(model) {
       return { provider: "fireworks", model: fireworksModel };
     }
   }
+  if (isOpenAiImageModelId(model)) {
+    return { provider: "openai", model };
+  }
   if (isOpenAiModelId(model)) {
     return {
       provider: "openai",
@@ -4995,7 +5145,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");
@@ -6082,12 +6232,40 @@ function toGeminiTools(tools) {
         return { googleSearch: {} };
       case "code-execution":
         return { codeExecution: {} };
+      case "shell":
+        throw new Error("Gemini provider does not support the OpenAI shell tool.");
       default:
         throw new Error("Unsupported tool configuration");
     }
   });
 }
-function toOpenAiTools(tools) {
+function toOpenAiShellEnvironment(environment) {
+  if (environment?.type === "container-reference") {
+    return {
+      type: "container_reference",
+      container_id: environment.containerId
+    };
+  }
+  return {
+    type: "container_auto",
+    ...environment?.fileIds ? { file_ids: Array.from(environment.fileIds) } : {},
+    ...environment?.memoryLimit !== void 0 ? { memory_limit: environment.memoryLimit } : {},
+    ...environment?.networkPolicy ? {
+      network_policy: environment.networkPolicy.type === "allowlist" ? {
+        type: "allowlist",
+        allowed_domains: Array.from(environment.networkPolicy.allowedDomains),
+        ...environment.networkPolicy.domainSecrets ? {
+          domain_secrets: environment.networkPolicy.domainSecrets.map((secret) => ({
+            domain: secret.domain,
+            name: secret.name,
+            value: secret.value
+          }))
+        } : {}
+      } : { type: "disabled" }
+    } : {}
+  };
+}
+function toOpenAiTools(tools, options) {
   if (!tools || tools.length === 0) {
     return void 0;
   }
@@ -6100,6 +6278,15 @@ function toOpenAiTools(tools) {
       case "code-execution": {
         return { type: "code_interpreter", container: { type: "auto" } };
       }
+      case "shell": {
+        if (options.provider !== "openai") {
+          throw new Error("OpenAI shell tool is only supported for OpenAI API models.");
+        }
+        return {
+          type: "shell",
+          environment: toOpenAiShellEnvironment(tool2.environment)
+        };
+      }
       default:
         throw new Error("Unsupported tool configuration");
     }
@@ -6114,8 +6301,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,
@@ -6138,8 +6328,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),
@@ -6254,10 +6447,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) {
@@ -6269,8 +6474,12 @@ function extractOpenAiUsageTokens(usage) {
   }
   return {
     promptTokens,
+    promptTextTokens,
+    promptImageTokens,
     cachedTokens,
     responseTokens,
+    responseTextTokens,
+    responseImageTokens,
     thinkingTokens: reasoningTokens,
     totalTokens
   };
@@ -7698,6 +7907,8 @@ async function runTextCall(params) {
   let responseRole;
   let latestUsage;
   let responseImages = 0;
+  let sawResponseDelta = false;
+  let sawThoughtDelta = false;
   const pushEvent = (event) => {
     queue.push(event);
     params.onEvent?.(event);
@@ -7708,8 +7919,10 @@ async function runTextCall(params) {
     }
     responseParts.push({ type: "text", text, ...channel === "thought" ? { thought: true } : {} });
     if (channel === "thought") {
+      sawThoughtDelta = true;
       callLogger?.appendThoughtDelta(text);
     } else {
+      sawResponseDelta = true;
       callLogger?.appendResponseDelta(text);
     }
     pushEvent({ type: "delta", channel, text });
@@ -7742,6 +7955,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,
@@ -7749,7 +7965,7 @@ async function runTextCall(params) {
           }),
           { model: request.model, provider: "openai" }
         );
-        const openAiTools = toOpenAiTools(request.tools);
+        const openAiTools = toOpenAiTools(request.tools, { provider: "openai" });
         const reasoningEffort = resolveOpenAiReasoningEffort(
           modelForProvider,
           request.thinkingLevel
@@ -7810,12 +8026,17 @@ async function runTextCall(params) {
             );
           }
           latestUsage = extractOpenAiUsageTokens(finalResponse.usage);
-          if (responseParts.length === 0) {
+          if (!sawResponseDelta || !sawThoughtDelta) {
+            const needsResponseFallback = !sawResponseDelta;
+            const needsThoughtFallback = !sawThoughtDelta;
             const fallback = extractOpenAiResponseParts(finalResponse);
             blocked = blocked || fallback.blocked;
             for (const part of fallback.parts) {
               if (part.type === "text") {
-                pushDelta(part.thought === true ? "thought" : "response", part.text);
+                const channel = part.thought === true ? "thought" : "response";
+                if (channel === "response" && needsResponseFallback || channel === "thought" && needsThoughtFallback) {
+                  pushDelta(channel, part.text);
+                }
               } else if (part.type === "inlineData") {
                 pushInline(part.data, part.mimeType);
               }
@@ -7832,7 +8053,7 @@ async function runTextCall(params) {
           provider: "chatgpt"
         });
         const reasoningEffort = resolveOpenAiReasoningEffort(request.model, request.thinkingLevel);
-        const openAiTools = toOpenAiTools(request.tools);
+        const openAiTools = toOpenAiTools(request.tools, { provider: "chatgpt" });
         const requestPayload = {
           model: modelForProvider,
           store: false,
@@ -7851,18 +8072,18 @@ async function runTextCall(params) {
           },
           ...openAiTools ? { tools: openAiTools } : {}
         };
-        let sawResponseDelta = false;
-        let sawThoughtDelta = false;
+        let sawResponseDelta2 = false;
+        let sawThoughtDelta2 = false;
         const result2 = await collectChatGptCodexResponseWithRetry({
           request: requestPayload,
           signal,
           onDelta: (delta) => {
             if (delta.thoughtDelta) {
-              sawThoughtDelta = true;
+              sawThoughtDelta2 = true;
               pushDelta("thought", delta.thoughtDelta);
             }
             if (delta.textDelta) {
-              sawResponseDelta = true;
+              sawResponseDelta2 = true;
               pushDelta("response", delta.textDelta);
             }
           }
@@ -7878,10 +8099,10 @@ async function runTextCall(params) {
         latestUsage = extractChatGptUsageTokens(result2.usage);
         const fallbackText = typeof result2.text === "string" ? result2.text : "";
         const fallbackThoughts = typeof result2.reasoningSummaryText === "string" && result2.reasoningSummaryText.length > 0 ? result2.reasoningSummaryText : typeof result2.reasoningText === "string" ? result2.reasoningText : "";
-        if (!sawThoughtDelta && fallbackThoughts.length > 0) {
+        if (!sawThoughtDelta2 && fallbackThoughts.length > 0) {
           pushDelta("thought", fallbackThoughts);
         }
-        if (!sawResponseDelta && fallbackText.length > 0) {
+        if (!sawResponseDelta2 && fallbackText.length > 0) {
           pushDelta("response", fallbackText);
         }
       } else if (provider === "fireworks") {
@@ -8601,7 +8822,7 @@ async function runToolLoop(request) {
   try {
     if (providerInfo.provider === "openai") {
       const openAiAgentTools = buildOpenAiToolsFromToolSet(request.tools);
-      const openAiNativeTools = toOpenAiTools(request.modelTools);
+      const openAiNativeTools = toOpenAiTools(request.modelTools, { provider: "openai" });
       const openAiTools = openAiNativeTools ? [...openAiNativeTools, ...openAiAgentTools] : [...openAiAgentTools];
       const reasoningEffort = resolveOpenAiReasoningEffort(
         providerInfo.model,
@@ -9004,7 +9225,7 @@ async function runToolLoop(request) {
     }
     if (providerInfo.provider === "chatgpt") {
       const openAiAgentTools = buildOpenAiToolsFromToolSet(request.tools);
-      const openAiNativeTools = toOpenAiTools(request.modelTools);
+      const openAiNativeTools = toOpenAiTools(request.modelTools, { provider: "chatgpt" });
       const openAiTools = openAiNativeTools ? [...openAiNativeTools, ...openAiAgentTools] : [...openAiAgentTools];
       const reasoningEffort = resolveOpenAiReasoningEffort(request.model, request.thinkingLevel);
       const toolLoopInput = toChatGptInput(contents, {
@@ -10102,7 +10323,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 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();
+  }
+}
 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) {
@@ -10116,7 +10514,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");
   }
@@ -13414,8 +13812,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),
@@ -14146,6 +14547,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,
@@ -14195,6 +14607,7 @@ export {
   isLlmImageModelId,
   isLlmModelId,
   isLlmTextModelId,
+  isOpenAiImageModelId,
   isOpenAiModelId,
   loadEnvFromFile,
   loadLocalEnv,
@@ -14214,6 +14627,7 @@ export {
   streamToolLoop,
   stripCodexCitationMarkers,
   toGeminiJsonSchema,
-  tool
+  tool,
+  validateOpenAiGptImage2Resolution
 };
 //# sourceMappingURL=index.js.map