@jaypie/llm 1.2.33 → 1.2.35

package/dist/cjs/operate/retry/createStaleRejectionGuard.d.ts

@@ -0,0 +1,19 @@
+export interface StaleRejectionGuard {
+    /** Install the unhandledRejection listener (idempotent) */
+    install(): void;
+    /** Remove the listener and forget recorded errors */
+    remove(): void;
+    /** Record an error the retry loop has caught and is handling */
+    recordCaught(error: unknown): void;
+}
+/**
+ * Create a guard that suppresses unhandled rejections firing as siblings of
+ * an error the retry loop has already caught. Provider SDKs occasionally
+ * surface a single upstream failure as twin rejections — the retry layer
+ * accepts responsibility for the first; this guard prevents the second from
+ * crashing the host while the retry is in flight.
+ *
+ * The guard also continues to suppress transient socket teardown errors
+ * (e.g. undici `TypeError: terminated`) emitted between attempts.
+ */
+export declare function createStaleRejectionGuard(): StaleRejectionGuard;

package/dist/esm/index.js

@@ -4815,6 +4815,78 @@ class RetryPolicy {
 // Export a default policy instance
 const defaultRetryPolicy = new RetryPolicy();
 
+//
+//
+// Helpers
+//
+/**
+ * Compare an unhandled rejection reason against errors the retry loop has
+ * already caught. Reference equality first, then fall back to message + name
+ * — providers sometimes surface twin rejections as fresh Error instances
+ * rebuilt from the same upstream failure.
+ */
+function matchesCaughtError(reason, caught) {
+    if (caught.has(reason))
+        return true;
+    if (!(reason instanceof Error))
+        return false;
+    for (const handled of caught) {
+        if (handled instanceof Error &&
+            handled.name === reason.name &&
+            handled.message === reason.message) {
+            return true;
+        }
+    }
+    return false;
+}
+//
+//
+// Main
+//
+/**
+ * Create a guard that suppresses unhandled rejections firing as siblings of
+ * an error the retry loop has already caught. Provider SDKs occasionally
+ * surface a single upstream failure as twin rejections — the retry layer
+ * accepts responsibility for the first; this guard prevents the second from
+ * crashing the host while the retry is in flight.
+ *
+ * The guard also continues to suppress transient socket teardown errors
+ * (e.g. undici `TypeError: terminated`) emitted between attempts.
+ */
+function createStaleRejectionGuard() {
+    const log = getLogger$5();
+    const caughtErrors = new Set();
+    let listener;
+    return {
+        install() {
+            if (listener)
+                return;
+            listener = (reason, promise) => {
+                if (isTransientNetworkError(reason)) {
+                    promise?.catch?.(() => { });
+                    log.trace("Suppressed stale socket error during retry");
+                    return;
+                }
+                if (matchesCaughtError(reason, caughtErrors)) {
+                    promise?.catch?.(() => { });
+                    log.trace("Suppressed sibling rejection of already-handled error");
+                }
+            };
+            process.on("unhandledRejection", listener);
+        },
+        remove() {
+            if (listener) {
+                process.removeListener("unhandledRejection", listener);
+                listener = undefined;
+            }
+            caughtErrors.clear();
+        },
+        recordCaught(error) {
+            caughtErrors.add(error);
+        },
+    };
+}
+
 //
 //
 // Main
@@ -4843,27 +4915,11 @@ class RetryExecutor {
     async execute(operation, options) {
         const log = getLogger$5();
         let attempt = 0;
-        // Persistent guard against stale socket errors (TypeError: terminated).
-        // Installed after the first abort and kept alive through subsequent attempts
-        // so that asynchronous undici socket teardown errors that fire between
-        // sleep completion and the next operation's await are caught.
-        let staleGuard;
-        const installGuard = () => {
-            if (staleGuard)
-                return;
-            staleGuard = (reason) => {
-                if (isTransientNetworkError(reason)) {
-                    log.trace("Suppressed stale socket error during retry");
-                }
-            };
-            process.on("unhandledRejection", staleGuard);
-        };
-        const removeGuard = () => {
-            if (staleGuard) {
-                process.removeListener("unhandledRejection", staleGuard);
-                staleGuard = undefined;
-            }
-        };
+        // Guard against stale rejections firing on a subsequent microtask after
+        // the retry layer has already caught the originating error: undici socket
+        // teardown (TypeError: terminated) and twin upstream-SDK rejections
+        // (e.g. issue #336 — OpenRouter SyntaxError siblings).
+        const guard = createStaleRejectionGuard();
         try {
             while (true) {
                 const controller = new AbortController();
@@ -4875,12 +4931,9 @@ class RetryExecutor {
                     return result;
                 }
                 catch (error) {
-                    // Abort the previous request to kill lingering socket callbacks
                     controller.abort("retry");
-                    // Install the guard immediately after abort — stale socket errors
-                    // can fire on any subsequent microtask boundary (during hook calls,
-                    // sleep, or the next operation attempt)
-                    installGuard();
+                    guard.recordCaught(error);
+                    guard.install();
                     // Check if we've exhausted retries
                     if (!this.policy.shouldRetry(attempt)) {
                         log.error(`API call failed after ${this.policy.maxRetries} retries`);
@@ -4926,7 +4979,7 @@ class RetryExecutor {
             }
         }
         finally {
-            removeGuard();
+            guard.remove();
         }
     }
 }
@@ -5229,7 +5282,7 @@ class OperateLoop {
                         };
                         const toolResultFormatted = this.adapter.formatToolResult(toolCall, errorResult);
                         state.responseBuilder.appendToHistory(toolResultFormatted);
-                        log.error(`Error executing function call ${toolCall.name}`);
+                        log.warn(`Error executing function call ${toolCall.name}`);
                         log.var({ error });
                         // Track consecutive errors and stop if threshold reached
                         state.consecutiveToolErrors++;
@@ -5536,25 +5589,10 @@ class StreamLoop {
         // Retry loop for connection-level failures
         let attempt = 0;
         let chunksYielded = false;
-        // Persistent guard against stale socket errors (TypeError: terminated).
-        // Installed after the first abort and kept alive through subsequent attempts.
-        let staleGuard;
-        const installGuard = () => {
-            if (staleGuard)
-                return;
-            staleGuard = (reason) => {
-                if (isTransientNetworkError(reason)) {
-                    log.trace("Suppressed stale socket error during retry");
-                }
-            };
-            process.on("unhandledRejection", staleGuard);
-        };
-        const removeGuard = () => {
-            if (staleGuard) {
-                process.removeListener("unhandledRejection", staleGuard);
-                staleGuard = undefined;
-            }
-        };
+        // Guard against stale rejections firing after the stream loop has already
+        // caught the originating error: undici socket teardown and twin
+        // upstream-SDK rejections (issue #336).
+        const guard = createStaleRejectionGuard();
         try {
             while (true) {
                 const controller = new AbortController();
@@ -5595,10 +5633,9 @@ class StreamLoop {
                     break;
                 }
                 catch (error) {
-                    // Abort the previous request to kill lingering socket callbacks
                     controller.abort("retry");
-                    // Install the guard immediately after abort
-                    installGuard();
+                    guard.recordCaught(error);
+                    guard.install();
                     // If chunks were already yielded, we can't transparently retry
                     if (chunksYielded) {
                         const errorMessage = error instanceof Error ? error.message : String(error);
@@ -5631,7 +5668,7 @@ class StreamLoop {
             }
         }
         finally {
-            removeGuard();
+            guard.remove();
         }
         // Execute afterEachModelResponse hook
         await this.hookRunnerInstance.runAfterModelResponse(context.hooks, {
@@ -5740,7 +5777,7 @@ class StreamLoop {
                     call_id: toolCall.callId,
                     name: toolCall.name,
                 });
-                log.error(`Error executing function call ${toolCall.name}`);
+                log.warn(`Error executing function call ${toolCall.name}`);
                 log.var({ error });
                 // Track consecutive errors and stop if threshold reached
                 state.consecutiveToolErrors++;