@jaypie/llm 1.2.9 → 1.2.11

package/dist/cjs/index.cjs

@@ -807,6 +807,90 @@ var ErrorCategory;
     ErrorCategory["Unknown"] = "unknown";
 })(ErrorCategory || (ErrorCategory = {}));
 
+/**
+ * Transient network error detection utility.
+ *
+ * Detects low-level Node.js/undici network errors that indicate
+ * a temporary network issue (not a provider API error).
+ * These errors should always be retried.
+ */
+//
+//
+// Constants
+//
+/** Error codes from Node.js net/dns subsystems that indicate transient failures */
+const TRANSIENT_ERROR_CODES = new Set([
+    "ECONNREFUSED",
+    "ECONNRESET",
+    "EAI_AGAIN",
+    "ENETRESET",
+    "ENETUNREACH",
+    "ENOTFOUND",
+    "EPIPE",
+    "ETIMEDOUT",
+]);
+/** Substrings in error messages that indicate transient network issues */
+const TRANSIENT_MESSAGE_PATTERNS = [
+    "network",
+    "socket hang up",
+    "terminated",
+];
+//
+//
+// Helpers
+//
+/**
+ * Check a single error (without walking the cause chain)
+ */
+function matchesSingleError(error) {
+    if (!(error instanceof Error))
+        return false;
+    // Check error code (e.g., ECONNRESET)
+    const code = error.code;
+    if (code && TRANSIENT_ERROR_CODES.has(code)) {
+        return true;
+    }
+    // Check error message for transient patterns
+    const message = error.message.toLowerCase();
+    for (const pattern of TRANSIENT_MESSAGE_PATTERNS) {
+        if (message.includes(pattern)) {
+            return true;
+        }
+    }
+    return false;
+}
+//
+//
+// Main
+//
+/**
+ * Detect transient network errors by inspecting the error and its cause chain.
+ *
+ * Undici (Node.js fetch) wraps low-level errors like ECONNRESET inside
+ * `TypeError: terminated`. This function recursively walks `error.cause`
+ * to detect these wrapped errors.
+ *
+ * @param error - The error to inspect
+ * @returns true if the error (or any cause in its chain) is a transient network error
+ */
+function isTransientNetworkError(error) {
+    let current = error;
+    while (current) {
+        if (matchesSingleError(current)) {
+            return true;
+        }
+        // Walk the cause chain (cause is ES2022, cast for compatibility)
+        const cause = current.cause;
+        if (current instanceof Error && cause) {
+            current = cause;
+        }
+        else {
+            break;
+        }
+    }
+    return false;
+}
+
 //
 //
 // Constants
@@ -1268,6 +1352,14 @@ class AnthropicAdapter extends BaseProviderAdapter {
                 shouldRetry: false,
             };
         }
+        // Check for transient network errors (ECONNRESET, etc.)
+        if (isTransientNetworkError(error)) {
+            return {
+                error,
+                category: ErrorCategory.Retryable,
+                shouldRetry: true,
+            };
+        }
         // Unknown error - treat as potentially retryable
         return {
             error,
@@ -1750,6 +1842,14 @@ class GeminiAdapter extends BaseProviderAdapter {
                 shouldRetry: true,
             };
         }
+        // Check for transient network errors (ECONNRESET, etc.)
+        if (isTransientNetworkError(error)) {
+            return {
+                error,
+                category: ErrorCategory.Retryable,
+                shouldRetry: true,
+            };
+        }
         // Unknown error - treat as potentially retryable
         return {
             error,
@@ -2352,6 +2452,14 @@ class OpenAiAdapter extends BaseProviderAdapter {
                 };
             }
         }
