@janole/ai-sdk-provider-codex-asp 0.2.3 → 0.3.0

package/README.md

@@ -147,6 +147,7 @@ See [`src/provider.ts`](src/provider.ts) for full type definitions.
 See the [`examples/`](examples/) directory:
 
 - [`generate-text.ts`](examples/generate-text.ts) — Non-streaming text generation
+- [`generate-object.ts`](examples/generate-object.ts) — Structured output with `generateText` + `Output.object`
 - [`stream-text.ts`](examples/stream-text.ts) — Streaming text generation
 - [`cross-call-tools.ts`](examples/cross-call-tools.ts) — Standard AI SDK tools via Codex
 - [`dynamic-tools.ts`](examples/dynamic-tools.ts) — Provider-level dynamic tools

package/dist/index.cjs

@@ -1,6 +1,11 @@
 'use strict';
 
 var child_process = require('child_process');
+var crypto = require('crypto');
+var promises = require('fs/promises');
+var os = require('os');
+var path = require('path');
+var url = require('url');
 var provider = require('@ai-sdk/provider');
 
 // src/utils/object.ts
@@ -930,7 +935,7 @@ var DynamicToolsDispatcher = class {
 // package.json
 var package_default = {
   name: "@janole/ai-sdk-provider-codex-asp",
-  version: "0.2.3"};
+  version: "0.3.0"};
 
 // src/package-info.ts
 var PACKAGE_NAME = package_default.name;
@@ -938,14 +943,14 @@ var PACKAGE_VERSION = package_default.version;
 
 // src/protocol/provider-metadata.ts
 var CODEX_PROVIDER_ID = "@janole/ai-sdk-provider-codex-asp";
