@jaypie/llm 1.2.9 → 1.2.10

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,
@@ -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,
@@ -4289,6 +4405,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 +4538,75 @@ 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) {
+            try {
+                // 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) {
+                        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) {
+                // 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