ai-sdk-provider-codex-cli 0.1.0

package/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2025 Ben Vargas
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

package/README.md

@@ -0,0 +1,137 @@
+# AI SDK Provider for Codex CLI
+
+A community provider for Vercel AI SDK v5 that uses OpenAI’s Codex CLI (non‑interactive `codex exec`) to talk to GPT‑5 class models with your ChatGPT Plus/Pro subscription. The provider spawns the Codex CLI process, parses its JSONL output, and adapts it to the AI SDK LanguageModelV2 interface.
+
+- Works with `generateText`, `streamText`, and `generateObject` (JSON schemas via prompt engineering)
+- Uses ChatGPT OAuth from `codex login` (tokens in `~/.codex/auth.json`) or `OPENAI_API_KEY`
+- Node-only (spawns a local process); supports CI and local dev
+
+## Installation
+
+1. Install and authenticate Codex CLI
+
+```bash
+npm i -g @openai/codex
+codex login   # or set OPENAI_API_KEY
+```
+
+2. Install provider and AI SDK
+
+```bash
+npm i ai ai-sdk-provider-codex-cli
+```
+
+## Quick Start
+
+Text generation
+
+```js
+import { generateText } from 'ai';
+import { codexCli } from 'ai-sdk-provider-codex-cli';
+
+const model = codexCli('gpt-5', {
+  allowNpx: true,
+  skipGitRepoCheck: true,
+  approvalMode: 'on-failure',
+  sandboxMode: 'workspace-write',
+});
+
+const { text } = await generateText({
+  model,
+  prompt: 'Reply with a single word: hello.',
+});
+console.log(text);
+```
+
+Streaming
+
+```js
+import { streamText } from 'ai';
+import { codexCli } from 'ai-sdk-provider-codex-cli';
+
+const { textStream } = await streamText({
+  model: codexCli('gpt-5', { allowNpx: true, skipGitRepoCheck: true }),
+  prompt: 'Write two short lines of encouragement.',
+});
+for await (const chunk of textStream) process.stdout.write(chunk);
+```
+
+Object generation (Zod)
+
+```js
+import { generateObject } from 'ai';
+import { z } from 'zod';
+import { codexCli } from 'ai-sdk-provider-codex-cli';
+
+const schema = z.object({ name: z.string(), age: z.number().int() });
+const { object } = await generateObject({
+  model: codexCli('gpt-5', { allowNpx: true, skipGitRepoCheck: true }),
+  schema,
+  prompt: 'Generate a small user profile.',
+});
+console.log(object);
+```
+
+## Features
+
+- AI SDK v5 compatible (LanguageModelV2)
+- Streaming and non‑streaming
+- JSON object generation with Zod schemas (prompt‑engineered)
+- Safe defaults for non‑interactive automation (`on-failure`, `workspace-write`, `--skip-git-repo-check`)
+- Fallback to `npx @openai/codex` when not on PATH (`allowNpx`)
+
+### Streaming behavior
+
+When using `codex exec --json`, the Codex CLI intentionally suppresses token/assistant deltas in its JSON event stream. Instead, it writes the final assistant message to the file you pass via `--output-last-message` and then signals completion. This provider:
+
+- emits `response-metadata` early (as soon as the session is configured), and
+- returns the final text as a single `text-delta` right before `finish`.
+
+This is expected behavior for JSON mode in Codex exec, so streaming typically “feels” like a final chunk rather than a gradual trickle.
+
+## Documentation
+
+- Getting started, configuration, and troubleshooting live in `docs/`:
+  - [docs/ai-sdk-v5/guide.md](docs/ai-sdk-v5/guide.md) – full usage guide and examples
+  - [docs/ai-sdk-v5/configuration.md](docs/ai-sdk-v5/configuration.md) – all settings and how they map to CLI flags
+  - [docs/ai-sdk-v5/troubleshooting.md](docs/ai-sdk-v5/troubleshooting.md) – common issues and fixes
+  - [docs/ai-sdk-v5/limitations.md](docs/ai-sdk-v5/limitations.md) – known constraints and behavior differences
+- See [examples/](examples/) for runnable scripts covering core usage, streaming, permissions/sandboxing, and object generation.
+
+## Authentication
+
+- Preferred: ChatGPT OAuth via `codex login` (stores tokens at `~/.codex/auth.json`)
+- Alternative: export `OPENAI_API_KEY` in the provider’s `env` settings (forwarded to the spawned process)
+
+## Configuration (high level)
+
+- `allowNpx`: If true, falls back to `npx -y @openai/codex` when Codex is not on PATH
+- `cwd`: Working directory for Codex
+- Autonomy/sandbox:
+  - `fullAuto` (equivalent to `--full-auto`)
+  - `dangerouslyBypassApprovalsAndSandbox` (bypass approvals and sandbox; dangerous)
+  - Otherwise the provider writes `-c approval_policy=...` and `-c sandbox_mode=...` for you; defaults to `on-failure` and `workspace-write`
+- `skipGitRepoCheck`: enable by default for CI/non‑repo contexts
+- `color`: `always` | `never` | `auto`
+- `outputLastMessageFile`: by default the provider sets a temp path and reads it to capture final text reliably
+
+See [docs/ai-sdk-v5/configuration.md](docs/ai-sdk-v5/configuration.md) for the full list and examples.
+
+## Zod Compatibility
+
+- Peer supports `zod@^3 || ^4`
+- Validation logic normalizes v3/v4 error shapes
+
+## Limitations
+
+- Node ≥ 18, local process only (no Edge)
+- Codex JSON mode (`codex exec --json`) suppresses mid‑response deltas; streaming typically yields a final chunk. The CLI writes the final assistant text via `--output-last-message`, which this provider reads and emits at the end.
+- Some AI SDK parameters are unsupported by Codex CLI (e.g., temperature/topP/penalties); the provider surfaces warnings and ignores them
+
+## Disclaimer
+
+This is a community provider and not an official OpenAI or Vercel product. You are responsible for complying with all applicable terms and ensuring safe usage.
+
+## License
+
+MIT

