@jaypie/llm 1.3.10 → 1.3.12

package/dist/cjs/index.d.cts

@@ -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 };

package/dist/cjs/index.d.ts

@@ -1,16 +1,20 @@
 export { default as Llm } from "./Llm.js";
 export * as LLM from "./constants.js";
 export type { LlmEffort } from "./constants.js";
-export type { LlmFallbackConfig, LlmHistory, LlmInputContent, LlmInputContentFile, LlmInputContentImage, LlmInputContentText, LlmInputMessage, LlmMessageOptions, LlmOperateInput, LlmOperateInputContent, LlmOperateInputFile, LlmOperateInputImage, LlmOperateOptions, LlmOperateResponse, LlmOptions, LlmProgressCallback, LlmProgressEvent, LlmProgressToolCall, LlmProvider, } from "./types/LlmProvider.interface.js";
+export type { LlmFallbackConfig, LlmHistory, LlmInputContent, LlmInputContentFile, LlmInputContentImage, LlmInputContentText, LlmInputMessage, LlmMessageOptions, LlmModelOption, LlmOperateInput, LlmOperateInputContent, LlmOperateInputFile, LlmOperateInputImage, LlmOperateOptions, LlmOperateResponse, LlmOptions, LlmProgressCallback, LlmProgressEvent, LlmProgressToolCall, LlmProvider, } from "./types/LlmProvider.interface.js";
 export { LlmMessageRole, LlmMessageType, LlmProgressEventType, } from "./types/LlmProvider.interface.js";
 export { isLlmOperateInput, isLlmOperateInputContent, isLlmOperateInputFile, isLlmOperateInputImage, } from "./types/LlmOperateInput.guards.js";
 export type { LlmTool } from "./types/LlmTool.interface.js";
 export type { LlmStreamChunk, LlmStreamChunkDone, LlmStreamChunkError, LlmStreamChunkText, LlmStreamChunkToolCall, LlmStreamChunkToolResult, } from "./types/LlmStreamChunk.interface.js";
 export { LlmStreamChunkType } from "./types/LlmStreamChunk.interface.js";
 export { JaypieToolkit, toolkit, Toolkit, tools } from "./tools/index.js";
+export { LlmError, LlmQuotaError, LlmRateLimitError, LlmTransientError, LlmUnrecoverableError, } from "./errors/LlmError.js";
+export type { LlmErrorOptions } from "./errors/LlmError.js";
+export { ErrorCategory } from "./operate/types.js";
 export { extractReasoning } from "./util/extractReasoning.js";
 export { jsonSchemaToNaturalSchema, naturalSchemaToJsonSchema, } from "./util/jsonSchema.js";
 export { BedrockProvider } from "./providers/bedrock/index.js";
+export { FireworksProvider } from "./providers/fireworks/index.js";
 /** @deprecated Use GoogleProvider — "Google" is the provider; Gemini is the model family */
 export { GoogleProvider as GeminiProvider } from "./providers/google/index.js";
 export { GoogleProvider } from "./providers/google/index.js";

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

