@jaypie/llm 1.3.10 → 1.3.11

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

@@ -1,13 +1,20 @@
 import { HookRunner, LlmHooks } from "../hooks/HookRunner.js";
 import { RetryPolicy } from "./RetryPolicy.js";
+import { ClassifiedError } from "../types.js";
 export interface RetryContext {
     input: unknown;
     options?: unknown;
     providerRequest: unknown;
+    /** Provider name, carried onto the thrown LlmError */
+    provider?: string;
+    /** Model in use, carried onto the thrown LlmError */
+    model?: string;
 }
 export interface ErrorClassifier {
     isRetryable(error: unknown): boolean;
     isKnownError(error: unknown): boolean;
+    /** Full classification, used to throw a typed LlmError on terminal failure */
+    classify(error: unknown): ClassifiedError;
 }
 export interface RetryExecutorConfig {
     errorClassifier: ErrorClassifier;
@@ -27,6 +34,12 @@ export declare class RetryExecutor {
     private readonly hookRunner;
     private readonly errorClassifier;
     constructor(config: RetryExecutorConfig);
+    /**
+     * Build the typed, provider-agnostic error thrown when a request cannot be
+     * completed — classified (rate limit / quota / unrecoverable / transient)
+     * and carrying the provider, model, and original error as `cause`.
+     */
+    private toTerminalError;
     /**
      * Execute an operation with retry logic.
      * Each attempt receives an AbortSignal. On failure, the signal is aborted

package/dist/esm/operate/types.d.ts

@@ -97,8 +97,14 @@ export interface ProviderToolDefinition {
 export declare enum ErrorCategory {
     /** Error is transient and can be retried */
     Retryable = "retryable",
-    /** Error is due to rate limiting */
+    /** Error is due to short-term rate limiting (retry after a delay) */
     RateLimit = "rate_limit",
+    /**
+     * Provider quota is exhausted or the account cannot be billed
+     * (insufficient funds, daily quota, plan limit). Terminal and actionable —
+     * retrying within the request budget will not help.
+     */
+    Quota = "quota",
     /** Error cannot be recovered from */
     Unrecoverable = "unrecoverable",
     /** Error type is unknown */
@@ -116,6 +122,11 @@ export interface ClassifiedError {
     shouldRetry: boolean;
     /** Suggested delay before retry (if applicable) */
     suggestedDelayMs?: number;
+    /**
+     * For {@link ErrorCategory.Quota}, distinguishes an exhausted usage quota
+     * from an account that cannot be billed (insufficient funds).
+     */
+    reason?: "quota" | "billing";
 }
 import type { ResponseBuilder } from "./response/ResponseBuilder.js";
 /**

package/dist/esm/types/LlmProvider.interface.d.ts

@@ -295,6 +295,15 @@ export interface LlmOperateOptions {
     turns?: boolean | number;
     user?: string;
 }
+/**
+ * A single model name, or a preference-ordered array of model names.
+ * An array is interpreted as a fallback chain: index 0 is primary, later
+ * entries are tried in order when earlier ones fail (provider auto-detected
+ * per entry). Accepted by the `Llm` constructor and static/instance
+ * `operate`/`send`/`stream` methods; normalized to a scalar model plus a
+ * derived fallback chain before reaching providers.
+ */
+export type LlmModelOption = string | string[];
 export interface LlmOptions {
     apiKey?: string;
     /** Chain of fallback providers to try if primary fails */

package/dist/esm/util/classifyProviderError.d.ts

@@ -0,0 +1,13 @@
+import { ClassifiedError } from "../operate/types.js";
+/**
+ * Shared, provider-agnostic first pass over an error. Returns a
+ * {@link ClassifiedError} when the message unambiguously identifies a
+ * cross-provider condition (retryable structured-output timeout, exhausted
+ * quota, or a billing failure), or `undefined` to defer to the adapter's own
+ * status/name classification.
+ *
+ * Adapters call this before their existing logic so that, for example, a
+ * `429` carrying a daily-quota message is classified as {@link
+ * ErrorCategory.Quota} rather than {@link ErrorCategory.RateLimit}.
+ */
+export declare function classifyProviderError(error: unknown): ClassifiedError | undefined;

package/dist/esm/util/resolveModelChain.d.ts

@@ -0,0 +1,17 @@
+import { LlmFallbackConfig } from "../types/LlmProvider.interface.js";
+/**
+ * Normalizes a `model` option that may be a single model name or a
+ * preference-ordered array of model names.
+ *
+ * A `string[]` is interpreted as a fallback chain: index `0` is the primary
+ * model, indices `1..` become fallback entries with an auto-detected provider
+ * (reusing `determineModelProvider`, exactly as the constructor's first
+ * argument does).
+ *
+ * Returns the primary model plus the derived fallback chain. A bare string
+ * yields an empty chain and is unchanged.
+ */
+export declare function resolveModelChain(model?: string | string[]): {
+    model?: string;
+    fallback: LlmFallbackConfig[];
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jaypie/llm",
-  "version": "1.3.10",
+  "version": "1.3.11",
   "description": "Large language model utilities",
   "repository": {
     "type": "git",