@janole/ai-sdk-provider-codex-asp 0.2.4 → 0.3.1

package/dist/index.js

@@ -278,6 +278,7 @@ var AppServerClient = class {
 var PersistentTransport = class {
   pool;
   signal;
+  threadId;
   worker = null;
   pendingInitializeId = null;
   initializeIntercepted = false;
@@ -287,9 +288,10 @@ var PersistentTransport = class {
   constructor(settings) {
     this.pool = settings.pool;
     this.signal = settings.signal;
+    this.threadId = settings.threadId;
   }
   async connect() {
-    this.worker = await this.pool.acquire(stripUndefined({ signal: this.signal }));
+    this.worker = await this.pool.acquire(stripUndefined({ signal: this.signal, threadId: this.threadId }));
     await this.worker.ensureConnected();
   }
   disconnect() {
@@ -661,6 +663,7 @@ var CodexWorker = class {
     await this.inner.connect();
   }
   acquire() {
+    this.clearSessionListeners();
     if (this.idleTimer) {
       clearTimeout(this.idleTimer);
       this.idleTimer = null;
@@ -745,8 +748,17 @@ var CodexWorkerPool = class {
     if (this.shutdownCalled) {
       throw new CodexProviderError("Worker pool has been shut down.");
     }
+    if (options?.threadId) {
+      const reserved = this.workers.find(
+        (w) => (w.state === "idle" || w.state === "disconnected") && w.pendingToolCall?.threadId === options.threadId
+      );
+      if (reserved) {
+        reserved.acquire();
+        return reserved;
+      }
+    }
     const worker = this.workers.find(
-      (w) => w.state === "idle" || w.state === "disconnected"
+      (w) => (w.state === "idle" || w.state === "disconnected") && !w.pendingToolCall
     );
     if (!worker) {
       if (options?.signal?.aborted) {
@@ -754,6 +766,7 @@ var CodexWorkerPool = class {
       }
       return new Promise((resolve, reject) => {
         const waiter = {
+          threadId: options?.threadId,
           resolve,
           reject,
           signal: options?.signal,
@@ -773,6 +786,16 @@ var CodexWorkerPool = class {
     return worker;
   }
   release(worker) {
+    worker.clearSessionListeners();
+    if (worker.pendingToolCall) {
+      const idx = this.waiters.findIndex((w) => w.threadId === worker.pendingToolCall?.threadId);
+      if (idx >= 0) {
+        const [waiter2] = this.waiters.splice(idx, 1);
+        this.clearWaiterAbortHandler(waiter2);
+        waiter2.resolve(worker);
+        return;
+      }
+    }
     const waiter = this.waiters.shift();
     if (waiter) {
       this.clearWaiterAbortHandler(waiter);
@@ -933,7 +956,7 @@ var DynamicToolsDispatcher = class {
 // package.json
 var package_default = {
   name: "@janole/ai-sdk-provider-codex-asp",
-  version: "0.2.4"};
+  version: "0.3.1"};
 
 // src/package-info.ts
 var PACKAGE_NAME = package_default.name;
@@ -941,14 +964,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;
 }
 
@@ -987,6 +1010,7 @@ var CodexEventMapper = class {
   openToolCalls = /* @__PURE__ */ new Map();
   planSequenceByTurnId = /* @__PURE__ */ new Map();
   threadId;
+  turnId;
   latestUsage;
   constructor(options) {
     this.options = {
@@ -996,6 +1020,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);
@@ -1003,7 +1033,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: [] });
@@ -1023,6 +1053,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;
       }
@@ -1320,6 +1354,75 @@ var CodexEventMapper = class {
     return parts;
   }
 };
+
+// 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) {
@@ -1732,7 +1835,8 @@ var CodexLanguageModel = class {
     });
   }
   doStream(options) {
-    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 resumeThreadId = extractResumeThreadId(options.prompt);
+    const transport = this.config.providerSettings.transportFactory ? this.config.providerSettings.transportFactory(options.abortSignal, resumeThreadId) : 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);
@@ -1752,6 +1856,7 @@ var CodexLanguageModel = class {
     }));
     let activeThreadId;
     let activeTurnId;
+    let session;
     const interruptTimeoutMs = this.config.providerSettings.interruptTimeoutMs ?? 1e4;
     const interruptTurnIfPossible = async () => {
       if (!activeThreadId || !activeTurnId) {
@@ -1772,6 +1877,7 @@ var CodexLanguageModel = class {
           if (closed) {
             return;
           }
+          session?.markInactive();
           controller.enqueue({ type: "error", error });
           closed = true;
           try {
@@ -1785,6 +1891,7 @@ var CodexLanguageModel = class {
           if (closed) {
             return;
           }
+          session?.markInactive();
           closed = true;
           try {
             controller.close();
@@ -1891,6 +1998,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") {
@@ -1927,7 +2039,6 @@ var CodexLanguageModel = class {
             await client.request("initialize", initializeParams);
             await client.notification("initialized");
             debugLog?.("inbound", "prompt", options.prompt);
-            const resumeThreadId = extractResumeThreadId(options.prompt);
             debugLog?.("inbound", "extractResumeThreadId", { resumeThreadId });
             const developerInstructions = mapSystemPrompt(options.prompt);
             let threadId;
@@ -1988,10 +2099,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
@@ -2023,17 +2137,26 @@ 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 {
@@ -2130,6 +2253,12 @@ function acquirePersistentPool(settings) {
 }
 
 // src/provider.ts
+var poolHandleCleanup = new FinalizationRegistry(
+  (handle) => {
+    void handle.release().catch(() => {
+    });
+  }
+);
 function createNoSuchModelError(modelId, modelType) {
   return new NoSuchModelError({ modelId, modelType });
 }
@@ -2150,7 +2279,7 @@ function createCodexAppServer(settings = {}) {
     });
   }
   const persistentPool = persistentPoolHandle?.pool ?? null;
-  const effectiveTransportFactory = persistentPool ? (signal) => new PersistentTransport(stripUndefined({ pool: persistentPool, signal })) : baseTransportFactory;
+  const effectiveTransportFactory = persistentPool ? (signal, threadId) => new PersistentTransport(stripUndefined({ pool: persistentPool, signal, threadId })) : baseTransportFactory;
   const resolvedSettings = Object.freeze(stripUndefined({
     defaultModel: settings.defaultModel,
     experimentalApi: settings.experimentalApi,
@@ -2168,12 +2297,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,
@@ -2195,15 +2327,44 @@ 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;
       }
+      poolHandleCleanup.unregister(provider);
       const handle = persistentPoolHandle;
       persistentPoolHandle = null;
       await handle.release();
     }
   });
+  if (persistentPoolHandle) {
+    poolHandleCleanup.register(provider, persistentPoolHandle, provider);
+  }
   return provider;
 }
 var codexAppServer = createCodexAppServer();