@jaypie/llm 1.3.10 → 1.3.12

package/dist/esm/Llm.d.ts

@@ -1,15 +1,19 @@
 import { JsonObject } from "@jaypie/types";
 import { LlmProviderName } from "./constants.js";
-import { LlmFallbackConfig, LlmHistory, LlmInputMessage, LlmMessageOptions, LlmOperateInput, LlmOperateOptions, LlmOperateResponse, LlmOptions, LlmProvider } from "./types/LlmProvider.interface.js";
+import { LlmFallbackConfig, LlmHistory, LlmInputMessage, LlmMessageOptions, LlmModelOption, LlmOperateInput, LlmOperateOptions, LlmOperateResponse, LlmOptions, LlmProvider } from "./types/LlmProvider.interface.js";
 import { LlmStreamChunk } from "./types/LlmStreamChunk.interface.js";
 declare class Llm implements LlmProvider {
     private _fallbackConfig?;
     private _llm;
     private _options;
     private _provider;
-    constructor(providerName?: LlmProviderName | string, options?: LlmOptions);
+    constructor(providerName?: LlmProviderName | string, options?: Omit<LlmOptions, "model"> & {
+        model?: LlmModelOption;
+    });
     private createProvider;
-    send(message: string, options?: LlmMessageOptions): Promise<string | JsonObject>;
+    send(message: string, options?: Omit<LlmMessageOptions, "model"> & {
+        model?: LlmModelOption;
+    }): Promise<string | JsonObject>;
     /**
      * Resolves the fallback chain from instance config and per-call options.
      * Per-call options take precedence over instance config.
@@ -20,23 +24,27 @@ declare class Llm implements LlmProvider {
      * Creates a fallback Llm instance lazily when needed.
      */
     private createFallbackInstance;
-    operate(input: string | LlmHistory | LlmInputMessage | LlmOperateInput, options?: LlmOperateOptions): Promise<LlmOperateResponse>;
-    stream(input: string | LlmHistory | LlmInputMessage | LlmOperateInput, options?: LlmOperateOptions): AsyncIterable<LlmStreamChunk>;
-    static send(message: string, options?: LlmMessageOptions & {
+    operate(input: string | LlmHistory | LlmInputMessage | LlmOperateInput, options?: Omit<LlmOperateOptions, "model"> & {
+        model?: LlmModelOption;
+    }): Promise<LlmOperateResponse>;
+    stream(input: string | LlmHistory | LlmInputMessage | LlmOperateInput, options?: Omit<LlmOperateOptions, "model"> & {
+        model?: LlmModelOption;
+    }): AsyncIterable<LlmStreamChunk>;
+    static send(message: string, options?: Omit<LlmMessageOptions, "model"> & {
         llm?: LlmProviderName;
         apiKey?: string;
-        model?: string;
+        model?: string | string[];
     }): Promise<string | JsonObject>;
-    static operate(input: string | LlmHistory | LlmInputMessage | LlmOperateInput, options?: LlmOperateOptions & {
+    static operate(input: string | LlmHistory | LlmInputMessage | LlmOperateInput, options?: Omit<LlmOperateOptions, "model"> & {
         apiKey?: string;
         fallback?: LlmFallbackConfig[] | false;
         llm?: LlmProviderName;
-        model?: string;
+        model?: string | string[];
     }): Promise<LlmOperateResponse>;
-    static stream(input: string | LlmHistory | LlmInputMessage | LlmOperateInput, options?: LlmOperateOptions & {
+    static stream(input: string | LlmHistory | LlmInputMessage | LlmOperateInput, options?: Omit<LlmOperateOptions, "model"> & {
         llm?: LlmProviderName;
         apiKey?: string;
-        model?: string;
+        model?: string | string[];
     }): AsyncIterable<LlmStreamChunk>;
 }
 export default Llm;

package/dist/esm/constants.d.ts

@@ -21,6 +21,13 @@ export declare const MODEL: {
     SONNET: string;
     HAIKU: string;
     MYTHOS: string;
+    FIREWORKS: {
+        DEEPSEEK: string;
+        GLM: string;
+        KIMI: string;
+        MINIMAX: string;
+        QWEN: string;
+    };
     GEMINI_FLASH: string;
     GEMINI_FLASH_LITE: string;
     GEMINI_PRO: string;
@@ -81,6 +88,13 @@ export declare const PROVIDER: {
             readonly SCHEMA_VERSION: "v2";
         };
     };
+    readonly FIREWORKS: {
+        readonly API_KEY: "FIREWORKS_API_KEY";
+        readonly BASE_URL: "https://api.fireworks.ai/inference/v1";
+        readonly DEFAULT: string;
+        readonly MODEL_MATCH_WORDS: readonly ["fireworks"];
+        readonly NAME: "fireworks";
+    };
     /** @deprecated Use PROVIDER.GOOGLE — "Google" is the provider; Gemini is the model family */
     readonly GEMINI: {
         readonly DEFAULT: string;
@@ -159,7 +173,7 @@ export declare const PROVIDER: {
         readonly NAME: "xai";
     };
 };
-export type LlmProviderName = typeof PROVIDER.ANTHROPIC.NAME | typeof PROVIDER.BEDROCK.NAME | typeof PROVIDER.GOOGLE.NAME | typeof PROVIDER.OPENAI.NAME | typeof PROVIDER.OPENROUTER.NAME | typeof PROVIDER.XAI.NAME;
+export type LlmProviderName = typeof PROVIDER.ANTHROPIC.NAME | typeof PROVIDER.BEDROCK.NAME | typeof PROVIDER.FIREWORKS.NAME | typeof PROVIDER.GOOGLE.NAME | typeof PROVIDER.OPENAI.NAME | typeof PROVIDER.OPENROUTER.NAME | typeof PROVIDER.XAI.NAME;
 export declare const DEFAULT: {
     /** @deprecated Size tiers are retired in 2.0. Use DEFAULT.PROVIDER.DEFAULT, or pick a specific model from MODEL.*. */
     readonly MODEL: {

package/dist/esm/errors/LlmError.d.ts

@@ -0,0 +1,62 @@
+import { JaypieError } from "@jaypie/errors";
+import { ErrorCategory } from "../operate/types.js";
+export interface LlmErrorOptions {
+    /** Provider name that produced the error (e.g. "anthropic", "google") */
+    provider?: string;
+    /** Model in use when the error occurred */
+    model?: string;
+    /** Milliseconds to wait before retrying, when the provider suggests one */
+    retryAfterMs?: number;
+    /** The original provider error, preserved for inspection */
+    cause?: unknown;
+}
+/**
+ * Normalized, provider-agnostic LLM error. Thrown by the operate/stream retry
+ * layer when a request cannot be completed, so consumers can `catch` a stable
+ * type regardless of which provider failed. Extends {@link JaypieError} so
+ * `isJaypieError()` and `.status` continue to work; the original provider error
+ * is preserved on `.cause`.
+ */
+export declare class LlmError extends JaypieError {
+    readonly category: ErrorCategory;
+    readonly provider?: string;
+    readonly model?: string;
+    readonly retryAfterMs?: number;
+    readonly cause?: unknown;
+    constructor(message: string, category: ErrorCategory, { status, title, provider, model, retryAfterMs, cause, }?: LlmErrorOptions & {
+        status?: number;
+        title?: string;
+    });
+}
+/**
+ * Short-term rate limiting (per-minute 429). Terminal within the request
+ * budget; `retryAfterMs` carries the provider's suggested wait when available.
+ */
+export declare class LlmRateLimitError extends LlmError {
+    constructor(message: string, options?: LlmErrorOptions);
+}
+/**
+ * Provider quota is exhausted or the account cannot be billed. Terminal and
+ * actionable. `reason` distinguishes an exhausted usage quota from insufficient
+ * funds.
+ */
+export declare class LlmQuotaError extends LlmError {
+    readonly reason: "quota" | "billing";
+    constructor(message: string, { reason, ...options }?: LlmErrorOptions & {
+        reason?: "quota" | "billing";
+    });
+}
+/**
+ * The request cannot be recovered from (bad request, authentication,
+ * permission, not found). Terminal.
+ */
+export declare class LlmUnrecoverableError extends LlmError {
+    constructor(message: string, options?: LlmErrorOptions);
+}
+/**
+ * A transient or unknown error survived the retry budget. Terminal only because
+ * retries were exhausted; the underlying condition may succeed later.
+ */
+export declare class LlmTransientError extends LlmError {
+    constructor(message: string, options?: LlmErrorOptions);
+}

package/dist/esm/errors/toLlmError.d.ts

@@ -0,0 +1,11 @@
+import { ClassifiedError } from "../operate/types.js";
+import { LlmError } from "./LlmError.js";
+/**
+ * Map a {@link ClassifiedError} to the matching {@link LlmError} subclass,
+ * preserving the original error as `cause`. Used by the retry layer to throw a
+ * stable, catchable type instead of a bare gateway error.
+ */
+export declare function toLlmError(classified: ClassifiedError, context?: {
+    provider?: string;
+    model?: string;
+}): LlmError;

package/dist/esm/index.d.ts

@@ -1,6 +1,7 @@
 import * as _jaypie_types from '@jaypie/types';
 import { JsonObject, AnyValue, NaturalMap, NaturalSchema, JsonReturn } from '@jaypie/types';
 import { z } from 'zod/v4';
+import { JaypieError } from '@jaypie/errors';
 
 /**
  * Provider-neutral reasoning-effort levels — a five-point relative scale that
@@ -25,6 +26,13 @@ declare const MODEL: {
     SONNET: string;
     HAIKU: string;
     MYTHOS: string;
+    FIREWORKS: {
+        DEEPSEEK: string;
+        GLM: string;
+        KIMI: string;
+        MINIMAX: string;
+        QWEN: string;
+    };
     GEMINI_FLASH: string;
     GEMINI_FLASH_LITE: string;
     GEMINI_PRO: string;
@@ -85,6 +93,13 @@ declare const PROVIDER: {
             readonly SCHEMA_VERSION: "v2";
         };
     };
+    readonly FIREWORKS: {
+        readonly API_KEY: "FIREWORKS_API_KEY";
+        readonly BASE_URL: "https://api.fireworks.ai/inference/v1";
+        readonly DEFAULT: string;
+        readonly MODEL_MATCH_WORDS: readonly ["fireworks"];
+        readonly NAME: "fireworks";
+    };
     /** @deprecated Use PROVIDER.GOOGLE — "Google" is the provider; Gemini is the model family */
     readonly GEMINI: {
         readonly DEFAULT: string;
@@ -163,7 +178,7 @@ declare const PROVIDER: {
         readonly NAME: "xai";
     };
 };
-type LlmProviderName = typeof PROVIDER.ANTHROPIC.NAME | typeof PROVIDER.BEDROCK.NAME | typeof PROVIDER.GOOGLE.NAME | typeof PROVIDER.OPENAI.NAME | typeof PROVIDER.OPENROUTER.NAME | typeof PROVIDER.XAI.NAME;
+type LlmProviderName = typeof PROVIDER.ANTHROPIC.NAME | typeof PROVIDER.BEDROCK.NAME | typeof PROVIDER.FIREWORKS.NAME | typeof PROVIDER.GOOGLE.NAME | typeof PROVIDER.OPENAI.NAME | typeof PROVIDER.OPENROUTER.NAME | typeof PROVIDER.XAI.NAME;
 declare const DEFAULT: {
     /** @deprecated Size tiers are retired in 2.0. Use DEFAULT.PROVIDER.DEFAULT, or pick a specific model from MODEL.*. */
     readonly MODEL: {
@@ -324,7 +339,7 @@ declare enum LlmResponseStatus {
     Incomplete = "incomplete",
     InProgress = "in_progress"
 }
-interface LlmError {
+interface LlmError$1 {
     detail?: string;
     status: number | string;
     title: string;
@@ -593,6 +608,15 @@ 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.
+ */
+type LlmModelOption = string | string[];
 interface LlmOptions {
     apiKey?: string;
     /** Chain of fallback providers to try if primary fails */
@@ -610,7 +634,7 @@ interface LlmUsageItem {
 type LlmUsage = LlmUsageItem[];
 interface LlmOperateResponse {
     content?: string | JsonObject;
-    error?: LlmError;
+    error?: LlmError$1;
     /** Number of providers attempted (1 = primary only, >1 = fallback(s) used) */
     fallbackAttempts?: number;
     /** Whether a fallback provider was used instead of the primary */
@@ -636,9 +660,13 @@ declare class Llm implements LlmProvider {
     private _llm;
     private _options;
     private _provider;
-    constructor(providerName?: LlmProviderName | string, options?: LlmOptions);
+    constructor(providerName?: LlmProviderName | string, options?: Omit<LlmOptions, "model"> & {
+        model?: LlmModelOption;
+    });
     private createProvider;
-    send(message: string, options?: LlmMessageOptions): Promise<string | JsonObject>;
+    send(message: string, options?: Omit<LlmMessageOptions, "model"> & {
+        model?: LlmModelOption;
+    }): Promise<string | JsonObject>;
     /**
      * Resolves the fallback chain from instance config and per-call options.
      * Per-call options take precedence over instance config.
@@ -649,23 +677,27 @@ declare class Llm implements LlmProvider {
      * Creates a fallback Llm instance lazily when needed.
      */
     private createFallbackInstance;
-    operate(input: string | LlmHistory | LlmInputMessage | LlmOperateInput, options?: LlmOperateOptions): Promise<LlmOperateResponse>;
-    stream(input: string | LlmHistory | LlmInputMessage | LlmOperateInput, options?: LlmOperateOptions): AsyncIterable<LlmStreamChunk>;
-    static send(message: string, options?: LlmMessageOptions & {
+    operate(input: string | LlmHistory | LlmInputMessage | LlmOperateInput, options?: Omit<LlmOperateOptions, "model"> & {
+        model?: LlmModelOption;
+    }): Promise<LlmOperateResponse>;
+    stream(input: string | LlmHistory | LlmInputMessage | LlmOperateInput, options?: Omit<LlmOperateOptions, "model"> & {
+        model?: LlmModelOption;
+    }): AsyncIterable<LlmStreamChunk>;
+    static send(message: string, options?: Omit<LlmMessageOptions, "model"> & {
         llm?: LlmProviderName;
         apiKey?: string;
-        model?: string;
+        model?: string | string[];
     }): Promise<string | JsonObject>;
-    static operate(input: string | LlmHistory | LlmInputMessage | LlmOperateInput, options?: LlmOperateOptions & {
+    static operate(input: string | LlmHistory | LlmInputMessage | LlmOperateInput, options?: Omit<LlmOperateOptions, "model"> & {
         apiKey?: string;
         fallback?: LlmFallbackConfig[] | false;
         llm?: LlmProviderName;
-        model?: string;
+        model?: string | string[];
     }): Promise<LlmOperateResponse>;
-    static stream(input: string | LlmHistory | LlmInputMessage | LlmOperateInput, options?: LlmOperateOptions & {
+    static stream(input: string | LlmHistory | LlmInputMessage | LlmOperateInput, options?: Omit<LlmOperateOptions, "model"> & {
         llm?: LlmProviderName;
         apiKey?: string;
-        model?: string;
+        model?: string | string[];
     }): AsyncIterable<LlmStreamChunk>;
 }
 
@@ -696,6 +728,87 @@ declare class JaypieToolkit extends Toolkit {
 }
 declare const toolkit: JaypieToolkit;
 
+/**
+ * Categories of errors for retry logic
+ */
+declare enum ErrorCategory {
+    /** Error is transient and can be retried */
+    Retryable = "retryable",
+    /** 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 */
+    Unknown = "unknown"
+}
+
+interface LlmErrorOptions {
+    /** Provider name that produced the error (e.g. "anthropic", "google") */
+    provider?: string;
+    /** Model in use when the error occurred */
+    model?: string;
+    /** Milliseconds to wait before retrying, when the provider suggests one */
+    retryAfterMs?: number;
+    /** The original provider error, preserved for inspection */
+    cause?: unknown;
+}
+/**
+ * Normalized, provider-agnostic LLM error. Thrown by the operate/stream retry
+ * layer when a request cannot be completed, so consumers can `catch` a stable
+ * type regardless of which provider failed. Extends {@link JaypieError} so
+ * `isJaypieError()` and `.status` continue to work; the original provider error
+ * is preserved on `.cause`.
+ */
+declare class LlmError extends JaypieError {
+    readonly category: ErrorCategory;
+    readonly provider?: string;
+    readonly model?: string;
+    readonly retryAfterMs?: number;
+    readonly cause?: unknown;
+    constructor(message: string, category: ErrorCategory, { status, title, provider, model, retryAfterMs, cause, }?: LlmErrorOptions & {
+        status?: number;
+        title?: string;
+    });
+}
+/**
+ * Short-term rate limiting (per-minute 429). Terminal within the request
+ * budget; `retryAfterMs` carries the provider's suggested wait when available.
+ */
+declare class LlmRateLimitError extends LlmError {
+    constructor(message: string, options?: LlmErrorOptions);
+}
+/**
+ * Provider quota is exhausted or the account cannot be billed. Terminal and
+ * actionable. `reason` distinguishes an exhausted usage quota from insufficient
+ * funds.
+ */
+declare class LlmQuotaError extends LlmError {
+    readonly reason: "quota" | "billing";
+    constructor(message: string, { reason, ...options }?: LlmErrorOptions & {
+        reason?: "quota" | "billing";
+    });
+}
+/**
+ * The request cannot be recovered from (bad request, authentication,
+ * permission, not found). Terminal.
+ */
+declare class LlmUnrecoverableError extends LlmError {
+    constructor(message: string, options?: LlmErrorOptions);
+}
+/**
+ * A transient or unknown error survived the retry budget. Terminal only because
+ * retries were exhausted; the underlying condition may succeed later.
+ */
+declare class LlmTransientError extends LlmError {
+    constructor(message: string, options?: LlmErrorOptions);
+}
+
 /**
  * Extracts reasoning text from LLM history items.
  *
@@ -741,6 +854,25 @@ declare class BedrockProvider implements LlmProvider {
     stream(input: string | LlmHistory | LlmInputMessage, options?: LlmOperateOptions): AsyncIterable<LlmStreamChunk>;
 }
 
+declare class FireworksProvider implements LlmProvider {
+    private model;
+    private _client?;
+    private _operateLoop?;
+    private _streamLoop?;
+    private apiKey?;
+    private log;
+    private conversationHistory;
+    constructor(model?: string, { apiKey }?: {
+        apiKey?: string;
+    });
+    private getClient;
+    private getOperateLoop;
+    private getStreamLoop;
+    send(message: string, options?: LlmMessageOptions): Promise<string | JsonObject>;
+    operate(input: string | LlmHistory | LlmInputMessage, options?: LlmOperateOptions): Promise<LlmOperateResponse>;
+    stream(input: string | LlmHistory | LlmInputMessage, options?: LlmOperateOptions): AsyncIterable<LlmStreamChunk>;
+}
+
 declare class GoogleProvider implements LlmProvider {
     private model;
     private _client?;
@@ -798,5 +930,5 @@ declare class XaiProvider implements LlmProvider {
     stream(input: string | LlmHistory | LlmInputMessage, options?: LlmOperateOptions): AsyncIterable<LlmStreamChunk>;
 }
 
-export { BedrockProvider, GoogleProvider as GeminiProvider, GoogleProvider, JaypieToolkit, constants as LLM, Llm, LlmMessageRole, LlmMessageType, LlmProgressEventType, LlmStreamChunkType, OpenRouterProvider, Toolkit, XaiProvider, extractReasoning, isLlmOperateInput, isLlmOperateInputContent, isLlmOperateInputFile, isLlmOperateInputImage, jsonSchemaToNaturalSchema, naturalSchemaToJsonSchema, toolkit, tools };
-export type { LlmEffort, LlmFallbackConfig, LlmHistory, LlmInputContent, LlmInputContentFile, LlmInputContentImage, LlmInputContentText, LlmInputMessage, LlmMessageOptions, LlmOperateInput, LlmOperateInputContent, LlmOperateInputFile, LlmOperateInputImage, LlmOperateOptions, LlmOperateResponse, LlmOptions, LlmProgressCallback, LlmProgressEvent, LlmProgressToolCall, LlmProvider, LlmStreamChunk, LlmStreamChunkDone, LlmStreamChunkError, LlmStreamChunkText, LlmStreamChunkToolCall, LlmStreamChunkToolResult, LlmTool };
+export { BedrockProvider, ErrorCategory, FireworksProvider, GoogleProvider as GeminiProvider, GoogleProvider, JaypieToolkit, constants as LLM, Llm, LlmError, LlmMessageRole, LlmMessageType, LlmProgressEventType, LlmQuotaError, LlmRateLimitError, LlmStreamChunkType, LlmTransientError, LlmUnrecoverableError, OpenRouterProvider, Toolkit, XaiProvider, extractReasoning, isLlmOperateInput, isLlmOperateInputContent, isLlmOperateInputFile, isLlmOperateInputImage, jsonSchemaToNaturalSchema, naturalSchemaToJsonSchema, toolkit, tools };
+export type { LlmEffort, LlmErrorOptions, LlmFallbackConfig, LlmHistory, LlmInputContent, LlmInputContentFile, LlmInputContentImage, LlmInputContentText, LlmInputMessage, LlmMessageOptions, LlmModelOption, LlmOperateInput, LlmOperateInputContent, LlmOperateInputFile, LlmOperateInputImage, LlmOperateOptions, LlmOperateResponse, LlmOptions, LlmProgressCallback, LlmProgressEvent, LlmProgressToolCall, LlmProvider, LlmStreamChunk, LlmStreamChunkDone, LlmStreamChunkError, LlmStreamChunkText, LlmStreamChunkToolCall, LlmStreamChunkToolResult, LlmTool };