ai-sdk-provider-codex-cli 0.6.0 → 0.7.0

package/README.md

@@ -104,6 +104,48 @@ console.log(object);
 - Safe defaults for non‑interactive automation (`on-failure`, `workspace-write`, `--skip-git-repo-check`)
 - Fallback to `npx @openai/codex` when not on PATH (`allowNpx`)
 - Usage tracking from experimental JSON event format
+- **Image support** - Pass images to vision-capable models via `--image` flag
+
+### Image Support
+
+The provider supports multimodal (image) inputs for vision-capable models:
+
+```js
+import { generateText } from 'ai';
+import { codexCli } from 'ai-sdk-provider-codex-cli';
+import { readFileSync } from 'fs';
+
+const model = codexCli('gpt-5.1-codex', { allowNpx: true, skipGitRepoCheck: true });
+const imageBuffer = readFileSync('./screenshot.png');
+
+const { text } = await generateText({
+  model,
+  messages: [
+    {
+      role: 'user',
+      content: [
+        { type: 'text', text: 'What do you see in this image?' },
+        { type: 'image', image: imageBuffer, mimeType: 'image/png' },
+      ],
+    },
+  ],
+});
+console.log(text);
+```
+
+**Supported image formats:**
+
+- Base64 data URL (`data:image/png;base64,...`)
+- Base64 string (without data URL prefix)
+- `Buffer` / `Uint8Array` / `ArrayBuffer`
+
+**Not supported:**
+
+- HTTP/HTTPS URLs (images must be provided as binary data)
+
+Images are written to temporary files and passed to Codex CLI via the `--image` flag. Temp files are automatically cleaned up after the request completes.
+
+See [examples/image-support.mjs](examples/image-support.mjs) for a complete working example.
 
 ### Tool Streaming (v0.3.0+)
 

package/dist/index.cjs

@@ -167,6 +167,94 @@ function validateModelId(modelId) {
   if (!modelId || modelId.trim() === "") return "Model ID cannot be empty";
   return void 0;
 }
