@ljoukov/llm 7.0.13 → 7.0.15

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
 
@@ -680,6 +699,57 @@ console.log(result.text);
 
 `{ type: "shell" }` uses OpenAI hosted shell containers by default. It is only supported for OpenAI API models; ChatGPT-authenticated, Gemini, and Fireworks providers reject it.
 
+When the shell writes artifacts under `/mnt/data`, `generateText()` returns the
+OpenAI container reference and the library can retrieve the resulting files:
+
+```ts
+import { downloadOpenAiContainerFile, generateText, listOpenAiContainerFiles } from "@ljoukov/llm";
+
+const result = await generateText({
+  model: "gpt-5.5",
+  input:
+    "Use the shell to write /mnt/data/report.txt containing 'hello'. Reply only when done.",
+  tools: [{ type: "shell" }],
+});
+
+const containerId = result.openAi?.containers.find((c) => c.toolType === "shell")?.containerId;
+if (!containerId) throw new Error("The response did not include a hosted shell container.");
+
+const files = await listOpenAiContainerFiles(containerId);
+const report = files.find((file) => file.path === "/mnt/data/report.txt");
+if (!report) throw new Error("The shell did not create report.txt.");
+
+const bytes = await downloadOpenAiContainerFile({
+  containerId,
+  fileId: report.id,
+});
+```
+
+For persistent multi-step shell work, create a container first, upload any input
+assets, then pass it back as a `container-reference`:
+
+```ts
+import {
+  createOpenAiContainer,
+  generateText,
+  uploadOpenAiContainerFile,
+} from "@ljoukov/llm";
+
+const container = await createOpenAiContainer({ name: "latex-build", memoryLimit: "1g" });
+const cover = await uploadOpenAiContainerFile({
+  containerId: container.id,
+  filename: "cover.png",
+  data: coverPngBytes,
+  mimeType: "image/png",
+});
+
+await generateText({
+  model: "gpt-5.5",
+  input: `Use ${cover.path}, write LaTeX, run xelatex, and save /mnt/data/article.pdf.`,
+  tools: [{ type: "shell", environment: { type: "container-reference", containerId: container.id } }],
+});
+```
+
 ### Runtime Tools (`runToolLoop()`)
 
 Use this when the model should call your local runtime functions.

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,
@@ -83,12 +84,16 @@ __export(index_exports, {
   createListDirectoryTool: () => createListDirectoryTool,
   createModelAgnosticFilesystemToolSet: () => createModelAgnosticFilesystemToolSet,
   createNodeAgentFilesystem: () => createNodeAgentFilesystem,
+  createOpenAiContainer: () => createOpenAiContainer,
   createReplaceTool: () => createReplaceTool,
   createRgSearchTool: () => createRgSearchTool,
   createToolLoopSteeringChannel: () => createToolLoopSteeringChannel,
   createViewImageTool: () => createViewImageTool,
   createWriteFileTool: () => createWriteFileTool,
   customTool: () => customTool,
+  deleteOpenAiContainer: () => deleteOpenAiContainer,
+  downloadOpenAiContainerFile: () => downloadOpenAiContainerFile,
+  downloadOpenAiContainerFileText: () => downloadOpenAiContainerFileText,
   emptyFileUploadMetrics: () => emptyFileUploadMetrics,
   encodeChatGptAuthJson: () => encodeChatGptAuthJson,
   encodeChatGptAuthJsonB64: () => encodeChatGptAuthJsonB64,
@@ -101,6 +106,7 @@ __export(index_exports, {
   generateText: () => generateText,
   getChatGptAuthProfile: () => getChatGptAuthProfile,
   getCurrentToolCallContext: () => getCurrentToolCallContext,
+  isChatGptImageModelId: () => isChatGptImageModelId,
   isChatGptModelId: () => isChatGptModelId,
   isExperimentalChatGptModelId: () => isExperimentalChatGptModelId,
   isFireworksModelId: () => isFireworksModelId,
@@ -112,12 +118,14 @@ __export(index_exports, {
   isLlmTextModelId: () => isLlmTextModelId,
   isOpenAiImageModelId: () => isOpenAiImageModelId,
   isOpenAiModelId: () => isOpenAiModelId,
+  listOpenAiContainerFiles: () => listOpenAiContainerFiles,
   loadEnvFromFile: () => loadEnvFromFile,
   loadLocalEnv: () => loadLocalEnv,
   parseJsonFromLlmText: () => parseJsonFromLlmText,
   refreshChatGptOauthToken: () => refreshChatGptOauthToken,
   resetModelConcurrencyConfig: () => resetModelConcurrencyConfig,
   resetTelemetry: () => resetTelemetry,
+  resolveChatGptImageProviderModel: () => resolveChatGptImageProviderModel,
   resolveFilesystemToolProfile: () => resolveFilesystemToolProfile,
   resolveFireworksModelId: () => resolveFireworksModelId,
   runAgentLoop: () => runAgentLoop,
@@ -131,6 +139,7 @@ __export(index_exports, {
   stripCodexCitationMarkers: () => stripCodexCitationMarkers,
   toGeminiJsonSchema: () => toGeminiJsonSchema,
   tool: () => tool,
+  uploadOpenAiContainerFile: () => uploadOpenAiContainerFile,
   validateOpenAiGptImage2Resolution: () => validateOpenAiGptImage2Resolution
 });
 module.exports = __toCommonJS(index_exports);
@@ -349,6 +358,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 +444,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 +471,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 +568,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 +1843,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 +1915,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 +1968,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 +4687,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 +4712,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 +5308,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",
@@ -6420,6 +6468,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;
@@ -8031,6 +8123,7 @@ async function runTextCall(params) {
   let modelVersion = request.model;
   let blocked = false;
   let grounding;
+  let openAi;
   const responseParts = [];
   let responseRole;
   let latestUsage;
@@ -8141,6 +8234,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) {
@@ -8172,6 +8266,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
@@ -8379,6 +8478,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,
@@ -8395,7 +8495,8 @@ async function runTextCall(params) {
         blocked,
         usage: latestUsage,
         costUsd,
-        grounding
+        grounding,
+        openAi
       };
     } catch (error) {
       const partialParts = mergeConsecutiveTextParts(responseParts);
@@ -10625,10 +10726,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) {
@@ -10910,6 +11145,104 @@ function appendMarkdownSourcesSection(value, sources) {
 ${lines}`;
 }
 
+// src/openai/containers.ts
+var import_openai4 = require("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 (0, import_openai4.toFile)(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
 var import_node_crypto4 = require("crypto");
 var import_node_path9 = __toESM(require("path"), 1);
@@ -14656,6 +14989,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,
@@ -14709,12 +15043,16 @@ async function runCandidateEvolution(options) {
   createListDirectoryTool,
   createModelAgnosticFilesystemToolSet,
   createNodeAgentFilesystem,
+  createOpenAiContainer,
   createReplaceTool,
   createRgSearchTool,
   createToolLoopSteeringChannel,
   createViewImageTool,
   createWriteFileTool,
   customTool,
+  deleteOpenAiContainer,
+  downloadOpenAiContainerFile,
+  downloadOpenAiContainerFileText,
   emptyFileUploadMetrics,
   encodeChatGptAuthJson,
   encodeChatGptAuthJsonB64,
@@ -14727,6 +15065,7 @@ async function runCandidateEvolution(options) {
   generateText,
   getChatGptAuthProfile,
   getCurrentToolCallContext,
+  isChatGptImageModelId,
   isChatGptModelId,
   isExperimentalChatGptModelId,
   isFireworksModelId,
@@ -14738,12 +15077,14 @@ async function runCandidateEvolution(options) {
   isLlmTextModelId,
   isOpenAiImageModelId,
   isOpenAiModelId,
+  listOpenAiContainerFiles,
   loadEnvFromFile,
   loadLocalEnv,
   parseJsonFromLlmText,
   refreshChatGptOauthToken,
   resetModelConcurrencyConfig,
   resetTelemetry,
+  resolveChatGptImageProviderModel,
   resolveFilesystemToolProfile,
   resolveFireworksModelId,
   runAgentLoop,
@@ -14757,6 +15098,7 @@ async function runCandidateEvolution(options) {
   stripCodexCitationMarkers,
   toGeminiJsonSchema,
   tool,
+  uploadOpenAiContainerFile,
   validateOpenAiGptImage2Resolution
 });
 //# sourceMappingURL=index.cjs.map