@jaypie/llm 1.2.9 → 1.2.10

package/dist/cjs/operate/StreamLoop.d.ts

@@ -3,11 +3,13 @@ import { LlmStreamChunk } from "../types/LlmStreamChunk.interface.js";
 import { ProviderAdapter } from "./adapters/ProviderAdapter.interface.js";
 import { HookRunner } from "./hooks/index.js";
 import { InputProcessor } from "./input/index.js";
+import { RetryPolicy } from "./retry/index.js";
 export interface StreamLoopConfig {
     adapter: ProviderAdapter;
     client: unknown;
     hookRunner?: HookRunner;
     inputProcessor?: InputProcessor;
+    retryPolicy?: RetryPolicy;
 }
 /**
  * StreamLoop implements streaming multi-turn conversation loop.
@@ -19,6 +21,7 @@ export declare class StreamLoop {
     private readonly client;
     private readonly hookRunnerInstance;
     private readonly inputProcessorInstance;
+    private readonly retryPolicy;
     constructor(config: StreamLoopConfig);
     /**
      * Execute the streaming loop for multi-turn conversations with tool calling.

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

@@ -1,4 +1,5 @@
 export { DEFAULT_BACKOFF_FACTOR, DEFAULT_INITIAL_DELAY_MS, DEFAULT_MAX_DELAY_MS, DEFAULT_MAX_RETRIES, defaultRetryPolicy, MAX_RETRIES_ABSOLUTE_LIMIT, RetryPolicy, } from "./RetryPolicy.js";
 export type { RetryPolicyConfig } from "./RetryPolicy.js";
+export { isTransientNetworkError } from "./isTransientNetworkError.js";
 export { RetryExecutor } from "./RetryExecutor.js";
 export type { ErrorClassifier, ExecuteOptions, RetryContext, RetryExecutorConfig, } from "./RetryExecutor.js";

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

@@ -0,0 +1,18 @@
+/**
+ * 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.
+ */
+/**
+ * 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
+ */
+export declare function isTransientNetworkError(error: unknown): boolean;

package/dist/esm/index.js

@@ -805,6 +805,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
@@ -1266,6 +1350,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,
@@ -1748,6 +1840,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,
@@ -2350,6 +2450,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,
@@ -2836,6 +2944,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,
@@ -4287,6 +4403,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.
@@ -4419,30 +4536,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 === LlmStreamChunkType.Text) {
-                yield chunk;
-            }
-            // Collect tool calls
-            if (chunk.type === 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 === 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 === LlmStreamChunkType.Text) {
+                        chunksYielded = true;
+                        yield chunk;
+                    }
+                    // Collect tool calls
+                    if (chunk.type === 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 === LlmStreamChunkType.Done && chunk.usage) {
+                        state.usageItems.push(...chunk.usage);
+                    }
+                    // Pass through error chunks
+                    if (chunk.type === 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 === 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: 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 BadGatewayError(errorMessage);
+                }
+                const delay = this.retryPolicy.getDelayForAttempt(attempt);
+                log$1.warn(`Stream request failed. Retrying in ${delay}ms...`);
+                log$1.var({ error });
+                await sleep(delay);
+                attempt++;
             }
         }
         // Execute afterEachModelResponse hook