package/dist/index.cjs

@@ -0,0 +1,541 @@
+'use strict';
+
+var provider = require('@ai-sdk/provider');
+var child_process = require('child_process');
+var crypto = require('crypto');
+var module$1 = require('module');
+var fs = require('fs');
+var os = require('os');
+var path = require('path');
+var providerUtils = require('@ai-sdk/provider-utils');
+var zod = require('zod');
+
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+// 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 = zod.z.object({
+  codexPath: zod.z.string().optional(),
+  cwd: zod.z.string().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(),
+  dangerouslyBypassApprovalsAndSandbox: zod.z.boolean().optional(),
+  skipGitRepoCheck: zod.z.boolean().optional(),
+  color: zod.z.enum(["always", "never", "auto"]).optional(),
+  allowNpx: zod.z.boolean().optional(),
+  env: zod.z.record(zod.z.string(), zod.z.string()).optional(),
+  verbose: zod.z.boolean().optional(),
+  logger: zod.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 provider.APICallError({
+    message,
+    isRetryable,
+    url: "codex-cli://exec",
+    requestBodyValues: promptExcerpt ? { prompt: promptExcerpt } : void 0,
+    data
+  });
+}
+function createAuthenticationError(message) {
+  return new provider.LoadAPIKeyError({
+    message: message || "Authentication failed. Ensure Codex CLI is logged in (codex login)."
+  });
+}
+function isAuthenticationError(err) {
+  if (err instanceof provider.LoadAPIKeyError) return true;
+  if (err instanceof provider.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 = module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)));
+    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 = "v2";
+  provider = "codex-cli";
+  defaultObjectGenerationMode = "json";
+  supportsImageUrls = false;
+  supportedUrls = {};
+  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 provider.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 = fs.mkdtempSync(path.join(os.tmpdir(), "codex-cli-"));
+      lastMessagePath = path.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.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.responseFormat?.type === "json" ? { type: "object-json" } : { type: "regular" };
+    const { promptText, warnings: mappingWarnings } = mapMessagesToPrompt(
+      options.prompt,
+      mode,
+      options.responseFormat?.type === "json" ? options.responseFormat.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 = { inputTokens: 0, outputTokens: 0, totalTokens: 0 };
+    const finishReason = "stop";
+    const child = child_process.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 = fs.readFileSync(lastMessagePath, "utf8");
+        if (fileText && typeof fileText === "string") {
+          text = fileText.trim();
+        }
+      } catch {
+      }
+      try {
+        fs.rmSync(lastMessagePath, { force: true });
+      } catch {
+      }
+    }
+    if (options.responseFormat?.type === "json" && text) {
+      text = extractJson(text);
+    }
+    const content = [{ type: "text", text }];
+    return {
+      content,
+      usage,
+      finishReason,
+      warnings,
+      response: { id: providerUtils.generateId(), timestamp: /* @__PURE__ */ new Date(), modelId: this.modelId },
+      request: { body: promptText },
+      providerMetadata: {
+        "codex-cli": { ...this.sessionId ? { sessionId: this.sessionId } : {} }
+      }
+    };
+  }
+  async doStream(options) {
+    const mode = options.responseFormat?.type === "json" ? { type: "object-json" } : { type: "regular" };
+    const { promptText, warnings: mappingWarnings } = mapMessagesToPrompt(
+      options.prompt,
+      mode,
+      options.responseFormat?.type === "json" ? options.responseFormat.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 = child_process.spawn(cmd, args, { env, cwd, stdio: ["ignore", "pipe", "pipe"] });
+        controller.enqueue({ type: "stream-start", warnings });
+        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: crypto.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 = fs.readFileSync(lastMessagePath, "utf8");
+              if (fileText) finalText = fileText.trim();
+            } catch {
+            }
+            try {
+              fs.rmSync(lastMessagePath, { force: true });
+            } catch {
+            }
+          }
+          if (finalText) {
+            if (options.responseFormat?.type === "json") {
+              finalText = extractJson(finalText);
+            }
+            controller.enqueue({ type: "text-delta", id: crypto.randomUUID(), delta: finalText });
+          }
+          controller.enqueue({
+            type: "finish",
+            finishReason: "stop",
+            usage: { inputTokens: 0, outputTokens: 0, totalTokens: 0 }
+          });
+          controller.close();
+        });
+      },
+      cancel: () => {
+      }
+    });
+    return { stream, request: { body: promptText } };
+  }
+};
+
+// 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$1 = function(modelId, settings) {
+    if (new.target) throw new Error("The Codex CLI provider function cannot be called with new.");
+    return createModel(modelId, settings);
+  };
+  provider$1.languageModel = createModel;
+  provider$1.chat = createModel;
+  provider$1.textEmbeddingModel = ((modelId) => {
+    throw new provider.NoSuchModelError({ modelId, modelType: "textEmbeddingModel" });
+  });
+  provider$1.imageModel = ((modelId) => {
+    throw new provider.NoSuchModelError({ modelId, modelType: "imageModel" });
+  });
+  return provider$1;
+}
+var codexCli = createCodexCli();
+
+exports.CodexCliLanguageModel = CodexCliLanguageModel;
+exports.codexCli = codexCli;
+exports.createCodexCli = createCodexCli;
+exports.isAuthenticationError = isAuthenticationError;