@ljoukov/llm 7.0.12 → 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");
@@ -6151,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,
@@ -6175,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),
@@ -6291,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) {
@@ -6306,8 +6474,12 @@ function extractOpenAiUsageTokens(usage) {
   }
   return {
     promptTokens,
+    promptTextTokens,
+    promptImageTokens,
     cachedTokens,
     responseTokens,
+    responseTextTokens,
+    responseImageTokens,
     thinkingTokens: reasoningTokens,
     totalTokens
   };
@@ -7783,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,
@@ -10148,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) {
@@ -10162,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");
   }
@@ -13460,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),
@@ -14192,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,
@@ -14241,6 +14607,7 @@ export {
   isLlmImageModelId,
   isLlmModelId,
   isLlmTextModelId,
+  isOpenAiImageModelId,
   isOpenAiModelId,
   loadEnvFromFile,
   loadLocalEnv,
@@ -14260,6 +14627,7 @@ export {
   streamToolLoop,
   stripCodexCitationMarkers,
   toGeminiJsonSchema,
-  tool
+  tool,
+  validateOpenAiGptImage2Resolution
 };
 //# sourceMappingURL=index.js.map