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

package/README.md

@@ -2,7 +2,7 @@
 
 `@janole/ai-sdk-provider-codex-asp` is a [Vercel AI SDK](https://ai-sdk.dev/) v6 custom provider for the Codex App Server Protocol.
 
-Status: POC feature-complete for language model usage. Currently tested with [codex-cli](https://github.com/openai/codex/releases/tag/rust-v0.105.0) 0.105.0.
+Status: POC feature-complete for language model usage. Currently tested with [codex-cli](https://github.com/openai/codex/releases/tag/rust-v0.106.0) 0.106.0.
 
 - `LanguageModelV3` provider implementation
 - Streaming (`streamText`) and non-streaming (`generateText`)

package/dist/index.cjs

@@ -274,6 +274,7 @@ var AppServerClient = class {
 // src/client/transport-persistent.ts
 var PersistentTransport = class {
   pool;
+  signal;
   worker = null;
   pendingInitializeId = null;
   initializeIntercepted = false;
@@ -282,9 +283,10 @@ var PersistentTransport = class {
   closeListeners = /* @__PURE__ */ new Set();
   constructor(settings) {
     this.pool = settings.pool;
+    this.signal = settings.signal;
   }
   async connect() {
-    this.worker = this.pool.acquire();
+    this.worker = await this.pool.acquire(stripUndefined({ signal: this.signal }));
     await this.worker.ensureConnected();
   }
   disconnect() {
@@ -724,6 +726,7 @@ var CodexWorker = class {
 var CodexWorkerPool = class {
   workers;
   shutdownCalled = false;
+  waiters = [];
   constructor(settings) {
     const size = settings.poolSize ?? 1;
     const idleTimeoutMs = settings.idleTimeoutMs ?? 3e5;
@@ -735,7 +738,7 @@ var CodexWorkerPool = class {
       })
     );
   }
-  acquire() {
+  async acquire(options) {
     if (this.shutdownCalled) {
       throw new CodexProviderError("Worker pool has been shut down.");
     }
@@ -743,20 +746,61 @@ var CodexWorkerPool = class {
       (w) => w.state === "idle" || w.state === "disconnected"
     );
     if (!worker) {
-      throw new CodexProviderError(
-        "All workers are busy. Try again later or increase poolSize."
-      );
+      if (options?.signal?.aborted) {
+        throw new CodexProviderError("Worker acquisition aborted while waiting.");
+      }
+      return new Promise((resolve, reject) => {
+        const waiter = {
+          resolve,
+          reject,
+          signal: options?.signal,
+          abortHandler: void 0
+        };
+        if (waiter.signal) {
+          waiter.abortHandler = () => {
+            this.removeWaiter(waiter);
+            waiter.reject(new CodexProviderError("Worker acquisition aborted while waiting."));
+          };
+          waiter.signal.addEventListener("abort", waiter.abortHandler, { once: true });
+        }
+        this.waiters.push(waiter);
+      });
     }
     worker.acquire();
     return worker;
   }
   release(worker) {
-    worker.release();
+    const waiter = this.waiters.shift();
+    if (waiter) {
+      this.clearWaiterAbortHandler(waiter);
+      waiter.resolve(worker);
+    } else {
+      worker.release();
+    }
   }
   async shutdown() {
     this.shutdownCalled = true;
+    while (this.waiters.length > 0) {
+      const waiter = this.waiters.shift();
+      this.clearWaiterAbortHandler(waiter);
+      waiter.reject(new CodexProviderError("Worker pool has been shut down."));
+    }
     await Promise.all(this.workers.map((w) => w.shutdown()));
   }
+  removeWaiter(target) {
+    const index = this.waiters.indexOf(target);
+    if (index >= 0) {
+      this.waiters.splice(index, 1);
+    }
+  }
+  /** Remove the abort listener so it doesn't fire after the waiter is already served. */
+  clearWaiterAbortHandler(waiter) {
+    if (!waiter.signal || !waiter.abortHandler) {
+      return;
+    }
+    waiter.signal.removeEventListener("abort", waiter.abortHandler);
+    waiter.abortHandler = void 0;
+  }
 };
 
 // src/dynamic-tools.ts
@@ -886,7 +930,7 @@ var DynamicToolsDispatcher = class {
 // package.json
 var package_default = {
   name: "@janole/ai-sdk-provider-codex-asp",
-  version: "0.2.1"};
+  version: "0.2.3"};
 
 // src/package-info.ts
 var PACKAGE_NAME = package_default.name;
@@ -932,15 +976,28 @@ function toFinishReason(status) {
   }
 }
 var CodexEventMapper = class {
+  options;
   streamStarted = false;
   openTextParts = /* @__PURE__ */ new Set();
+  textDeltaReceived = /* @__PURE__ */ new Set();
   openReasoningParts = /* @__PURE__ */ new Set();
   openToolCalls = /* @__PURE__ */ new Map();
+  planSequenceByTurnId = /* @__PURE__ */ new Map();
   threadId;
   latestUsage;
+  constructor(options) {
+    this.options = {
+      emitPlanUpdates: options?.emitPlanUpdates ?? true
+    };
+  }
   setThreadId(threadId) {
     this.threadId = threadId;
   }
+  nextPlanSequence(turnId) {
+    const next = (this.planSequenceByTurnId.get(turnId) ?? 0) + 1;
+    this.planSequenceByTurnId.set(turnId, next);
+    return next;
+  }
   map(event) {
     const parts = [];
     const withMeta = (part) => withProviderMetadata(part, this.threadId);
@@ -1020,6 +1077,7 @@ var CodexEventMapper = class {
           parts.push(withMeta({ type: "text-start", id: delta.itemId }));
         }
         parts.push(withMeta({ type: "text-delta", id: delta.itemId, delta: delta.delta }));
+        this.textDeltaReceived.add(delta.itemId);
         break;
       }
       case "item/completed": {
@@ -1028,9 +1086,19 @@ var CodexEventMapper = class {
         if (!item?.id) {
           break;
         }
-        if (item.type === "agentMessage" && this.openTextParts.has(item.id)) {
-          parts.push(withMeta({ type: "text-end", id: item.id }));
-          this.openTextParts.delete(item.id);
+        if (item.type === "agentMessage") {
+          if (!this.textDeltaReceived.has(item.id) && item.text) {
+            pushStreamStart();
+            if (!this.openTextParts.has(item.id)) {
+              this.openTextParts.add(item.id);
+              parts.push(withMeta({ type: "text-start", id: item.id }));
+            }
+            parts.push(withMeta({ type: "text-delta", id: item.id, delta: item.text }));
+          }
+          if (this.openTextParts.has(item.id)) {
+            parts.push(withMeta({ type: "text-end", id: item.id }));
+            this.openTextParts.delete(item.id);
+          }
         } else if (item.type === "commandExecution" && this.openToolCalls.has(item.id)) {
           const tracked = this.openToolCalls.get(item.id);
           const output = item.aggregatedOutput ?? tracked.output;
@@ -1059,6 +1127,64 @@ var CodexEventMapper = class {
         }
         break;
       }
+      case "item/reasoning/summaryPartAdded": {
+        const params = event.params ?? {};
+        if (params.itemId) {
+          pushReasoningDelta(params.itemId, "\n\n");
+        }
+        break;
+      }
+      // codex/event/agent_reasoning mirrors canonical reasoning summary
+      // stream events in current logs. Ignore wrapper to avoid duplicate
+      // reasoning text in consumers.
+      case "codex/event/agent_reasoning":
+        break;
+      // codex/event/agent_reasoning_section_break is the wrapper form of
+      // item/reasoning/summaryPartAdded (identical 1:1). Handled by the
+      // canonical event above — skip the wrapper to avoid double "\n\n".
+      case "codex/event/agent_reasoning_section_break":
+        break;
+      case "turn/plan/updated": {
+        if (!this.options.emitPlanUpdates) {
+          break;
+        }
+        const params = event.params ?? {};
+        const turnId = params.turnId;
+        const plan = params.plan;
+        if (turnId && plan) {
+          pushStreamStart();
+          const planSequence = this.nextPlanSequence(turnId);
+          const toolCallId = `plan:${turnId}:${planSequence}`;
+          const toolName = "codex_plan_update";
+          parts.push(withMeta({
+            type: "tool-call",
+            toolCallId,
+            toolName,
+            input: JSON.stringify({}),
+            providerExecuted: true,
+            dynamic: true
+          }));
+          parts.push(withMeta({
+            type: "tool-result",
+            toolCallId,
+            toolName,
+            result: { plan, explanation: params.explanation ?? void 0 }
+          }));
+        }
+        break;
+      }
+      // codex/event/plan_update is the wrapper form of turn/plan/updated (1:1).
+      case "codex/event/plan_update":
+        break;
+      // NOTE: turn/diff/updated and codex/event/turn_diff are intentionally
+      // NOT mapped. They carry full unified diffs (often 50-100 KB) which,
+      // when emitted as reasoning deltas, crash or freeze the frontend
+      // markdown renderer. If these need to surface in the UI, they should
+      // use a dedicated part type with lazy/collapsed rendering — not
+      // reasoning text.
+      case "turn/diff/updated":
+      case "codex/event/turn_diff":
+        break;
       case "item/commandExecution/outputDelta": {
         const delta = event.params ?? {};
         if (delta.itemId && delta.delta && this.openToolCalls.has(delta.itemId)) {
@@ -1074,6 +1200,43 @@ var CodexEventMapper = class {
         }
         break;
       }
+      case "codex/event/mcp_tool_call_begin": {
+        const params = event.params ?? {};
+        const callId = params.msg?.call_id;
+        const inv = params.msg?.invocation;
+        if (callId && inv) {
+          pushStreamStart();
+          const toolName = `mcp:${inv.server}/${inv.tool}`;
+          this.openToolCalls.set(callId, { toolName, output: "" });
+          parts.push(withMeta({
+            type: "tool-call",
+            toolCallId: callId,
+            toolName,
+            input: JSON.stringify(inv.arguments ?? {}),
+            providerExecuted: true,
+            dynamic: true
+          }));
+        }
+        break;
+      }
+      case "codex/event/mcp_tool_call_end": {
+        const params = event.params ?? {};
+        const callId = params.msg?.call_id;
+        if (callId && this.openToolCalls.has(callId)) {
+          const tracked = this.openToolCalls.get(callId);
+          const result = params.msg?.result;
+          const textParts = result?.Ok?.content?.filter((c) => c.type === "text").map((c) => c.text) ?? [];
+          const output = textParts.join("\n") || (result?.Err ? JSON.stringify(result.Err) : "");
+          parts.push(withMeta({
+            type: "tool-result",
+            toolCallId: callId,
+            toolName: tracked.toolName,
+            result: { output }
+          }));
+          this.openToolCalls.delete(callId);
+        }
+        break;
+      }
       case "item/mcpToolCall/progress": {
         const params = event.params ?? {};
         if (params.itemId && params.message) {
@@ -1143,6 +1306,9 @@ var CodexEventMapper = class {
         }
         this.openToolCalls.clear();
         const completed = event.params ?? {};
+        if (completed.turn?.id) {
+          this.planSequenceByTurnId.delete(completed.turn.id);
+        }
         const usage = this.latestUsage ?? EMPTY_USAGE;
         parts.push(withMeta({ type: "finish", finishReason: toFinishReason(completed.turn?.status), usage }));
         break;
@@ -1433,7 +1599,7 @@ var CodexLanguageModel = class {
     });
   }
   doStream(options) {
-    const transport = this.config.providerSettings.transportFactory ? this.config.providerSettings.transportFactory() : this.config.providerSettings.transport?.type === "websocket" ? new WebSocketTransport(this.config.providerSettings.transport.websocket) : new StdioTransport(this.config.providerSettings.transport?.stdio);
+    const transport = this.config.providerSettings.transportFactory ? this.config.providerSettings.transportFactory(options.abortSignal) : this.config.providerSettings.transport?.type === "websocket" ? new WebSocketTransport(this.config.providerSettings.transport.websocket) : new StdioTransport(this.config.providerSettings.transport?.stdio);
     const packetLogger = this.config.providerSettings.debug?.logPackets === true ? this.config.providerSettings.debug.logger ?? ((packet) => {
       if (packet.direction === "inbound") {
         console.debug("[codex packet]", packet.message);
@@ -1448,7 +1614,9 @@ var CodexLanguageModel = class {
     const client = new AppServerClient(transport, stripUndefined({
       onPacket: packetLogger
     }));
-    const mapper = new CodexEventMapper();
+    const mapper = new CodexEventMapper(stripUndefined({
+      emitPlanUpdates: this.config.providerSettings.emitPlanUpdates
+    }));
     let activeThreadId;
     let activeTurnId;
     const interruptTimeoutMs = this.config.providerSettings.interruptTimeoutMs ?? 1e4;
@@ -1845,7 +2013,7 @@ function createCodexAppServer(settings = {}) {
     });
   }
   const persistentPool = persistentPoolHandle?.pool ?? null;
-  const effectiveTransportFactory = persistentPool ? () => new PersistentTransport({ pool: persistentPool }) : baseTransportFactory;
+  const effectiveTransportFactory = persistentPool ? (signal) => new PersistentTransport(stripUndefined({ pool: persistentPool, signal })) : baseTransportFactory;
   const resolvedSettings = Object.freeze(stripUndefined({
     defaultModel: settings.defaultModel,
     experimentalApi: settings.experimentalApi,