-function codexProviderMetadata(threadId) {
+function codexProviderMetadata(threadId, turnId) {
   if (!threadId) {
     return void 0;
   }
-  return { [CODEX_PROVIDER_ID]: { threadId } };
+  return { [CODEX_PROVIDER_ID]: stripUndefined({ threadId, turnId }) };
 }
-function withProviderMetadata(part, threadId) {
-  const meta = codexProviderMetadata(threadId);
+function withProviderMetadata(part, threadId, turnId) {
+  const meta = codexProviderMetadata(threadId, turnId);
   return meta ? { ...part, providerMetadata: meta } : part;
 }
 
@@ -984,6 +989,7 @@ var CodexEventMapper = class {
   openToolCalls = /* @__PURE__ */ new Map();
   planSequenceByTurnId = /* @__PURE__ */ new Map();
   threadId;
+  turnId;
   latestUsage;
   constructor(options) {
     this.options = {
@@ -993,6 +999,12 @@ var CodexEventMapper = class {
   setThreadId(threadId) {
     this.threadId = threadId;
   }
+  setTurnId(turnId) {
+    this.turnId = turnId;
+  }
+  getTurnId() {
+    return this.turnId;
+  }
   nextPlanSequence(turnId) {
     const next = (this.planSequenceByTurnId.get(turnId) ?? 0) + 1;
     this.planSequenceByTurnId.set(turnId, next);
@@ -1000,7 +1012,7 @@ var CodexEventMapper = class {
   }
   map(event) {
     const parts = [];
-    const withMeta = (part) => withProviderMetadata(part, this.threadId);
+    const withMeta = (part) => withProviderMetadata(part, this.threadId, this.turnId);
     const pushStreamStart = () => {
       if (!this.streamStarted) {
         parts.push({ type: "stream-start", warnings: [] });
@@ -1020,6 +1032,10 @@ var CodexEventMapper = class {
     };
     switch (event.method) {
       case "turn/started": {
+        const turnStartedParams = event.params;
+        if (turnStartedParams?.turn?.id) {
+          this.turnId = turnStartedParams.turn.id;
+        }
         pushStreamStart();
         break;
       }
@@ -1318,7 +1334,74 @@ var CodexEventMapper = class {
   }
 };
 
-// src/protocol/prompt-mapper.ts
+// src/session.ts
+var CodexSessionImpl = class {
+  _threadId;
+  _turnId;
+  _active = true;
+  client;
+  interruptTimeoutMs;
+  constructor(opts) {
+    this.client = opts.client;
+    this._threadId = opts.threadId;
+    this._turnId = opts.turnId;
+    this.interruptTimeoutMs = opts.interruptTimeoutMs;
+  }
+  get threadId() {
+    return this._threadId;
+  }
+  get turnId() {
+    return this._turnId;
+  }
+  /** @internal Called by the model when turn/started arrives with a turnId. */
+  setTurnId(turnId) {
+    this._turnId = turnId;
+  }
+  /** @internal Called by the model when the turn completes or the stream closes. */
+  markInactive() {
+    this._active = false;
+  }
+  isActive() {
+    return this._active;
+  }
+  /**
+   * Inject follow-up input into the current thread.
+   *
+   * Uses turn/start which the app-server routes through steer_input when a
+   * turn is already active, or starts a new turn otherwise. This avoids the
+   * strict timing requirements of turn/steer (which needs codex/event/task_started
+   * before it accepts input). We may revisit turn/steer in the future.
+   */
+  async injectMessage(input) {
+    if (!this._active) {
+      throw new Error("Session is no longer active.");
+    }
+    const userInput = typeof input === "string" ? [{ type: "text", text: input, text_elements: [] }] : input;
+    const turnStartParams = {
+      threadId: this._threadId,
+      input: userInput
+    };
+    const result = await this.client.request("turn/start", turnStartParams);
+    const newTurnId = result.turnId ?? result.turn?.id;
+    if (newTurnId) {
+      this._turnId = newTurnId;
+    }
+  }
+  async interrupt() {
+    if (!this._active || !this._turnId) {
+      return;
+    }
+    const interruptParams = {
+      threadId: this._threadId,
+      turnId: this._turnId
+    };
+    await this.client.request(
+      "turn/interrupt",
+      interruptParams,
+      this.interruptTimeoutMs
+    );
+  }
+};
 function mapSystemPrompt(prompt) {
   const chunks = [];
   for (const message of prompt) {
@@ -1331,8 +1414,111 @@ function mapSystemPrompt(prompt) {
   }
   return chunks.length > 0 ? chunks.join("\n\n") : void 0;
 }
-function mapPromptToTurnInput(prompt, isResume = false) {
-  if (isResume) {
+function textItem(text) {
+  return { type: "text", text, text_elements: [] };
+}
+var MEDIA_TYPE_TO_EXT = {
+  "image/png": ".png",
+  "image/jpeg": ".jpg",
+  "image/gif": ".gif",
+  "image/webp": ".webp",
+  "image/svg+xml": ".svg",
+  "image/bmp": ".bmp",
+  "image/tiff": ".tiff"
+};
+function extensionForMediaType(mediaType) {
+  return MEDIA_TYPE_TO_EXT[mediaType] ?? ".bin";
+}
+var LocalFileWriter = class {
+  async write(data, mediaType) {
+    const ext = extensionForMediaType(mediaType);
+    const filename = `codex-ai-sdk-${crypto.randomUUID()}${ext}`;
+    const filepath = path.join(os.tmpdir(), filename);
+    const buffer = typeof data === "string" ? Buffer.from(data, "base64") : data;
+    await promises.writeFile(filepath, buffer);
+    return url.pathToFileURL(filepath);
+  }
+  async cleanup(urls) {
+    await Promise.allSettled(
+      urls.filter((u) => u.protocol === "file:").map((u) => promises.unlink(u))
+    );
+  }
+};
+var PromptFileResolver = class {
+  writer;
+  written = [];
+  constructor(writer) {
+    this.writer = writer ?? new LocalFileWriter();
+  }
+  /**
+   * Resolve inline file data and map user content to Codex input items.
+   *
+   * - Inline image data (base64 / Uint8Array) is written via the
+   *   {@link FileWriter} and converted to `localImage` or `image` items.
+   * - URL-based image file parts are converted directly.
+   * - Inline text file data is decoded and inlined as text.
+   * - Unsupported media types are silently skipped.
+   *
+   * @param isResume - When true only the last user message is extracted.
+   *   When false (fresh thread) all user text is accumulated with images
+   *   flushing the text buffer to preserve ordering.
+   */
+  async resolve(prompt, isResume = false) {
+    if (isResume) {
+      return this.resolveResumed(prompt);
+    }
+    return this.resolveFresh(prompt);
+  }
+  /**
+   * Remove all files created by previous {@link resolve} calls.
+   * Best-effort — never throws.
+   */
+  async cleanup() {
+    const urls = this.written.splice(0);
+    if (urls.length > 0) {
+      await this.writer.cleanup(urls);
+    }
+  }
+  /**
+   * Convert a resolved image URL to a Codex input item.
+   */
+  mapImageUrl(mediaType, data) {
+    if (!mediaType.startsWith("image/")) {
+      return null;
+    }
+    if (data.protocol === "file:") {
+      return { type: "localImage", path: url.fileURLToPath(data) };
+    }
+    return { type: "image", url: data.href };
+  }
+  /**
+   * Resolve a single file part: write inline data via the writer, then
+   * convert to a Codex input item.  Text files are decoded and returned
+   * as text items.  Returns `null` for unsupported media types.
+   */
+  async resolveFilePart(part) {
+    const { mediaType, data } = part;
+    if (mediaType.startsWith("text/")) {
+      if (data instanceof URL) {
+        return textItem(data.href);
+      }
+      const text = typeof data === "string" ? Buffer.from(data, "base64").toString("utf-8") : new TextDecoder().decode(data);
+      return textItem(text);
+    }
+    if (mediaType.startsWith("image/") && !(data instanceof URL)) {
+      const url = await this.writer.write(data, mediaType);
+      this.written.push(url);
+      return this.mapImageUrl(mediaType, url);
+    }
+    if (data instanceof URL) {
+      return this.mapImageUrl(mediaType, data);
+    }
+    return null;
+  }
+  /**
+   * Resume path: extract parts from the last user message individually.
+   */
+  async resolveResumed(prompt) {
     for (let i = prompt.length - 1; i >= 0; i--) {
       const message = prompt[i];
       if (message?.role === "user") {
@@ -1341,7 +1527,12 @@ function mapPromptToTurnInput(prompt, isResume = false) {
           if (part.type === "text") {
             const text = part.text.trim();
             if (text.length > 0) {
-              items.push({ type: "text", text, text_elements: [] });
+              items.push(textItem(text));
+            }
+          } else if (part.type === "file") {
+            const mapped = await this.resolveFilePart(part);
+            if (mapped) {
+              items.push(mapped);
             }
           }
         }
@@ -1350,21 +1541,45 @@ function mapPromptToTurnInput(prompt, isResume = false) {
     }
     return [];
   }
-  const chunks = [];
-  for (const message of prompt) {
-    if (message.role === "user") {
-      for (const part of message.content) {
-        if (part.type === "text") {
-          const text = part.text.trim();
-          if (text.length > 0) {
-            chunks.push(text);
+  /**
+   * Fresh thread path: accumulate text chunks across all user messages,
+   * flushing before each image to preserve ordering.
+   */
+  async resolveFresh(prompt) {
+    const items = [];
+    const textChunks = [];
+    const flushText = () => {
+      if (textChunks.length > 0) {
+        items.push(textItem(textChunks.join("\n\n")));
+        textChunks.length = 0;
+      }
+    };
+    for (const message of prompt) {
+      if (message.role === "user") {
+        for (const part of message.content) {
+          if (part.type === "text") {
+            const text = part.text.trim();
+            if (text.length > 0) {
+              textChunks.push(text);
+            }
+          } else if (part.type === "file") {
+            const mapped = await this.resolveFilePart(part);
+            if (mapped) {
+              if (mapped.type === "text") {
+                textChunks.push(mapped.text);
+              } else {
+                flushText();
+                items.push(mapped);
+              }
+            }
           }
         }
       }
     }
+    flushText();
+    return items;
   }
-  return [{ type: "text", text: chunks.join("\n\n"), text_elements: [] }];
-}
+};
 
 // src/model.ts
 function createEmptyUsage() {
@@ -1619,6 +1834,7 @@ var CodexLanguageModel = class {
     }));
     let activeThreadId;
     let activeTurnId;
+    let session;
     const interruptTimeoutMs = this.config.providerSettings.interruptTimeoutMs ?? 1e4;
     const interruptTurnIfPossible = async () => {
       if (!activeThreadId || !activeTurnId) {
@@ -1631,6 +1847,7 @@ var CodexLanguageModel = class {
       debugLog?.("outbound", "turn/interrupt", interruptParams);
       await client.request("turn/interrupt", interruptParams, interruptTimeoutMs);
     };
+    const fileResolver = new PromptFileResolver();
     const stream = new ReadableStream({
       start: (controller) => {
         let closed = false;
@@ -1638,11 +1855,13 @@ var CodexLanguageModel = class {
           if (closed) {
             return;
           }
+          session?.markInactive();
           controller.enqueue({ type: "error", error });
           closed = true;
           try {
             controller.close();
           } finally {
+            await fileResolver.cleanup();
             await client.disconnect();
           }
         };
@@ -1650,10 +1869,12 @@ var CodexLanguageModel = class {
           if (closed) {
             return;
           }
+          session?.markInactive();
           closed = true;
           try {
             controller.close();
           } finally {
+            await fileResolver.cleanup();
             await client.disconnect();
           }
         };
@@ -1755,6 +1976,11 @@ var CodexLanguageModel = class {
             approvalsDispatcher.attach(client);
             client.onAnyNotification((method, params) => {
               const parts = mapper.map({ method, params });
+              const mappedTurnId = mapper.getTurnId();
+              if (mappedTurnId && mappedTurnId !== activeTurnId) {
+                activeTurnId = mappedTurnId;
+                session?.setTurnId(mappedTurnId);
+              }
               for (const part of parts) {
                 controller.enqueue(part);
                 if (part.type === "finish") {
@@ -1852,10 +2078,13 @@ var CodexLanguageModel = class {
                 }
               }
             } else {
+              const mcpServers = this.config.providerSettings.mcpServers;
+              const config = mcpServers ? { mcp_servers: mcpServers } : void 0;
               const threadStartParams = stripUndefined({
                 model: this.config.providerSettings.defaultModel ?? this.modelId,
                 dynamicTools,
                 developerInstructions,
+                config,
                 cwd: this.config.providerSettings.defaultThreadSettings?.cwd,
                 approvalPolicy: this.config.providerSettings.defaultThreadSettings?.approvalPolicy,
                 sandbox: this.config.providerSettings.defaultThreadSettings?.sandbox
@@ -1878,7 +2107,7 @@ var CodexLanguageModel = class {
                 closeSuccessfully
               );
             }
-            const turnInput = mapPromptToTurnInput(options.prompt, !!resumeThreadId);
+            const turnInput = await fileResolver.resolve(options.prompt, !!resumeThreadId);
             const turnStartParams = stripUndefined({
               threadId,
               input: turnInput,
@@ -1887,21 +2116,31 @@ var CodexLanguageModel = class {
               sandboxPolicy: this.config.providerSettings.defaultTurnSettings?.sandboxPolicy,
               model: this.config.providerSettings.defaultTurnSettings?.model,
               effort: this.config.providerSettings.defaultTurnSettings?.effort,
-              summary: this.config.providerSettings.defaultTurnSettings?.summary
+              summary: this.config.providerSettings.defaultTurnSettings?.summary,
+              outputSchema: options.responseFormat?.type === "json" ? options.responseFormat.schema : void 0
             });
             debugLog?.("outbound", "turn/start", turnStartParams);
             const turnStartResult = await client.request("turn/start", turnStartParams);
             activeTurnId = extractTurnId(turnStartResult);
+            session = new CodexSessionImpl({
+              client,
+              threadId: activeThreadId,
+              turnId: activeTurnId,
+              interruptTimeoutMs
+            });
+            this.config.providerSettings.onSessionCreated?.(session);
           } catch (error) {
             await closeWithError(error);
           }
         })();
       },
       cancel: async () => {
+        session?.markInactive();
         try {
           await interruptTurnIfPossible();
         } catch {
         }
+        await fileResolver.cleanup();
         await client.disconnect();
       }
     });
@@ -2031,12 +2270,15 @@ function createCodexAppServer(settings = {}) {
     defaultTurnSettings: settings.defaultTurnSettings ? { ...settings.defaultTurnSettings } : void 0,
     compaction: settings.compaction ? { ...settings.compaction } : void 0,
     transportFactory: effectiveTransportFactory,
+    mcpServers: settings.mcpServers ? { ...settings.mcpServers } : void 0,
     tools: settings.tools ? { ...settings.tools } : void 0,
     toolHandlers: settings.toolHandlers ? { ...settings.toolHandlers } : void 0,
     toolTimeoutMs: settings.toolTimeoutMs,
     interruptTimeoutMs: settings.interruptTimeoutMs,
     approvals: settings.approvals ? { ...settings.approvals } : void 0,
-    debug: settings.debug ? { ...settings.debug } : void 0
+    debug: settings.debug ? { ...settings.debug } : void 0,
+    emitPlanUpdates: settings.emitPlanUpdates,
+    onSessionCreated: settings.onSessionCreated
   }));
   const createLanguageModel = (modelId, modelSettings = {}) => new CodexLanguageModel(modelId, modelSettings, {
     provider: CODEX_PROVIDER_ID,
@@ -2058,6 +2300,31 @@ function createCodexAppServer(settings = {}) {
     imageModel(modelId) {
       throw createNoSuchModelError(modelId, "imageModel");
     },
+    async listModels(params) {
+      const transport = effectiveTransportFactory ? effectiveTransportFactory() : resolvedSettings.transport?.type === "websocket" ? new WebSocketTransport(resolvedSettings.transport.websocket) : new StdioTransport(resolvedSettings.transport?.stdio);
+      const client = new AppServerClient(transport);
+      try {
+        await client.connect();
+        const initializeParams = stripUndefined({
+          clientInfo: resolvedSettings.clientInfo ?? {
+            name: PACKAGE_NAME,
+            version: PACKAGE_VERSION
+          }
+        });
+        await client.request("initialize", initializeParams);
+        await client.notification("initialized");
+        const models = [];
+        let cursor;
+        do {
+          const response = await client.request("model/list", stripUndefined({ ...params, cursor }));
+          models.push(...response.data);
+          cursor = response.nextCursor ?? void 0;
+        } while (cursor);
+        return models;
+      } finally {
+        await client.disconnect();
+      }
+    },
     async shutdown() {
       if (!persistentPoolHandle) {
         return;
@@ -2083,16 +2350,17 @@ exports.CodexWorker = CodexWorker;
 exports.CodexWorkerPool = CodexWorkerPool;
 exports.DynamicToolsDispatcher = DynamicToolsDispatcher;
 exports.JsonRpcError = JsonRpcError;
+exports.LocalFileWriter = LocalFileWriter;
 exports.PACKAGE_NAME = PACKAGE_NAME;
 exports.PACKAGE_VERSION = PACKAGE_VERSION;
 exports.PersistentTransport = PersistentTransport;
+exports.PromptFileResolver = PromptFileResolver;
 exports.StdioTransport = StdioTransport;
 exports.WebSocketTransport = WebSocketTransport;
 exports.codexAppServer = codexAppServer;
 exports.codexProviderMetadata = codexProviderMetadata;
 exports.createCodexAppServer = createCodexAppServer;
 exports.createCodexProvider = createCodexProvider;
-exports.mapPromptToTurnInput = mapPromptToTurnInput;
 exports.mapSystemPrompt = mapSystemPrompt;
 exports.withProviderMetadata = withProviderMetadata;
 //# sourceMappingURL=index.cjs.map