ai-sdk-provider-codex-cli 0.5.2 → 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+)
 
@@ -223,6 +265,7 @@ When OpenAI adds streaming support, this provider will be updated to handle thos
 
 - `allowNpx`: If true, falls back to `npx -y @openai/codex` when Codex is not on PATH
 - `cwd`: Working directory for Codex
+- `addDirs`: Extra directories Codex may read/write (repeats `--add-dir`)
 - Autonomy/sandbox:
   - `fullAuto` (equivalent to `--full-auto`)
   - `dangerouslyBypassApprovalsAndSandbox` (bypass approvals and sandbox; dangerous)
@@ -246,6 +289,7 @@ import { codexCli } from 'ai-sdk-provider-codex-cli';
 const model = codexCli('gpt-5.1-codex', {
   allowNpx: true,
   skipGitRepoCheck: true,
+  addDirs: ['../shared'],
 
   // Reasoning & verbosity
   reasoningEffort: 'medium', // minimal | low | medium | high | xhigh (xhigh only on gpt-5.1-codex-max)
@@ -259,6 +303,23 @@ const model = codexCli('gpt-5.1-codex', {
   oss: false, // adds --oss when true
   webSearch: true, // maps to -c tools.web_search=true
 
+  // MCP servers (stdio + HTTP/RMCP)
+  rmcpClient: true, // enables HTTP-based MCP clients (features.rmcp_client=true)
+  mcpServers: {
+    local: {
+      transport: 'stdio',
+      command: 'node',
+      args: ['tools/mcp.js'],
+      env: { API_KEY: process.env.MCP_API_KEY ?? '' },
+    },
+    docs: {
+      transport: 'http',
+      url: 'https://mcp.my-org.com',
+      bearerTokenEnvVar: 'MCP_BEARER',
+      httpHeaders: { 'x-tenant': 'acme' },
+    },
+  },
+
   // Generic overrides (maps to -c key=value)
   configOverrides: {
     experimental_resume: '/tmp/session.jsonl',
@@ -269,6 +330,7 @@ const model = codexCli('gpt-5.1-codex', {
 
 Nested override objects are flattened to dotted keys (e.g., the example above emits
 `-c sandbox_workspace_write.network_access=true`). Arrays are serialized to JSON strings.
+MCP server env/header objects flatten the same way (e.g., `mcp_servers.docs.http_headers.x-tenant=acme`).
 
 ### Per-call overrides via `providerOptions` (v0.4.0+)
 
@@ -293,6 +355,14 @@ const response = await generateText({
       reasoningEffort: 'high',
       reasoningSummary: 'detailed',
       textVerbosity: 'high', // AI SDK naming; maps to model_verbosity
+      rmcpClient: true,
+      mcpServers: {
+        scratch: {
+          transport: 'stdio',
+          command: 'pnpm',
+          args: ['mcp', 'serve'],
+        },
+      },
       configOverrides: {
         experimental_resume: '/tmp/resume.jsonl',
       },

package/dist/index.cjs

@@ -68,9 +68,37 @@ var loggerFunctionSchema = zod.z.object({
     message: "error must be a function"
   })
 });
+var mcpServerBaseSchema = zod.z.object({
+  enabled: zod.z.boolean().optional(),
+  startupTimeoutSec: zod.z.number().int().positive().optional(),
+  toolTimeoutSec: zod.z.number().int().positive().optional(),
+  enabledTools: zod.z.array(zod.z.string()).optional(),
+  disabledTools: zod.z.array(zod.z.string()).optional()
+});
+var mcpServerStdioSchema = mcpServerBaseSchema.extend({
+  transport: zod.z.literal("stdio"),
+  command: zod.z.string().min(1),
+  args: zod.z.array(zod.z.string()).optional(),
+  env: zod.z.record(zod.z.string(), zod.z.string()).optional(),
+  cwd: zod.z.string().optional()
+});
+var mcpServerHttpSchema = mcpServerBaseSchema.extend({
+  transport: zod.z.literal("http"),
+  url: zod.z.string().min(1),
+  bearerToken: zod.z.string().optional(),
+  bearerTokenEnvVar: zod.z.string().optional(),
+  httpHeaders: zod.z.record(zod.z.string(), zod.z.string()).optional(),
+  envHttpHeaders: zod.z.record(zod.z.string(), zod.z.string()).optional()
+});
+var mcpServerSchema = zod.z.discriminatedUnion("transport", [
+  mcpServerStdioSchema,
+  mcpServerHttpSchema
+]);
+var mcpServersSchema = zod.z.record(zod.z.string(), mcpServerSchema);
 var settingsSchema = zod.z.object({
   codexPath: zod.z.string().optional(),
   cwd: zod.z.string().optional(),
+  addDirs: zod.z.array(zod.z.string().min(1)).optional(),
   approvalMode: zod.z.enum(["untrusted", "on-failure", "on-request", "never"]).optional(),
   sandboxMode: zod.z.enum(["read-only", "workspace-write", "danger-full-access"]).optional(),
   fullAuto: zod.z.boolean().optional(),
@@ -78,6 +106,7 @@ var settingsSchema = zod.z.object({
   skipGitRepoCheck: zod.z.boolean().optional(),
   color: zod.z.enum(["always", "never", "auto"]).optional(),
   allowNpx: zod.z.boolean().optional(),
+  outputLastMessageFile: zod.z.string().optional(),
   env: zod.z.record(zod.z.string(), zod.z.string()).optional(),
   verbose: zod.z.boolean().optional(),
   logger: zod.z.union([zod.z.literal(false), loggerFunctionSchema]).optional(),
@@ -92,6 +121,8 @@ var settingsSchema = zod.z.object({
   profile: zod.z.string().optional(),
   oss: zod.z.boolean().optional(),
   webSearch: zod.z.boolean().optional(),
+  mcpServers: mcpServersSchema.optional(),
+  rmcpClient: zod.z.boolean().optional(),
   // NEW: Generic overrides
   configOverrides: zod.z.record(
     zod.z.string(),
@@ -136,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) {
@@ -156,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") {
@@ -168,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;
     }
@@ -196,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,
@@ -235,6 +361,7 @@ var codexCliProviderOptionsSchema = zod.z.object({
   reasoningSummary: zod.z.enum(["auto", "detailed"]).optional(),
   reasoningSummaryFormat: zod.z.enum(["none", "experimental"]).optional(),
   textVerbosity: zod.z.enum(["low", "medium", "high"]).optional(),
+  addDirs: zod.z.array(zod.z.string().min(1)).optional(),
   configOverrides: zod.z.record(
     zod.z.string(),
     zod.z.union([
@@ -244,7 +371,9 @@ var codexCliProviderOptionsSchema = zod.z.object({
       zod.z.object({}).passthrough(),
       zod.z.array(zod.z.any())
     ])
-  ).optional()
+  ).optional(),
+  mcpServers: mcpServersSchema.optional(),
+  rmcpClient: zod.z.boolean().optional()
 }).strict();
 function resolveCodexPath(explicitPath, allowNpx) {
   if (explicitPath) return { cmd: "node", args: [explicitPath] };
@@ -286,14 +415,79 @@ var CodexCliLanguageModel = class {
       ...this.settings.configOverrides ?? {},
       ...providerOptions.configOverrides ?? {}
     } : void 0;
+    const mergedAddDirs = providerOptions.addDirs || this.settings.addDirs ? [...this.settings.addDirs ?? [], ...providerOptions.addDirs ?? []] : void 0;
+    const mergedMcpServers = this.mergeMcpServers(
+      this.settings.mcpServers,
+      providerOptions.mcpServers
+    );
     return {
       ...this.settings,
       reasoningEffort: providerOptions.reasoningEffort ?? this.settings.reasoningEffort,
       reasoningSummary: providerOptions.reasoningSummary ?? this.settings.reasoningSummary,
       reasoningSummaryFormat: providerOptions.reasoningSummaryFormat ?? this.settings.reasoningSummaryFormat,
       modelVerbosity: providerOptions.textVerbosity ?? this.settings.modelVerbosity,
-      configOverrides: mergedConfigOverrides
+      configOverrides: mergedConfigOverrides,
+      addDirs: mergedAddDirs,
+      mcpServers: mergedMcpServers,
+      rmcpClient: providerOptions.rmcpClient ?? this.settings.rmcpClient
+    };
+  }
+  mergeMcpServers(base, override) {
+    if (!base) return override;
+    if (!override) return base;
+    const merged = { ...base };
+    for (const [name, incoming] of Object.entries(override)) {
+      const existing = base[name];
+      merged[name] = this.mergeSingleMcpServer(existing, incoming);
+    }
+    return merged;
+  }
+  mergeSingleMcpServer(existing, incoming) {
+    if (!existing || existing.transport !== incoming.transport) {
+      return { ...incoming };
+    }
+    if (incoming.transport === "stdio") {
+      const baseStdio = existing;
+      const result2 = {
+        transport: "stdio",
+        command: incoming.command,
+        args: incoming.args ?? baseStdio.args,
+        env: this.mergeStringRecord(baseStdio.env, incoming.env),
+        cwd: incoming.cwd ?? baseStdio.cwd,
+        enabled: incoming.enabled ?? existing.enabled,
+        startupTimeoutSec: incoming.startupTimeoutSec ?? existing.startupTimeoutSec,
+        toolTimeoutSec: incoming.toolTimeoutSec ?? existing.toolTimeoutSec,
+        enabledTools: incoming.enabledTools ?? existing.enabledTools,
+        disabledTools: incoming.disabledTools ?? existing.disabledTools
+      };
+      return result2;
+    }
+    const baseHttp = existing;
+    const hasIncomingAuth = incoming.bearerToken !== void 0 || incoming.bearerTokenEnvVar !== void 0;
+    const bearerToken = hasIncomingAuth ? incoming.bearerToken : baseHttp.bearerToken;
+    const bearerTokenEnvVar = hasIncomingAuth ? incoming.bearerTokenEnvVar : baseHttp.bearerTokenEnvVar;
+    const result = {
+      transport: "http",
+      url: incoming.url,
+      bearerToken,
+      bearerTokenEnvVar,
+      httpHeaders: this.mergeStringRecord(baseHttp.httpHeaders, incoming.httpHeaders),
+      envHttpHeaders: this.mergeStringRecord(baseHttp.envHttpHeaders, incoming.envHttpHeaders),
+      enabled: incoming.enabled ?? existing.enabled,
+      startupTimeoutSec: incoming.startupTimeoutSec ?? existing.startupTimeoutSec,
+      toolTimeoutSec: incoming.toolTimeoutSec ?? existing.toolTimeoutSec,
+      enabledTools: incoming.enabledTools ?? existing.enabledTools,
+      disabledTools: incoming.disabledTools ?? existing.disabledTools
     };
+    return result;
+  }
+  mergeStringRecord(base, override) {
+    if (override !== void 0) {
+      if (Object.keys(override).length === 0) return {};
+      return { ...base ?? {}, ...override };
+    }
+    if (base) return { ...base };
+    return void 0;
   }
   // Codex JSONL items use `type` for the item discriminator, but some
   // earlier fixtures (and defensive parsing) might still surface `item_type`.
@@ -305,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) {
@@ -345,12 +539,20 @@ var CodexCliLanguageModel = class {
     if (settings.webSearch) {
       args.push("-c", "tools.web_search=true");
     }
+    this.applyMcpSettings(args, settings);
     if (settings.color) {
       args.push("--color", settings.color);
     }
     if (this.modelId) {
       args.push("-m", this.modelId);
     }
+    if (settings.addDirs?.length) {
+      for (const dir of settings.addDirs) {
+        if (typeof dir === "string" && dir.trim().length > 0) {
+          args.push("--add-dir", dir);
+        }
+      }
+    }
     if (settings.configOverrides) {
       for (const [key, value] of Object.entries(settings.configOverrides)) {
         this.addConfigOverride(args, key, value);
@@ -372,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,
@@ -379,16 +591,74 @@ var CodexCliLanguageModel = class {
       RUST_LOG: process.env.RUST_LOG || "error"
     };
     let lastMessagePath = settings.outputLastMessageFile;
+    let lastMessageIsTemp = false;
     if (!lastMessagePath) {
       const dir = fs.mkdtempSync(path.join(os.tmpdir(), "codex-cli-"));
       lastMessagePath = path.join(dir, "last-message.txt");
+      lastMessageIsTemp = true;
     }
     args.push("--output-last-message", lastMessagePath);
-    return { cmd: base.cmd, args, env, cwd: settings.cwd, lastMessagePath, schemaPath };
+    return {
+      cmd: base.cmd,
+      args,
+      env,
+      cwd: settings.cwd,
+      lastMessagePath,
+      lastMessageIsTemp,
+      schemaPath,
+      tempImagePaths: tempImagePaths.length > 0 ? tempImagePaths : void 0
+    };
+  }
+  applyMcpSettings(args, settings) {
+    if (settings.rmcpClient) {
+      this.addConfigOverride(args, "features.rmcp_client", true);
+    }
+    if (!settings.mcpServers) return;
+    for (const [rawName, server] of Object.entries(settings.mcpServers)) {
+      const name = rawName.trim();
+      if (!name) continue;
+      const prefix = `mcp_servers.${name}`;
+      if (server.enabled !== void 0) {
+        this.addConfigOverride(args, `${prefix}.enabled`, server.enabled);
+      }
+      if (server.startupTimeoutSec !== void 0) {
+        this.addConfigOverride(args, `${prefix}.startup_timeout_sec`, server.startupTimeoutSec);
+      }
+      if (server.toolTimeoutSec !== void 0) {
+        this.addConfigOverride(args, `${prefix}.tool_timeout_sec`, server.toolTimeoutSec);
+      }
+      if (server.enabledTools !== void 0) {
+        this.addConfigOverride(args, `${prefix}.enabled_tools`, server.enabledTools);
+      }
+      if (server.disabledTools !== void 0) {
+        this.addConfigOverride(args, `${prefix}.disabled_tools`, server.disabledTools);
+      }
+      if (server.transport === "stdio") {
+        this.addConfigOverride(args, `${prefix}.command`, server.command);
+        if (server.args !== void 0) this.addConfigOverride(args, `${prefix}.args`, server.args);
+        if (server.env !== void 0) this.addConfigOverride(args, `${prefix}.env`, server.env);
+        if (server.cwd) this.addConfigOverride(args, `${prefix}.cwd`, server.cwd);
+      } else {
+        this.addConfigOverride(args, `${prefix}.url`, server.url);
+        if (server.bearerToken !== void 0)
+          this.addConfigOverride(args, `${prefix}.bearer_token`, server.bearerToken);
+        if (server.bearerTokenEnvVar)
+          this.addConfigOverride(args, `${prefix}.bearer_token_env_var`, server.bearerTokenEnvVar);
+        if (server.httpHeaders !== void 0)
+          this.addConfigOverride(args, `${prefix}.http_headers`, server.httpHeaders);
+        if (server.envHttpHeaders !== void 0)
+          this.addConfigOverride(args, `${prefix}.env_http_headers`, server.envHttpHeaders);
+      }
+    }
   }
   addConfigOverride(args, key, value) {
     if (this.isPlainObject(value)) {
-      for (const [childKey, childValue] of Object.entries(value)) {
+      const entries = Object.entries(value);
+      if (entries.length === 0) {
+        args.push("-c", `${key}={}`);
+        return;
+      }
+      for (const [childKey, childValue] of entries) {
         this.addConfigOverride(
           args,
           `${key}.${childKey}`,
@@ -666,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,
@@ -682,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, 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"}`
     );
@@ -699,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");
@@ -793,6 +1069,9 @@ var CodexCliLanguageModel = class {
         } catch {
         }
       }
+      if (tempImagePaths?.length) {
+        cleanupTempImages(tempImagePaths);
+      }
     }
     if (!text && lastMessagePath) {
       try {
@@ -802,9 +1081,11 @@ var CodexCliLanguageModel = class {
         }
       } catch {
       }
-      try {
-        fs.rmSync(lastMessagePath, { force: true });
-      } catch {
+      if (lastMessageIsTemp) {
+        try {
+          fs.rmSync(lastMessagePath, { force: true });
+        } catch {
+        }
       }
     }
     const content = [{ type: "text", text }];
@@ -822,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,
@@ -838,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, 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`
     );
@@ -857,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",
@@ -930,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;
           }
@@ -969,9 +1259,11 @@ var CodexCliLanguageModel = class {
               if (fileText) finalText = fileText.trim();
             } catch {
             }
-            try {
-              fs.rmSync(lastMessagePath, { force: true });
-            } catch {
+            if (lastMessageIsTemp) {
+              try {
+                fs.rmSync(lastMessagePath, { force: true });
+              } catch {
+              }
             }
           }
           if (finalText) {
@@ -1047,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));
         });
       },