+        // Check for transient network errors (ECONNRESET, etc.)
+        if (isTransientNetworkError(error)) {
+            return {
+                error,
+                category: ErrorCategory.Retryable,
+                shouldRetry: true,
+            };
+        }
         // Unknown error - treat as potentially retryable
         return {
             error,
@@ -2565,7 +2673,7 @@ class OpenRouterAdapter extends BaseProviderAdapter {
     //
     // API Execution
     //
-    async executeRequest(client, request) {
+    async executeRequest(client, request, signal) {
         const openRouter = client;
         const openRouterRequest = request;
         const response = await openRouter.chat.send({
@@ -2574,10 +2682,10 @@ class OpenRouterAdapter extends BaseProviderAdapter {
             tools: openRouterRequest.tools,
             toolChoice: openRouterRequest.tool_choice,
             user: openRouterRequest.user,
-        });
+        }, signal ? { signal } : undefined);
         return response;
     }
-    async *executeStreamRequest(client, request) {
+    async *executeStreamRequest(client, request, signal) {
         const openRouter = client;
         const openRouterRequest = request;
         // Use chat.send with stream: true for streaming responses
@@ -2588,7 +2696,7 @@ class OpenRouterAdapter extends BaseProviderAdapter {
             toolChoice: openRouterRequest.tool_choice,
             user: openRouterRequest.user,
             stream: true,
-        });
+        }, signal ? { signal } : undefined);
         // Track current tool call being built
         let currentToolCall = null;
         // Track usage for final chunk
@@ -2838,6 +2946,14 @@ class OpenRouterAdapter extends BaseProviderAdapter {
                 suggestedDelayMs: 60000,
             };
         }
