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

package/README.md

@@ -15,6 +15,7 @@ A community provider for Vercel AI SDK v5 that uses OpenAI’s Codex CLI (non‑
 - Works with `generateText`, `streamText`, and `generateObject` (native JSON Schema support via `--output-schema`)
 - 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
+- **v0.5.0**: Adds comprehensive logging system with verbose mode and custom logger support
 - **v0.3.0**: Adds comprehensive tool streaming support for monitoring autonomous tool execution
 - **v0.2.0 Breaking Changes**: Switched to `--experimental-json` and native schema enforcement (see [CHANGELOG](CHANGELOG.md))
 
@@ -96,6 +97,7 @@ console.log(object);
 
 - AI SDK v5 compatible (LanguageModelV2)
 - Streaming and non‑streaming
+- **Configurable logging** (v0.5.0+) - Verbose mode, custom loggers, or silent operation
 - **Tool streaming support** (v0.3.0+) - Monitor autonomous tool execution in real-time
 - **Native JSON Schema support** via `--output-schema` (API-enforced with `strict: true`)
 - JSON object generation with Zod schemas (100-200 fewer tokens per request vs prompt engineering)
@@ -135,6 +137,58 @@ for await (const part of result.fullStream) {
 
 **Limitation:** Real-time output streaming (`output-delta` events) not yet available. Tool outputs delivered in final `tool-result` event. See `examples/streaming-tool-calls.mjs` and `examples/streaming-multiple-tools.mjs` for usage patterns.
 
+### Logging Configuration (v0.5.0+)
+
+Control logging verbosity and integrate with your observability stack:
+
+```js
+import { codexCli } from 'ai-sdk-provider-codex-cli';
+
+// Default: warn/error only (clean production output)
+const model = codexCli('gpt-5-codex', {
+  allowNpx: true,
+  skipGitRepoCheck: true,
+});
+
+// Verbose mode: enable debug/info logs for troubleshooting
+const verboseModel = codexCli('gpt-5-codex', {
+  allowNpx: true,
+  skipGitRepoCheck: true,
+  verbose: true, // Shows all log levels
+});
+
+// Custom logger: integrate with Winston, Pino, Datadog, etc.
+const customModel = codexCli('gpt-5-codex', {
+  allowNpx: true,
+  skipGitRepoCheck: true,
+  verbose: true,
+  logger: {
+    debug: (msg) => myLogger.debug('Codex:', msg),
+    info: (msg) => myLogger.info('Codex:', msg),
+    warn: (msg) => myLogger.warn('Codex:', msg),
+    error: (msg) => myLogger.error('Codex:', msg),
+  },
+});
+
+// Silent: disable all logging
+const silentModel = codexCli('gpt-5-codex', {
+  allowNpx: true,
+  skipGitRepoCheck: true,
+  logger: false, // No logs at all
+});
+```
+
+**Log Levels:**
+
+- `debug`: Detailed execution traces (verbose mode only)
+- `info`: General execution flow (verbose mode only)
+- `warn`: Warnings and misconfigurations (always shown)
+- `error`: Errors and failures (always shown)
+
+**Default Logger:** Adds level tags `[DEBUG]`, `[INFO]`, `[WARN]`, `[ERROR]` to console output. Use a custom logger or `logger: false` if you need different formatting.
+
+See `examples/logging-*.mjs` for complete examples and [docs/ai-sdk-v5/guide.md](docs/ai-sdk-v5/guide.md) for detailed configuration.
+
 ### Text Streaming behavior
 
 **Status:** Incremental streaming not currently supported with `--experimental-json` format (expected in future Codex CLI releases)
@@ -176,9 +230,79 @@ When OpenAI adds streaming support, this provider will be updated to handle thos
 - `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
+- Logging (v0.5.0+):
+  - `verbose`: Enable debug/info logs (default: `false` for clean output)
+  - `logger`: Custom logger object or `false` to disable all logging
 
 See [docs/ai-sdk-v5/configuration.md](docs/ai-sdk-v5/configuration.md) for the full list and examples.
 
+## Model Parameters & Advanced Options (v0.4.0+)
+
+Control reasoning effort, verbosity, and advanced Codex features at model creation time:
+
+```ts
+import { codexCli } from 'ai-sdk-provider-codex-cli';
+
+const model = codexCli('gpt-5-codex', {
+  allowNpx: true,
+  skipGitRepoCheck: true,
+
+  // Reasoning & verbosity
+  reasoningEffort: 'medium', // minimal | low | medium | high
+  reasoningSummary: 'auto', // auto | detailed (Note: 'concise' and 'none' are rejected by API)
+  reasoningSummaryFormat: 'none', // none | experimental
+  modelVerbosity: 'high', // low | medium | high
+
+  // Advanced features
+  includePlanTool: true, // adds --include-plan-tool
+  profile: 'production', // adds --profile production
+  oss: false, // adds --oss when true
+  webSearch: true, // maps to -c tools.web_search=true
+
+  // Generic overrides (maps to -c key=value)
+  configOverrides: {
+    experimental_resume: '/tmp/session.jsonl',
+    sandbox_workspace_write: { network_access: true },
+  },
+});
+```
+
+Nested override objects are flattened to dotted keys (e.g., the example above emits
+`-c sandbox_workspace_write.network_access=true`). Arrays are serialized to JSON strings.
+
+### Per-call overrides via `providerOptions` (v0.4.0+)
+
+Override these parameters for individual AI SDK calls using the `providerOptions` map. Per-call
+values take precedence over constructor defaults while leaving other settings intact.
+
+```ts
+import { generateText } from 'ai';
+import { codexCli } from 'ai-sdk-provider-codex-cli';
+
+const model = codexCli('gpt-5-codex', {
+  allowNpx: true,
+  reasoningEffort: 'medium',
+  modelVerbosity: 'medium',
+});
+
+const response = await generateText({
+  model,
+  prompt: 'Summarize the latest release notes.',
+  providerOptions: {
+    'codex-cli': {
+      reasoningEffort: 'high',
+      reasoningSummary: 'detailed',
+      textVerbosity: 'high', // AI SDK naming; maps to model_verbosity
+      configOverrides: {
+        experimental_resume: '/tmp/resume.jsonl',
+      },
+    },
+  },
+});
+```
+
+**Precedence:** `providerOptions['codex-cli']` > constructor `CodexCliSettings` > Codex CLI defaults.
+
 ## Zod Compatibility
 
 - Peer supports `zod@^3 || ^4`

package/dist/index.cjs

@@ -7,28 +7,67 @@ 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 providerUtils = require('@ai-sdk/provider-utils');
 
 var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
 // 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 = zod.z.object({
+  debug: zod.z.any().refine((val) => typeof val === "function", {
+    message: "debug must be a function"
+  }),
+  info: zod.z.any().refine((val) => typeof val === "function", {
+    message: "info must be a function"
+  }),
+  warn: zod.z.any().refine((val) => typeof val === "function", {
+    message: "warn must be a function"
+  }),
+  error: zod.z.any().refine((val) => typeof val === "function", {
+    message: "error must be a function"
+  })
+});
 var settingsSchema = zod.z.object({
   codexPath: zod.z.string().optional(),
   cwd: zod.z.string().optional(),
@@ -41,7 +80,29 @@ var settingsSchema = zod.z.object({
   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()
+  logger: zod.z.union([zod.z.literal(false), loggerFunctionSchema]).optional(),
+  // NEW: Reasoning & Verbosity
+  reasoningEffort: zod.z.enum(["minimal", "low", "medium", "high"]).optional(),
+  // Note: API rejects 'concise' and 'none' despite error messages claiming they're valid
+  reasoningSummary: zod.z.enum(["auto", "detailed"]).optional(),
+  reasoningSummaryFormat: zod.z.enum(["none", "experimental"]).optional(),
+  modelVerbosity: zod.z.enum(["low", "medium", "high"]).optional(),
+  // NEW: Advanced features
+  includePlanTool: zod.z.boolean().optional(),
+  profile: zod.z.string().optional(),
+  oss: zod.z.boolean().optional(),
+  webSearch: zod.z.boolean().optional(),
+  // NEW: Generic overrides
+  configOverrides: zod.z.record(
+    zod.z.string(),
+    zod.z.union([
+      zod.z.string(),
+      zod.z.number(),
+      zod.z.boolean(),
+      zod.z.object({}).passthrough(),
+      zod.z.array(zod.z.any())
+    ])
+  ).optional()
 }).strict();
 function validateSettings(settings) {
   const warnings = [];
@@ -169,6 +230,22 @@ function isAuthenticationError(err) {
 }
 
 // src/codex-cli-language-model.ts
+var codexCliProviderOptionsSchema = zod.z.object({
+  reasoningEffort: zod.z.enum(["minimal", "low", "medium", "high"]).optional(),
+  reasoningSummary: zod.z.enum(["auto", "detailed"]).optional(),
+  reasoningSummaryFormat: zod.z.enum(["none", "experimental"]).optional(),
+  textVerbosity: zod.z.enum(["low", "medium", "high"]).optional(),
+  configOverrides: zod.z.record(
+    zod.z.string(),
+    zod.z.union([
+      zod.z.string(),
+      zod.z.number(),
+      zod.z.boolean(),
+      zod.z.object({}).passthrough(),
+      zod.z.array(zod.z.any())
+    ])
+  ).optional()
+}).strict();
 function resolveCodexPath(explicitPath, allowNpx) {
   if (explicitPath) return { cmd: "node", args: [explicitPath] };
   try {
@@ -195,13 +272,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 provider.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.
@@ -212,28 +305,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 : {};
@@ -253,16 +375,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 = 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, 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) {
@@ -504,20 +665,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 providerUtils.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 = child_process.spawn(cmd, args, { env, cwd, stdio: ["ignore", "pipe", "pipe"] });
     let onAbort;
     if (options.abortSignal) {
@@ -539,11 +715,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);
@@ -559,15 +738,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(
@@ -579,8 +764,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}`,
@@ -629,19 +821,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 providerUtils.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 = child_process.spawn(cmd, args, { env, cwd, stdio: ["ignore", "pipe", "pipe"] });
         controller.enqueue({ type: "stream-start", warnings });
         let stderr = "";
@@ -664,12 +871,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 : crypto.randomUUID();
           let toolState = activeTools.get(mapKey);
           const latestInput = this.buildToolInputPayload(item);
@@ -688,6 +901,7 @@ var CodexCliLanguageModel = class {
             }
           }
           if (!toolState.hasEmittedCall) {
+            this.logger.debug(`[codex-cli] Emitting tool invocation: ${toolState.toolName}`);
             this.emitToolInvocation(
               controller,
               toolState.toolCallId,
@@ -698,6 +912,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,
@@ -721,7 +936,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}`,
@@ -733,6 +952,7 @@ var CodexCliLanguageModel = class {
             return;
           }
           if (turnFailureMessage) {
+            this.logger.error(`[codex-cli] Stream failed: ${turnFailureMessage}`);
             controller.error(
               createAPICallError({
                 message: turnFailureMessage,
@@ -761,6 +981,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",
@@ -775,8 +1001,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();
@@ -785,6 +1013,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();
@@ -801,6 +1030,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;
             }
@@ -808,6 +1038,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;
             }
@@ -825,6 +1056,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));