ai-sdk-provider-codex-cli 0.3.0 → 0.5.0

package/dist/index.js

@@ -5,27 +5,66 @@ import { createRequire } from 'module';
 import { mkdtempSync, writeFileSync, rmSync, readFileSync } from 'fs';
 import { tmpdir } from 'os';
 import { join, dirname } from 'path';
-import { generateId } from '@ai-sdk/provider-utils';
 import { z } from 'zod';
+import { parseProviderOptions, generateId } from '@ai-sdk/provider-utils';
 
 // src/codex-cli-provider.ts
 
 // src/logger.ts
 var defaultLogger = {
-  warn: (m) => console.warn(m),
-  error: (m) => console.error(m)
+  debug: (message) => console.debug(`[DEBUG] ${message}`),
+  info: (message) => console.info(`[INFO] ${message}`),
+  warn: (message) => console.warn(`[WARN] ${message}`),
+  error: (message) => console.error(`[ERROR] ${message}`)
 };
 var noopLogger = {
+  debug: () => {
+  },
+  info: () => {
+  },
   warn: () => {
   },
   error: () => {
   }
 };
 function getLogger(logger) {
-  if (logger === false) return noopLogger;
-  if (!logger) return defaultLogger;
+  if (logger === false) {
+    return noopLogger;
+  }
+  if (logger === void 0) {
+    return defaultLogger;
+  }
   return logger;
 }