+        // Check for transient network errors (ECONNRESET, etc.)
+        if (isTransientNetworkError(error)) {
+            return {
+                error,
+                category: ErrorCategory.Retryable,
+                shouldRetry: true,
+            };
+        }
         // Unknown error - treat as potentially retryable
         return {
             error,
@@ -3791,9 +3907,12 @@ class RetryExecutor {
         this.errorClassifier = config.errorClassifier;
     }
     /**
-     * Execute an operation with retry logic
+     * Execute an operation with retry logic.
+     * Each attempt receives an AbortSignal. On failure, the signal is aborted
+     * before sleeping — this kills lingering socket callbacks from the previous
+     * request and prevents stale async errors from escaping the retry loop.
      *
-     * @param operation - The async operation to execute
+     * @param operation - The async operation to execute (receives AbortSignal)
      * @param options - Execution options including context and hooks
      * @returns The result of the operation
      * @throws BadGatewayError if all retries are exhausted or error is not retryable
@@ -3801,14 +3920,17 @@ class RetryExecutor {
     async execute(operation, options) {
         let attempt = 0;
         while (true) {
+            const controller = new AbortController();
             try {
-                const result = await operation();
+                const result = await operation(controller.signal);
                 if (attempt > 0) {
                     log$1.debug(`API call succeeded after ${attempt} retries`);
                 }
                 return result;
             }
             catch (error) {
+                // Abort the previous request to kill lingering socket callbacks
+                controller.abort("retry");
                 // Check if we've exhausted retries
                 if (!this.policy.shouldRetry(attempt)) {
                     log$1.error(`API call failed after ${this.policy.maxRetries} retries`);
@@ -4033,7 +4155,7 @@ class OperateLoop {
             providerRequest,
         });
         // Execute with retry (RetryExecutor handles error hooks and throws appropriate errors)
-        const response = await retryExecutor.execute(() => this.adapter.executeRequest(this.client, providerRequest), {
+        const response = await retryExecutor.execute((signal) => this.adapter.executeRequest(this.client, providerRequest, signal), {
             context: {
                 input: state.currentInput,
                 options,
@@ -4289,6 +4411,7 @@ class StreamLoop {
         this.client = config.client;
         this.hookRunnerInstance = config.hookRunner ?? hookRunner;
         this.inputProcessorInstance = config.inputProcessor ?? inputProcessor;
+        this.retryPolicy = config.retryPolicy ?? defaultRetryPolicy;
     }
     /**
      * Execute the streaming loop for multi-turn conversations with tool calling.
@@ -4421,30 +4544,78 @@ class StreamLoop {
         });
         // Collect tool calls from the stream
         const collectedToolCalls = [];
-        // Execute streaming request
-        const streamGenerator = this.adapter.executeStreamRequest(this.client, providerRequest);
-        for await (const chunk of streamGenerator) {
-            // Pass through text chunks
-            if (chunk.type === exports.LlmStreamChunkType.Text) {
-                yield chunk;
-            }
-            // Collect tool calls
-            if (chunk.type === exports.LlmStreamChunkType.ToolCall) {
-                collectedToolCalls.push({
-                    callId: chunk.toolCall.id,
-                    name: chunk.toolCall.name,
-                    arguments: chunk.toolCall.arguments,
-                    raw: chunk.toolCall,
-                });
-                yield chunk;
-            }
-            // Track usage from done chunk (but don't yield it yet - we'll emit our own)
-            if (chunk.type === exports.LlmStreamChunkType.Done && chunk.usage) {
-                state.usageItems.push(...chunk.usage);
+        // Retry loop for connection-level failures
+        let attempt = 0;
+        let chunksYielded = false;
+        while (true) {
+            const controller = new AbortController();
+            try {
+                // Execute streaming request
+                const streamGenerator = this.adapter.executeStreamRequest(this.client, providerRequest, controller.signal);
+                for await (const chunk of streamGenerator) {
+                    // Pass through text chunks
+                    if (chunk.type === exports.LlmStreamChunkType.Text) {
+                        chunksYielded = true;
+                        yield chunk;
+                    }
+                    // Collect tool calls
+                    if (chunk.type === exports.LlmStreamChunkType.ToolCall) {
+                        chunksYielded = true;
+                        collectedToolCalls.push({
+                            callId: chunk.toolCall.id,
+                            name: chunk.toolCall.name,
+                            arguments: chunk.toolCall.arguments,
+                            raw: chunk.toolCall,
+                        });
+                        yield chunk;
+                    }
+                    // Track usage from done chunk (but don't yield it yet - we'll emit our own)
+                    if (chunk.type === exports.LlmStreamChunkType.Done && chunk.usage) {
+                        state.usageItems.push(...chunk.usage);
+                    }
+                    // Pass through error chunks
+                    if (chunk.type === exports.LlmStreamChunkType.Error) {
+                        chunksYielded = true;
+                        yield chunk;
+                    }
+                }
+                // Stream completed successfully
+                if (attempt > 0) {
+                    log$1.debug(`Stream request succeeded after ${attempt} retries`);
+                }
+                break;
             }
-            // Pass through error chunks
-            if (chunk.type === exports.LlmStreamChunkType.Error) {
-                yield chunk;
+            catch (error) {
+                // Abort the previous request to kill lingering socket callbacks
+                controller.abort("retry");
+                // If chunks were already yielded, we can't transparently retry
+                if (chunksYielded) {
+                    const errorMessage = error instanceof Error ? error.message : String(error);
+                    log$1.error("Stream failed after partial data was delivered");
+                    log$1.var({ error });
+                    yield {
+                        type: exports.LlmStreamChunkType.Error,
+                        error: {
+                            detail: errorMessage,
+                            status: 502,
+                            title: "Stream Error",
+                        },
+                    };
+                    return { shouldContinue: false };
+                }
+                // Check if we've exhausted retries or error is not retryable
+                if (!this.retryPolicy.shouldRetry(attempt) ||
+                    !this.adapter.isRetryableError(error)) {
+                    log$1.error(`Stream request failed after ${this.retryPolicy.maxRetries} retries`);
+                    log$1.var({ error });
+                    const errorMessage = error instanceof Error ? error.message : String(error);
+                    throw new errors.BadGatewayError(errorMessage);
+                }
+                const delay = this.retryPolicy.getDelayForAttempt(attempt);
+                log$1.warn(`Stream request failed. Retrying in ${delay}ms...`);
+                log$1.var({ error });
+                await kit.sleep(delay);
+                attempt++;
             }
         }
         // Execute afterEachModelResponse hook