@janole/ai-sdk-provider-codex-asp 0.1.5 → 0.1.6

package/README.md

@@ -111,6 +111,7 @@ const codex = createCodexAppServer({
   clientInfo?: { name, version, title? },  // defaults to package.json
   transport?: { type: 'stdio' | 'websocket', stdio?, websocket? },
   persistent?: { poolSize?, idleTimeoutMs?, scope?, key? },
+  compaction?: { onResume?, strict? },     // optional thread/compact/start before resumed turns
   debug?: { logPackets?, logger? },         // packet-level JSON-RPC debug logging
   defaultThreadSettings?: { cwd?, approvalMode?, sandboxMode? },
   approvals?: { onCommandApproval?, onFileChangeApproval? },
@@ -154,6 +155,9 @@ npx tsx examples/stream-text.ts
   - Increase `interruptTimeoutMs` if `turn/interrupt` acks are slow under heavy load.
 - Empty generated text:
   - Verify Codex emits `item/agentMessage/delta` and `turn/completed` notifications.
+- Compaction fails on resumed threads:
+  - Leave `compaction.strict` unset/false to continue the turn when `thread/compact/start` fails.
+  - Set `compaction.strict: true` if you want compaction failures to fail fast.
 
 ## Development
 

package/dist/index.cjs

@@ -776,16 +776,26 @@ function withTimeout(promise, timeoutMs) {
 var DynamicToolsDispatcher = class {
   handlers = /* @__PURE__ */ new Map();
   timeoutMs;
+  onDebugEvent;
   constructor(settings = {}) {
     this.timeoutMs = settings.timeoutMs ?? 3e4;
+    this.onDebugEvent = settings.onDebugEvent;
     if (settings.tools) {
       for (const [name, def] of Object.entries(settings.tools)) {
         this.register(name, def.execute);
+        this.onDebugEvent?.({
+          event: "dynamic-tool-registered",
+          data: { name, source: "tools" }
+        });
       }
     }
     if (settings.handlers) {
       for (const [name, handler] of Object.entries(settings.handlers)) {
         this.register(name, handler);
+        this.onDebugEvent?.({
+          event: "dynamic-tool-registered",
+          data: { name, source: "handlers" }
+        });
       }
     }
   }
@@ -798,10 +808,27 @@ var DynamicToolsDispatcher = class {
   async dispatch(params) {
     const toolName = params.tool ?? params.toolName;
     if (!toolName) {
+      this.onDebugEvent?.({
+        event: "dynamic-tool-missing-name",
+        data: {
+          callId: params.callId,
+          threadId: params.threadId,
+          turnId: params.turnId
+        }
+      });
       return toTextResult("Dynamic tool call is missing the tool name.", false);
     }
     const handler = this.handlers.get(toolName);
     if (!handler) {
+      this.onDebugEvent?.({
+        event: "dynamic-tool-missing-handler",
+        data: {
+          toolName,
+          callId: params.callId,
+          threadId: params.threadId,
+          turnId: params.turnId
+        }
+      });
       return toTextResult(`No dynamic tool handler registered for "${toolName}".`, false);
     }
     const context = stripUndefined({
@@ -811,10 +838,41 @@ var DynamicToolsDispatcher = class {
       callId: params.callId
     });
     const args = params.arguments ?? params.input;
+    const startedAt = Date.now();
+    this.onDebugEvent?.({
+      event: "dynamic-tool-dispatch-start",
+      data: {
+        toolName,
+        callId: params.callId,
+        threadId: params.threadId,
+        turnId: params.turnId,
+        hasArguments: args !== void 0
+      }
+    });
     try {
-      return await withTimeout(handler(args, context), this.timeoutMs);
+      const result = await withTimeout(handler(args, context), this.timeoutMs);
+      this.onDebugEvent?.({
+        event: "dynamic-tool-dispatch-success",
+        data: {
+          toolName,
+          callId: params.callId,
+          durationMs: Date.now() - startedAt,
+          success: result.success,
+          contentItemsCount: result.contentItems.length
+        }
+      });
+      return result;
     } catch (error) {
       const message = error instanceof Error ? error.message : "Dynamic tool execution failed.";
+      this.onDebugEvent?.({
+        event: "dynamic-tool-dispatch-error",
+        data: {
+          toolName,
+          callId: params.callId,
+          durationMs: Date.now() - startedAt,
+          message
+        }
+      });
       return toTextResult(message, false);
     }
   }
@@ -823,7 +881,7 @@ var DynamicToolsDispatcher = class {
 // package.json
 var package_default = {
   name: "@janole/ai-sdk-provider-codex-asp",
-  version: "0.1.5"};
+  version: "0.1.6"};
 
 // src/package-info.ts
 var PACKAGE_NAME = package_default.name;
@@ -1198,7 +1256,7 @@ function extractResumeThreadId(prompt) {
   }
   return void 0;
 }
-function extractToolResults(prompt) {
+function extractToolResults(prompt, callId) {
   for (let i = prompt.length - 1; i >= 0; i--) {
     const message = prompt[i];
     if (message?.role === "tool") {
@@ -1206,6 +1264,9 @@ function extractToolResults(prompt) {
       let success = true;
       for (const part of message.content) {
         if (part.type === "tool-result") {
+          if (callId && part.toolCallId !== callId) {
+            continue;
+          }
           if (part.output.type === "text") {
             contentItems.push({ type: "inputText", text: part.output.value });
           } else if (part.output.type === "json") {
@@ -1222,6 +1283,9 @@ function extractToolResults(prompt) {
       if (contentItems.length > 0) {
         return { success, contentItems };
       }
+      if (callId) {
+        return void 0;
+      }
     }
   }
   return void 0;
@@ -1370,6 +1434,9 @@ var CodexLanguageModel = class {
         console.debug("[codex packet]", packet.message);
       }
     }) : void 0;
+    const toolLogger = this.config.providerSettings.debug?.logToolCalls === true ? this.config.providerSettings.debug.toolLogger ?? ((event) => {
+      console.debug("[codex tool]", event.event, event.data);
+    }) : void 0;
     const debugLog = packetLogger ? (direction, label, data) => {
       packetLogger({ direction, message: { debug: label, data } });
     } : void 0;
@@ -1439,7 +1506,24 @@ var CodexLanguageModel = class {
             const persistentTransport = transport instanceof PersistentTransport ? transport : null;
             const pendingToolCall = persistentTransport?.getPendingToolCall() ?? null;
             if (pendingToolCall && persistentTransport) {
-              const toolResult = extractToolResults(options.prompt);
+              toolLogger?.({
+                event: "cross-call-resume",
+                data: {
+                  threadId: pendingToolCall.threadId,
+                  callId: pendingToolCall.callId,
+                  toolName: pendingToolCall.toolName
+                }
+              });
+              const toolResult = extractToolResults(options.prompt, pendingToolCall.callId);
+              toolLogger?.({
+                event: "cross-call-result-extracted",
+                data: {
+                  callId: pendingToolCall.callId,
+                  found: !!toolResult,
+                  success: toolResult?.success,
+                  contentItemsCount: toolResult?.contentItems.length ?? 0
+                }
+              });
               mapper.setThreadId(pendingToolCall.threadId);
               client.onAnyNotification((method, params) => {
                 const parts = mapper.map({ method, params });
@@ -1462,9 +1546,23 @@ var CodexLanguageModel = class {
                 onFileChangeApproval: this.config.providerSettings.approvals?.onFileChangeApproval
               }));
               approvalsDispatcher2.attach(client);
-              await persistentTransport.respondToToolCall(
-                toolResult ?? { success: true, contentItems: [] }
-              );
+              const result = toolResult ?? {
+                success: false,
+                contentItems: [{
+                  type: "inputText",
+                  text: `Missing tool result for pending callId "${pendingToolCall.callId}".`
+                }]
+              };
+              await persistentTransport.respondToToolCall(result);
+              toolLogger?.({
+                event: "cross-call-result-sent",
+                data: {
+                  callId: pendingToolCall.callId,
+                  found: !!toolResult,
+                  success: result.success,
+                  contentItemsCount: result.contentItems.length ?? 0
+                }
+              });
               return;
             }
             const dynamicToolsEnabled = this.config.providerSettings.experimentalApi === true;
@@ -1472,7 +1570,8 @@ var CodexLanguageModel = class {
               const dispatcher = new DynamicToolsDispatcher(stripUndefined({
                 tools: this.config.providerSettings.tools,
                 handlers: this.config.providerSettings.toolHandlers,
-                timeoutMs: this.config.providerSettings.toolTimeoutMs
+                timeoutMs: this.config.providerSettings.toolTimeoutMs,
+                onDebugEvent: toolLogger
               }));
               dispatcher.attach(client);
             }
@@ -1499,6 +1598,14 @@ var CodexLanguageModel = class {
             const sdkDynamicTools = options.tools ? sdkToolsToCodexDynamicTools(options.tools) : [];
             const allDynamicTools = [...providerDynamicTools, ...sdkDynamicTools];
             const dynamicTools = allDynamicTools.length > 0 ? allDynamicTools : void 0;
+            toolLogger?.({
+              event: "dynamic-tools-advertised",
+              data: {
+                providerTools: providerDynamicTools.map((t) => t.name),
+                sdkTools: sdkDynamicTools.map((t) => t.name),
+                total: allDynamicTools.length
+              }
+            });
             const hasSdkTools = sdkDynamicTools.length > 0;
             const needsExperimentalApi = this.config.providerSettings.experimentalApi === true || dynamicTools !== void 0;
             const initializeParams = stripUndefined({
@@ -1527,6 +1634,28 @@ var CodexLanguageModel = class {
                 resumeParams
               );
               threadId = resumeResult.thread.id;
+              if (this.config.providerSettings.compaction?.onResume) {
+                const compactParams = { threadId };
+                debugLog?.("outbound", "thread/compact/start", compactParams);
+                const strictCompaction = this.config.providerSettings.compaction.strict === true;
+                if (strictCompaction) {
+                  await client.request(
+                    "thread/compact/start",
+                    compactParams
+                  );
+                } else {
+                  try {
+                    await client.request(
+                      "thread/compact/start",
+                      compactParams
+                    );
+                  } catch (error) {
+                    debugLog?.("inbound", "thread/compact/start:error", {
+                      message: error instanceof Error ? error.message : String(error)
+                    });
+                  }
+                }
+              }
             } else {
               const threadStartParams = stripUndefined({
                 model: this.config.providerSettings.defaultModel ?? this.modelId,
@@ -1697,6 +1826,7 @@ function createCodexAppServer(settings = {}) {
       websocket: settings.transport.websocket ? { ...settings.transport.websocket } : void 0
     }) : void 0,
     defaultThreadSettings: settings.defaultThreadSettings ? { ...settings.defaultThreadSettings } : void 0,
+    compaction: settings.compaction ? { ...settings.compaction } : void 0,
     transportFactory: effectiveTransportFactory,
     tools: settings.tools ? { ...settings.tools } : void 0,
     toolHandlers: settings.toolHandlers ? { ...settings.toolHandlers } : void 0,