+function createVerboseLogger(logger, verbose = false) {
+  if (verbose) {
+    return logger;
+  }
+  return {
+    debug: () => {
+    },
+    // No-op when not verbose
+    info: () => {
+    },
+    // No-op when not verbose
+    warn: logger.warn.bind(logger),
+    error: logger.error.bind(logger)
+  };
+}
+var loggerFunctionSchema = z.object({
+  debug: z.any().refine((val) => typeof val === "function", {
+    message: "debug must be a function"
+  }),
+  info: z.any().refine((val) => typeof val === "function", {
+    message: "info must be a function"
+  }),
+  warn: z.any().refine((val) => typeof val === "function", {
+    message: "warn must be a function"
+  }),
+  error: z.any().refine((val) => typeof val === "function", {
+    message: "error must be a function"
+  })
+});
 var settingsSchema = z.object({
   codexPath: z.string().optional(),
   cwd: z.string().optional(),
@@ -38,7 +77,29 @@ var settingsSchema = z.object({
   allowNpx: z.boolean().optional(),
   env: z.record(z.string(), z.string()).optional(),
   verbose: z.boolean().optional(),
-  logger: z.any().optional()
+  logger: z.union([z.literal(false), loggerFunctionSchema]).optional(),
+  // NEW: Reasoning & Verbosity
+  reasoningEffort: z.enum(["minimal", "low", "medium", "high"]).optional(),
+  // Note: API rejects 'concise' and 'none' despite error messages claiming they're valid
+  reasoningSummary: z.enum(["auto", "detailed"]).optional(),
+  reasoningSummaryFormat: z.enum(["none", "experimental"]).optional(),
+  modelVerbosity: z.enum(["low", "medium", "high"]).optional(),
+  // NEW: Advanced features
+  includePlanTool: z.boolean().optional(),
+  profile: z.string().optional(),
+  oss: z.boolean().optional(),
+  webSearch: z.boolean().optional(),
+  // NEW: Generic overrides
+  configOverrides: z.record(
+    z.string(),
+    z.union([
+      z.string(),
+      z.number(),
+      z.boolean(),
+      z.object({}).passthrough(),
+      z.array(z.any())
+    ])
+  ).optional()
 }).strict();
 function validateSettings(settings) {
   const warnings = [];
@@ -166,6 +227,22 @@ function isAuthenticationError(err) {
 }
 
 // src/codex-cli-language-model.ts
+var codexCliProviderOptionsSchema = z.object({
+  reasoningEffort: z.enum(["minimal", "low", "medium", "high"]).optional(),
+  reasoningSummary: z.enum(["auto", "detailed"]).optional(),
+  reasoningSummaryFormat: z.enum(["none", "experimental"]).optional(),
+  textVerbosity: z.enum(["low", "medium", "high"]).optional(),
+  configOverrides: z.record(
+    z.string(),
+    z.union([
+      z.string(),
+      z.number(),
+      z.boolean(),
+      z.object({}).passthrough(),
+      z.array(z.any())
+    ])
+  ).optional()
+}).strict();
 function resolveCodexPath(explicitPath, allowNpx) {
   if (explicitPath) return { cmd: "node", args: [explicitPath] };
   try {
@@ -192,13 +269,29 @@ var CodexCliLanguageModel = class {
   constructor(options) {
     this.modelId = options.id;
     this.settings = options.settings ?? {};
-    this.logger = getLogger(this.settings.logger);
+    const baseLogger = getLogger(this.settings.logger);
+    this.logger = createVerboseLogger(baseLogger, this.settings.verbose ?? false);
     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}`);
   }
+  mergeSettings(providerOptions) {
+    if (!providerOptions) return this.settings;
+    const mergedConfigOverrides = providerOptions.configOverrides || this.settings.configOverrides ? {
+      ...this.settings.configOverrides ?? {},
+      ...providerOptions.configOverrides ?? {}
+    } : void 0;
+    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
+    };
+  }
   // Codex JSONL items use `type` for the item discriminator, but some
   // earlier fixtures (and defensive parsing) might still surface `item_type`.
   // This helper returns whichever is present.
@@ -209,28 +302,57 @@ var CodexCliLanguageModel = class {
     const current = typeof data.type === "string" ? data.type : void 0;
     return legacy ?? current;
   }
-  buildArgs(promptText, responseFormat) {
-    const base = resolveCodexPath(this.settings.codexPath, this.settings.allowNpx);
+  buildArgs(promptText, responseFormat, settings = this.settings) {
+    const base = resolveCodexPath(settings.codexPath, settings.allowNpx);
     const args = [...base.args, "exec", "--experimental-json"];
-    if (this.settings.fullAuto) {
+    if (settings.fullAuto) {
       args.push("--full-auto");
-    } else if (this.settings.dangerouslyBypassApprovalsAndSandbox) {
+    } else if (settings.dangerouslyBypassApprovalsAndSandbox) {
       args.push("--dangerously-bypass-approvals-and-sandbox");
     } else {
-      const approval = this.settings.approvalMode ?? "on-failure";
+      const approval = settings.approvalMode ?? "on-failure";
       args.push("-c", `approval_policy=${approval}`);
-      const sandbox = this.settings.sandboxMode ?? "workspace-write";
+      const sandbox = settings.sandboxMode ?? "workspace-write";
       args.push("-c", `sandbox_mode=${sandbox}`);
     }
-    if (this.settings.skipGitRepoCheck !== false) {
+    if (settings.skipGitRepoCheck !== false) {
       args.push("--skip-git-repo-check");
     }
-    if (this.settings.color) {
-      args.push("--color", this.settings.color);
+    if (settings.reasoningEffort) {
+      args.push("-c", `model_reasoning_effort=${settings.reasoningEffort}`);
+    }
+    if (settings.reasoningSummary) {
+      args.push("-c", `model_reasoning_summary=${settings.reasoningSummary}`);
+    }
+    if (settings.reasoningSummaryFormat) {
+      args.push("-c", `model_reasoning_summary_format=${settings.reasoningSummaryFormat}`);
+    }
+    if (settings.modelVerbosity) {
+      args.push("-c", `model_verbosity=${settings.modelVerbosity}`);
+    }
+    if (settings.includePlanTool) {
+      args.push("--include-plan-tool");
+    }
+    if (settings.profile) {
+      args.push("--profile", settings.profile);
+    }
+    if (settings.oss) {
+      args.push("--oss");
+    }
+    if (settings.webSearch) {
+      args.push("-c", "tools.web_search=true");
+    }
+    if (settings.color) {
+      args.push("--color", settings.color);
     }
     if (this.modelId) {
       args.push("-m", this.modelId);
     }
+    if (settings.configOverrides) {
+      for (const [key, value] of Object.entries(settings.configOverrides)) {
+        this.addConfigOverride(args, key, value);
+      }
+    }
     let schemaPath;
     if (responseFormat?.type === "json" && responseFormat.schema) {
       const schema = typeof responseFormat.schema === "object" ? responseFormat.schema : {};
@@ -250,16 +372,55 @@ var CodexCliLanguageModel = class {
     args.push(promptText);
     const env = {
       ...process.env,
-      ...this.settings.env || {},
+      ...settings.env || {},
       RUST_LOG: process.env.RUST_LOG || "error"
     };
-    let lastMessagePath = this.settings.outputLastMessageFile;
+    let lastMessagePath = 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, schemaPath };
+    return { cmd: base.cmd, args, env, cwd: settings.cwd, lastMessagePath, schemaPath };
+  }
+  addConfigOverride(args, key, value) {
+    if (this.isPlainObject(value)) {
+      for (const [childKey, childValue] of Object.entries(value)) {
+        this.addConfigOverride(
+          args,
+          `${key}.${childKey}`,
+          childValue
+        );
+      }
+      return;
+    }
+    const serialized = this.serializeConfigValue(value);
+    args.push("-c", `${key}=${serialized}`);
+  }
+  /**
+   * Serialize a config override value into a CLI-safe string.
+   */
+  serializeConfigValue(value) {
+    if (typeof value === "string") return value;
+    if (typeof value === "number" || typeof value === "boolean") return String(value);
+    if (Array.isArray(value)) {
+      try {
+        return JSON.stringify(value);
+      } catch {
+        return String(value);
+      }
+    }
+    if (value && typeof value === "object") {
+      try {
+        return JSON.stringify(value);
+      } catch {
+        return String(value);
+      }
+    }
+    return String(value);
+  }
+  isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value) && Object.prototype.toString.call(value) === "[object Object]";
   }
   sanitizeJsonSchema(value) {
     if (typeof value !== "object" || value === null) {
@@ -501,20 +662,35 @@ 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 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"}`
+    );
+    const providerOptions = await parseProviderOptions({
+      provider: this.provider,
+      providerOptions: options.providerOptions,
+      schema: codexCliProviderOptionsSchema
+    });
+    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
+      responseFormat,
+      effectiveSettings
+    );
+    this.logger.debug(
+      `[codex-cli] Executing Codex CLI: ${cmd} with ${args.length} arguments, cwd: ${cwd ?? "default"}`
     );
     let text = "";
     const usage = { inputTokens: 0, outputTokens: 0, totalTokens: 0 };
     const finishReason = "stop";
+    const startTime = Date.now();
     const child = spawn(cmd, args, { env, cwd, stdio: ["ignore", "pipe", "pipe"] });
     let onAbort;
     if (options.abortSignal) {
@@ -536,11 +712,14 @@ var CodexCliLanguageModel = class {
           for (const line of lines) {
             const event = this.parseExperimentalJsonEvent(line);
             if (!event) continue;
+            this.logger.debug(`[codex-cli] Received event type: ${event.type ?? "unknown"}`);
             if (event.type === "thread.started" && typeof event.thread_id === "string") {
               this.sessionId = event.thread_id;
+              this.logger.debug(`[codex-cli] Session started: ${this.sessionId}`);
             }
             if (event.type === "session.created" && typeof event.session_id === "string") {
               this.sessionId = event.session_id;
+              this.logger.debug(`[codex-cli] Session created: ${this.sessionId}`);
             }
             if (event.type === "turn.completed") {
               const usageEvent = this.extractUsage(event);
@@ -556,15 +735,21 @@ var CodexCliLanguageModel = class {
             if (event.type === "turn.failed") {
               const errorText = event.error && typeof event.error.message === "string" && event.error.message || (typeof event.message === "string" ? event.message : void 0);
               turnFailureMessage = errorText ?? turnFailureMessage ?? "Codex turn failed";
+              this.logger.error(`[codex-cli] Turn failed: ${turnFailureMessage}`);
             }
             if (event.type === "error") {
               const errorText = typeof event.message === "string" ? event.message : void 0;
               turnFailureMessage = errorText ?? turnFailureMessage ?? "Codex error";
+              this.logger.error(`[codex-cli] Error event: ${turnFailureMessage}`);
             }
           }
         });
-        child.on("error", (e) => reject(this.handleSpawnError(e, promptExcerpt)));
+        child.on("error", (e) => {
+          this.logger.error(`[codex-cli] Spawn error: ${String(e)}`);
+          reject(this.handleSpawnError(e, promptExcerpt));
+        });
         child.on("close", (code) => {
+          const duration = Date.now() - startTime;
           if (code === 0) {
             if (turnFailureMessage) {
               reject(
@@ -576,8 +761,15 @@ var CodexCliLanguageModel = class {
               );
               return;
             }
+            this.logger.info(
+              `[codex-cli] Request completed - Session: ${this.sessionId ?? "N/A"}, Duration: ${duration}ms, Tokens: ${usage.totalTokens}`
+            );
+            this.logger.debug(
+              `[codex-cli] Token usage - Input: ${usage.inputTokens}, Output: ${usage.outputTokens}, Total: ${usage.totalTokens}`
+            );
             resolve();
           } else {
+            this.logger.error(`[codex-cli] Process exited with code ${code} after ${duration}ms`);
             reject(
               createAPICallError({
                 message: `Codex CLI exited with code ${code}`,
@@ -626,19 +818,34 @@ 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 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"}`
+    );
+    const providerOptions = await parseProviderOptions({
+      provider: this.provider,
+      providerOptions: options.providerOptions,
+      schema: codexCliProviderOptionsSchema
+    });
+    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
+      responseFormat,
+      effectiveSettings
+    );
+    this.logger.debug(
+      `[codex-cli] Executing Codex CLI for streaming: ${cmd} with ${args.length} arguments`
     );
     const stream = new ReadableStream({
       start: (controller) => {
+        const startTime = Date.now();
         const child = spawn(cmd, args, { env, cwd, stdio: ["ignore", "pipe", "pipe"] });
         controller.enqueue({ type: "stream-start", warnings });
         let stderr = "";
@@ -661,12 +868,18 @@ var CodexCliLanguageModel = class {
           if (!item) return;
           if (event.type === "item.completed" && this.getItemType(item) === "assistant_message" && typeof item.text === "string") {
             accumulatedText = item.text;
+            this.logger.debug(
+              `[codex-cli] Received assistant message, length: ${item.text.length}`
+            );
             return;
           }
           const toolName = this.getToolName(item);
           if (!toolName) {
             return;
           }
+          this.logger.debug(
+            `[codex-cli] Tool detected: ${toolName}, item type: ${this.getItemType(item)}`
+          );
           const mapKey = typeof item.id === "string" && item.id.length > 0 ? item.id : randomUUID();
           let toolState = activeTools.get(mapKey);
           const latestInput = this.buildToolInputPayload(item);
@@ -685,6 +898,7 @@ var CodexCliLanguageModel = class {
             }
           }
           if (!toolState.hasEmittedCall) {
+            this.logger.debug(`[codex-cli] Emitting tool invocation: ${toolState.toolName}`);
             this.emitToolInvocation(
               controller,
               toolState.toolCallId,
@@ -695,6 +909,7 @@ var CodexCliLanguageModel = class {
           }
           if (event.type === "item.completed") {
             const { result, metadata } = this.buildToolResultPayload(item);
+            this.logger.debug(`[codex-cli] Tool completed: ${toolState.toolName}`);
             this.emitToolResult(
               controller,
               toolState.toolCallId,
@@ -718,7 +933,11 @@ var CodexCliLanguageModel = class {
           options.abortSignal.addEventListener("abort", onAbort, { once: true });
         }
         const finishStream = (code) => {
+          const duration = Date.now() - startTime;
           if (code !== 0) {
+            this.logger.error(
+              `[codex-cli] Stream process exited with code ${code} after ${duration}ms`
+            );
             controller.error(
               createAPICallError({
                 message: `Codex CLI exited with code ${code}`,
@@ -730,6 +949,7 @@ var CodexCliLanguageModel = class {
             return;
           }
           if (turnFailureMessage) {
+            this.logger.error(`[codex-cli] Stream failed: ${turnFailureMessage}`);
             controller.error(
               createAPICallError({
                 message: turnFailureMessage,
@@ -758,6 +978,12 @@ var CodexCliLanguageModel = class {
             controller.enqueue({ type: "text-end", id: textId });
           }
           const usageSummary = lastUsage ?? { inputTokens: 0, outputTokens: 0, totalTokens: 0 };
+          this.logger.info(
+            `[codex-cli] Stream completed - Session: ${this.sessionId ?? "N/A"}, Duration: ${duration}ms, Tokens: ${usageSummary.totalTokens}`
+          );
+          this.logger.debug(
+            `[codex-cli] Token usage - Input: ${usageSummary.inputTokens}, Output: ${usageSummary.outputTokens}, Total: ${usageSummary.totalTokens}`
+          );
           controller.enqueue({
             type: "finish",
             finishReason: "stop",
@@ -772,8 +998,10 @@ var CodexCliLanguageModel = class {
           for (const line of lines) {
             const event = this.parseExperimentalJsonEvent(line);
             if (!event) continue;
+            this.logger.debug(`[codex-cli] Stream event: ${event.type ?? "unknown"}`);
             if (event.type === "thread.started" && typeof event.thread_id === "string") {
               this.sessionId = event.thread_id;
+              this.logger.debug(`[codex-cli] Stream session started: ${this.sessionId}`);
               if (!responseMetadataSent) {
                 responseMetadataSent = true;
                 sendMetadata();
@@ -782,6 +1010,7 @@ var CodexCliLanguageModel = class {
             }
             if (event.type === "session.created" && typeof event.session_id === "string") {
               this.sessionId = event.session_id;
+              this.logger.debug(`[codex-cli] Stream session created: ${this.sessionId}`);
               if (!responseMetadataSent) {
                 responseMetadataSent = true;
                 sendMetadata();
@@ -798,6 +1027,7 @@ var CodexCliLanguageModel = class {
             if (event.type === "turn.failed") {
               const errorText = event.error && typeof event.error.message === "string" && event.error.message || (typeof event.message === "string" ? event.message : void 0);
               turnFailureMessage = errorText ?? turnFailureMessage ?? "Codex turn failed";
+              this.logger.error(`[codex-cli] Stream turn failed: ${turnFailureMessage}`);
               sendMetadata({ error: turnFailureMessage });
               continue;
             }
@@ -805,6 +1035,7 @@ var CodexCliLanguageModel = class {
               const errorText = typeof event.message === "string" ? event.message : void 0;
               const effective = errorText ?? "Codex error";
               turnFailureMessage = turnFailureMessage ?? effective;
+              this.logger.error(`[codex-cli] Stream error event: ${effective}`);
               sendMetadata({ error: effective });
               continue;
             }
@@ -822,6 +1053,7 @@ var CodexCliLanguageModel = class {
           }
         };
         child.on("error", (e) => {
+          this.logger.error(`[codex-cli] Stream spawn error: ${String(e)}`);
           if (options.abortSignal) options.abortSignal.removeEventListener("abort", onAbort);
           cleanupSchema();
           controller.error(this.handleSpawnError(e, promptExcerpt));

package/package.json

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