@@ -0,0 +1,151 @@
+import { JsonObject, NaturalSchema } from "@jaypie/types";
+import { z } from "zod/v4";
+import { Toolkit } from "../../tools/Toolkit.class.js";
+import { LlmHistory, LlmOperateOptions, LlmUsageItem } from "../../types/LlmProvider.interface.js";
+import { LlmStreamChunk } from "../../types/LlmStreamChunk.interface.js";
+import { ClassifiedError, OperateRequest, ParsedResponse, ProviderToolDefinition, StandardToolCall, StandardToolResult } from "../types.js";
+import { BaseProviderAdapter } from "./ProviderAdapter.interface.js";
+interface FireworksMessage {
+    role: "system" | "user" | "assistant" | "tool";
+    content?: string | FireworksContentPart[] | null;
+    toolCalls?: FireworksToolCall[];
+    toolCallId?: string;
+}
+interface FireworksToolCall {
+    id: string;
+    type: "function";
+    function: {
+        name: string;
+        arguments: string;
+    };
+}
+interface FireworksResponseMessage {
+    role: "assistant";
+    content?: string | null;
+    toolCalls?: FireworksToolCall[];
+    refusal?: string | null;
+    reasoning?: string | null;
+    reasoning_content?: string | null;
+}
+interface FireworksChoice {
+    index: number;
+    message: FireworksResponseMessage;
+    finishReason: string | null;
+    finish_reason?: string | null;
+}
+interface FireworksUsage {
+    promptTokens: number;
+    completionTokens: number;
+    totalTokens: number;
+    prompt_tokens?: number;
+    completion_tokens?: number;
+    total_tokens?: number;
+    completionTokensDetails?: {
+        reasoningTokens?: number;
+    };
+}
+interface FireworksResponse {
+    id: string;
+    object: string;
+    created: number;
+    model: string;
+    choices: FireworksChoice[];
+    usage?: FireworksUsage;
+}
+interface FireworksTool {
+    type: "function";
+    function: {
+        name: string;
+        description: string;
+        parameters: JsonObject;
+    };
+}
+interface FireworksJsonSchemaConfig {
+    name: string;
+    description?: string;
+    schema: JsonObject;
+    strict?: boolean;
+}
+type FireworksResponseFormat = {
+    type: "json_schema";
+    json_schema: FireworksJsonSchemaConfig;
+} | {
+    type: "json_object";
+} | {
+    type: "text";
+};
+interface FireworksRequest {
+    model: string;
+    messages: FireworksMessage[];
+    tools?: FireworksTool[];
+    tool_choice?: "auto" | "none" | "required";
+    response_format?: FireworksResponseFormat;
+    reasoning_effort?: string;
+    user?: string;
+}
+/**
+ * Fireworks content part types. Fireworks follows the OpenAI Chat Completions
+ * multimodal schema for `image_url` parts (URL or base64 data URI). There is
+ * no OpenAI-style `file` part, and the API rejects `data:` URIs for documents
+ * ("Unsupported URL scheme 'data'"), so file inputs cannot be delivered.
+ */
+type FireworksContentPart = {
+    type: "text";
+    text: string;
+} | {
+    type: "image_url";
+    imageUrl: {
+        url: string;
+    };
+};
+/**
+ * FireworksAdapter implements the ProviderAdapter interface for Fireworks AI's
+ * OpenAI-compatible Chat Completions API. It handles request building,
+ * response parsing, and error classification specific to Fireworks.
+ */
+export declare class FireworksAdapter extends BaseProviderAdapter {
+    readonly name: "fireworks";
+    readonly defaultModel: string;
+    private runtimeNoStructuredOutputModels;
+    rememberModelRejectsStructuredOutput(model: string): void;
+    clearRuntimeNoStructuredOutputModels(): void;
+    private supportsStructuredOutput;
+    private runtimeNoTemperatureModels;
+    rememberModelRejectsTemperature(model: string): void;
+    clearRuntimeNoTemperatureModels(): void;
+    private supportsTemperature;
+    buildRequest(request: OperateRequest): FireworksRequest;
+    formatTools(toolkit: Toolkit, _outputSchema?: JsonObject): ProviderToolDefinition[];
+    formatOutputSchema(schema: JsonObject | NaturalSchema | z.ZodType): JsonObject;
+    executeRequest(client: unknown, request: unknown, signal?: AbortSignal): Promise<FireworksResponse>;
+    /**
+     * Serialize the internal request into the OpenAI-compatible wire body for
+     * Fireworks' Chat Completions endpoint. Top-level fields (model, tools,
+     * tool_choice, response_format, reasoning_effort, user, temperature, and any
+     * providerOptions) are already wire-shaped (snake_case); only messages carry
+     * camelCase tool fields that must become snake_case on the wire.
+     */
+    private toWireBody;
+    /**
+     * Rebuild a structured-output request without `response_format`, swapping in
+     * the legacy fake-tool emulation. Used as a runtime fallback when a model
+     * rejects native json_schema.
+     */
+    private toFallbackStructuredOutputRequest;
+    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;
+    formatToolResult(toolCall: StandardToolCall, result: StandardToolResult): FireworksMessage;
+    appendToolResult(request: unknown, toolCall: StandardToolCall, result: StandardToolResult): FireworksRequest;
+    responseToHistoryItems(response: unknown): LlmHistory;
+    classifyError(error: unknown): ClassifiedError;
+    isComplete(response: unknown): boolean;
+    hasStructuredOutput(response: unknown): boolean;
+    extractStructuredOutput(response: unknown): JsonObject | undefined;
+    private hasToolCalls;
+    private extractContent;
+    private convertMessagesToFireworks;
+}
+export declare const fireworksAdapter: FireworksAdapter;
+export {};

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

@@ -2,6 +2,7 @@ export { BaseProviderAdapter } from "./ProviderAdapter.interface.js";
 export type { ProviderAdapter } from "./ProviderAdapter.interface.js";
 export { AnthropicAdapter, anthropicAdapter } from "./AnthropicAdapter.js";
 export { BedrockAdapter, bedrockAdapter } from "./BedrockAdapter.js";
+export { FireworksAdapter, fireworksAdapter } from "./FireworksAdapter.js";
 export { GoogleAdapter, googleAdapter } from "./GoogleAdapter.js";
 export { OpenAiAdapter, openAiAdapter } from "./OpenAiAdapter.js";
 export { OpenRouterAdapter, openRouterAdapter } from "./OpenRouterAdapter.js";

package/dist/cjs/operate/index.d.ts

