@ljoukov/llm 7.0.13 → 7.0.15

package/dist/index.js

@@ -221,6 +221,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",
@@ -303,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;
@@ -329,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;
 }
@@ -423,7 +431,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
@@ -547,7 +555,7 @@ function resolveOpenAiImagePriceResolution(imageSize) {
 
 // src/openai/chatgpt-codex.ts
 import os2 from "os";
-import { TextDecoder } from "util";
+import { TextDecoder as TextDecoder2 } from "util";
 
 // src/utils/runtimeSingleton.ts
 var runtimeSingletonStoreKey = /* @__PURE__ */ Symbol.for("@ljoukov/llm.runtimeSingletonStore");
@@ -1698,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 = "";
@@ -1768,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;
@@ -1807,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,
@@ -1860,7 +1886,7 @@ function buildUserAgent() {
 }
 async function* parseEventStream(stream) {
   const reader = stream.getReader();
-  const decoder = new TextDecoder();
+  const decoder = new TextDecoder2();
   let buffer = "";
   while (true) {
     const { done, value } = await reader.read();
@@ -4524,13 +4550,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);
@@ -4545,6 +4575,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",
@@ -5138,6 +5171,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",
@@ -6292,6 +6331,50 @@ function toOpenAiTools(tools, options) {
     }
   });
 }
