ai-sdk-provider-codex-cli 1.3.0 → 2.0.0

package/dist/index.js

@@ -6,7 +6,7 @@ import { mkdtempSync, writeFileSync, rmSync, readFileSync } from 'fs';
 import { tmpdir } from 'os';
 import path, { join, dirname } from 'path';
 import { z } from 'zod';
-import { generateId, parseProviderOptions } from '@ai-sdk/provider-utils';
+import { generateId, parseProviderOptions, getTopLevelMediaType, isFullMediaType, detectMediaType } from '@ai-sdk/provider-utils';
 import { createServer } from 'http';
 import { EventEmitter } from 'events';
 import readline from 'readline';
@@ -324,75 +324,41 @@ function validateModelId(modelId) {
   if (!modelId || modelId.trim() === "") return "Model ID cannot be empty";
   return void 0;
 }
-
-// src/converters/tool-result-converter.ts
-function safeJsonStringify(value) {
-  if (value === void 0) return "";
-  if (typeof value === "string") return value;
-  try {
-    return JSON.stringify(value);
-  } catch {
-    return "[unserializable]";
-  }
+function isTaggedFileData(value) {
+  if (typeof value !== "object" || value === null || !("type" in value)) return false;
+  return value.type === "data" || value.type === "url" || value.type === "reference" || value.type === "text";
 }
-function formatToolResultOutput(output) {
-  switch (output.type) {
-    case "text":
-      return { text: output.value, warnings: [] };
-    case "json":
-      return { text: safeJsonStringify(output.value), warnings: [] };
-    case "execution-denied":
-      return {
-        text: output.reason ? `Execution denied: ${output.reason}` : "Execution denied",
-        warnings: []
-      };
-    case "error-text":
-      return { text: `Tool error: ${output.value}`, warnings: [] };
-    case "error-json":
-      return { text: `Tool error: ${safeJsonStringify(output.value)}`, warnings: [] };
-    case "content": {
-      const warnings = [];
-      const parts = output.value.map((part) => {
-        if (part.type === "text") return part.text;
-        if (part.type === "file-data") {
-          return `[file-data: ${part.mediaType}${part.filename ? `, ${part.filename}` : ""}]`;
-        }
-        if (part.type === "file-url") return `[file-url: ${part.url}]`;
-        if (part.type === "file-id") return "[file-id]";
-        if (part.type === "image-data") return `[image-data: ${part.mediaType}]`;
-        if (part.type === "image-url") return `[image-url: ${part.url}]`;
-        if (part.type === "image-file-id") return "[image-file-id]";
-        warnings.push({
-          type: "unsupported",
-          feature: `tool-result.content.${String(part.type)}`,
-          details: `Unsupported tool content part "${String(part.type)}".`
-        });
-        return "[unsupported-tool-content-part]";
-      }).filter((part) => part.length > 0);
-      return { text: parts.join("\n"), warnings };
-    }
-    default:
-      return {
-        text: "[unsupported-tool-result-output]",
-        warnings: [
-          {
-            type: "unsupported",
-            feature: `tool-result.output.${String(output.type)}`,
-            details: `Unsupported tool result output type "${String(output.type)}".`
-          }
-        ]
-      };
+function resolveImageMimeType(declaredType, data) {
+  if (isFullMediaType(declaredType)) return declaredType;
+  const bytes = typeof data === "string" || data instanceof Uint8Array ? data : data instanceof ArrayBuffer ? new Uint8Array(data) : void 0;
+  if (bytes !== void 0) {
+    const detected = detectMediaType({
+      data: bytes,
+      topLevelType: getTopLevelMediaType(declaredType)
+    });
+    if (detected) return detected;
   }
+  return "image/png";
 }
 function extractImageData(part) {
   if (typeof part !== "object" || part === null) return null;
   const p = part;
   const isFilePart2 = p.type === "file";
-  const mimeType = isFilePart2 ? p.mediaType || "image/png" : p.mimeType || "image/png";
-  if (isFilePart2 && !mimeType.toLowerCase().startsWith("image/")) {
+  const declaredType = isFilePart2 ? p.mediaType || "image/png" : p.mimeType || "image/png";
+  if (isFilePart2 && getTopLevelMediaType(declaredType).toLowerCase() !== "image") {
     return null;
   }
-  const primaryInput = isFilePart2 ? p.data : p.image;
+  let primaryInput = isFilePart2 ? p.data : p.image;
+  if (isTaggedFileData(primaryInput)) {
+    if (primaryInput.type === "data") {
+      primaryInput = primaryInput.data;
+    } else if (primaryInput.type === "url") {
+      primaryInput = primaryInput.url;
+    } else {
+      return null;
+    }
+  }
+  const mimeType = resolveImageMimeType(declaredType, primaryInput);
   if (typeof primaryInput === "string") {
     return extractFromString(primaryInput, mimeType);
   }
@@ -538,14 +504,18 @@ function asRemoteUrl(value) {
   return void 0;
 }
 function isImageMediaType(mediaType) {
-  return mediaType.toLowerCase().startsWith("image/");
+  return getTopLevelMediaType(mediaType).toLowerCase() === "image";
 }
 function isFilePart(part) {
-  return part.type === "file" && typeof part.mediaType === "string";
+  return part.type === "file" && "mediaType" in part && typeof part.mediaType === "string";
 }
 function isCompatImagePart(part) {
   return part.type === "image";
 }
+function isTaggedFileData2(value) {
+  if (typeof value !== "object" || value === null || !("type" in value)) return false;
+  return value.type === "data" || value.type === "url" || value.type === "reference" || value.type === "text";
+}
 function toImageReference(part) {
   if (isFilePart(part)) {
     if (!isImageMediaType(part.mediaType)) {
@@ -554,7 +524,42 @@ function toImageReference(part) {
         warning: `Unsupported file mediaType "${part.mediaType}"; only image/* is supported.`
       };
     }
-    const remote = asRemoteUrl(part.data);
+    const data = part.data;
+    if (isTaggedFileData2(data)) {
+      if (data.type === "reference") {
+        return {
+          kind: "unsupported",
+          warning: "File reference data is not supported for images."
+        };
+      }
+      if (data.type === "text") {
+        return {
+          kind: "unsupported",
+          warning: "Inline text file data is not supported for images."
+        };
+      }
+      if (data.type === "url") {
+        const remote2 = asRemoteUrl(data.url);
+        if (remote2) {
+          return { kind: "remote", url: remote2 };
+        }
+        if (isFileUrlValue(data.url)) {
+          return {
+            kind: "unsupported",
+            warning: "file:// image URLs are not supported."
+          };
+        }
+      }
+      const image2 = extractImageData(part);
+      if (image2) {
+        return { kind: "local", image: image2 };
+      }
+      return {
+        kind: "unsupported",
+        warning: "Unsupported image format in message."
+      };
+    }
+    const remote = asRemoteUrl(data);
     if (remote) {
       return { kind: "remote", url: remote };
     }
@@ -562,7 +567,7 @@ function toImageReference(part) {
     if (image) {
       return { kind: "local", image };
     }
-    if (isFileUrlValue(part.data) || isFileUrlValue(part.url)) {
+    if (isFileUrlValue(data) || "url" in part && isFileUrlValue(part.url)) {
       return {
         kind: "unsupported",
         warning: "file:// image URLs are not supported."
@@ -596,6 +601,90 @@ function toImageReference(part) {
   return void 0;
 }
 
+// src/converters/tool-result-converter.ts
+function safeJsonStringify(value) {
+  if (value === void 0) return "";
+  if (typeof value === "string") return value;
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return "[unserializable]";
+  }
+}
+function describeTypeTag(value) {
+  if (typeof value === "object" && value !== null && "type" in value) {
+    return String(value.type);
+  }
+  return "unknown";
+}
+function formatToolResultOutput(output) {
+  switch (output.type) {
+    case "text":
+      return { text: output.value, warnings: [] };
+    case "json":
+      return { text: safeJsonStringify(output.value), warnings: [] };
+    case "execution-denied":
+      return {
+        text: output.reason ? `Execution denied: ${output.reason}` : "Execution denied",
+        warnings: []
+      };
+    case "error-text":
+      return { text: `Tool error: ${output.value}`, warnings: [] };
+    case "error-json":
+      return { text: `Tool error: ${safeJsonStringify(output.value)}`, warnings: [] };
+    case "content": {
+      const warnings = [];
+      const parts = output.value.map((part) => {
+        if (part.type === "text") return part.text;
+        if (part.type === "file") {
+          const prefix = isImageMediaType(part.mediaType) ? "image" : "file";
+          const data = part.data;
+          if (data.type === "data") {
+            return prefix === "image" ? `[image-data: ${part.mediaType}]` : `[file-data: ${part.mediaType}${part.filename ? `, ${part.filename}` : ""}]`;
+          }
+          if (data.type === "url") return `[${prefix}-url: ${data.url}]`;
+          if (data.type === "reference") {
+            return prefix === "image" ? "[image-file-id]" : "[file-id]";
+          }
+          if (data.type === "text") return data.text;
+          warnings.push({
+            type: "unsupported",
+            feature: "tool-result.content.file",
+            details: `Unsupported tool file content data type "${describeTypeTag(data)}".`
+          });
+          return "[unsupported-tool-content-part]";
+        }
+        if (part.type === "custom") {
+          warnings.push({
+            type: "unsupported",
+            feature: "tool-result.content.custom",
+            details: "Custom tool content parts are not supported."
+          });
+          return "";
+        }
+        warnings.push({
+          type: "unsupported",
+          feature: `tool-result.content.${describeTypeTag(part)}`,
+          details: `Unsupported tool content part "${describeTypeTag(part)}".`
+        });
+        return "[unsupported-tool-content-part]";
+      }).filter((part) => part.length > 0);
+      return { text: parts.join("\n"), warnings };
+    }
+    default:
+      return {
+        text: "[unsupported-tool-result-output]",
+        warnings: [
+          {
+            type: "unsupported",
+            feature: `tool-result.output.${describeTypeTag(output)}`,
+            details: `Unsupported tool result output type "${describeTypeTag(output)}".`
+          }
+        ]
+      };
+  }
+}
+
 // src/converters/prompt-converter.ts
 function isTextPart(part) {
   return part.type === "text" && typeof part.text === "string";
@@ -730,6 +819,23 @@ function formatAssistantParts(parts) {
       lines.push(`[assistant-file: ${part.mediaType}]`);
       continue;
     }
+    if (part.type === "custom") {
+      const kind = "kind" in part && typeof part.kind === "string" ? part.kind : void 0;
+      warnings.push({
+        type: "unsupported",
+        feature: "prompt.assistant.custom",
+        details: `Custom content parts are not supported${kind ? ` (kind "${kind}")` : ""}.`
+      });
+      continue;
+    }
+    if (part.type === "reasoning-file") {
+      warnings.push({
+        type: "unsupported",
+        feature: "prompt.assistant.reasoning-file",
+        details: "Reasoning file parts are not supported."
+      });
+      continue;
+    }
     warnings.push({
       type: "unsupported",
       feature: `prompt.assistant.${part.type}`,
@@ -1146,7 +1252,11 @@ function mapUnsupportedSettingsWarnings(options) {
   add(options.stopSequences?.length ? options.stopSequences : void 0, "stopSequences");
   add(options.seed, "seed");
   add(options.tools, "tools");
-  add(options.toolChoice, "toolChoice");
+  const toolChoice = options.toolChoice;
+  add(
+    toolChoice !== void 0 && toolChoice.type === "auto" ? void 0 : toolChoice,
+    "toolChoice"
+  );
   return unsupported;
 }
 function mcpServersToConfigOverrides(mcpServers, rmcpClient) {
@@ -1200,6 +1310,14 @@ function mcpServersToConfigOverrides(mcpServers, rmcpClient) {
 }
 
 // src/exec-language-model.ts
+var codexReasoningEfforts = {
+  none: true,
+  minimal: true,
+  low: true,
+  medium: true,
+  high: true,
+  xhigh: true
+};
 var codexCliProviderOptionsSchema = z.object({
   reasoningEffort: z.enum(["none", "minimal", "low", "medium", "high", "xhigh"]).optional(),
   reasoningSummary: z.enum(["auto", "detailed"]).optional(),
@@ -1240,12 +1358,9 @@ function resolveCodexPath(explicitPath, allowNpx) {
   }
 }
 var ExecLanguageModel = class {
-  specificationVersion = "v3";
+  specificationVersion = "v4";
   provider = "codex-cli";
-  defaultObjectGenerationMode = "json";
-  supportsImageUrls = false;
   supportedUrls = {};
-  supportsStructuredOutputs = true;
   modelId;
   settings;
   logger;
@@ -1874,7 +1989,22 @@ var ExecLanguageModel = class {
       providerOptions: options.providerOptions,
       schema: codexCliProviderOptionsSchema
     });
-    const effectiveSettings = this.mergeSettings(providerOptions);
+    let effectiveSettings = this.mergeSettings(providerOptions);
+    const topLevelReasoning = options.reasoning;
+    if (topLevelReasoning !== void 0 && topLevelReasoning !== "provider-default" && providerOptions?.reasoningEffort === void 0) {
+      if (Object.hasOwn(codexReasoningEfforts, topLevelReasoning)) {
+        effectiveSettings = {
+          ...effectiveSettings,
+          reasoningEffort: topLevelReasoning
+        };
+      } else {
+        warnings.push({
+          type: "unsupported",
+          feature: "reasoning",
+          details: `Codex CLI does not support reasoning effort '${topLevelReasoning}'; it will be ignored.`
+        });
+      }
+    }
     const responseFormat = options.responseFormat?.type === "json" ? { type: "json", schema: options.responseFormat.schema } : void 0;
     const { cmd, args, env, cwd, lastMessagePath, lastMessageIsTemp, schemaPath, tempImagePaths } = this.buildArgs(images, responseFormat, effectiveSettings);
     this.logger.debug(
@@ -1889,6 +2019,7 @@ var ExecLanguageModel = class {
         controller.enqueue({ type: "stream-start", warnings });
         let stderr = "";
         let accumulatedText = "";
+        let stdoutBuffer = "";
         const activeTools = /* @__PURE__ */ new Map();
         let responseMetadataSent = false;
         let lastUsage;
@@ -2046,57 +2177,62 @@ var ExecLanguageModel = class {
           });
           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;
-            this.logger.debug(`[codex-cli] Stream event: ${event.type ?? "unknown"}`);
-            if (event.type === "thread.started" && typeof event.thread_id === "string") {
-              this.sessionId = event.thread_id;
-              this.logger.debug(`[codex-cli] Stream session started: ${this.sessionId}`);
-              if (!responseMetadataSent) {
-                responseMetadataSent = true;
-                sendMetadata();
-              }
-              continue;
+        const processLine = (line) => {
+          const event = this.parseExperimentalJsonEvent(line);
+          if (!event) return;
+          this.logger.debug(`[codex-cli] Stream event: ${event.type ?? "unknown"}`);
+          if (event.type === "thread.started" && typeof event.thread_id === "string") {
+            this.sessionId = event.thread_id;
+            this.logger.debug(`[codex-cli] Stream session started: ${this.sessionId}`);
+            if (!responseMetadataSent) {
+              responseMetadataSent = true;
+              sendMetadata();
             }
-            if (event.type === "session.created" && typeof event.session_id === "string") {
-              this.sessionId = event.session_id;
-              this.logger.debug(`[codex-cli] Stream session created: ${this.sessionId}`);
-              if (!responseMetadataSent) {
-                responseMetadataSent = true;
-                sendMetadata();
-              }
-              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";
-              this.logger.error(`[codex-cli] Stream turn failed: ${turnFailureMessage}`);
-              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;
-              this.logger.error(`[codex-cli] Stream error event: ${effective}`);
-              sendMetadata({ error: effective });
-              continue;
+            return;
+          }
+          if (event.type === "session.created" && typeof event.session_id === "string") {
+            this.sessionId = event.session_id;
+            this.logger.debug(`[codex-cli] Stream session created: ${this.sessionId}`);
+            if (!responseMetadataSent) {
+              responseMetadataSent = true;
+              sendMetadata();
             }
-            if (event.type && event.type.startsWith("item.")) {
-              handleItemEvent(event);
+            return;
+          }
+          if (event.type === "turn.completed") {
+            const usageEvent = this.extractUsage(event);
+            if (usageEvent) {
+              lastUsage = usageEvent;
             }
+            return;
+          }
+          if (event.type === "turn.failed") {
+            const errorText = event.error && typeof event.error.message === "string" && event.error.message || (typeof event.message === "string" ? event.message : void 0);
+            turnFailureMessage = errorText ?? turnFailureMessage ?? "Codex turn failed";
+            this.logger.error(`[codex-cli] Stream turn failed: ${turnFailureMessage}`);
+            sendMetadata({ error: turnFailureMessage });
+            return;
+          }
+          if (event.type === "error") {
+            const errorText = typeof event.message === "string" ? event.message : void 0;
+            const effective = errorText ?? "Codex error";
+            turnFailureMessage = turnFailureMessage ?? effective;
+            this.logger.error(`[codex-cli] Stream error event: ${effective}`);
+            sendMetadata({ error: effective });
+            return;
+          }
+          if (event.type && event.type.startsWith("item.")) {
+            handleItemEvent(event);
+          }
+        };
+        child.stderr.on("data", (d) => stderr += String(d));
+        child.stdout.setEncoding("utf8");
+        child.stdout.on("data", (chunk) => {
+          const pieces = (stdoutBuffer + chunk).split(/\r?\n/);
+          stdoutBuffer = pieces.pop() ?? "";
+          for (const line of pieces) {
+            if (!line) continue;
+            processLine(line);
           }
         });
         child.on("error", (e) => {
@@ -2108,7 +2244,13 @@ var ExecLanguageModel = class {
         child.on("close", (code) => {
           if (options.abortSignal) options.abortSignal.removeEventListener("abort", onAbort);
           cleanupTempFiles();
-          setImmediate(() => finishStream(code));
+          setImmediate(() => {
+            if (stdoutBuffer) {
+              processLine(stdoutBuffer);
+              stdoutBuffer = "";
+            }
+            finishStream(code);
+          });
         });
       },
       cancel: () => {
@@ -2140,7 +2282,7 @@ function createCodexExec(options = {}) {
       if (new.target) throw new Error("The Codex CLI provider function cannot be called with new.");
       return createModel(modelId, settings);
     },
-    { specificationVersion: "v3" }
+    { specificationVersion: "v4" }
   );
   provider.languageModel = createModel;
   provider.chat = createModel;
@@ -2335,6 +2477,14 @@ function mapTool(item) {
       dynamic: true
     };
   }
+  if (type === "dynamictoolcall") {
+    const tool2 = "tool" in item && typeof item.tool === "string" && item.tool ? item.tool : "tool";
+    const namespace = "namespace" in item && typeof item.namespace === "string" && item.namespace ? item.namespace : void 0;
+    return {
+      toolName: namespace ? `${namespace}__${tool2}` : tool2,
+      dynamic: true
+    };
+  }
   if (type === "websearch") {
     return { toolName: "web_search", dynamic: true };
   }
@@ -3409,6 +3559,34 @@ function isSdkMcpServer(value) {
 }
 
 // src/app-server/language-model.ts
+var CODEX_REASONING_EFFORTS = {
+  none: true,
+  minimal: true,
+  low: true,
+  medium: true,
+  high: true,
+  xhigh: true
+};
+function resolveReasoningEffort(args) {
+  if (args.providerEffort !== void 0) {
+    return { effort: args.providerEffort };
+  }
+  const { reasoning } = args;
+  if (reasoning === void 0 || reasoning === "provider-default") {
+    return { effort: args.defaultEffort };
+  }
+  if (Object.hasOwn(CODEX_REASONING_EFFORTS, reasoning)) {
+    return { effort: reasoning };
+  }
+  return {
+    effort: args.defaultEffort,
+    warning: {
+      type: "unsupported",
+      feature: "reasoning",
+      details: `Codex app-server does not support reasoning effort '${reasoning}'; it will be ignored.`
+    }
+  };
+}
 function isThreadNotFoundError2(error) {
   const message = String(error?.message ?? error);
   return /thread.*not found/i.test(message);
@@ -3470,12 +3648,9 @@ function mergeAppServerMcpServers(base, override) {
   return merged;
 }
 var AppServerLanguageModel = class {
-  specificationVersion = "v3";
+  specificationVersion = "v4";
   provider = "codex-app-server";
-  defaultObjectGenerationMode = "json";
-  supportsImageUrls = true;
   supportedUrls = {};
-  supportsStructuredOutputs = true;
   modelId;
   settings;
   client;
@@ -3484,6 +3659,7 @@ var AppServerLanguageModel = class {
   onSdkMcpServerReleased;
   persistentThreadId;
   persistentThreadRawEventsEnabled;
+  rawEventsByThreadId = /* @__PURE__ */ new Map();
   persistentSession;
   persistentBootstrapLock = Promise.resolve();
   constructor(options) {
@@ -3617,7 +3793,14 @@ var AppServerLanguageModel = class {
     return { input, tempImagePaths };
   }
   async startOrResumeThread(args) {
-    const { settings, providerOptions, configOverrides, developerInstructions, includeRawChunks } = args;
+    const {
+      settings,
+      providerOptions,
+      configOverrides,
+      developerInstructionsOverride,
+      systemInstruction,
+      includeRawChunks
+    } = args;
     const threadState = this.resolveTargetThreadId(settings, providerOptions);
     const startThread = async (ephemeral) => {
       const thread = await this.client.threadStart({
@@ -3627,7 +3810,7 @@ var AppServerLanguageModel = class {
         sandbox: mapSandboxToThreadSandboxMode(settings),
         config: configOverrides,
         baseInstructions: settings.baseInstructions,
-        developerInstructions,
+        developerInstructions: developerInstructionsOverride ?? systemInstruction,
         personality: settings.personality,
         ephemeral,
         experimentalRawEvents: includeRawChunks,
@@ -3646,16 +3829,18 @@ var AppServerLanguageModel = class {
             sandbox: mapSandboxToThreadSandboxMode(settings),
             config: configOverrides,
             baseInstructions: settings.baseInstructions,
-            developerInstructions,
+            developerInstructions: developerInstructionsOverride ?? systemInstruction,
             personality: settings.personality,
             persistExtendedHistory: settings.persistExtendedHistory ?? false
           });
-          const knownRawEvents = target.persistent && this.persistentThreadId === target.threadId ? this.persistentThreadRawEventsEnabled : void 0;
+          const cachedRawEvents = this.rawEventsByThreadId.get(target.threadId);
+          const knownRawEvents = cachedRawEvents ?? (target.persistent && this.persistentThreadId === target.threadId ? this.persistentThreadRawEventsEnabled : void 0);
+          if (cachedRawEvents !== void 0) {
+            this.rememberThreadRawEvents(target.threadId, cachedRawEvents);
+          }
           if (target.persistent) {
             this.persistentThreadId = target.threadId;
-            if (target.explicit) {
-              this.persistentThreadRawEventsEnabled = void 0;
-            }
+            this.persistentThreadRawEventsEnabled = knownRawEvents;
           }
           return {
             threadId: target.threadId,
@@ -3683,6 +3868,7 @@ var AppServerLanguageModel = class {
           });
         }
         const newThreadId = await startThread(false);
+        this.rememberThreadRawEvents(newThreadId, includeRawChunks);
         this.persistentThreadId = newThreadId;
         this.persistentThreadRawEventsEnabled = includeRawChunks;
         return {
@@ -3695,6 +3881,7 @@ var AppServerLanguageModel = class {
       }
       if (!threadState.threadId) {
         const newThreadId = await startThread(!threadState.persistent);
+        this.rememberThreadRawEvents(newThreadId, includeRawChunks);
         if (threadState.persistent) {
           this.persistentThreadId = newThreadId;
           this.persistentThreadRawEventsEnabled = includeRawChunks;
@@ -3736,12 +3923,26 @@ var AppServerLanguageModel = class {
       }
     }
   }
+  rememberThreadRawEvents(threadId, enabled) {
+    this.rawEventsByThreadId.delete(threadId);
+    this.rawEventsByThreadId.set(threadId, enabled);
+    if (this.rawEventsByThreadId.size <= 256) {
+      return;
+    }
+    const oldestThreadId = this.rawEventsByThreadId.keys().next().value;
+    if (typeof oldestThreadId === "string") {
+      this.rawEventsByThreadId.delete(oldestThreadId);
+    }
+  }
   clearPersistentThreadState(threadId) {
     if (threadId && this.persistentThreadId && this.persistentThreadId !== threadId) {
       return;
     }
     this.persistentThreadId = void 0;
     this.persistentThreadRawEventsEnabled = void 0;
+    if (threadId) {
+      this.rawEventsByThreadId.delete(threadId);
+    }
     if (!threadId || this.persistentSession?.threadId === threadId) {
       this.persistentSession = void 0;
     }
@@ -3962,7 +4163,13 @@ var AppServerLanguageModel = class {
       providerOptions: options.providerOptions,
       schema: appServerProviderOptionsSchema
     });
-    const settings = this.mergeSettings(providerOptions);
+    const mergedSettings = this.mergeSettings(providerOptions);
+    const resolvedReasoning = resolveReasoningEffort({
+      reasoning: options.reasoning,
+      providerEffort: providerOptions?.effort,
+      defaultEffort: mergedSettings.effort
+    });
+    const settings = resolvedReasoning.effort === mergedSettings.effort ? mergedSettings : { ...mergedSettings, effort: resolvedReasoning.effort };
     const sdkServerLifecycle = this.resolveThreadMode(settings, providerOptions) === "persistent" ? "provider" : "request";
     const includeRawChunks = this.resolveIncludeRawChunks(
       options.includeRawChunks,
@@ -3983,11 +4190,11 @@ var AppServerLanguageModel = class {
         toolChoice: options.toolChoice
       })
     ];
+    if (resolvedReasoning.warning) {
+      warnings.push(resolvedReasoning.warning);
+    }
     const developerInstructionsOverride = providerOptions?.developerInstructions ?? settings.developerInstructions;
-    const threadState = this.resolveTargetThreadId(settings, providerOptions);
-    const prompt = this.preparePrompt(options.prompt, Boolean(threadState.threadId));
-    warnings.push(...prompt.warnings);
-    const effectiveDeveloperInstructions = developerInstructionsOverride ?? (!threadState.threadId ? prompt.systemInstruction : void 0);
+    const systemInstruction = collectSystemInstruction(options.prompt);
     const resolvedConfig = await this.resolveConfig(settings, sdkServerLifecycle);
     let releasedSdkServers = false;
     const releaseUsedSdkMcpServers = () => {
@@ -4005,7 +4212,8 @@ var AppServerLanguageModel = class {
         settings,
         providerOptions,
         configOverrides: resolvedConfig.configOverrides,
-        developerInstructions: effectiveDeveloperInstructions,
+        developerInstructionsOverride,
+        systemInstruction,
         includeRawChunks
       });
     } catch (error) {
@@ -4019,6 +4227,8 @@ var AppServerLanguageModel = class {
         message: "includeRawChunks was requested while resuming an existing thread that may not emit raw events. Start a new thread to guarantee raw chunk events."
       });
     }
+    const prompt = this.preparePrompt(options.prompt, threadResolution.resumed);
+    warnings.push(...prompt.warnings);
     let input = [];
     let tempImagePaths = [];
     let session;
@@ -4059,7 +4269,7 @@ var AppServerLanguageModel = class {
       session,
       abortSignal: options.abortSignal,
       shouldSerializeTurnStart: threadResolution.persistent || threadResolution.explicit,
-      hadInitialThreadId: Boolean(threadState.threadId),
+      hadInitialThreadId: threadResolution.resumed,
       threadResolution: {
         persistent: threadResolution.persistent,
         explicit: threadResolution.explicit
@@ -4229,7 +4439,46 @@ var contextCompactionItemSchema = z.object({
   type: z.literal("contextCompaction"),
   id: z.string()
 }).passthrough();
-var threadItemSchema = z.discriminatedUnion("type", [
+var hookPromptItemSchema = z.object({
+  type: z.literal("hookPrompt"),
+  id: z.string(),
+  fragments: z.array(z.unknown())
+}).passthrough();
+var dynamicToolCallItemSchema = z.object({
+  type: z.literal("dynamicToolCall"),
+  id: z.string(),
+  namespace: z.string().nullable(),
+  tool: z.string(),
+  arguments: z.unknown(),
+  status: z.string(),
+  contentItems: z.array(z.unknown()).nullable(),
+  success: z.boolean().nullable(),
+  durationMs: z.number().nullable()
+}).passthrough();
+var subAgentActivityItemSchema = z.object({
+  type: z.literal("subAgentActivity"),
+  id: z.string(),
+  kind: z.string(),
+  agentThreadId: z.string(),
+  agentPath: z.string()
+}).passthrough();
+var sleepItemSchema = z.object({
+  type: z.literal("sleep"),
+  id: z.string(),
+  durationMs: z.number()
+}).passthrough();
+var imageGenerationItemSchema = z.object({
+  type: z.literal("imageGeneration"),
+  id: z.string(),
+  status: z.string(),
+  revisedPrompt: z.string().nullable(),
+  result: z.string(),
+  savedPath: z.string().optional()
+}).passthrough();
+var unknownThreadItemSchema = z.object({
+  type: z.string()
+}).passthrough();
+var knownThreadItemSchema = z.discriminatedUnion("type", [
   userMessageItemSchema,
   agentMessageItemSchema,
   planItemSchema,
@@ -4237,13 +4486,19 @@ var threadItemSchema = z.discriminatedUnion("type", [
   commandExecutionItemSchema,
   fileChangeItemSchema,
   mcpToolCallItemSchema,
+  dynamicToolCallItemSchema,
   collabAgentToolCallItemSchema,
+  hookPromptItemSchema,
+  subAgentActivityItemSchema,
+  sleepItemSchema,
+  imageGenerationItemSchema,
   webSearchItemSchema,
   imageViewItemSchema,
   enteredReviewModeItemSchema,
   exitedReviewModeItemSchema,
   contextCompactionItemSchema
 ]);
+var threadItemSchema = knownThreadItemSchema.or(unknownThreadItemSchema);
 var codexHttpStatusCodeSchema = z.object({
   httpStatusCode: z.number().nullable()
 }).passthrough();
@@ -4252,6 +4507,7 @@ var codexErrorInfoSchema = z.union([
     "contextWindowExceeded",
     "usageLimitExceeded",
     "serverOverloaded",
+    "cyberPolicy",
     "internalServerError",
     "unauthorized",
     "badRequest",
@@ -4262,17 +4518,23 @@ var codexErrorInfoSchema = z.union([
   z.object({ httpConnectionFailed: codexHttpStatusCodeSchema }).passthrough(),
   z.object({ responseStreamConnectionFailed: codexHttpStatusCodeSchema }).passthrough(),
   z.object({ responseStreamDisconnected: codexHttpStatusCodeSchema }).passthrough(),
-  z.object({ responseTooManyFailedAttempts: codexHttpStatusCodeSchema }).passthrough()
+  z.object({ responseTooManyFailedAttempts: codexHttpStatusCodeSchema }).passthrough(),
+  z.object({ activeTurnNotSteerable: z.object({ turnKind: z.string() }).passthrough() }).passthrough(),
+  // Forward-compat catch-alls: consumers only compare against the known string
+  // codes above (unknown codes fall back to the generic error path), so a new
+  // errorInfo variant must never fail validation and drop the notification.
+  z.string(),
+  z.record(z.string(), z.unknown())
 ]);
 var turnSchema = z.object({
   id: z.string(),
   items: z.array(threadItemSchema),
-  status: z.enum(["completed", "interrupted", "failed", "inProgress"]),
+  status: z.string(),
   error: z.object({
     message: z.string(),
-    codexErrorInfo: codexErrorInfoSchema.nullable(),
-    additionalDetails: z.string().nullable()
-  }).nullable()
+    codexErrorInfo: codexErrorInfoSchema.nullish(),
+    additionalDetails: z.string().nullish()
+  }).nullish()
 }).passthrough();
 var threadStartedNotificationSchema = z.object({
   thread: z.object({ id: z.string() }).passthrough()
@@ -4659,7 +4921,7 @@ var AppServerRpcClient = class extends EventEmitter {
     if (this.serverCapabilities?.modelList === false) {
       throw new UnsupportedFeatureError({
         feature: "model/list",
-        minCodexVersion: this.settings.minCodexVersion ?? "0.144.0",
+        minCodexVersion: this.settings.minCodexVersion ?? "0.142.5",
         serverVersion: this.serverVersion
       });
     }
@@ -4672,7 +4934,7 @@ var AppServerRpcClient = class extends EventEmitter {
       if (error instanceof JsonRpcRequestError && error.code === -32601) {
         throw new UnsupportedFeatureError({
           feature: "model/list",
-          minCodexVersion: this.settings.minCodexVersion ?? "0.144.0",
+          minCodexVersion: this.settings.minCodexVersion ?? "0.142.5",
           serverVersion: this.serverVersion
         });
       }
@@ -4829,7 +5091,7 @@ var AppServerRpcClient = class extends EventEmitter {
       const message = String(error?.message ?? error);
       if (message.includes("ENOENT") || message.includes("unknown subcommand")) {
         throw new Error(
-          "codex app-server requires codex CLI >= 0.144.0. Run 'codex --version' to check."
+          "codex app-server requires codex CLI >= 0.142.5. Run 'codex --version' to check."
         );
       }
       throw createAPICallError({
@@ -4851,7 +5113,7 @@ var AppServerRpcClient = class extends EventEmitter {
       return;
     }
     this.serverVersion = detected;
-    const minVersion = this.settings.minCodexVersion ?? "0.144.0";
+    const minVersion = this.settings.minCodexVersion ?? "0.142.5";
     const compared = compareSemver(detected, minVersion);
     if (compared === void 0) {
       this.logger.warn(
@@ -5587,7 +5849,7 @@ function createCodexAppServer(options = {}) {
       }
       return createModel(modelId, settings);
     },
-    { specificationVersion: "v3" }
+    { specificationVersion: "v4" }
   );
   provider.languageModel = createModel;
   provider.chat = createModel;