ai-sdk-provider-codex-cli 0.1.0-ai-sdk-v4

package/dist/index.js

@@ -0,0 +1,541 @@
+import { NoSuchModelError, LoadAPIKeyError, APICallError } from '@ai-sdk/provider';
+import { spawn } from 'child_process';
+import { randomUUID } from 'crypto';
+import { createRequire } from 'module';
+import { mkdtempSync, readFileSync, rmSync } from 'fs';
+import { tmpdir } from 'os';
+import { join } from 'path';
+import { generateId } from '@ai-sdk/provider-utils';
+import { z } from 'zod';
+
+// src/codex-cli-provider.ts
+
+// src/extract-json.ts
+function extractJson(text) {
+  const start = text.indexOf("{");
+  if (start === -1) return text;
+  let depth = 0;
+  for (let i = start; i < text.length; i++) {
+    const ch = text[i];
+    if (ch === "{") depth++;
+    else if (ch === "}") {
+      depth--;
+      if (depth === 0) return text.slice(start, i + 1);
+    }
+  }
+  return text;
+}
+
+// src/logger.ts
+var defaultLogger = {
+  warn: (m) => console.warn(m),
+  error: (m) => console.error(m)
+};
+var noopLogger = {
+  warn: () => {
+  },
+  error: () => {
+  }
+};
+function getLogger(logger) {
+  if (logger === false) return noopLogger;
+  if (!logger) return defaultLogger;
+  return logger;
+}
+var settingsSchema = z.object({
+  codexPath: z.string().optional(),
+  cwd: z.string().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(),
+  dangerouslyBypassApprovalsAndSandbox: z.boolean().optional(),
+  skipGitRepoCheck: z.boolean().optional(),
+  color: z.enum(["always", "never", "auto"]).optional(),
+  allowNpx: z.boolean().optional(),
+  env: z.record(z.string(), z.string()).optional(),
+  verbose: z.boolean().optional(),
+  logger: z.any().optional()
+}).strict();
+function validateSettings(settings) {
+  const warnings = [];
+  const errors = [];
+  const parsed = settingsSchema.safeParse(settings);
+  if (!parsed.success) {
+    const raw = parsed.error;
+    let issues = [];
+    if (raw && typeof raw === "object") {
+      const v4 = raw.issues;
+      const v3 = raw.errors;
+      if (Array.isArray(v4)) issues = v4;
+      else if (Array.isArray(v3)) issues = v3;
+    }
+    for (const i of issues) {
+      const path = Array.isArray(i?.path) ? i.path.join(".") : "";
+      const message = i?.message || "Invalid value";
+      errors.push(`${path ? path + ": " : ""}${message}`);
+    }
+    return { valid: false, warnings, errors };
+  }
+  const s = parsed.data;
+  if (s.fullAuto && s.dangerouslyBypassApprovalsAndSandbox) {
+    warnings.push(
+      "Both fullAuto and dangerouslyBypassApprovalsAndSandbox specified; fullAuto takes precedence."
+    );
+  }
+  return { valid: true, warnings, errors };
+}
+function validateModelId(modelId) {
+  if (!modelId || modelId.trim() === "") return "Model ID cannot be empty";
+  return void 0;
+}
+
+// src/message-mapper.ts
+function isTextPart(p) {
+  return typeof p === "object" && p !== null && "type" in p && p.type === "text" && "text" in p && typeof p.text === "string";
+}
+function isImagePart(p) {
+  return typeof p === "object" && p !== null && "type" in p && p.type === "image";
+}
+function isToolItem(p) {
+  if (typeof p !== "object" || p === null) return false;
+  const obj = p;
+  if (typeof obj.toolName !== "string") return false;
+  const out = obj.output;
+  if (!out || out.type !== "text" && out.type !== "json") return false;
+  if (out.type === "text" && typeof out.value !== "string") return false;
+  return true;
+}
+function mapMessagesToPrompt(prompt, mode = { type: "regular" }, jsonSchema) {
+  const warnings = [];
+  const parts = [];
+  let systemText;
+  for (const msg of prompt) {
+    if (msg.role === "system") {
+      systemText = typeof msg.content === "string" ? msg.content : String(msg.content);
+      continue;
+    }
+    if (msg.role === "user") {
+      if (typeof msg.content === "string") {
+        parts.push(`Human: ${msg.content}`);
+      } 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.");
+      }
+      continue;
+    }
+    if (msg.role === "assistant") {
+      if (typeof msg.content === "string") {
+        parts.push(`Assistant: ${msg.content}`);
+      } else if (Array.isArray(msg.content)) {
+        const text = msg.content.filter(isTextPart).map((p) => p.text).join("\n");
+        if (text) parts.push(`Assistant: ${text}`);
+      }
+      continue;
+    }
+    if (msg.role === "tool") {
+      if (Array.isArray(msg.content)) {
+        for (const maybeTool of msg.content) {
+          if (!isToolItem(maybeTool)) continue;
+          const value = maybeTool.output.type === "text" ? maybeTool.output.value : JSON.stringify(maybeTool.output.value);
+          parts.push(`Tool Result (${maybeTool.toolName}): ${value}`);
+        }
+      }
+      continue;
+    }
+  }
+  let promptText = "";
+  if (systemText) promptText += systemText + "\n\n";
+  promptText += parts.join("\n\n");
+  if (mode.type === "object-json" && jsonSchema) {
+    const schemaStr = JSON.stringify(jsonSchema, null, 2);
+    promptText = `CRITICAL: You MUST respond with ONLY a JSON object. NO other text.
+Your response MUST start with { and end with }
+The JSON MUST match this EXACT schema:
+${schemaStr}
+
+Now, based on the following conversation, generate ONLY the JSON object:
+
+${promptText}`;
+  }
+  return { promptText, ...warnings.length ? { warnings } : {} };
+}
+function createAPICallError({
+  message,
+  code,
+  exitCode,
+  stderr,
+  promptExcerpt,
+  isRetryable = false
+}) {
+  const data = { code, exitCode, stderr, promptExcerpt };
+  return new APICallError({
+    message,
+    isRetryable,
+    url: "codex-cli://exec",
+    requestBodyValues: promptExcerpt ? { prompt: promptExcerpt } : void 0,
+    data
+  });
+}
+function createAuthenticationError(message) {
+  return new LoadAPIKeyError({
+    message: message || "Authentication failed. Ensure Codex CLI is logged in (codex login)."
+  });
+}
+function isAuthenticationError(err) {
+  if (err instanceof LoadAPIKeyError) return true;
+  if (err instanceof APICallError) {
+    const data = err.data;
+    if (data?.exitCode === 401) return true;
+  }
+  return false;
+}
+
+// src/codex-cli-language-model.ts
+function resolveCodexPath(explicitPath, allowNpx) {
+  if (explicitPath) return { cmd: "node", args: [explicitPath] };
+  try {
+    const req = createRequire(import.meta.url);
+    const pkgPath = req.resolve("@openai/codex/package.json");
+    const root = pkgPath.replace(/package\.json$/, "");
+    return { cmd: "node", args: [root + "bin/codex.js"] };
+  } catch {
+    if (allowNpx) return { cmd: "npx", args: ["-y", "@openai/codex"] };
+    return { cmd: "codex", args: [] };
+  }
+}
+var CodexCliLanguageModel = class {
+  specificationVersion = "v1";
+  provider = "codex-cli";
+  defaultObjectGenerationMode = "json";
+  supportsImageUrls = false;
+  supportsStructuredOutputs = false;
+  modelId;
+  settings;
+  logger;
+  sessionId;
+  constructor(options) {
+    this.modelId = options.id;
+    this.settings = options.settings ?? {};
+    this.logger = getLogger(this.settings.logger);
+    if (!this.modelId || this.modelId.trim() === "") {
+      throw new NoSuchModelError({ modelId: this.modelId, modelType: "languageModel" });
+    }
+    const warn = validateModelId(this.modelId);
+    if (warn) this.logger.warn(`Codex CLI model: ${warn}`);
+  }
+  buildArgs(promptText) {
+    const base = resolveCodexPath(this.settings.codexPath, this.settings.allowNpx);
+    const args = [...base.args, "exec", "--json"];
+    if (this.settings.fullAuto) {
+      args.push("--full-auto");
+    } else if (this.settings.dangerouslyBypassApprovalsAndSandbox) {
+      args.push("--dangerously-bypass-approvals-and-sandbox");
+    } else {
+      const approval = this.settings.approvalMode ?? "on-failure";
+      args.push("-c", `approval_policy=${approval}`);
+      const sandbox = this.settings.sandboxMode ?? "workspace-write";
+      args.push("-c", `sandbox_mode=${sandbox}`);
+    }
+    if (this.settings.skipGitRepoCheck !== false) {
+      args.push("--skip-git-repo-check");
+    }
+    if (this.settings.color) {
+      args.push("--color", this.settings.color);
+    }
+    if (this.modelId) {
+      args.push("-m", this.modelId);
+    }
+    args.push(promptText);
+    const env = {
+      ...process.env,
+      ...this.settings.env || {},
+      RUST_LOG: process.env.RUST_LOG || "error"
+    };
+    let lastMessagePath = this.settings.outputLastMessageFile;
+    if (!lastMessagePath) {
+      const dir = mkdtempSync(join(tmpdir(), "codex-cli-"));
+      lastMessagePath = join(dir, "last-message.txt");
+    }
+    args.push("--output-last-message", lastMessagePath);
+    return { cmd: base.cmd, args, env, cwd: this.settings.cwd, lastMessagePath };
+  }
+  mapWarnings(options) {
+    const unsupported = [];
+    const add = (setting, name) => {
+      if (setting !== void 0)
+        unsupported.push({
+          type: "unsupported-setting",
+          setting: name,
+          details: `Codex CLI does not support ${name}; it will be ignored.`
+        });
+    };
+    add(options.temperature, "temperature");
+    add(options.maxTokens, "maxTokens");
+    add(options.topP, "topP");
+    add(options.topK, "topK");
+    add(options.presencePenalty, "presencePenalty");
+    add(options.frequencyPenalty, "frequencyPenalty");
+    add(options.stopSequences?.length ? options.stopSequences : void 0, "stopSequences");
+    add(options.seed, "seed");
+    return unsupported;
+  }
+  parseJsonLine(line) {
+    try {
+      return JSON.parse(line);
+    } catch {
+      return void 0;
+    }
+  }
+  handleSpawnError(err, promptExcerpt) {
+    const e = err && typeof err === "object" ? err : void 0;
+    const message = String((e?.message ?? err) || "Failed to run Codex CLI");
+    if (/login|auth|unauthorized|not\s+logged/i.test(message)) {
+      throw createAuthenticationError(message);
+    }
+    throw createAPICallError({
+      message,
+      code: typeof e?.code === "string" ? e.code : void 0,
+      exitCode: typeof e?.exitCode === "number" ? e.exitCode : void 0,
+      stderr: typeof e?.stderr === "string" ? e.stderr : void 0,
+      promptExcerpt
+    });
+  }
+  async doGenerate(options) {
+    const mode = options.mode?.type === "object-json" ? { type: "object-json" } : { type: "regular" };
+    const { promptText, warnings: mappingWarnings } = mapMessagesToPrompt(
+      options.prompt,
+      mode,
+      options.mode?.type === "object-json" ? options.mode.schema : void 0
+    );
+    const promptExcerpt = promptText.slice(0, 200);
+    const warnings = [
+      ...this.mapWarnings(options),
+      ...mappingWarnings?.map((m) => ({ type: "other", message: m })) || []
+    ];
+    const { cmd, args, env, cwd, lastMessagePath } = this.buildArgs(promptText);
+    let text = "";
+    const usage = { promptTokens: 0, completionTokens: 0 };
+    const finishReason = "stop";
+    const child = spawn(cmd, args, { env, cwd, stdio: ["ignore", "pipe", "pipe"] });
+    let onAbort;
+    if (options.abortSignal) {
+      if (options.abortSignal.aborted) {
+        child.kill("SIGTERM");
+        throw options.abortSignal.reason ?? new Error("Request aborted");
+      }
+      onAbort = () => child.kill("SIGTERM");
+      options.abortSignal.addEventListener("abort", onAbort, { once: true });
+    }
+    try {
+      await new Promise((resolve, reject) => {
+        let stderr = "";
+        child.stderr.on("data", (d) => stderr += String(d));
+        child.stdout.setEncoding("utf8");
+        child.stdout.on("data", (chunk) => {
+          const lines = chunk.split(/\r?\n/).filter(Boolean);
+          for (const line of lines) {
+            const evt = this.parseJsonLine(line);
+            if (!evt) continue;
+            const msg = evt.msg;
+            const type = msg?.type;
+            if (type === "session_configured" && msg) {
+              this.sessionId = msg.session_id;
+            } else if (type === "task_complete" && msg) {
+              const last = msg.last_agent_message;
+              if (typeof last === "string") text = last;
+            }
+          }
+        });
+        child.on("error", (e) => reject(this.handleSpawnError(e, promptExcerpt)));
+        child.on("close", (code) => {
+          if (code === 0) resolve();
+          else
+            reject(
+              createAPICallError({
+                message: `Codex CLI exited with code ${code}`,
+                exitCode: code ?? void 0,
+                stderr,
+                promptExcerpt
+              })
+            );
+        });
+      });
+    } finally {
+      if (options.abortSignal && onAbort) options.abortSignal.removeEventListener("abort", onAbort);
+    }
+    if (!text && lastMessagePath) {
+      try {
+        const fileText = readFileSync(lastMessagePath, "utf8");
+        if (fileText && typeof fileText === "string") {
+          text = fileText.trim();
+        }
+      } catch {
+      }
+      try {
+        rmSync(lastMessagePath, { force: true });
+      } catch {
+      }
+    }
+    if (options.mode?.type === "object-json" && text) {
+      text = extractJson(text);
+    }
+    return {
+      text: text || void 0,
+      usage,
+      finishReason,
+      warnings: warnings.length ? warnings : void 0,
+      response: { id: generateId(), timestamp: /* @__PURE__ */ new Date(), modelId: this.modelId },
+      request: { body: promptText },
+      providerMetadata: {
+        "codex-cli": { ...this.sessionId ? { sessionId: this.sessionId } : {} }
+      },
+      rawCall: { rawPrompt: promptText, rawSettings: { model: this.modelId, settings: this.settings } }
+    };
+  }
+  async doStream(options) {
+    const mode = options.mode?.type === "object-json" ? { type: "object-json" } : { type: "regular" };
+    const { promptText, warnings: mappingWarnings } = mapMessagesToPrompt(
+      options.prompt,
+      mode,
+      options.mode?.type === "object-json" ? options.mode.schema : void 0
+    );
+    const promptExcerpt = promptText.slice(0, 200);
+    const warnings = [
+      ...this.mapWarnings(options),
+      ...mappingWarnings?.map((m) => ({ type: "other", message: m })) || []
+    ];
+    const { cmd, args, env, cwd, lastMessagePath } = this.buildArgs(promptText);
+    const stream = new ReadableStream({
+      start: (controller) => {
+        const child = spawn(cmd, args, { env, cwd, stdio: ["ignore", "pipe", "pipe"] });
+        let stderr = "";
+        let accumulatedText = "";
+        const onAbort = () => {
+          child.kill("SIGTERM");
+        };
+        if (options.abortSignal) {
+          if (options.abortSignal.aborted) {
+            child.kill("SIGTERM");
+            controller.error(options.abortSignal.reason ?? new Error("Request aborted"));
+            return;
+          }
+          options.abortSignal.addEventListener("abort", onAbort, { once: true });
+        }
+        child.stderr.on("data", (d) => stderr += String(d));
+        child.stdout.setEncoding("utf8");
+        child.stdout.on("data", (chunk) => {
+          const lines = chunk.split(/\r?\n/).filter(Boolean);
+          for (const line of lines) {
+            const evt = this.parseJsonLine(line);
+            if (!evt) continue;
+            const msg = evt.msg;
+            const type = msg?.type;
+            if (type === "session_configured" && msg) {
+              this.sessionId = msg.session_id;
+              controller.enqueue({
+                type: "response-metadata",
+                id: randomUUID(),
+                timestamp: /* @__PURE__ */ new Date(),
+                modelId: this.modelId
+              });
+            } else if (type === "task_complete" && msg) {
+              const last = msg.last_agent_message;
+              if (typeof last === "string") {
+                accumulatedText = last;
+              }
+            }
+          }
+        });
+        child.on("error", (e) => {
+          if (options.abortSignal) options.abortSignal.removeEventListener("abort", onAbort);
+          controller.error(this.handleSpawnError(e, promptExcerpt));
+        });
+        child.on("close", (code) => {
+          if (options.abortSignal) options.abortSignal.removeEventListener("abort", onAbort);
+          if (code !== 0) {
+            controller.error(
+              createAPICallError({
+                message: `Codex CLI exited with code ${code}`,
+                exitCode: code ?? void 0,
+                stderr,
+                promptExcerpt
+              })
+            );
+            return;
+          }
+          let finalText = accumulatedText;
+          if (!finalText && lastMessagePath) {
+            try {
+              const fileText = readFileSync(lastMessagePath, "utf8");
+              if (fileText) finalText = fileText.trim();
+            } catch {
+            }
+            try {
+              rmSync(lastMessagePath, { force: true });
+            } catch {
+            }
+          }
+          if (finalText) {
+            if (options.mode?.type === "object-json") {
+              finalText = extractJson(finalText);
+            }
+            controller.enqueue({ type: "text-delta", textDelta: finalText });
+          }
+          controller.enqueue({
+            type: "finish",
+            finishReason: "stop",
+            usage: { promptTokens: 0, completionTokens: 0 },
+            providerMetadata: {
+              "codex-cli": { ...this.sessionId ? { sessionId: this.sessionId } : {} }
+            }
+          });
+          controller.close();
+        });
+      },
+      cancel: () => {
+      }
+    });
+    return {
+      stream,
+      rawCall: { rawPrompt: promptText, rawSettings: { model: this.modelId, settings: this.settings } },
+      warnings: warnings.length ? warnings : void 0
+    };
+  }
+};
+
+// src/codex-cli-provider.ts
+function createCodexCli(options = {}) {
+  const logger = getLogger(options.defaultSettings?.logger);
+  if (options.defaultSettings) {
+    const v = validateSettings(options.defaultSettings);
+    if (!v.valid) {
+      throw new Error(`Invalid default settings: ${v.errors.join(", ")}`);
+    }
+    for (const w of v.warnings) logger.warn(`Codex CLI Provider: ${w}`);
+  }
+  const createModel = (modelId, settings = {}) => {
+    const merged = { ...options.defaultSettings, ...settings };
+    const v = validateSettings(merged);
+    if (!v.valid) throw new Error(`Invalid settings: ${v.errors.join(", ")}`);
+    for (const w of v.warnings) logger.warn(`Codex CLI: ${w}`);
+    return new CodexCliLanguageModel({ id: modelId, settings: merged });
+  };
+  const provider = function(modelId, settings) {
+    if (new.target) throw new Error("The Codex CLI provider function cannot be called with new.");
+    return createModel(modelId, settings);
+  };
+  provider.languageModel = createModel;
+  provider.chat = createModel;
+  provider.textEmbeddingModel = ((modelId) => {
+    throw new NoSuchModelError({ modelId, modelType: "textEmbeddingModel" });
+  });
+  provider.imageModel = ((modelId) => {
+    throw new NoSuchModelError({ modelId, modelType: "imageModel" });
+  });
+  return provider;
+}
+var codexCli = createCodexCli();
+
+export { CodexCliLanguageModel, codexCli, createCodexCli, isAuthenticationError };