+function extractOpenAiResponseMetadata(response) {
+  if (!response || typeof response !== "object") {
+    return void 0;
+  }
+  const record = response;
+  const responseId = typeof record.id === "string" ? record.id : void 0;
+  const output = Array.isArray(record.output) ? record.output : [];
+  const containers = [];
+  const seen = /* @__PURE__ */ new Set();
+  const addContainer = (container) => {
+    const key = `${container.toolType}:${container.containerId}:${container.itemId ?? ""}:${container.callId ?? ""}`;
+    if (seen.has(key)) {
+      return;
+    }
+    seen.add(key);
+    containers.push(container);
+  };
+  for (const item of output) {
+    if (!item || typeof item !== "object") {
+      continue;
+    }
+    const itemRecord = item;
+    const itemId = typeof itemRecord.id === "string" ? itemRecord.id : void 0;
+    const callId = typeof itemRecord.call_id === "string" ? itemRecord.call_id : void 0;
+    if (itemRecord.type === "shell_call") {
+      const environment = itemRecord.environment && typeof itemRecord.environment === "object" ? itemRecord.environment : void 0;
+      const containerId = environment?.type === "container_reference" && typeof environment.container_id === "string" ? environment.container_id : void 0;
+      if (containerId) {
+        addContainer({ containerId, toolType: "shell", itemId, callId });
+      }
+      continue;
+    }
+    if (itemRecord.type === "code_interpreter_call") {
+      const containerId = typeof itemRecord.container_id === "string" ? itemRecord.container_id : void 0;
+      if (containerId) {
+        addContainer({ containerId, toolType: "code_interpreter", itemId, callId });
+      }
+    }
+  }
+  if (!responseId && containers.length === 0) {
+    return void 0;
+  }
+  return { ...responseId ? { responseId } : {}, containers };
+}
 function mergeTokenUpdates(current, next) {
   if (!next) {
     return current;
@@ -7903,6 +7986,7 @@ async function runTextCall(params) {
   let modelVersion = request.model;
   let blocked = false;
   let grounding;
+  let openAi;
   const responseParts = [];
   let responseRole;
   let latestUsage;
@@ -8013,6 +8097,7 @@ async function runTextCall(params) {
             }
           }
           const finalResponse = await stream.finalResponse();
+          openAi = extractOpenAiResponseMetadata(finalResponse);
           modelVersion = typeof finalResponse.model === "string" ? finalResponse.model : request.model;
           pushEvent({ type: "model", modelVersion });
           if (finalResponse.error) {
@@ -8044,6 +8129,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
@@ -8251,6 +8341,7 @@ async function runTextCall(params) {
           costUsd,
           usage: latestUsage,
           grounding: grounding ? sanitiseLogValue(grounding) : void 0,
+          openAi: openAi ? sanitiseLogValue(openAi) : void 0,
           responseChars: text.length,
           thoughtChars: thoughts.length,
           responseImages,
@@ -8267,7 +8358,8 @@ async function runTextCall(params) {
         blocked,
         usage: latestUsage,
         costUsd,
-        grounding
+        grounding,
+        openAi
       };
     } catch (error) {
       const partialParts = mergeConsecutiveTextParts(responseParts);
@@ -10497,10 +10589,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: 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) {
@@ -10782,6 +11008,104 @@ function appendMarkdownSourcesSection(value, sources) {
 ${lines}`;
 }
 
+// src/openai/containers.ts
+import { toFile as toFile2 } from "openai";
+function toOpenAiContainerNetworkPolicy(policy) {
+  if (!policy) {
+    return void 0;
+  }
+  if (policy.type === "disabled") {
+    return { type: "disabled" };
+  }
+  return {
+    type: "allowlist",
+    allowed_domains: Array.from(policy.allowedDomains),
+    ...policy.domainSecrets ? {
+      domain_secrets: policy.domainSecrets.map((secret) => ({
+        domain: secret.domain,
+        name: secret.name,
+        value: secret.value
+      }))
+    } : {}
+  };
+}
+function toContainer(container) {
+  return {
+    id: String(container.id),
+    name: typeof container.name === "string" ? container.name : "",
+    status: typeof container.status === "string" ? container.status : "",
+    ...typeof container.created_at === "number" ? { createdAt: container.created_at } : {},
+    ...typeof container.last_active_at === "number" ? { lastActiveAt: container.last_active_at } : {},
+    ...typeof container.memory_limit === "string" ? { memoryLimit: container.memory_limit } : {}
+  };
+}
+function toContainerFile(file) {
+  return {
+    id: String(file.id),
+    containerId: typeof file.container_id === "string" ? file.container_id : "",
+    path: typeof file.path === "string" ? file.path : "",
+    ...typeof file.bytes === "number" || file.bytes === null ? { bytes: file.bytes } : {},
+    ...typeof file.created_at === "number" ? { createdAt: file.created_at } : {},
+    ...typeof file.source === "string" ? { source: file.source } : {}
+  };
+}
+async function createOpenAiContainer(options) {
+  const container = await runOpenAiCall(
+    async (client) => await client.containers.create({
+      name: options.name,
+      ...options.fileIds ? { file_ids: Array.from(options.fileIds) } : {},
+      ...options.memoryLimit ? { memory_limit: options.memoryLimit } : {},
+      ...options.networkPolicy ? { network_policy: toOpenAiContainerNetworkPolicy(options.networkPolicy) } : {},
+      ...options.expiresAfterMinutes ? {
+        expires_after: {
+          anchor: "last_active_at",
+          minutes: options.expiresAfterMinutes
+        }
+      } : {}
+    }),
+    "openai-containers"
+  );
+  return toContainer(container);
+}
+async function deleteOpenAiContainer(containerId) {
+  await runOpenAiCall(
+    async (client) => await client.containers.delete(containerId),
+    "openai-containers"
+  );
+}
+async function listOpenAiContainerFiles(containerId) {
+  const files2 = [];
+  await runOpenAiCall(async (client) => {
+    for await (const file of client.containers.files.list(containerId)) {
+      files2.push(toContainerFile(file));
+    }
+  }, "openai-containers");
+  return files2;
+}
+async function uploadOpenAiContainerFile(upload) {
+  const file = await toFile2(upload.data, upload.filename, {
+    ...upload.mimeType ? { type: upload.mimeType } : {}
+  });
+  const created = await runOpenAiCall(
+    async (client) => await client.containers.files.create(upload.containerId, { file }),
+    "openai-containers"
+  );
+  return toContainerFile(created);
+}
+async function downloadOpenAiContainerFile(params) {
+  const response = await runOpenAiCall(
+    async (client) => await client.containers.files.content.retrieve(params.fileId, {
+      container_id: params.containerId
+    }),
+    "openai-containers"
+  );
+  return new Uint8Array(await response.arrayBuffer());
+}
+async function downloadOpenAiContainerFileText(params) {
+  const bytes = await downloadOpenAiContainerFile(params);
+  return new TextDecoder().decode(bytes);
+}
+
 // src/agent.ts
 import { randomBytes as randomBytes3 } from "crypto";
 import path9 from "path";
@@ -14527,6 +14851,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,
@@ -14580,12 +14905,16 @@ export {
   createListDirectoryTool,
   createModelAgnosticFilesystemToolSet,
   createNodeAgentFilesystem,
+  createOpenAiContainer,
   createReplaceTool,
   createRgSearchTool,
   createToolLoopSteeringChannel,
   createViewImageTool,
   createWriteFileTool,
   customTool,
+  deleteOpenAiContainer,
+  downloadOpenAiContainerFile,
+  downloadOpenAiContainerFileText,
   emptyFileUploadMetrics,
   encodeChatGptAuthJson,
   encodeChatGptAuthJsonB64,
@@ -14598,6 +14927,7 @@ export {
   generateText,
   getChatGptAuthProfile,
   getCurrentToolCallContext,
+  isChatGptImageModelId,
   isChatGptModelId,
   isExperimentalChatGptModelId,
   isFireworksModelId,
@@ -14609,12 +14939,14 @@ export {
   isLlmTextModelId,
   isOpenAiImageModelId,
   isOpenAiModelId,
+  listOpenAiContainerFiles,
   loadEnvFromFile,
   loadLocalEnv,
   parseJsonFromLlmText,
   refreshChatGptOauthToken,
   resetModelConcurrencyConfig,
   resetTelemetry,
+  resolveChatGptImageProviderModel,
   resolveFilesystemToolProfile,
   resolveFireworksModelId,
   runAgentLoop,
@@ -14628,6 +14960,7 @@ export {
   stripCodexCitationMarkers,
   toGeminiJsonSchema,
   tool,
+  uploadOpenAiContainerFile,
   validateOpenAiGptImage2Resolution
 };
 //# sourceMappingURL=index.js.map