ai-sdk-provider-codex-cli 0.2.0 → 0.3.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.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))
 
 ## Installation
@@ -26,7 +27,7 @@ npm i -g @openai/codex
 codex login   # or set OPENAI_API_KEY
 ```
 
-> **⚠️ Version Requirement**: Requires Codex CLI **>= 0.42.0** for `--experimental-json` and `--output-schema` support. Check your version with `codex --version` and upgrade if needed:
+> **⚠️ Version Requirement**: Requires Codex CLI **>= 0.42.0** for `--experimental-json` and `--output-schema` support. **>= 0.44.0 recommended** for full usage tracking and tool streaming support. Check your version with `codex --version` and upgrade if needed:
 >
 > ```bash
 > npm i -g @openai/codex@latest
@@ -95,19 +96,53 @@ console.log(object);
 
 - AI SDK v5 compatible (LanguageModelV2)
 - Streaming and non‑streaming
+- **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)
 - Safe defaults for non‑interactive automation (`on-failure`, `workspace-write`, `--skip-git-repo-check`)
 - Fallback to `npx @openai/codex` when not on PATH (`allowNpx`)
 - Usage tracking from experimental JSON event format
 
-### Streaming behavior
+### Tool Streaming (v0.3.0+)
+
+The provider supports comprehensive tool streaming, enabling real-time monitoring of Codex CLI's autonomous tool execution:
+
+```js
+import { streamText } from 'ai';
+import { codexCli } from 'ai-sdk-provider-codex-cli';
+
+const result = await streamText({
+  model: codexCli('gpt-5-codex', { allowNpx: true, skipGitRepoCheck: true }),
+  prompt: 'List files and count lines in the largest one',
+});
+
+for await (const part of result.fullStream) {
+  if (part.type === 'tool-call') {
+    console.log('🔧 Tool:', part.toolName);
+  }
+  if (part.type === 'tool-result') {
+    console.log('✅ Result:', part.result);
+  }
+}
+```
+
+**What you get:**
+
+- Tool invocation events when Codex starts executing tools (exec, patch, web_search, mcp_tool_call)
+- Tool input tracking with full parameter visibility
+- Tool result events with complete output payloads
+- `providerExecuted: true` on all tool calls (Codex executes autonomously, app doesn't need to)
+
+**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.
+
+### Text Streaming behavior
 
 **Status:** Incremental streaming not currently supported with `--experimental-json` format (expected in future Codex CLI releases)
 
 The `--experimental-json` output format (introduced Sept 25, 2025) currently only emits `item.completed` events with full text content. Incremental streaming via `item.updated` or delta events is not yet implemented by OpenAI.
 
 **What this means:**
+
 - `streamText()` works functionally but delivers the entire response in a single chunk after generation completes
 - No incremental text deltas—you wait for the full response, then receive it all at once
 - The AI SDK's streaming interface is supported, but actual incremental streaming is not available

package/dist/index.cjs

@@ -202,6 +202,16 @@ var CodexCliLanguageModel = class {
     const warn = validateModelId(this.modelId);
     if (warn) this.logger.warn(`Codex CLI model: ${warn}`);
   }
+  // 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) {
     const base = resolveCodexPath(this.settings.codexPath, this.settings.allowNpx);
     const args = [...base.args, "exec", "--experimental-json"];
@@ -226,17 +236,19 @@ var CodexCliLanguageModel = class {
     }
     let schemaPath;
     if (responseFormat?.type === "json" && responseFormat.schema) {
-      const dir = fs.mkdtempSync(path.join(os.tmpdir(), "codex-schema-"));
-      schemaPath = path.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
-      };
-      fs.writeFileSync(schemaPath, JSON.stringify(schemaWithAdditional, null, 2));
-      args.push("--output-schema", schemaPath);
+      const hasProperties = Object.keys(sanitizedSchema).length > 0;
+      if (hasProperties) {
+        const dir = fs.mkdtempSync(path.join(os.tmpdir(), "codex-schema-"));
+        schemaPath = path.join(dir, "schema.json");
+        const schemaWithAdditional = {
+          ...sanitizedSchema,
+          additionalProperties: false
+        };
+        fs.writeFileSync(schemaPath, JSON.stringify(schemaWithAdditional, null, 2));
+        args.push("--output-schema", schemaPath);
+      }
     }
     args.push(promptText);
     const env = {
@@ -300,34 +312,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;
       }
