@jaypie/llm 1.2.9 → 1.2.11

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/adapters/OpenRouterAdapter.d.ts

@@ -88,8 +88,8 @@ export declare class OpenRouterAdapter extends BaseProviderAdapter {
     buildRequest(request: OperateRequest): OpenRouterRequest;
     formatTools(toolkit: Toolkit, outputSchema?: JsonObject): ProviderToolDefinition[];
     formatOutputSchema(schema: JsonObject | NaturalSchema | z.ZodType): JsonObject;
-    executeRequest(client: unknown, request: unknown): Promise<OpenRouterResponse>;
-    executeStreamRequest(client: unknown, request: unknown): AsyncIterable<LlmStreamChunk>;
+    executeRequest(client: unknown, request: unknown, signal?: AbortSignal): Promise<OpenRouterResponse>;
+    executeStreamRequest(client: unknown, request: unknown, signal?: AbortSignal): AsyncIterable<LlmStreamChunk>;
     parseResponse(response: unknown, _options?: LlmOperateOptions): ParsedResponse;
     extractToolCalls(response: unknown): StandardToolCall[];
     extractUsage(response: unknown, model: string): LlmUsageItem;

package/dist/cjs/operate/adapters/ProviderAdapter.interface.d.ts

@@ -47,17 +47,19 @@ export interface ProviderAdapter {
      *
      * @param client - The provider's SDK client instance
      * @param request - Provider-specific request object (from buildRequest)
+     * @param signal - Optional AbortSignal to cancel the request on retry
      * @returns Raw provider response
      */
-    executeRequest(client: unknown, request: unknown): Promise<unknown>;
+    executeRequest(client: unknown, request: unknown, signal?: AbortSignal): Promise<unknown>;
     /**
      * Execute a streaming API request to the provider
      *
      * @param client - The provider's SDK client instance
      * @param request - Provider-specific request object (from buildRequest)
+     * @param signal - Optional AbortSignal to cancel the request on retry
      * @returns AsyncIterable of stream chunks
      */
-    executeStreamRequest?(client: unknown, request: unknown): AsyncIterable<LlmStreamChunk>;
+    executeStreamRequest?(client: unknown, request: unknown, signal?: AbortSignal): AsyncIterable<LlmStreamChunk>;
     /**
      * Parse a provider response into standardized format
      *
@@ -158,7 +160,7 @@ export declare abstract class BaseProviderAdapter implements ProviderAdapter {
     abstract buildRequest(request: OperateRequest): unknown;
     abstract formatTools(toolkit: Toolkit, outputSchema?: JsonObject): ProviderToolDefinition[];
     abstract formatOutputSchema(schema: JsonObject | NaturalSchema | z.ZodType): JsonObject;
-    abstract executeRequest(client: unknown, request: unknown): Promise<unknown>;
+    abstract executeRequest(client: unknown, request: unknown, signal?: AbortSignal): Promise<unknown>;
     abstract parseResponse(response: unknown, options?: LlmOperateOptions): ParsedResponse;
     abstract extractToolCalls(response: unknown): StandardToolCall[];
     abstract extractUsage(response: unknown, model: string): LlmUsageItem;

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

@@ -28,12 +28,15 @@ export declare class RetryExecutor {
     private readonly errorClassifier;
     constructor(config: RetryExecutorConfig);
     /**
-     * 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
      */
-    execute<T>(operation: () => Promise<T>, options: ExecuteOptions): Promise<T>;
+    execute<T>(operation: ((signal: AbortSignal) => Promise<T>) | (() => Promise<T>), options: ExecuteOptions): Promise<T>;
 }

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,
@@ -2563,7 +2671,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({
@@ -2572,10 +2680,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
@@ -2586,7 +2694,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
@@ -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,
@@ -3789,9 +3905,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
@@ -3799,14 +3918,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`);
@@ -4031,7 +4153,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,
@@ -4287,6 +4409,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 +4542,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 === 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) {
+            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 === 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) {
+                // 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: 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