+function extractImageData(part) {
+  if (typeof part !== "object" || part === null) return null;
+  const p = part;
+  const mimeType = p.mimeType || "image/png";
+  if (typeof p.image === "string") {
+    return extractFromString(p.image, mimeType);
+  }
+  if (p.image instanceof URL) {
+    if (p.image.protocol === "data:") {
+      const dataUrlStr = p.image.toString();
+      const match = dataUrlStr.match(/^data:([^;,]+)/);
+      const extractedMimeType = match?.[1] || mimeType;
+      return { data: dataUrlStr, mimeType: extractedMimeType };
+    }
+    return null;
+  }
+  if (Buffer.isBuffer(p.image)) {
+    const base64 = p.image.toString("base64");
+    return { data: `data:${mimeType};base64,${base64}`, mimeType };
+  }
+  if (p.image instanceof ArrayBuffer || p.image instanceof Uint8Array) {
+    const buffer = Buffer.from(p.image);
+    const base64 = buffer.toString("base64");
+    return { data: `data:${mimeType};base64,${base64}`, mimeType };
+  }
+  if (typeof p.data === "string") {
+    return extractFromString(p.data, mimeType);
+  }
+  if (typeof p.url === "string") {
+    return extractFromString(p.url, mimeType);
+  }
+  return null;
+}
+function extractFromString(value, fallbackMimeType) {
+  const trimmed = value.trim();
+  if (/^https?:\/\//i.test(trimmed)) {
+    return null;
+  }
+  if (trimmed.startsWith("data:")) {
+    if (!trimmed.includes(";base64,")) {
+      return null;
+    }
+    const match = trimmed.match(/^data:([^;,]+)/);
+    const mimeType = match?.[1] || fallbackMimeType;
+    return { data: trimmed, mimeType };
+  }
+  return {
+    data: `data:${fallbackMimeType};base64,${trimmed}`,
+    mimeType: fallbackMimeType
+  };
+}
+function writeImageToTempFile(imageData) {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "codex-img-"));
+  const ext = getExtensionFromMimeType(imageData.mimeType);
+  const filePath = path.join(dir, `image.${ext}`);
+  const base64Match = imageData.data.match(/^data:[^;]+;base64,(.+)$/);
+  if (!base64Match) {
+    throw new Error("Invalid data URL format: expected data:[type];base64,[data]");
+  }
+  const buffer = Buffer.from(base64Match[1], "base64");
+  fs.writeFileSync(filePath, buffer);
+  return filePath;
+}
+function cleanupTempImages(paths) {
+  for (const filePath of paths) {
+    try {
+      fs.rmSync(filePath, { force: true });
+      const dir = filePath.replace(/[/\\][^/\\]+$/, "");
+      if (dir.includes("codex-img-")) {
+        fs.rmSync(dir, { force: true, recursive: true });
+      }
+    } catch {
+    }
+  }
+}
+function getExtensionFromMimeType(mimeType) {
+  if (!mimeType) return "png";
+  const mapping = {
+    "image/png": "png",
+    "image/jpeg": "jpg",
+    "image/jpg": "jpg",
+    "image/gif": "gif",
+    "image/webp": "webp",
+    "image/bmp": "bmp",
+    "image/svg+xml": "svg"
+  };
+  return mapping[mimeType.toLowerCase()] || mimeType.split("/")[1] || "png";
+}
 
 // src/message-mapper.ts
 function isTextPart(p) {
@@ -187,6 +275,7 @@ function isToolItem(p) {
 function mapMessagesToPrompt(prompt) {
   const warnings = [];
   const parts = [];
+  const images = [];
   let systemText;
   for (const msg of prompt) {
     if (msg.role === "system") {
@@ -199,8 +288,14 @@ function mapMessagesToPrompt(prompt) {
       } else if (Array.isArray(msg.content)) {
         const text = msg.content.filter(isTextPart).map((p) => p.text).join("\n");
         if (text) parts.push(`Human: ${text}`);
-        const images = msg.content.filter(isImagePart);
-        if (images.length) warnings.push("Image inputs ignored by Codex CLI integration.");
+        for (const part of msg.content.filter(isImagePart)) {
+          const imageData = extractImageData(part);
+          if (imageData) {
+            images.push(imageData);
+          } else {
+            warnings.push("Unsupported image format in message (HTTP URLs not supported)");
+          }
+        }
       }
       continue;
     }
@@ -227,7 +322,7 @@ function mapMessagesToPrompt(prompt) {
   let promptText = "";
   if (systemText) promptText += systemText + "\n\n";
   promptText += parts.join("\n\n");
-  return { promptText, ...warnings.length ? { warnings } : {} };
+  return { promptText, images, ...warnings.length ? { warnings } : {} };
 }
 function createAPICallError({
   message,
@@ -404,7 +499,7 @@ var CodexCliLanguageModel = class {
     const current = typeof data.type === "string" ? data.type : void 0;
     return legacy ?? current;
   }
-  buildArgs(promptText, responseFormat, settings = this.settings) {
+  buildArgs(promptText, images = [], responseFormat, settings = this.settings) {
     const base = resolveCodexPath(settings.codexPath, settings.allowNpx);
     const args = [...base.args, "exec", "--experimental-json"];
     if (settings.fullAuto) {
@@ -479,6 +574,16 @@ var CodexCliLanguageModel = class {
         args.push("--output-schema", schemaPath);
       }
     }
+    const tempImagePaths = [];
+    for (const img of images) {
+      try {
+        const tempPath = writeImageToTempFile(img);
+        tempImagePaths.push(tempPath);
+        args.push("--image", tempPath);
+      } catch (e) {
+        this.logger.warn(`[codex-cli] Failed to write image to temp file: ${String(e)}`);
+      }
+    }
     args.push(promptText);
     const env = {
       ...process.env,
@@ -500,7 +605,8 @@ var CodexCliLanguageModel = class {
       cwd: settings.cwd,
       lastMessagePath,
       lastMessageIsTemp,
-      schemaPath
+      schemaPath,
+      tempImagePaths: tempImagePaths.length > 0 ? tempImagePaths : void 0
     };
   }
   applyMcpSettings(args, settings) {
@@ -830,14 +936,14 @@ var CodexCliLanguageModel = class {
   }
   async doGenerate(options) {
     this.logger.debug(`[codex-cli] Starting doGenerate request with model: ${this.modelId}`);
-    const { promptText, warnings: mappingWarnings } = mapMessagesToPrompt(options.prompt);
+    const { promptText, images, warnings: mappingWarnings } = mapMessagesToPrompt(options.prompt);
     const promptExcerpt = promptText.slice(0, 200);
     const warnings = [
       ...this.mapWarnings(options),
       ...mappingWarnings?.map((m) => ({ type: "other", message: m })) || []
     ];
     this.logger.debug(
-      `[codex-cli] Converted ${options.prompt.length} messages, response format: ${options.responseFormat?.type ?? "none"}`
+      `[codex-cli] Converted ${options.prompt.length} messages (${images.length} images), response format: ${options.responseFormat?.type ?? "none"}`
     );
     const providerOptions = await providerUtils.parseProviderOptions({
       provider: this.provider,
@@ -846,11 +952,7 @@ var CodexCliLanguageModel = class {
     });
     const effectiveSettings = this.mergeSettings(providerOptions);
     const responseFormat = options.responseFormat?.type === "json" ? { type: "json", schema: options.responseFormat.schema } : void 0;
-    const { cmd, args, env, cwd, lastMessagePath, lastMessageIsTemp, schemaPath } = this.buildArgs(
-      promptText,
-      responseFormat,
-      effectiveSettings
-    );
+    const { cmd, args, env, cwd, lastMessagePath, lastMessageIsTemp, schemaPath, tempImagePaths } = this.buildArgs(promptText, images, responseFormat, effectiveSettings);
     this.logger.debug(
       `[codex-cli] Executing Codex CLI: ${cmd} with ${args.length} arguments, cwd: ${cwd ?? "default"}`
     );
@@ -863,6 +965,16 @@ var CodexCliLanguageModel = class {
     if (options.abortSignal) {
       if (options.abortSignal.aborted) {
         child.kill("SIGTERM");
+        if (schemaPath) {
+          try {
+            const schemaDir = path.dirname(schemaPath);
+            fs.rmSync(schemaDir, { recursive: true, force: true });
+          } catch {
+          }
+        }
+        if (tempImagePaths?.length) {
+          cleanupTempImages(tempImagePaths);
+        }
         throw options.abortSignal.reason ?? new Error("Request aborted");
       }
       onAbort = () => child.kill("SIGTERM");
@@ -957,6 +1069,9 @@ var CodexCliLanguageModel = class {
         } catch {
         }
       }
+      if (tempImagePaths?.length) {
+        cleanupTempImages(tempImagePaths);
+      }
     }
     if (!text && lastMessagePath) {
       try {
@@ -988,14 +1103,14 @@ var CodexCliLanguageModel = class {
   }
   async doStream(options) {
     this.logger.debug(`[codex-cli] Starting doStream request with model: ${this.modelId}`);
-    const { promptText, warnings: mappingWarnings } = mapMessagesToPrompt(options.prompt);
+    const { promptText, images, warnings: mappingWarnings } = mapMessagesToPrompt(options.prompt);
     const promptExcerpt = promptText.slice(0, 200);
     const warnings = [
       ...this.mapWarnings(options),
       ...mappingWarnings?.map((m) => ({ type: "other", message: m })) || []
     ];
     this.logger.debug(
-      `[codex-cli] Converted ${options.prompt.length} messages for streaming, response format: ${options.responseFormat?.type ?? "none"}`
+      `[codex-cli] Converted ${options.prompt.length} messages (${images.length} images) for streaming, response format: ${options.responseFormat?.type ?? "none"}`
     );
     const providerOptions = await providerUtils.parseProviderOptions({
       provider: this.provider,
@@ -1004,11 +1119,7 @@ var CodexCliLanguageModel = class {
     });
     const effectiveSettings = this.mergeSettings(providerOptions);
     const responseFormat = options.responseFormat?.type === "json" ? { type: "json", schema: options.responseFormat.schema } : void 0;
-    const { cmd, args, env, cwd, lastMessagePath, lastMessageIsTemp, schemaPath } = this.buildArgs(
-      promptText,
-      responseFormat,
-      effectiveSettings
-    );
+    const { cmd, args, env, cwd, lastMessagePath, lastMessageIsTemp, schemaPath, tempImagePaths } = this.buildArgs(promptText, images, responseFormat, effectiveSettings);
     this.logger.debug(
       `[codex-cli] Executing Codex CLI for streaming: ${cmd} with ${args.length} arguments`
     );
@@ -1023,6 +1134,18 @@ var CodexCliLanguageModel = class {
         let responseMetadataSent = false;
         let lastUsage;
         let turnFailureMessage;
+        const cleanupTempFiles = () => {
+          if (schemaPath) {
+            try {
+              const schemaDir = path.dirname(schemaPath);
+              fs.rmSync(schemaDir, { recursive: true, force: true });
+            } catch {
+            }
+          }
+          if (tempImagePaths?.length) {
+            cleanupTempImages(tempImagePaths);
+          }
+        };
         const sendMetadata = (meta = {}) => {
           controller.enqueue({
             type: "response-metadata",
@@ -1096,6 +1219,7 @@ var CodexCliLanguageModel = class {
         if (options.abortSignal) {
           if (options.abortSignal.aborted) {
             child.kill("SIGTERM");
+            cleanupTempFiles();
             controller.error(options.abortSignal.reason ?? new Error("Request aborted"));
             return;
           }
@@ -1215,23 +1339,15 @@ var CodexCliLanguageModel = class {
             }
           }
         });
-        const cleanupSchema = () => {
-          if (!schemaPath) return;
-          try {
-            const schemaDir = path.dirname(schemaPath);
-            fs.rmSync(schemaDir, { recursive: true, force: true });
-          } catch {
-          }
-        };
         child.on("error", (e) => {
           this.logger.error(`[codex-cli] Stream spawn error: ${String(e)}`);
           if (options.abortSignal) options.abortSignal.removeEventListener("abort", onAbort);
-          cleanupSchema();
+          cleanupTempFiles();
           controller.error(this.handleSpawnError(e, promptExcerpt));
         });
         child.on("close", (code) => {
           if (options.abortSignal) options.abortSignal.removeEventListener("abort", onAbort);
-          cleanupSchema();
+          cleanupTempFiles();
           setImmediate(() => finishStream(code));
         });
       },

package/dist/index.js

@@ -164,6 +164,94 @@ function validateModelId(modelId) {
   if (!modelId || modelId.trim() === "") return "Model ID cannot be empty";
   return void 0;
 }
+function extractImageData(part) {
+  if (typeof part !== "object" || part === null) return null;
+  const p = part;
+  const mimeType = p.mimeType || "image/png";
+  if (typeof p.image === "string") {
+    return extractFromString(p.image, mimeType);
+  }
+  if (p.image instanceof URL) {
+    if (p.image.protocol === "data:") {
+      const dataUrlStr = p.image.toString();
+      const match = dataUrlStr.match(/^data:([^;,]+)/);
+      const extractedMimeType = match?.[1] || mimeType;
+      return { data: dataUrlStr, mimeType: extractedMimeType };
+    }
+    return null;
+  }
+  if (Buffer.isBuffer(p.image)) {
+    const base64 = p.image.toString("base64");
+    return { data: `data:${mimeType};base64,${base64}`, mimeType };
+  }
+  if (p.image instanceof ArrayBuffer || p.image instanceof Uint8Array) {
+    const buffer = Buffer.from(p.image);
+    const base64 = buffer.toString("base64");
+    return { data: `data:${mimeType};base64,${base64}`, mimeType };
+  }
+  if (typeof p.data === "string") {
+    return extractFromString(p.data, mimeType);
+  }
+  if (typeof p.url === "string") {
+    return extractFromString(p.url, mimeType);
+  }
+  return null;
+}
+function extractFromString(value, fallbackMimeType) {
+  const trimmed = value.trim();
+  if (/^https?:\/\//i.test(trimmed)) {
+    return null;
+  }
+  if (trimmed.startsWith("data:")) {
+    if (!trimmed.includes(";base64,")) {
+      return null;
+    }
+    const match = trimmed.match(/^data:([^;,]+)/);
+    const mimeType = match?.[1] || fallbackMimeType;
+    return { data: trimmed, mimeType };
+  }
+  return {
+    data: `data:${fallbackMimeType};base64,${trimmed}`,
+    mimeType: fallbackMimeType
+  };
+}
+function writeImageToTempFile(imageData) {
+  const dir = mkdtempSync(join(tmpdir(), "codex-img-"));
+  const ext = getExtensionFromMimeType(imageData.mimeType);
+  const filePath = join(dir, `image.${ext}`);
+  const base64Match = imageData.data.match(/^data:[^;]+;base64,(.+)$/);
+  if (!base64Match) {
+    throw new Error("Invalid data URL format: expected data:[type];base64,[data]");
+  }
+  const buffer = Buffer.from(base64Match[1], "base64");
+  writeFileSync(filePath, buffer);
+  return filePath;
+}
+function cleanupTempImages(paths) {
+  for (const filePath of paths) {
+    try {
+      rmSync(filePath, { force: true });
+      const dir = filePath.replace(/[/\\][^/\\]+$/, "");
+      if (dir.includes("codex-img-")) {
+        rmSync(dir, { force: true, recursive: true });
+      }
+    } catch {
+    }
+  }
+}
+function getExtensionFromMimeType(mimeType) {
+  if (!mimeType) return "png";
+  const mapping = {
+    "image/png": "png",
+    "image/jpeg": "jpg",
+    "image/jpg": "jpg",
+    "image/gif": "gif",
+    "image/webp": "webp",
+    "image/bmp": "bmp",
+    "image/svg+xml": "svg"
+  };
+  return mapping[mimeType.toLowerCase()] || mimeType.split("/")[1] || "png";
+}
 
 // src/message-mapper.ts
 function isTextPart(p) {
@@ -184,6 +272,7 @@ function isToolItem(p) {
 function mapMessagesToPrompt(prompt) {
   const warnings = [];
   const parts = [];
+  const images = [];
   let systemText;
   for (const msg of prompt) {
     if (msg.role === "system") {
@@ -196,8 +285,14 @@ function mapMessagesToPrompt(prompt) {
       } else if (Array.isArray(msg.content)) {
         const text = msg.content.filter(isTextPart).map((p) => p.text).join("\n");
         if (text) parts.push(`Human: ${text}`);
-        const images = msg.content.filter(isImagePart);
-        if (images.length) warnings.push("Image inputs ignored by Codex CLI integration.");
+        for (const part of msg.content.filter(isImagePart)) {
+          const imageData = extractImageData(part);
+          if (imageData) {
+            images.push(imageData);
+          } else {
+            warnings.push("Unsupported image format in message (HTTP URLs not supported)");
+          }
+        }
       }
       continue;
     }
@@ -224,7 +319,7 @@ function mapMessagesToPrompt(prompt) {
   let promptText = "";
   if (systemText) promptText += systemText + "\n\n";
   promptText += parts.join("\n\n");
-  return { promptText, ...warnings.length ? { warnings } : {} };
+  return { promptText, images, ...warnings.length ? { warnings } : {} };
 }
 function createAPICallError({
   message,
@@ -401,7 +496,7 @@ var CodexCliLanguageModel = class {
     const current = typeof data.type === "string" ? data.type : void 0;
     return legacy ?? current;
   }
-  buildArgs(promptText, responseFormat, settings = this.settings) {
+  buildArgs(promptText, images = [], responseFormat, settings = this.settings) {
     const base = resolveCodexPath(settings.codexPath, settings.allowNpx);
     const args = [...base.args, "exec", "--experimental-json"];
     if (settings.fullAuto) {
@@ -476,6 +571,16 @@ var CodexCliLanguageModel = class {
         args.push("--output-schema", schemaPath);
       }
     }
+    const tempImagePaths = [];
+    for (const img of images) {
+      try {
+        const tempPath = writeImageToTempFile(img);
+        tempImagePaths.push(tempPath);
+        args.push("--image", tempPath);
+      } catch (e) {
+        this.logger.warn(`[codex-cli] Failed to write image to temp file: ${String(e)}`);
+      }
+    }
     args.push(promptText);
     const env = {
       ...process.env,
@@ -497,7 +602,8 @@ var CodexCliLanguageModel = class {
       cwd: settings.cwd,
       lastMessagePath,
       lastMessageIsTemp,
-      schemaPath
+      schemaPath,
+      tempImagePaths: tempImagePaths.length > 0 ? tempImagePaths : void 0
     };
   }
   applyMcpSettings(args, settings) {
@@ -827,14 +933,14 @@ var CodexCliLanguageModel = class {
   }
   async doGenerate(options) {
     this.logger.debug(`[codex-cli] Starting doGenerate request with model: ${this.modelId}`);
-    const { promptText, warnings: mappingWarnings } = mapMessagesToPrompt(options.prompt);
+    const { promptText, images, warnings: mappingWarnings } = mapMessagesToPrompt(options.prompt);
     const promptExcerpt = promptText.slice(0, 200);
     const warnings = [
       ...this.mapWarnings(options),
       ...mappingWarnings?.map((m) => ({ type: "other", message: m })) || []
     ];
     this.logger.debug(
-      `[codex-cli] Converted ${options.prompt.length} messages, response format: ${options.responseFormat?.type ?? "none"}`
+      `[codex-cli] Converted ${options.prompt.length} messages (${images.length} images), response format: ${options.responseFormat?.type ?? "none"}`
     );
     const providerOptions = await parseProviderOptions({
       provider: this.provider,
@@ -843,11 +949,7 @@ var CodexCliLanguageModel = class {
     });
     const effectiveSettings = this.mergeSettings(providerOptions);
     const responseFormat = options.responseFormat?.type === "json" ? { type: "json", schema: options.responseFormat.schema } : void 0;
-    const { cmd, args, env, cwd, lastMessagePath, lastMessageIsTemp, schemaPath } = this.buildArgs(
-      promptText,
-      responseFormat,
-      effectiveSettings
-    );
+    const { cmd, args, env, cwd, lastMessagePath, lastMessageIsTemp, schemaPath, tempImagePaths } = this.buildArgs(promptText, images, responseFormat, effectiveSettings);
     this.logger.debug(
       `[codex-cli] Executing Codex CLI: ${cmd} with ${args.length} arguments, cwd: ${cwd ?? "default"}`
     );
@@ -860,6 +962,16 @@ var CodexCliLanguageModel = class {
     if (options.abortSignal) {
       if (options.abortSignal.aborted) {
         child.kill("SIGTERM");
+        if (schemaPath) {
+          try {
+            const schemaDir = dirname(schemaPath);
+            rmSync(schemaDir, { recursive: true, force: true });
+          } catch {
+          }
+        }
+        if (tempImagePaths?.length) {
+          cleanupTempImages(tempImagePaths);
+        }
         throw options.abortSignal.reason ?? new Error("Request aborted");
       }
       onAbort = () => child.kill("SIGTERM");
@@ -954,6 +1066,9 @@ var CodexCliLanguageModel = class {
         } catch {
         }
       }
+      if (tempImagePaths?.length) {
+        cleanupTempImages(tempImagePaths);
+      }
     }
     if (!text && lastMessagePath) {
       try {
@@ -985,14 +1100,14 @@ var CodexCliLanguageModel = class {
   }
   async doStream(options) {
     this.logger.debug(`[codex-cli] Starting doStream request with model: ${this.modelId}`);
-    const { promptText, warnings: mappingWarnings } = mapMessagesToPrompt(options.prompt);
+    const { promptText, images, warnings: mappingWarnings } = mapMessagesToPrompt(options.prompt);
     const promptExcerpt = promptText.slice(0, 200);
     const warnings = [
       ...this.mapWarnings(options),
       ...mappingWarnings?.map((m) => ({ type: "other", message: m })) || []
     ];
     this.logger.debug(
-      `[codex-cli] Converted ${options.prompt.length} messages for streaming, response format: ${options.responseFormat?.type ?? "none"}`
+      `[codex-cli] Converted ${options.prompt.length} messages (${images.length} images) for streaming, response format: ${options.responseFormat?.type ?? "none"}`
     );
     const providerOptions = await parseProviderOptions({
       provider: this.provider,
@@ -1001,11 +1116,7 @@ var CodexCliLanguageModel = class {
     });
     const effectiveSettings = this.mergeSettings(providerOptions);
     const responseFormat = options.responseFormat?.type === "json" ? { type: "json", schema: options.responseFormat.schema } : void 0;
-    const { cmd, args, env, cwd, lastMessagePath, lastMessageIsTemp, schemaPath } = this.buildArgs(
-      promptText,
-      responseFormat,
-      effectiveSettings
-    );
+    const { cmd, args, env, cwd, lastMessagePath, lastMessageIsTemp, schemaPath, tempImagePaths } = this.buildArgs(promptText, images, responseFormat, effectiveSettings);
     this.logger.debug(
       `[codex-cli] Executing Codex CLI for streaming: ${cmd} with ${args.length} arguments`
     );
@@ -1020,6 +1131,18 @@ var CodexCliLanguageModel = class {
         let responseMetadataSent = false;
         let lastUsage;
         let turnFailureMessage;
+        const cleanupTempFiles = () => {
+          if (schemaPath) {
+            try {
+              const schemaDir = dirname(schemaPath);
+              rmSync(schemaDir, { recursive: true, force: true });
+            } catch {
+            }
+          }
+          if (tempImagePaths?.length) {
+            cleanupTempImages(tempImagePaths);
+          }
+        };
         const sendMetadata = (meta = {}) => {
           controller.enqueue({
             type: "response-metadata",
@@ -1093,6 +1216,7 @@ var CodexCliLanguageModel = class {
         if (options.abortSignal) {
           if (options.abortSignal.aborted) {
             child.kill("SIGTERM");
+            cleanupTempFiles();
             controller.error(options.abortSignal.reason ?? new Error("Request aborted"));
             return;
           }
@@ -1212,23 +1336,15 @@ var CodexCliLanguageModel = class {
             }
           }
         });
-        const cleanupSchema = () => {
-          if (!schemaPath) return;
-          try {
-            const schemaDir = dirname(schemaPath);
-            rmSync(schemaDir, { recursive: true, force: true });
-          } catch {
-          }
-        };
         child.on("error", (e) => {
           this.logger.error(`[codex-cli] Stream spawn error: ${String(e)}`);
           if (options.abortSignal) options.abortSignal.removeEventListener("abort", onAbort);
-          cleanupSchema();
+          cleanupTempFiles();
           controller.error(this.handleSpawnError(e, promptExcerpt));
         });
         child.on("close", (code) => {
           if (options.abortSignal) options.abortSignal.removeEventListener("abort", onAbort);
-          cleanupSchema();
+          cleanupTempFiles();
           setImmediate(() => finishStream(code));
         });
       },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-sdk-provider-codex-cli",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "AI SDK v5 provider for OpenAI Codex CLI with native JSON Schema support",
   "keywords": [
     "ai-sdk",