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

package/dist/index.js

@@ -65,9 +65,37 @@ var loggerFunctionSchema = z.object({
     message: "error must be a function"
   })
 });
+var mcpServerBaseSchema = z.object({
+  enabled: z.boolean().optional(),
+  startupTimeoutSec: z.number().int().positive().optional(),
+  toolTimeoutSec: z.number().int().positive().optional(),
+  enabledTools: z.array(z.string()).optional(),
+  disabledTools: z.array(z.string()).optional()
+});
+var mcpServerStdioSchema = mcpServerBaseSchema.extend({
+  transport: z.literal("stdio"),
+  command: z.string().min(1),
+  args: z.array(z.string()).optional(),
+  env: z.record(z.string(), z.string()).optional(),
+  cwd: z.string().optional()
+});
+var mcpServerHttpSchema = mcpServerBaseSchema.extend({
+  transport: z.literal("http"),
+  url: z.string().min(1),
+  bearerToken: z.string().optional(),
+  bearerTokenEnvVar: z.string().optional(),
+  httpHeaders: z.record(z.string(), z.string()).optional(),
+  envHttpHeaders: z.record(z.string(), z.string()).optional()
+});
+var mcpServerSchema = z.discriminatedUnion("transport", [
+  mcpServerStdioSchema,
+  mcpServerHttpSchema
+]);
+var mcpServersSchema = z.record(z.string(), mcpServerSchema);
 var settingsSchema = z.object({
   codexPath: z.string().optional(),
   cwd: z.string().optional(),
+  addDirs: z.array(z.string().min(1)).optional(),
   approvalMode: z.enum(["untrusted", "on-failure", "on-request", "never"]).optional(),
   sandboxMode: z.enum(["read-only", "workspace-write", "danger-full-access"]).optional(),
   fullAuto: z.boolean().optional(),
@@ -75,6 +103,7 @@ var settingsSchema = z.object({
   skipGitRepoCheck: z.boolean().optional(),
   color: z.enum(["always", "never", "auto"]).optional(),
   allowNpx: z.boolean().optional(),
+  outputLastMessageFile: z.string().optional(),
   env: z.record(z.string(), z.string()).optional(),
   verbose: z.boolean().optional(),
   logger: z.union([z.literal(false), loggerFunctionSchema]).optional(),
@@ -89,6 +118,8 @@ var settingsSchema = z.object({
   profile: z.string().optional(),
   oss: z.boolean().optional(),
   webSearch: z.boolean().optional(),
+  mcpServers: mcpServersSchema.optional(),
+  rmcpClient: z.boolean().optional(),
   // NEW: Generic overrides
   configOverrides: z.record(
     z.string(),
@@ -133,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) {
@@ -153,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") {
@@ -165,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;
     }
@@ -193,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,
@@ -232,6 +358,7 @@ var codexCliProviderOptionsSchema = z.object({
   reasoningSummary: z.enum(["auto", "detailed"]).optional(),
   reasoningSummaryFormat: z.enum(["none", "experimental"]).optional(),
   textVerbosity: z.enum(["low", "medium", "high"]).optional(),
+  addDirs: z.array(z.string().min(1)).optional(),
   configOverrides: z.record(
     z.string(),
     z.union([
@@ -241,7 +368,9 @@ var codexCliProviderOptionsSchema = z.object({
       z.object({}).passthrough(),
       z.array(z.any())
     ])
-  ).optional()
+  ).optional(),
+  mcpServers: mcpServersSchema.optional(),
+  rmcpClient: z.boolean().optional()
 }).strict();
 function resolveCodexPath(explicitPath, allowNpx) {
   if (explicitPath) return { cmd: "node", args: [explicitPath] };
@@ -283,14 +412,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`.
@@ -302,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) {
@@ -342,12 +536,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);
@@ -369,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,
@@ -376,16 +588,74 @@ var CodexCliLanguageModel = class {
       RUST_LOG: process.env.RUST_LOG || "error"
     };
     let lastMessagePath = settings.outputLastMessageFile;
+    let lastMessageIsTemp = false;
     if (!lastMessagePath) {
       const dir = mkdtempSync(join(tmpdir(), "codex-cli-"));
       lastMessagePath = 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}`,
@@ -663,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,
@@ -679,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, 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"}`
     );
@@ -696,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");
@@ -790,6 +1066,9 @@ var CodexCliLanguageModel = class {
         } catch {
         }
       }
+      if (tempImagePaths?.length) {
+        cleanupTempImages(tempImagePaths);
+      }
     }
     if (!text && lastMessagePath) {
       try {
@@ -799,9 +1078,11 @@ var CodexCliLanguageModel = class {
         }
       } catch {
       }
-      try {
-        rmSync(lastMessagePath, { force: true });
-      } catch {
+      if (lastMessageIsTemp) {
+        try {
+          rmSync(lastMessagePath, { force: true });
+        } catch {
+        }
       }
     }
     const content = [{ type: "text", text }];
@@ -819,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,
@@ -835,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, 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`
     );
@@ -854,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",
@@ -927,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;
           }
@@ -966,9 +1256,11 @@ var CodexCliLanguageModel = class {
               if (fileText) finalText = fileText.trim();
             } catch {
             }
-            try {
-              rmSync(lastMessagePath, { force: true });
-            } catch {
+            if (lastMessageIsTemp) {
+              try {
+                rmSync(lastMessagePath, { force: true });
+              } catch {
+              }
             }
           }
           if (finalText) {
@@ -1044,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.5.2",
+  "version": "0.7.0",
   "description": "AI SDK v5 provider for OpenAI Codex CLI with native JSON Schema support",
   "keywords": [
     "ai-sdk",