package/package.json

@@ -0,0 +1,88 @@
+{
+  "name": "ai-sdk-provider-codex-cli",
+  "version": "0.1.0-ai-sdk-v4",
+  "description": "AI SDK v4 provider for spawning OpenAI Codex CLI (gpt-5 via ChatGPT OAuth)",
+  "keywords": [
+    "ai-sdk",
+    "codex",
+    "openai",
+    "cli",
+    "language-model",
+    "gpt-5",
+    "provider"
+  ],
+  "homepage": "https://github.com/ben-vargas/ai-sdk-provider-codex-cli",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ben-vargas/ai-sdk-provider-codex-cli.git"
+  },
+  "bugs": {
+    "url": "https://github.com/ben-vargas/ai-sdk-provider-codex-cli/issues"
+  },
+  "license": "MIT",
+  "author": "Ben Vargas",
+  "type": "module",
+  "sideEffects": false,
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "files": [
+    "dist/**/*",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "clean": "rm -rf dist",
+    "dev": "tsup --watch",
+    "prepare": "npm run build",
+    "prepublishOnly": "npm run clean && npm run build",
+    "typecheck": "tsc --noEmit",
+    "format": "prettier --check .",
+    "format:fix": "prettier --write .",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
+    "validate": "npm run build && npm run typecheck && npm run format && npm run lint && npm run test",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage"
+  },
+  "dependencies": {
+    "@ai-sdk/provider": "1.1.3",
+    "@ai-sdk/provider-utils": "2.2.8",
+    "jsonc-parser": "^3.3.1"
+  },
+  "optionalDependencies": {
+    "@openai/codex": "*"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.14.0",
+    "@types/node": "20.17.24",
+    "@vitest/coverage-v8": "^3.2.4",
+    "ai": "4.3.16",
+    "eslint": "^9.14.0",
+    "prettier": "^3.3.3",
+    "tsup": "8.5.0",
+    "typescript": "5.6.3",
+    "vitest": "^3.2.4",
+    "typescript-eslint": "^8.6.0",
+    "zod": "3.24.1"
+  },
+  "peerDependencies": {
+    "zod": "^3.0.0"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}