-      return result;
+      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);
+      }
+      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");
@@ -370,25 +531,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}`,
@@ -397,6 +589,7 @@ var CodexCliLanguageModel = class {
                 promptExcerpt
               })
             );
+          }
         });
       });
     } finally {
@@ -453,6 +646,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: crypto.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 : crypto.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");
         };
@@ -464,42 +720,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: crypto.randomUUID(),
-                timestamp: /* @__PURE__ */ new Date(),
-                modelId: this.modelId
-              });
-            }
-            if (parsed.text) {
-              accumulatedText = parsed.text;
-            }
-          }
-        });
-        const cleanupSchema = () => {
-          if (!schemaPath) return;
-          try {
-            const schemaDir = path.dirname(schemaPath);
-            fs.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({
@@ -511,6 +732,16 @@ var CodexCliLanguageModel = class {
             );
             return;
           }
+          if (turnFailureMessage) {
+            controller.error(
+              createAPICallError({
+                message: turnFailureMessage,
+                stderr,
+                promptExcerpt
+              })
+            );
+            return;
+          }
           let finalText = accumulatedText;
           if (!finalText && lastMessagePath) {
             try {
@@ -524,14 +755,84 @@ var CodexCliLanguageModel = class {
             }
           }
           if (finalText) {
-            controller.enqueue({ type: "text-delta", id: crypto.randomUUID(), delta: finalText });
+            const textId = crypto.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 = path.dirname(schemaPath);
+            fs.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: () => {

package/dist/index.d.cts

@@ -51,10 +51,18 @@ declare class CodexCliLanguageModel implements LanguageModelV2 {
     private logger;
     private sessionId?;
     constructor(options: CodexLanguageModelOptions);
+    private getItemType;
     private buildArgs;
     private sanitizeJsonSchema;
     private mapWarnings;
     private parseExperimentalJsonEvent;
+    private extractUsage;
+    private getToolName;
+    private buildToolInputPayload;
+    private buildToolResultPayload;
+    private safeStringify;
+    private emitToolInvocation;
+    private emitToolResult;
     private handleSpawnError;
     doGenerate(options: Parameters<LanguageModelV2['doGenerate']>[0]): Promise<Awaited<ReturnType<LanguageModelV2['doGenerate']>>>;
     doStream(options: Parameters<LanguageModelV2['doStream']>[0]): Promise<Awaited<ReturnType<LanguageModelV2['doStream']>>>;

package/dist/index.d.ts

@@ -51,10 +51,18 @@ declare class CodexCliLanguageModel implements LanguageModelV2 {
     private logger;
     private sessionId?;
     constructor(options: CodexLanguageModelOptions);
+    private getItemType;
     private buildArgs;
     private sanitizeJsonSchema;
     private mapWarnings;
     private parseExperimentalJsonEvent;
+    private extractUsage;
+    private getToolName;
+    private buildToolInputPayload;
+    private buildToolResultPayload;
+    private safeStringify;
+    private emitToolInvocation;
+    private emitToolResult;
     private handleSpawnError;
     doGenerate(options: Parameters<LanguageModelV2['doGenerate']>[0]): Promise<Awaited<ReturnType<LanguageModelV2['doGenerate']>>>;
     doStream(options: Parameters<LanguageModelV2['doStream']>[0]): Promise<Awaited<ReturnType<LanguageModelV2['doStream']>>>;

package/dist/index.js

@@ -199,6 +199,16 @@ var CodexCliLanguageModel = class {
     const warn = validateModelId(this.modelId);
     if (warn) this.logger.warn(`Codex CLI model: ${warn}`);
   }
+  // 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) {
     const base = resolveCodexPath(this.settings.codexPath, this.settings.allowNpx);
     const args = [...base.args, "exec", "--experimental-json"];
@@ -223,17 +233,19 @@ var CodexCliLanguageModel = class {
     }
     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 = {
@@ -297,34 +309,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;
       }
-      return result;
+      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);
+      }
+      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");
@@ -367,25 +528,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 +586,7 @@ var CodexCliLanguageModel = class {
                 promptExcerpt
               })
             );
+          }
         });
       });
     } finally {
@@ -450,6 +643,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 +717,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 +729,16 @@ var CodexCliLanguageModel = class {
             );
             return;
           }
+          if (turnFailureMessage) {
+            controller.error(
+              createAPICallError({
+                message: turnFailureMessage,
+                stderr,
+                promptExcerpt
+              })
+            );
+            return;
+          }
           let finalText = accumulatedText;
           if (!finalText && lastMessagePath) {
             try {
@@ -521,14 +752,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: () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-sdk-provider-codex-cli",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "AI SDK v5 provider for OpenAI Codex CLI with native JSON Schema support",
   "keywords": [
     "ai-sdk",
@@ -61,7 +61,7 @@
     "jsonc-parser": "^3.3.1"
   },
   "optionalDependencies": {
-    "@openai/codex": "*"
+    "@openai/codex": "^0.44.0"
   },
   "devDependencies": {
     "@eslint/js": "^9.14.0",