@jaypie/llm 1.2.10 → 1.2.12

package/dist/cjs/operate/adapters/AnthropicAdapter.d.ts

@@ -17,8 +17,8 @@ export declare class AnthropicAdapter extends BaseProviderAdapter {
     buildRequest(request: OperateRequest): Anthropic.MessageCreateParams;
     formatTools(toolkit: Toolkit, outputSchema?: JsonObject): ProviderToolDefinition[];
     formatOutputSchema(schema: JsonObject | NaturalSchema | z.ZodType): JsonObject;
-    executeRequest(client: unknown, request: unknown): Promise<Anthropic.Message>;
-    executeStreamRequest(client: unknown, request: unknown): AsyncIterable<LlmStreamChunk>;
+    executeRequest(client: unknown, request: unknown, signal?: AbortSignal): Promise<Anthropic.Message>;
+    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/GeminiAdapter.d.ts

@@ -17,8 +17,8 @@ export declare class GeminiAdapter extends BaseProviderAdapter {
     buildRequest(request: OperateRequest): GeminiRequest;
     formatTools(toolkit: Toolkit, outputSchema?: JsonObject): ProviderToolDefinition[];
     formatOutputSchema(schema: JsonObject | NaturalSchema | z.ZodType): JsonObject;
-    executeRequest(client: unknown, request: unknown): Promise<GeminiRawResponse>;
-    executeStreamRequest(client: unknown, request: unknown): AsyncIterable<LlmStreamChunk>;
+    executeRequest(client: unknown, request: unknown, signal?: AbortSignal): Promise<GeminiRawResponse>;
+    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/OpenAiAdapter.d.ts

@@ -16,8 +16,8 @@ export declare class OpenAiAdapter extends BaseProviderAdapter {
     buildRequest(request: OperateRequest): unknown;
     formatTools(toolkit: Toolkit, _outputSchema?: JsonObject): ProviderToolDefinition[];
     formatOutputSchema(schema: JsonObject | NaturalSchema | z.ZodType): JsonObject;
-    executeRequest(client: unknown, request: unknown): Promise<unknown>;
-    executeStreamRequest(client: unknown, request: unknown): AsyncIterable<LlmStreamChunk>;
+    executeRequest(client: unknown, request: unknown, signal?: AbortSignal): Promise<unknown>;
+    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/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/esm/index.js

@@ -1126,17 +1126,24 @@ class AnthropicAdapter extends BaseProviderAdapter {
     //
     // API Execution
     //
-    async executeRequest(client, request) {
+    async executeRequest(client, request, signal) {
         const anthropic = client;
-        return (await anthropic.messages.create(request));
+        try {
+            return (await anthropic.messages.create(request, signal ? { signal } : undefined));
+        }
+        catch (error) {
+            if (signal?.aborted)
+                return undefined;
+            throw error;
+        }
     }
-    async *executeStreamRequest(client, request) {
+    async *executeStreamRequest(client, request, signal) {
         const anthropic = client;
         const streamRequest = {
             ...request,
             stream: true,
         };
-        const stream = await anthropic.messages.create(streamRequest);
+        const stream = await anthropic.messages.create(streamRequest, signal ? { signal } : undefined);
         // Track current tool call being built
         let currentToolCall = null;
         // Track usage for final chunk
@@ -1566,19 +1573,26 @@ class GeminiAdapter extends BaseProviderAdapter {
     //
     // API Execution
     //
-    async executeRequest(client, request) {
+    async executeRequest(client, request, signal) {
         const genAI = client;
         const geminiRequest = request;
-        // Cast config to any to bypass strict type checking between our internal types
-        // and the SDK's types. The SDK will validate at runtime.
-        const response = await genAI.models.generateContent({
-            model: geminiRequest.model,
-            contents: geminiRequest.contents,
-            config: geminiRequest.config,
-        });
-        return response;
+        try {
+            // Cast config to any to bypass strict type checking between our internal types
+            // and the SDK's types. The SDK will validate at runtime.
+            const response = await genAI.models.generateContent({
+                model: geminiRequest.model,
+                contents: geminiRequest.contents,
+                config: geminiRequest.config,
+            });
+            return response;
+        }
+        catch (error) {
+            if (signal?.aborted)
+                return undefined;
+            throw error;
+        }
     }
-    async *executeStreamRequest(client, request) {
+    async *executeStreamRequest(client, request, signal) {
         const genAI = client;
         const geminiRequest = request;
         // Use generateContentStream for streaming
@@ -2228,19 +2242,26 @@ class OpenAiAdapter extends BaseProviderAdapter {
     //
     // API Execution
     //
-    async executeRequest(client, request) {
+    async executeRequest(client, request, signal) {
         const openai = client;
-        // @ts-expect-error OpenAI SDK types don't match our request format exactly
-        return await openai.responses.create(request);
+        try {
+            // @ts-expect-error OpenAI SDK types don't match our request format exactly
+            return await openai.responses.create(request, signal ? { signal } : undefined);
+        }
+        catch (error) {
+            if (signal?.aborted)
+                return undefined;
+            throw error;
+        }
     }
-    async *executeStreamRequest(client, request) {
+    async *executeStreamRequest(client, request, signal) {
         const openai = client;
         const baseRequest = request;
         const streamRequest = {
             ...baseRequest,
             stream: true,
         };
-        const stream = await openai.responses.create(streamRequest);
+        const stream = await openai.responses.create(streamRequest, signal ? { signal } : undefined);
         // Track current function call being built
         let currentFunctionCall = null;
         // Track usage for final chunk
@@ -2671,19 +2692,26 @@ 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({
-            model: openRouterRequest.model,
-            messages: openRouterRequest.messages,
-            tools: openRouterRequest.tools,
-            toolChoice: openRouterRequest.tool_choice,
-            user: openRouterRequest.user,
-        });
-        return response;
+        try {
+            const response = await openRouter.chat.send({
+                model: openRouterRequest.model,
+                messages: openRouterRequest.messages,
+                tools: openRouterRequest.tools,
+                toolChoice: openRouterRequest.tool_choice,
+                user: openRouterRequest.user,
+            }, signal ? { signal } : undefined);
+            return response;
+        }
+        catch (error) {
+            if (signal?.aborted)
+                return undefined;
+            throw error;
+        }
     }
-    async *executeStreamRequest(client, request) {
+    async *executeStreamRequest(client, request, signal) {
         const openRouter = client;
         const openRouterRequest = request;
         // Use chat.send with stream: true for streaming responses
@@ -2694,7 +2722,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
@@ -3905,9 +3933,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
@@ -3915,14 +3946,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`);
@@ -3962,7 +3996,19 @@ class RetryExecutor {
                     providerRequest: options.context.providerRequest,
                     error,
                 });
-                await sleep(delay);
+                // Guard against stale socket errors that fire during sleep
+                const staleHandler = (reason) => {
+                    if (isTransientNetworkError(reason)) {
+                        log$1.trace("Suppressed stale socket error during retry sleep");
+                    }
+                };
+                process.on("unhandledRejection", staleHandler);
+                try {
+                    await sleep(delay);
+                }
+                finally {
+                    process.removeListener("unhandledRejection", staleHandler);
+                }
                 attempt++;
             }
         }
@@ -4147,7 +4193,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,
@@ -4540,9 +4586,10 @@ class StreamLoop {
         let attempt = 0;
         let chunksYielded = false;
         while (true) {
+            const controller = new AbortController();
             try {
                 // Execute streaming request
-                const streamGenerator = this.adapter.executeStreamRequest(this.client, providerRequest);
+                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) {
@@ -4577,6 +4624,8 @@ class StreamLoop {
                 break;
             }
             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);
@@ -4603,7 +4652,19 @@ class StreamLoop {
                 const delay = this.retryPolicy.getDelayForAttempt(attempt);
                 log$1.warn(`Stream request failed. Retrying in ${delay}ms...`);
                 log$1.var({ error });
-                await sleep(delay);
+                // Guard against stale socket errors that fire during sleep
+                const staleHandler = (reason) => {
+                    if (isTransientNetworkError(reason)) {
+                        log$1.trace("Suppressed stale socket error during retry sleep");
+                    }
+                };
+                process.on("unhandledRejection", staleHandler);
+                try {
+                    await sleep(delay);
+                }
+                finally {
+                    process.removeListener("unhandledRejection", staleHandler);
+                }
                 attempt++;
             }
         }