ai-sdk-provider-codex-cli 0.2.0 → 0.4.0

package/dist/index.js

@@ -5,8 +5,8 @@ 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
 
@@ -38,7 +38,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.any().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 +188,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 {
@@ -199,55 +237,150 @@ var CodexCliLanguageModel = class {
     const warn = validateModelId(this.modelId);
     if (warn) this.logger.warn(`Codex CLI model: ${warn}`);
   }
-  buildArgs(promptText, responseFormat) {
-    const base = resolveCodexPath(this.settings.codexPath, this.settings.allowNpx);
+  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.
+  getItemType(item) {
+    if (!item) return void 0;
+    const data = item;
+    const legacy = typeof data.item_type === "string" ? data.item_type : void 0;
+    const current = typeof data.type === "string" ? data.type : void 0;
+    return legacy ?? current;
+  }
+  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 dir = mkdtempSync(join(tmpdir(), "codex-schema-"));
-      schemaPath = join(dir, "schema.json");
       const schema = typeof responseFormat.schema === "object" ? responseFormat.schema : {};
       const sanitizedSchema = this.sanitizeJsonSchema(schema);
-      const schemaWithAdditional = {
-        ...sanitizedSchema,
-        // OpenAI strict mode requires additionalProperties=false even if user requested otherwise.
-        additionalProperties: false
-      };
-      writeFileSync(schemaPath, JSON.stringify(schemaWithAdditional, null, 2));
-      args.push("--output-schema", schemaPath);
+      const hasProperties = Object.keys(sanitizedSchema).length > 0;
+      if (hasProperties) {
+        const dir = mkdtempSync(join(tmpdir(), "codex-schema-"));
+        schemaPath = join(dir, "schema.json");
+        const schemaWithAdditional = {
+          ...sanitizedSchema,
+          additionalProperties: false
+        };
+        writeFileSync(schemaPath, JSON.stringify(schemaWithAdditional, null, 2));
+        args.push("--output-schema", schemaPath);
+      }
     }
     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) {
@@ -297,34 +430,183 @@ var CodexCliLanguageModel = class {
   }
   parseExperimentalJsonEvent(line) {
     try {
-      const evt = JSON.parse(line);
-      const result = {};
-      switch (evt.type) {
-        case "session.created":
-          result.sessionId = evt.session_id;
-          break;
-        case "turn.completed":
-          if (evt.usage) {
-            result.usage = {
-              inputTokens: evt.usage.input_tokens || 0,
-              outputTokens: evt.usage.output_tokens || 0
-            };
-          }
-          break;
-        case "item.completed":
-          if (evt.item?.item_type === "assistant_message" || evt.item?.item_type === "reasoning") {
-            result.text = evt.item.text;
-          }
-          break;
-        case "error":
-          result.error = evt.message;
-          break;
+      return JSON.parse(line);
+    } catch {
+      return void 0;
+    }
+  }
+  extractUsage(evt) {
+    const reported = evt.usage;
+    if (!reported) return void 0;
+    const inputTokens = reported.input_tokens ?? 0;
+    const outputTokens = reported.output_tokens ?? 0;
+    const cachedInputTokens = reported.cached_input_tokens ?? 0;
+    return {
+      inputTokens,
+      outputTokens,
+      // totalTokens should not double-count cached tokens; track cached separately
+      totalTokens: inputTokens + outputTokens,
+      cachedInputTokens
+    };
+  }
+  getToolName(item) {
+    if (!item) return void 0;
+    const itemType = this.getItemType(item);
+    switch (itemType) {
+      case "command_execution":
+        return "exec";
+      case "file_change":
+        return "patch";
+      case "mcp_tool_call": {
+        const tool = item.tool;
+        if (typeof tool === "string" && tool.length > 0) return tool;
+        return "mcp_tool";
+      }
+      case "web_search":
+        return "web_search";
+      default:
+        return void 0;
+    }
+  }
+  buildToolInputPayload(item) {
+    if (!item) return void 0;
+    const data = item;
+    switch (this.getItemType(item)) {
+      case "command_execution": {
+        const payload = {};
+        if (typeof data.command === "string") payload.command = data.command;
+        if (typeof data.status === "string") payload.status = data.status;
+        if (typeof data.cwd === "string") payload.cwd = data.cwd;
+        return Object.keys(payload).length ? payload : void 0;
+      }
+      case "file_change": {
+        const payload = {};
+        if (Array.isArray(data.changes)) payload.changes = data.changes;
+        if (typeof data.status === "string") payload.status = data.status;
+        return Object.keys(payload).length ? payload : void 0;
+      }
+      case "mcp_tool_call": {
+        const payload = {};
+        if (typeof data.server === "string") payload.server = data.server;
+        if (typeof data.tool === "string") payload.tool = data.tool;
+        if (typeof data.status === "string") payload.status = data.status;
+        if (data.arguments !== void 0) payload.arguments = data.arguments;
+        return Object.keys(payload).length ? payload : void 0;
+      }
+      case "web_search": {
+        const payload = {};
+        if (typeof data.query === "string") payload.query = data.query;
+        return Object.keys(payload).length ? payload : void 0;
+      }
+      default:
+        return void 0;
+    }
+  }
+  buildToolResultPayload(item) {
+    if (!item) return { result: {} };
+    const data = item;
+    const metadata = {};
+    const itemType = this.getItemType(item);
+    if (typeof itemType === "string") metadata.itemType = itemType;
+    if (typeof item.id === "string") metadata.itemId = item.id;
+    if (typeof data.status === "string") metadata.status = data.status;
+    const buildResult = (result) => ({
+      result,
+      metadata: Object.keys(metadata).length ? metadata : void 0
+    });
+    switch (itemType) {
+      case "command_execution": {
+        const result = {};
+        if (typeof data.command === "string") result.command = data.command;
+        if (typeof data.aggregated_output === "string")
+          result.aggregatedOutput = data.aggregated_output;
+        if (typeof data.exit_code === "number") result.exitCode = data.exit_code;
+        if (typeof data.status === "string") result.status = data.status;
+        return buildResult(result);
+      }
+      case "file_change": {
+        const result = {};
+        if (Array.isArray(data.changes)) result.changes = data.changes;
+        if (typeof data.status === "string") result.status = data.status;
+        return buildResult(result);
+      }
+      case "mcp_tool_call": {
+        const result = {};
+        if (typeof data.server === "string") {
+          result.server = data.server;
+          metadata.server = data.server;
+        }
+        if (typeof data.tool === "string") result.tool = data.tool;
+        if (typeof data.status === "string") result.status = data.status;
+        if (data.result !== void 0) result.result = data.result;
+        if (data.error !== void 0) result.error = data.error;
+        return buildResult(result);
+      }
+      case "web_search": {
+        const result = {};
+        if (typeof data.query === "string") result.query = data.query;
+        if (typeof data.status === "string") result.status = data.status;
+        return buildResult(result);
       }
-      return result;
+      default: {
+        const result = { ...data };
+        return buildResult(result);
+      }
+    }
+  }
+  safeStringify(value) {
+    if (value === void 0) return "";
+    if (typeof value === "string") return value;
+    try {
+      return JSON.stringify(value);
     } catch {
-      return {};
+      return "";
     }
   }
+  emitToolInvocation(controller, toolCallId, toolName, inputPayload) {
+    const inputString = this.safeStringify(inputPayload);
+    controller.enqueue({ type: "tool-input-start", id: toolCallId, toolName });
+    if (inputString) {
+      controller.enqueue({ type: "tool-input-delta", id: toolCallId, delta: inputString });
+    }
+    controller.enqueue({ type: "tool-input-end", id: toolCallId });
+    controller.enqueue({
+      type: "tool-call",
+      toolCallId,
+      toolName,
+      input: inputString,
+      providerExecuted: true
+    });
+  }
+  emitToolResult(controller, toolCallId, toolName, item, resultPayload, metadata) {
+    const providerMetadataEntries = {
+      ...metadata ?? {}
+    };
+    const itemType = this.getItemType(item);
+    if (itemType && providerMetadataEntries.itemType === void 0) {
+      providerMetadataEntries.itemType = itemType;
+    }
+    if (item.id && providerMetadataEntries.itemId === void 0) {
+      providerMetadataEntries.itemId = item.id;
+    }
+    let isError;
+    if (itemType === "command_execution") {
+      const data = item;
+      const exitCode = typeof data.exit_code === "number" ? data.exit_code : void 0;
+      const status = typeof data.status === "string" ? data.status : void 0;
+      if (exitCode !== void 0 && exitCode !== 0 || status === "failed") {
+        isError = true;
+      }
+    }
+    controller.enqueue({
+      type: "tool-result",
+      toolCallId,
+      toolName,
+      result: resultPayload ?? {},
+      ...isError ? { isError: true } : {},
+      ...Object.keys(providerMetadataEntries).length ? { providerMetadata: { "codex-cli": providerMetadataEntries } } : {}
+    });
+  }
   handleSpawnError(err, promptExcerpt) {
     const e = err && typeof err === "object" ? err : void 0;
     const message = String((e?.message ?? err) || "Failed to run Codex CLI");
@@ -346,10 +628,17 @@ var CodexCliLanguageModel = class {
       ...this.mapWarnings(options),
       ...mappingWarnings?.map((m) => ({ type: "other", message: m })) || []
     ];
+    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
     );
     let text = "";
     const usage = { inputTokens: 0, outputTokens: 0, totalTokens: 0 };
@@ -367,25 +656,56 @@ var CodexCliLanguageModel = class {
     try {
       await new Promise((resolve, reject) => {
         let stderr = "";
+        let turnFailureMessage;
         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 parsed = this.parseExperimentalJsonEvent(line);
-            if (parsed.sessionId) this.sessionId = parsed.sessionId;
-            if (parsed.text) text = parsed.text;
-            if (parsed.usage) {
-              usage.inputTokens = parsed.usage.inputTokens;
-              usage.outputTokens = parsed.usage.outputTokens;
-              usage.totalTokens = usage.inputTokens + usage.outputTokens;
+            const event = this.parseExperimentalJsonEvent(line);
+            if (!event) continue;
+            if (event.type === "thread.started" && typeof event.thread_id === "string") {
+              this.sessionId = event.thread_id;
+            }
+            if (event.type === "session.created" && typeof event.session_id === "string") {
+              this.sessionId = event.session_id;
+            }
+            if (event.type === "turn.completed") {
+              const usageEvent = this.extractUsage(event);
+              if (usageEvent) {
+                usage.inputTokens = usageEvent.inputTokens;
+                usage.outputTokens = usageEvent.outputTokens;
+                usage.totalTokens = usageEvent.totalTokens;
+              }
+            }
+            if (event.type === "item.completed" && this.getItemType(event.item) === "assistant_message" && typeof event.item?.text === "string") {
+              text = event.item.text;
+            }
+            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";
+            }
+            if (event.type === "error") {
+              const errorText = typeof event.message === "string" ? event.message : void 0;
+              turnFailureMessage = errorText ?? turnFailureMessage ?? "Codex error";
             }
           }
         });
         child.on("error", (e) => reject(this.handleSpawnError(e, promptExcerpt)));
         child.on("close", (code) => {
-          if (code === 0) resolve();
-          else
+          if (code === 0) {
+            if (turnFailureMessage) {
+              reject(
+                createAPICallError({
+                  message: turnFailureMessage,
+                  stderr,
+                  promptExcerpt
+                })
+              );
+              return;
+            }
+            resolve();
+          } else {
             reject(
               createAPICallError({
                 message: `Codex CLI exited with code ${code}`,
@@ -394,6 +714,7 @@ var CodexCliLanguageModel = class {
                 promptExcerpt
               })
             );
+          }
         });
       });
     } finally {
@@ -439,10 +760,17 @@ var CodexCliLanguageModel = class {
       ...this.mapWarnings(options),
       ...mappingWarnings?.map((m) => ({ type: "other", message: m })) || []
     ];
+    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
     );
     const stream = new ReadableStream({
       start: (controller) => {
@@ -450,6 +778,69 @@ var CodexCliLanguageModel = class {
         controller.enqueue({ type: "stream-start", warnings });
         let stderr = "";
         let accumulatedText = "";
+        const activeTools = /* @__PURE__ */ new Map();
+        let responseMetadataSent = false;
+        let lastUsage;
+        let turnFailureMessage;
+        const sendMetadata = (meta = {}) => {
+          controller.enqueue({
+            type: "response-metadata",
+            id: randomUUID(),
+            timestamp: /* @__PURE__ */ new Date(),
+            modelId: this.modelId,
+            ...Object.keys(meta).length ? { providerMetadata: { "codex-cli": meta } } : {}
+          });
+        };
+        const handleItemEvent = (event) => {
+          const item = event.item;
+          if (!item) return;
+          if (event.type === "item.completed" && this.getItemType(item) === "assistant_message" && typeof item.text === "string") {
+            accumulatedText = item.text;
+            return;
+          }
+          const toolName = this.getToolName(item);
+          if (!toolName) {
+            return;
+          }
+          const mapKey = typeof item.id === "string" && item.id.length > 0 ? item.id : randomUUID();
+          let toolState = activeTools.get(mapKey);
+          const latestInput = this.buildToolInputPayload(item);
+          if (!toolState) {
+            toolState = {
+              toolCallId: mapKey,
+              toolName,
+              inputPayload: latestInput,
+              hasEmittedCall: false
+            };
+            activeTools.set(mapKey, toolState);
+          } else {
+            toolState.toolName = toolName;
+            if (latestInput !== void 0) {
+              toolState.inputPayload = latestInput;
+            }
+          }
+          if (!toolState.hasEmittedCall) {
+            this.emitToolInvocation(
+              controller,
+              toolState.toolCallId,
+              toolState.toolName,
+              toolState.inputPayload
+            );
+            toolState.hasEmittedCall = true;
+          }
+          if (event.type === "item.completed") {
+            const { result, metadata } = this.buildToolResultPayload(item);
+            this.emitToolResult(
+              controller,
+              toolState.toolCallId,
+              toolState.toolName,
+              item,
+              result,
+              metadata
+            );
+            activeTools.delete(mapKey);
+          }
+        };
         const onAbort = () => {
           child.kill("SIGTERM");
         };
@@ -461,42 +852,7 @@ var CodexCliLanguageModel = class {
           }
           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 parsed = this.parseExperimentalJsonEvent(line);
-            if (parsed.sessionId) {
-              this.sessionId = parsed.sessionId;
-              controller.enqueue({
-                type: "response-metadata",
-                id: randomUUID(),
-                timestamp: /* @__PURE__ */ new Date(),
-                modelId: this.modelId
-              });
-            }
-            if (parsed.text) {
-              accumulatedText = parsed.text;
-            }
-          }
-        });
-        const cleanupSchema = () => {
-          if (!schemaPath) return;
-          try {
-            const schemaDir = dirname(schemaPath);
-            rmSync(schemaDir, { recursive: true, force: true });
-          } catch {
-          }
-        };
-        child.on("error", (e) => {
-          if (options.abortSignal) options.abortSignal.removeEventListener("abort", onAbort);
-          cleanupSchema();
-          controller.error(this.handleSpawnError(e, promptExcerpt));
-        });
-        child.on("close", (code) => {
-          if (options.abortSignal) options.abortSignal.removeEventListener("abort", onAbort);
-          cleanupSchema();
+        const finishStream = (code) => {
           if (code !== 0) {
             controller.error(
               createAPICallError({
@@ -508,6 +864,16 @@ var CodexCliLanguageModel = class {
             );
             return;
           }
+          if (turnFailureMessage) {
+            controller.error(
+              createAPICallError({
+                message: turnFailureMessage,
+                stderr,
+                promptExcerpt
+              })
+            );
+            return;
+          }
           let finalText = accumulatedText;
           if (!finalText && lastMessagePath) {
             try {
@@ -521,14 +887,84 @@ var CodexCliLanguageModel = class {
             }
           }
           if (finalText) {
-            controller.enqueue({ type: "text-delta", id: randomUUID(), delta: finalText });
+            const textId = randomUUID();
+            controller.enqueue({ type: "text-start", id: textId });
+            controller.enqueue({ type: "text-delta", id: textId, delta: finalText });
+            controller.enqueue({ type: "text-end", id: textId });
           }
+          const usageSummary = lastUsage ?? { inputTokens: 0, outputTokens: 0, totalTokens: 0 };
           controller.enqueue({
             type: "finish",
             finishReason: "stop",
-            usage: { inputTokens: 0, outputTokens: 0, totalTokens: 0 }
+            usage: usageSummary
           });
           controller.close();
+        };
+        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 event = this.parseExperimentalJsonEvent(line);
+            if (!event) continue;
+            if (event.type === "thread.started" && typeof event.thread_id === "string") {
+              this.sessionId = event.thread_id;
+              if (!responseMetadataSent) {
+                responseMetadataSent = true;
+                sendMetadata();
+              }
+              continue;
+            }
+            if (event.type === "session.created" && typeof event.session_id === "string") {
+              this.sessionId = event.session_id;
+              if (!responseMetadataSent) {
+                responseMetadataSent = true;
+                sendMetadata();
+              }
+              continue;
+            }
+            if (event.type === "turn.completed") {
+              const usageEvent = this.extractUsage(event);
+              if (usageEvent) {
+                lastUsage = usageEvent;
+              }
+              continue;
+            }
+            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";
+              sendMetadata({ error: turnFailureMessage });
+              continue;
+            }
+            if (event.type === "error") {
+              const errorText = typeof event.message === "string" ? event.message : void 0;
+              const effective = errorText ?? "Codex error";
+              turnFailureMessage = turnFailureMessage ?? effective;
+              sendMetadata({ error: effective });
+              continue;
+            }
+            if (event.type && event.type.startsWith("item.")) {
+              handleItemEvent(event);
+            }
+          }
+        });
+        const cleanupSchema = () => {
+          if (!schemaPath) return;
+          try {
+            const schemaDir = dirname(schemaPath);
+            rmSync(schemaDir, { recursive: true, force: true });
+          } catch {
+          }
+        };
+        child.on("error", (e) => {
+          if (options.abortSignal) options.abortSignal.removeEventListener("abort", onAbort);
+          cleanupSchema();
+          controller.error(this.handleSpawnError(e, promptExcerpt));
+        });
+        child.on("close", (code) => {
+          if (options.abortSignal) options.abortSignal.removeEventListener("abort", onAbort);
+          cleanupSchema();
+          setImmediate(() => finishStream(code));
         });
       },
       cancel: () => {