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

package/dist/index.js

@@ -2,30 +2,14 @@ import { NoSuchModelError, LoadAPIKeyError, APICallError } from '@ai-sdk/provide
 import { spawn } from 'child_process';
 import { randomUUID } from 'crypto';
 import { createRequire } from 'module';
-import { mkdtempSync, readFileSync, rmSync } from 'fs';
+import { mkdtempSync, writeFileSync, rmSync, readFileSync } from 'fs';
 import { tmpdir } from 'os';
-import { join } from 'path';
+import { join, dirname } from 'path';
 import { generateId } from '@ai-sdk/provider-utils';
 import { z } from 'zod';
 
 // src/codex-cli-provider.ts
 
-// src/extract-json.ts
-function extractJson(text) {
-  const start = text.indexOf("{");
-  if (start === -1) return text;
-  let depth = 0;
-  for (let i = start; i < text.length; i++) {
-    const ch = text[i];
-    if (ch === "{") depth++;
-    else if (ch === "}") {
-      depth--;
-      if (depth === 0) return text.slice(start, i + 1);
-    }
-  }
-  return text;
-}
-
 // src/logger.ts
 var defaultLogger = {
   warn: (m) => console.warn(m),
@@ -105,7 +89,7 @@ function isToolItem(p) {
   if (out.type === "text" && typeof out.value !== "string") return false;
   return true;
 }
-function mapMessagesToPrompt(prompt, mode = { type: "regular" }, jsonSchema) {
+function mapMessagesToPrompt(prompt) {
   const warnings = [];
   const parts = [];
   let systemText;
@@ -148,17 +132,6 @@ function mapMessagesToPrompt(prompt, mode = { type: "regular" }, jsonSchema) {
   let promptText = "";
   if (systemText) promptText += systemText + "\n\n";
   promptText += parts.join("\n\n");
-  if (mode.type === "object-json" && jsonSchema) {
-    const schemaStr = JSON.stringify(jsonSchema, null, 2);
-    promptText = `CRITICAL: You MUST respond with ONLY a JSON object. NO other text.
-Your response MUST start with { and end with }
-The JSON MUST match this EXACT schema:
-${schemaStr}
-
-Now, based on the following conversation, generate ONLY the JSON object:
-
-${promptText}`;
-  }
   return { promptText, ...warnings.length ? { warnings } : {} };
 }
 function createAPICallError({
@@ -211,7 +184,7 @@ var CodexCliLanguageModel = class {
   defaultObjectGenerationMode = "json";
   supportsImageUrls = false;
   supportedUrls = {};
-  supportsStructuredOutputs = false;
+  supportsStructuredOutputs = true;
   modelId;
   settings;
   logger;
@@ -226,9 +199,19 @@ var CodexCliLanguageModel = class {
     const warn = validateModelId(this.modelId);
     if (warn) this.logger.warn(`Codex CLI model: ${warn}`);
   }
-  buildArgs(promptText) {
+  // 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", "--json"];
+    const args = [...base.args, "exec", "--experimental-json"];
     if (this.settings.fullAuto) {
       args.push("--full-auto");
     } else if (this.settings.dangerouslyBypassApprovalsAndSandbox) {
@@ -248,6 +231,22 @@ var CodexCliLanguageModel = class {
     if (this.modelId) {
       args.push("-m", this.modelId);
     }
+    let schemaPath;
+    if (responseFormat?.type === "json" && responseFormat.schema) {
+      const schema = typeof responseFormat.schema === "object" ? responseFormat.schema : {};
+      const sanitizedSchema = this.sanitizeJsonSchema(schema);
+      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,
@@ -260,7 +259,34 @@ var CodexCliLanguageModel = class {
       lastMessagePath = join(dir, "last-message.txt");
     }
     args.push("--output-last-message", lastMessagePath);
-    return { cmd: base.cmd, args, env, cwd: this.settings.cwd, lastMessagePath };
+    return { cmd: base.cmd, args, env, cwd: this.settings.cwd, lastMessagePath, schemaPath };
+  }
+  sanitizeJsonSchema(value) {
+    if (typeof value !== "object" || value === null) {
+      return value;
+    }
+    if (Array.isArray(value)) {
+      return value.map((item) => this.sanitizeJsonSchema(item));
+    }
+    const obj = value;
+    const result = {};
+    for (const [key, val] of Object.entries(obj)) {
+      if (key === "properties" && typeof val === "object" && val !== null && !Array.isArray(val)) {
+        const props = val;
+        const sanitizedProps = {};
+        for (const [propName, propSchema] of Object.entries(props)) {
+          sanitizedProps[propName] = this.sanitizeJsonSchema(propSchema);
+        }
+        result[key] = sanitizedProps;
+        continue;
+      }
+      if (key === "$schema" || key === "$id" || key === "$ref" || key === "$defs" || key === "definitions" || key === "title" || key === "examples" || key === "default" || key === "format" || // OpenAI strict mode doesn't support format
+      key === "pattern") {
+        continue;
+      }
+      result[key] = this.sanitizeJsonSchema(val);
+    }
+    return result;
   }
   mapWarnings(options) {
     const unsupported = [];
@@ -281,13 +307,185 @@ var CodexCliLanguageModel = class {
     add(options.seed, "seed");
     return unsupported;
   }
-  parseJsonLine(line) {
+  parseExperimentalJsonEvent(line) {
     try {
       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);
+      }
+      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 "";
+    }
+  }
+  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");
@@ -303,18 +501,17 @@ var CodexCliLanguageModel = class {
     });
   }
   async doGenerate(options) {
-    const mode = options.responseFormat?.type === "json" ? { type: "object-json" } : { type: "regular" };
-    const { promptText, warnings: mappingWarnings } = mapMessagesToPrompt(
-      options.prompt,
-      mode,
-      options.responseFormat?.type === "json" ? options.responseFormat.schema : void 0
-    );
+    const { promptText, warnings: mappingWarnings } = mapMessagesToPrompt(options.prompt);
     const promptExcerpt = promptText.slice(0, 200);
     const warnings = [
       ...this.mapWarnings(options),
       ...mappingWarnings?.map((m) => ({ type: "other", message: m })) || []
     ];
-    const { cmd, args, env, cwd, lastMessagePath } = this.buildArgs(promptText);
+    const responseFormat = options.responseFormat?.type === "json" ? { type: "json", schema: options.responseFormat.schema } : void 0;
+    const { cmd, args, env, cwd, lastMessagePath, schemaPath } = this.buildArgs(
+      promptText,
+      responseFormat
+    );
     let text = "";
     const usage = { inputTokens: 0, outputTokens: 0, totalTokens: 0 };
     const finishReason = "stop";
@@ -331,27 +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 evt = this.parseJsonLine(line);
-            if (!evt) continue;
-            const msg = evt.msg;
-            const type = msg?.type;
-            if (type === "session_configured" && msg) {
-              this.sessionId = msg.session_id;
-            } else if (type === "task_complete" && msg) {
-              const last = msg.last_agent_message;
-              if (typeof last === "string") text = last;
+            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}`,
@@ -360,10 +586,18 @@ var CodexCliLanguageModel = class {
                 promptExcerpt
               })
             );
+          }
         });
       });
     } finally {
       if (options.abortSignal && onAbort) options.abortSignal.removeEventListener("abort", onAbort);
+      if (schemaPath) {
+        try {
+          const schemaDir = dirname(schemaPath);
+          rmSync(schemaDir, { recursive: true, force: true });
+        } catch {
+        }
+      }
     }
     if (!text && lastMessagePath) {
       try {
@@ -378,9 +612,6 @@ var CodexCliLanguageModel = class {
       } catch {
       }
     }
-    if (options.responseFormat?.type === "json" && text) {
-      text = extractJson(text);
-    }
     const content = [{ type: "text", text }];
     return {
       content,
@@ -395,24 +626,86 @@ var CodexCliLanguageModel = class {
     };
   }
   async doStream(options) {
-    const mode = options.responseFormat?.type === "json" ? { type: "object-json" } : { type: "regular" };
-    const { promptText, warnings: mappingWarnings } = mapMessagesToPrompt(
-      options.prompt,
-      mode,
-      options.responseFormat?.type === "json" ? options.responseFormat.schema : void 0
-    );
+    const { promptText, warnings: mappingWarnings } = mapMessagesToPrompt(options.prompt);
     const promptExcerpt = promptText.slice(0, 200);
     const warnings = [
       ...this.mapWarnings(options),
       ...mappingWarnings?.map((m) => ({ type: "other", message: m })) || []
     ];
-    const { cmd, args, env, cwd, lastMessagePath } = this.buildArgs(promptText);
+    const responseFormat = options.responseFormat?.type === "json" ? { type: "json", schema: options.responseFormat.schema } : void 0;
+    const { cmd, args, env, cwd, lastMessagePath, schemaPath } = this.buildArgs(
+      promptText,
+      responseFormat
+    );
     const stream = new ReadableStream({
       start: (controller) => {
         const child = spawn(cmd, args, { env, cwd, stdio: ["ignore", "pipe", "pipe"] });
         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");
         };
@@ -424,37 +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 evt = this.parseJsonLine(line);
-            if (!evt) continue;
-            const msg = evt.msg;
-            const type = msg?.type;
-            if (type === "session_configured" && msg) {
-              this.sessionId = msg.session_id;
-              controller.enqueue({
-                type: "response-metadata",
-                id: randomUUID(),
-                timestamp: /* @__PURE__ */ new Date(),
-                modelId: this.modelId
-              });
-            } else if (type === "task_complete" && msg) {
-              const last = msg.last_agent_message;
-              if (typeof last === "string") {
-                accumulatedText = last;
-              }
-            }
-          }
-        });
-        child.on("error", (e) => {
-          if (options.abortSignal) options.abortSignal.removeEventListener("abort", onAbort);
-          controller.error(this.handleSpawnError(e, promptExcerpt));
-        });
-        child.on("close", (code) => {
-          if (options.abortSignal) options.abortSignal.removeEventListener("abort", onAbort);
+        const finishStream = (code) => {
           if (code !== 0) {
             controller.error(
               createAPICallError({
@@ -466,6 +729,16 @@ var CodexCliLanguageModel = class {
             );
             return;
           }
+          if (turnFailureMessage) {
+            controller.error(
+              createAPICallError({
+                message: turnFailureMessage,
+                stderr,
+                promptExcerpt
+              })
+            );
+            return;
+          }
           let finalText = accumulatedText;
           if (!finalText && lastMessagePath) {
             try {
@@ -479,17 +752,84 @@ var CodexCliLanguageModel = class {
             }
           }
           if (finalText) {
-            if (options.responseFormat?.type === "json") {
-              finalText = extractJson(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: () => {