@@ -1,4 +1,4 @@
-export { AnthropicAdapter, anthropicAdapter, BaseProviderAdapter, BedrockAdapter, bedrockAdapter, GoogleAdapter, googleAdapter, OpenAiAdapter, openAiAdapter, OpenRouterAdapter, openRouterAdapter, XaiAdapter, xaiAdapter, } from "./adapters/index.js";
+export { AnthropicAdapter, anthropicAdapter, BaseProviderAdapter, BedrockAdapter, bedrockAdapter, FireworksAdapter, fireworksAdapter, GoogleAdapter, googleAdapter, OpenAiAdapter, openAiAdapter, OpenRouterAdapter, openRouterAdapter, XaiAdapter, xaiAdapter, } from "./adapters/index.js";
 export type { ProviderAdapter } from "./adapters/index.js";
 export { createOperateLoop, OperateLoop } from "./OperateLoop.js";
 export type { OperateLoopConfig } from "./OperateLoop.js";

package/dist/cjs/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/cjs/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/cjs/providers/fireworks/FireworksProvider.class.d.ts

@@ -0,0 +1,21 @@
+import { JsonObject } from "@jaypie/types";
+import { LlmHistory, LlmInputMessage, LlmMessageOptions, LlmOperateOptions, LlmOperateResponse, LlmProvider } from "../../types/LlmProvider.interface.js";
+import { LlmStreamChunk } from "../../types/LlmStreamChunk.interface.js";
+export 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>;
+}

package/dist/cjs/providers/fireworks/client.d.ts

@@ -0,0 +1,37 @@
+import { JsonObject } from "@jaypie/types";
+export interface FireworksClientOptions {
+    apiKey: string;
+    baseURL?: string;
+}
+export interface ChatCompletionOptions {
+    signal?: AbortSignal;
+}
+/**
+ * HTTP error carrying the upstream status and parsed API message. The
+ * FireworksAdapter classifies errors by reading `.status` / `.statusCode` and
+ * `.message` / `.error.message`.
+ */
+export declare class FireworksHttpError extends Error {
+    readonly status: number;
+    readonly statusCode: number;
+    readonly error?: {
+        message?: string;
+    };
+    constructor(status: number, message: string, error?: {
+        message?: string;
+    });
+}
+/**
+ * Minimal `fetch`-based client for Fireworks AI's OpenAI-compatible Chat
+ * Completions endpoint. The adapter only needs a single POST (streaming and
+ * non-streaming), header auth, and HTTP error surfacing.
+ */
+export declare class FireworksClient {
+    private readonly apiKey;
+    private readonly baseURL;
+    constructor({ apiKey, baseURL, }: FireworksClientOptions);
+    private headers;
+    private toError;
+    chatCompletion(body: Record<string, unknown>, { signal }?: ChatCompletionOptions): Promise<JsonObject>;
+    streamChatCompletion(body: Record<string, unknown>, { signal }?: ChatCompletionOptions): AsyncIterable<JsonObject>;
+}

package/dist/cjs/providers/fireworks/index.d.ts

@@ -0,0 +1,2 @@
+export { FireworksProvider } from "./FireworksProvider.class.js";
+export * from "./utils.js";

package/dist/cjs/providers/fireworks/utils.d.ts

@@ -0,0 +1,15 @@
+import { createLogger } from "@jaypie/logger";
+import { LlmMessageOptions } from "../../types/LlmProvider.interface.js";
+import { FireworksClient } from "./client.js";
+export declare const getLogger: () => ReturnType<typeof createLogger>;
+export declare function initializeClient({ apiKey, }?: {
+    apiKey?: string;
+}): Promise<FireworksClient>;
+export declare function getDefaultModel(): string;
+export interface ChatMessage {
+    role: "system" | "user" | "assistant";
+    content: string;
+}
+export declare function formatSystemMessage(systemPrompt: string, { data, placeholders }?: Pick<LlmMessageOptions, "data" | "placeholders">): ChatMessage;
+export declare function formatUserMessage(message: string, { data, placeholders }?: Pick<LlmMessageOptions, "data" | "placeholders">): ChatMessage;
+export declare function prepareMessages(message: string, { system, data, placeholders }?: LlmMessageOptions): ChatMessage[];

package/dist/cjs/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/cjs/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/cjs/util/effort.d.ts

@@ -39,4 +39,5 @@ export declare function toXaiEffort(effort: LlmEffort): LlmEffortMapping;
 export declare function toAnthropicEffort(effort: LlmEffort): LlmEffortMapping;
 export declare function toGeminiThinkingLevel(effort: LlmEffort): LlmEffortMapping;
 export declare function toGeminiThinkingBudget(effort: LlmEffort): LlmEffortMapping<number>;
+export declare function toFireworksEffort(effort: LlmEffort): LlmEffortMapping;
 export declare function toOpenRouterEffort(effort: LlmEffort): LlmEffortMapping;

package/dist/cjs/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[];
+};