@ljoukov/llm 7.0.13 → 7.0.14

package/README.md

@@ -218,6 +218,23 @@ multiple of 16px, the long edge must be at most 3:1 relative to the short edge,
 must be between 655,360 and 8,294,400. Resolutions above 3,686,400 pixels are documented as
 experimental by OpenAI.
 
+To use ChatGPT/Codex subscription-backed image generation instead of the public Images API, use
+`chatgpt-gpt-image-2`:
+
+```ts
+const images = await generateImages({
+  model: "chatgpt-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"],
+  numImages: 1,
+});
+```
+
+That path reuses the same ChatGPT auth setup as other `chatgpt-*` models and sends the request
+through the ChatGPT/Codex Responses `image_generation` built-in tool. It returns PNG images. The
+public Images API controls such as `imageResolution`, `imageQuality`, `outputFormat`, and
+`outputCompression` are intentionally only on the `gpt-image-2` request type.
+
 ### Streaming (response + thoughts + usage)
 
 ```ts
@@ -495,10 +512,12 @@ console.log(result.text);
 
 `gpt-5.5-fast` and `chatgpt-gpt-5.5-fast` are also supported as convenience aliases for `gpt-5.5` with priority processing enabled (`service_tier="priority"`), matching Codex `/fast` semantics.
 
-Supported OpenAI text model ids are fixed literal unions in code, not arbitrary strings:
+Supported OpenAI and ChatGPT model ids are fixed literal unions in code, not arbitrary strings:
 
-- OpenAI API: `gpt-5.5`, `gpt-5.5-fast`, `gpt-5.4`, `gpt-5.4-mini`, `gpt-5.4-nano`
-- ChatGPT auth: `chatgpt-gpt-5.5`, `chatgpt-gpt-5.5-fast`, `chatgpt-gpt-5.4`, `chatgpt-gpt-5.4-fast`, `chatgpt-gpt-5.4-mini`, `chatgpt-gpt-5.3-codex-spark`
+- OpenAI API text: `gpt-5.5`, `gpt-5.5-fast`, `gpt-5.4`, `gpt-5.4-mini`, `gpt-5.4-nano`
+- OpenAI API image: `gpt-image-2`
+- ChatGPT auth text: `chatgpt-gpt-5.5`, `chatgpt-gpt-5.5-fast`, `chatgpt-gpt-5.4`, `chatgpt-gpt-5.4-fast`, `chatgpt-gpt-5.4-mini`, `chatgpt-gpt-5.3-codex-spark`
+- ChatGPT auth image: `chatgpt-gpt-image-2`
 
 ## JSON outputs
 

package/dist/index.cjs

@@ -30,6 +30,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  CHATGPT_IMAGE_MODEL_IDS: () => CHATGPT_IMAGE_MODEL_IDS,
   CHATGPT_MODEL_IDS: () => CHATGPT_MODEL_IDS,
   CODEX_APPLY_PATCH_FREEFORM_TOOL_DESCRIPTION: () => CODEX_APPLY_PATCH_FREEFORM_TOOL_DESCRIPTION,
   CODEX_APPLY_PATCH_JSON_TOOL_DESCRIPTION: () => CODEX_APPLY_PATCH_JSON_TOOL_DESCRIPTION,
@@ -101,6 +102,7 @@ __export(index_exports, {
   generateText: () => generateText,
   getChatGptAuthProfile: () => getChatGptAuthProfile,
   getCurrentToolCallContext: () => getCurrentToolCallContext,
+  isChatGptImageModelId: () => isChatGptImageModelId,
   isChatGptModelId: () => isChatGptModelId,
   isExperimentalChatGptModelId: () => isExperimentalChatGptModelId,
   isFireworksModelId: () => isFireworksModelId,
@@ -118,6 +120,7 @@ __export(index_exports, {
   refreshChatGptOauthToken: () => refreshChatGptOauthToken,
   resetModelConcurrencyConfig: () => resetModelConcurrencyConfig,
   resetTelemetry: () => resetTelemetry,
+  resolveChatGptImageProviderModel: () => resolveChatGptImageProviderModel,
   resolveFilesystemToolProfile: () => resolveFilesystemToolProfile,
   resolveFireworksModelId: () => resolveFireworksModelId,
   runAgentLoop: () => runAgentLoop,
@@ -349,6 +352,10 @@ 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",
@@ -431,6 +438,7 @@ var CHATGPT_MODEL_IDS = [
 var FAST_MODEL_SUFFIX = "-fast";
 var OPENAI_PRIORITY_MODEL_IDS = ["gpt-5.5-fast"];
 var CHATGPT_PRIORITY_MODEL_IDS = ["chatgpt-gpt-5.5-fast", "chatgpt-gpt-5.4-fast"];
+var CHATGPT_IMAGE_GENERATION_PROVIDER_MODEL = "gpt-5.4";
 var EXPERIMENTAL_CHATGPT_MODEL_PREFIX = "experimental-chatgpt-";
 function isExperimentalChatGptModelId(value) {
   return value.startsWith(EXPERIMENTAL_CHATGPT_MODEL_PREFIX) && value.length > EXPERIMENTAL_CHATGPT_MODEL_PREFIX.length;
@@ -457,6 +465,9 @@ function resolveChatGptProviderModel(model) {
   const providerModel = stripChatGptPrefix(model);
   return CHATGPT_PRIORITY_MODEL_IDS.includes(model) ? stripFastSuffix(providerModel) : providerModel;
 }
+function resolveChatGptImageProviderModel(_model) {
+  return CHATGPT_IMAGE_GENERATION_PROVIDER_MODEL;
+}
 function resolveChatGptServiceTier(model) {
   return CHATGPT_PRIORITY_MODEL_IDS.includes(model) ? "priority" : void 0;
 }
@@ -551,7 +562,7 @@ function getOpenAiPricing(modelId) {
   return void 0;
 }
 function getOpenAiImagePricing(modelId) {
-  return isOpenAiImageModelId(modelId) ? OPENAI_GPT_IMAGE_2_PRICING : void 0;
+  return isOpenAiImageModelId(modelId) || isChatGptImageModelId(modelId) ? OPENAI_GPT_IMAGE_2_PRICING : void 0;
 }
 
 // src/utils/cost.ts
@@ -1826,6 +1837,8 @@ async function collectChatGptCodexStream(options) {
   const toolCallOrder = [];
   const webSearchCalls = /* @__PURE__ */ new Map();
   const webSearchCallOrder = [];
+  const imageGenerationCalls = /* @__PURE__ */ new Map();
+  const imageGenerationCallOrder = [];
   let text = "";
   const reasoningText = "";
   let reasoningSummaryText = "";
@@ -1896,6 +1909,20 @@ async function collectChatGptCodexStream(options) {
               action: item.action && typeof item.action === "object" ? item.action : void 0
             });
           }
+        } else if (item.type === "image_generation_call") {
+          const id = typeof item.id === "string" ? item.id : "";
+          const result = typeof item.result === "string" ? item.result : "";
+          if (id && result) {
+            if (!imageGenerationCalls.has(id)) {
+              imageGenerationCallOrder.push(id);
+            }
+            imageGenerationCalls.set(id, {
+              id,
+              status: typeof item.status === "string" ? item.status : void 0,
+              revisedPrompt: typeof item.revised_prompt === "string" ? item.revised_prompt : void 0,
+              result
+            });
+          }
         }
       }
       continue;
@@ -1935,12 +1962,14 @@ async function collectChatGptCodexStream(options) {
   }
   const orderedToolCalls = toolCallOrder.map((id) => toolCalls.get(id)).filter((call) => call !== void 0);
   const orderedWebSearchCalls = webSearchCallOrder.map((id) => webSearchCalls.get(id)).filter((call) => call !== void 0);
+  const orderedImageGenerationCalls = imageGenerationCallOrder.map((id) => imageGenerationCalls.get(id)).filter((call) => call !== void 0);
   return {
     text,
     reasoningText,
     reasoningSummaryText,
     toolCalls: orderedToolCalls,
     webSearchCalls: orderedWebSearchCalls,
+    imageGenerationCalls: orderedImageGenerationCalls,
     usage,
     id: responseId,
     model,
@@ -4652,13 +4681,17 @@ var LLM_TEXT_MODEL_IDS = [
   ...FIREWORKS_MODEL_IDS,
   ...GEMINI_TEXT_MODEL_IDS
 ];
-var LLM_IMAGE_MODEL_IDS = [...OPENAI_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 isOpenAiImageModelId(value) || isGeminiImageModelId(value);
+  return isOpenAiImageModelId(value) || isChatGptImageModelId(value) || isGeminiImageModelId(value);
 }
 function isLlmModelId(value) {
   return isLlmTextModelId(value) || isLlmImageModelId(value);
@@ -4673,6 +4706,9 @@ var LlmJsonCallError = class extends Error {
 function isOpenAiGenerateImagesRequest(request) {
   return isOpenAiImageModelId(request.model);
 }
+function isChatGptGenerateImagesRequest(request) {
+  return isChatGptImageModelId(request.model);
+}
 function tool(options) {
   return {
     type: "function",
@@ -5266,6 +5302,12 @@ function resolveProvider(model) {
   if (isOpenAiImageModelId(model)) {
     return { provider: "openai", model };
   }
+  if (isChatGptImageModelId(model)) {
+    return {
+      provider: "chatgpt",
+      model: resolveChatGptImageProviderModel(model)
+    };
+  }
   if (isOpenAiModelId(model)) {
     return {
       provider: "openai",
@@ -8172,6 +8214,11 @@ async function runTextCall(params) {
           }
         }, modelForProvider);
       } else if (provider === "chatgpt") {
+        if (isChatGptImageModelId(request.model)) {
+          throw new Error(
+            "chatgpt-gpt-image-2 is an image generation model; use generateImages()."
+          );
+        }
         const chatGptInput = toChatGptInput(contents, {
           defaultMediaResolution: request.mediaResolution,
           model: request.model
@@ -10625,10 +10672,144 @@ async function generateImagesWithOpenAiImageApi(request) {
     await telemetry.flush();
   }
 }
+function buildChatGptImageInputContent(params) {
+  const parts = [
+    {
+      type: "text",
+      text: params.prompt
+    }
+  ];
+  for (const [index, image] of (params.styleImages ?? []).entries()) {
+    const mimeType = image.mimeType ?? "image/png";
+    parts.push({
+      type: "inlineData",
+      data: image.data.toString("base64"),
+      mimeType,
+      filename: `style-${index + 1}.${resolveAttachmentExtension(mimeType)}`
+    });
+  }
+  return [{ role: "user", parts }];
+}
+async function generateImagesWithChatGptImageTool(request) {
+  const promptEntries = Array.from(request.imagePrompts, (rawPrompt, index) => {
+    const prompt = rawPrompt.trim();
+    if (!prompt) {
+      throw new Error(`imagePrompts[${index}] must be a non-empty string`);
+    }
+    return prompt;
+  });
+  if (promptEntries.length === 0) {
+    return [];
+  }
+  const providerInfo = resolveProvider(request.model);
+  const telemetry = createLlmTelemetryEmitter({
+    telemetry: request.telemetry,
+    operation: "generateImages",
+    provider: providerInfo.provider,
+    model: request.model
+  });
+  const startedAtMs = Date.now();
+  const numImagesPerPrompt = request.numImages ?? 1;
+  let totalUsage;
+  let costUsd = 0;
+  let outputImages = 0;
+  telemetry.emit({
+    type: "llm.call.started",
+    imagePromptCount: promptEntries.length,
+    styleImageCount: request.styleImages?.length ?? 0,
+    numImagesPerPrompt
+  });
+  try {
+    const images = [];
+    for (const imagePrompt of promptEntries) {
+      const prompt = buildOpenAiImagePrompt({
+        stylePrompt: request.stylePrompt,
+        imagePrompt,
+        hasStyleImages: Boolean(request.styleImages && request.styleImages.length > 0)
+      });
+      for (let imageIndex = 0; imageIndex < numImagesPerPrompt; imageIndex += 1) {
+        const chatGptInput = toChatGptInput(
+          buildChatGptImageInputContent({
+            prompt,
+            styleImages: request.styleImages
+          }),
+          { model: request.model }
+        );
+        const preparedInput = await maybePrepareOpenAiPromptInput(chatGptInput.input, {
+          model: request.model,
+          provider: "chatgpt"
+        });
+        const result = await collectChatGptCodexResponseWithRetry({
+          request: {
+            model: providerInfo.model,
+            store: false,
+            stream: true,
+            instructions: chatGptInput.instructions ?? "Use the image_generation tool to generate exactly one PNG image. Do not return prose instead of the image.",
+            input: preparedInput,
+            tool_choice: "required",
+            parallel_tool_calls: false,
+            tools: [{ type: "image_generation", output_format: "png" }]
+          },
+          signal: request.signal
+        });
+        if (result.status && result.status !== "completed") {
+          throw new Error(`ChatGPT image generation response status ${result.status}`);
+        }
+        if (result.imageGenerationCalls.length === 0) {
+          throw new Error("ChatGPT image generation returned no image_generation_call result.");
+        }
+        for (const call of result.imageGenerationCalls) {
+          images.push({
+            mimeType: "image/png",
+            data: import_node_buffer4.Buffer.from(call.result, "base64")
+          });
+        }
+        outputImages = images.length;
+        const usage = extractChatGptUsageTokens(result.usage);
+        totalUsage = sumUsageTokens(totalUsage, usage);
+        costUsd += estimateCallCostUsd({
+          modelId: request.model,
+          tokens: usage,
+          responseImages: result.imageGenerationCalls.length,
+          imageSize: "1024x1024",
+          imageQuality: "medium"
+        });
+      }
+    }
+    telemetry.emit({
+      type: "llm.call.completed",
+      success: true,
+      durationMs: Math.max(0, Date.now() - startedAtMs),
+      modelVersion: request.model,
+      usage: totalUsage,
+      costUsd,
+      imageCount: images.length,
+      attempts: promptEntries.length * numImagesPerPrompt
+    });
+    return images;
+  } catch (error) {
+    const err = error instanceof Error ? error : new Error(String(error));
+    telemetry.emit({
+      type: "llm.call.completed",
+      success: false,
+      durationMs: Math.max(0, Date.now() - startedAtMs),
+      usage: totalUsage,
+      costUsd,
+      imageCount: outputImages,
+      error: err.message
+    });
+    throw err;
+  } finally {
+    await telemetry.flush();
+  }
+}
 async function generateImages(request) {
   if (isOpenAiGenerateImagesRequest(request)) {
     return await generateImagesWithOpenAiImageApi(request);
   }
+  if (isChatGptGenerateImagesRequest(request)) {
+    return await generateImagesWithChatGptImageTool(request);
+  }
   const maxAttempts = Math.max(1, Math.floor(request.maxAttempts ?? 4));
   const promptList = Array.from(request.imagePrompts);
   if (promptList.length === 0) {
@@ -14656,6 +14837,7 @@ async function runCandidateEvolution(options) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  CHATGPT_IMAGE_MODEL_IDS,
   CHATGPT_MODEL_IDS,
   CODEX_APPLY_PATCH_FREEFORM_TOOL_DESCRIPTION,
   CODEX_APPLY_PATCH_JSON_TOOL_DESCRIPTION,
@@ -14727,6 +14909,7 @@ async function runCandidateEvolution(options) {
   generateText,
   getChatGptAuthProfile,
   getCurrentToolCallContext,
+  isChatGptImageModelId,
   isChatGptModelId,
   isExperimentalChatGptModelId,
   isFireworksModelId,
@@ -14744,6 +14927,7 @@ async function runCandidateEvolution(options) {
   refreshChatGptOauthToken,
   resetModelConcurrencyConfig,
   resetTelemetry,
+  resolveChatGptImageProviderModel,
   resolveFilesystemToolProfile,
   resolveFireworksModelId,
   runAgentLoop,