@jaypie/llm 1.2.13 → 1.2.15

package/dist/cjs/constants.d.ts

@@ -32,7 +32,7 @@ export declare const PROVIDER: {
             readonly TINY: "gemini-3-flash-preview";
         };
         readonly MODEL_MATCH_WORDS: readonly ["gemini", "google"];
-        readonly NAME: "gemini";
+        readonly NAME: "google";
         readonly ROLE: {
             readonly MODEL: "model";
             readonly USER: "user";

package/dist/cjs/index.cjs

@@ -81,7 +81,7 @@ const PROVIDER = {
             TINY: FIRST_CLASS_PROVIDER.GEMINI.TINY,
         },
         MODEL_MATCH_WORDS: ["gemini", "google"],
-        NAME: "gemini",
+        NAME: "google",
         ROLE: {
             MODEL: "model",
             USER: "user",
@@ -196,7 +196,7 @@ function determineModelProvider(input) {
             provider: PROVIDER.ANTHROPIC.NAME,
         };
     }
-    if (input === PROVIDER.GEMINI.NAME) {
+    if (input === PROVIDER.GEMINI.NAME || input === "gemini") {
         return {
             model: PROVIDER.GEMINI.MODEL.DEFAULT,
             provider: PROVIDER.GEMINI.NAME,
@@ -3957,73 +3957,91 @@ class RetryExecutor {
      */
     async execute(operation, options) {
         let attempt = 0;
-        while (true) {
-            const controller = new AbortController();
-            try {
-                const result = await operation(controller.signal);
-                if (attempt > 0) {
-                    log$1.debug(`API call succeeded after ${attempt} retries`);
+        // Persistent guard against stale socket errors (TypeError: terminated).
+        // Installed after the first abort and kept alive through subsequent attempts
+        // so that asynchronous undici socket teardown errors that fire between
+        // sleep completion and the next operation's await are caught.
+        let staleGuard;
+        const installGuard = () => {
+            if (staleGuard)
+                return;
+            staleGuard = (reason) => {
+                if (isTransientNetworkError(reason)) {
+                    log$1.trace("Suppressed stale socket error during retry");
                 }
-                return result;
+            };
+            process.on("unhandledRejection", staleGuard);
+        };
+        const removeGuard = () => {
+            if (staleGuard) {
+                process.removeListener("unhandledRejection", staleGuard);
+                staleGuard = undefined;
             }
-            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`);
-                    log$1.var({ error });
-                    await this.hookRunner.runOnUnrecoverableError(options.hooks, {
-                        input: options.context.input,
-                        options: options.context.options,
-                        providerRequest: options.context.providerRequest,
-                        error,
-                    });
-                    const errorMessage = error instanceof Error ? error.message : String(error);
-                    throw new errors.BadGatewayError(errorMessage);
+        };
+        try {
+            while (true) {
+                const controller = new AbortController();
+                try {
+                    const result = await operation(controller.signal);
+                    if (attempt > 0) {
+                        log$1.debug(`API call succeeded after ${attempt} retries`);
+                    }
+                    return result;
                 }
-                // Check if error is not retryable
-                if (!this.errorClassifier.isRetryable(error)) {
-                    log$1.error("API call failed with non-retryable error");
-                    log$1.var({ error });
-                    await this.hookRunner.runOnUnrecoverableError(options.hooks, {
+                catch (error) {
+                    // Abort the previous request to kill lingering socket callbacks
+                    controller.abort("retry");
+                    // Install the guard immediately after abort — stale socket errors
+                    // can fire on any subsequent microtask boundary (during hook calls,
+                    // sleep, or the next operation attempt)
+                    installGuard();
+                    // Check if we've exhausted retries
+                    if (!this.policy.shouldRetry(attempt)) {
+                        log$1.error(`API call failed after ${this.policy.maxRetries} retries`);
+                        log$1.var({ error });
+                        await this.hookRunner.runOnUnrecoverableError(options.hooks, {
+                            input: options.context.input,
+                            options: options.context.options,
+                            providerRequest: options.context.providerRequest,
+                            error,
+                        });
+                        const errorMessage = error instanceof Error ? error.message : String(error);
+                        throw new errors.BadGatewayError(errorMessage);
+                    }
+                    // Check if error is not retryable
+                    if (!this.errorClassifier.isRetryable(error)) {
+                        log$1.error("API call failed with non-retryable error");
+                        log$1.var({ error });
+                        await this.hookRunner.runOnUnrecoverableError(options.hooks, {
+                            input: options.context.input,
+                            options: options.context.options,
+                            providerRequest: options.context.providerRequest,
+                            error,
+                        });
+                        const errorMessage = error instanceof Error ? error.message : String(error);
+                        throw new errors.BadGatewayError(errorMessage);
+                    }
+                    // Warn if this is an unknown error type
+                    if (!this.errorClassifier.isKnownError(error)) {
+                        log$1.warn("API returned unknown error type, will retry");
+                        log$1.var({ error });
+                    }
+                    const delay = this.policy.getDelayForAttempt(attempt);
+                    log$1.warn(`API call failed. Retrying in ${delay}ms...`);
+                    await this.hookRunner.runOnRetryableError(options.hooks, {
                         input: options.context.input,
                         options: options.context.options,
                         providerRequest: options.context.providerRequest,
                         error,
                     });
-                    const errorMessage = error instanceof Error ? error.message : String(error);
-                    throw new errors.BadGatewayError(errorMessage);
-                }
-                // Warn if this is an unknown error type
-                if (!this.errorClassifier.isKnownError(error)) {
-                    log$1.warn("API returned unknown error type, will retry");
-                    log$1.var({ error });
-                }
-                const delay = this.policy.getDelayForAttempt(attempt);
-                log$1.warn(`API call failed. Retrying in ${delay}ms...`);
-                await this.hookRunner.runOnRetryableError(options.hooks, {
-                    input: options.context.input,
-                    options: options.context.options,
-                    providerRequest: options.context.providerRequest,
-                    error,
-                });
-                // 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 kit.sleep(delay);
+                    attempt++;
                 }
-                finally {
-                    process.removeListener("unhandledRejection", staleHandler);
-                }
-                attempt++;
             }
         }
+        finally {
+            removeGuard();
+        }
     }
 }
 
@@ -4597,89 +4615,103 @@ class StreamLoop {
         // 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;
+        // Persistent guard against stale socket errors (TypeError: terminated).
+        // Installed after the first abort and kept alive through subsequent attempts.
+        let staleGuard;
+        const installGuard = () => {
+            if (staleGuard)
+                return;
+            staleGuard = (reason) => {
+                if (isTransientNetworkError(reason)) {
+                    log$1.trace("Suppressed stale socket error during retry");
+                }
+            };
+            process.on("unhandledRejection", staleGuard);
+        };
+        const removeGuard = () => {
+            if (staleGuard) {
+                process.removeListener("unhandledRejection", staleGuard);
+                staleGuard = undefined;
+            }
+        };
+        try {
+            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;
+                        }
                     }
-                    // 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;
+                    // Stream completed successfully
+                    if (attempt > 0) {
+                        log$1.debug(`Stream request succeeded after ${attempt} retries`);
                     }
-                    // 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);
+                    break;
+                }
+                catch (error) {
+                    // Abort the previous request to kill lingering socket callbacks
+                    controller.abort("retry");
+                    // Install the guard immediately after abort
+                    installGuard();
+                    // 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 };
                     }
-                    // Pass through error chunks
-                    if (chunk.type === exports.LlmStreamChunkType.Error) {
-                        chunksYielded = true;
-                        yield chunk;
+                    // 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);
                     }
-                }
-                // Stream completed successfully
-                if (attempt > 0) {
-                    log$1.debug(`Stream request succeeded after ${attempt} retries`);
-                }
-                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);
-                    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`);
+                    const delay = this.retryPolicy.getDelayForAttempt(attempt);
+                    log$1.warn(`Stream request failed. Retrying in ${delay}ms...`);
                     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 });
-                // 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 kit.sleep(delay);
+                    attempt++;
                 }
-                finally {
-                    process.removeListener("unhandledRejection", staleHandler);
-                }
-                attempt++;
             }
         }
+        finally {
+            removeGuard();
+        }
         // Execute afterEachModelResponse hook
         await this.hookRunnerInstance.runAfterModelResponse(context.hooks, {
             content: "",
@@ -5539,6 +5571,10 @@ class Llm {
         const { fallback, model } = options;
         let finalProvider = providerName;
         let finalModel = model;
+        // Legacy: accept "gemini" but warn
+        if (providerName === "gemini") {
+            log$2.warn(`Provider "gemini" is deprecated, use "${PROVIDER.GEMINI.NAME}" instead`);
+        }
         if (model) {
             const modelDetermined = determineModelProvider(model);
             finalModel = modelDetermined.model;
@@ -5553,6 +5589,10 @@ class Llm {
                 throw new errors.ConfigurationError(`Unable to determine provider from: ${providerName}`);
             }
             finalProvider = providerDetermined.provider;
+            // When providerName is actually a model name, extract the model (#213)
+            if (!finalModel && providerName !== providerDetermined.provider) {
+                finalModel = providerDetermined.model;
+            }
         }
         // Handle conflicts: if both providerName and model specify different providers
         if (model && providerName !== DEFAULT.PROVIDER.NAME) {