@jaypie/llm 1.3.9 → 1.3.11

package/dist/cjs/index.d.cts

@@ -1,7 +1,25 @@
 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
+ * deliberately borrows no provider's vocabulary. Each adapter translates these
+ * to its provider's native control (OpenAI `reasoning.effort`, Anthropic
+ * `output_config.effort`, Gemini `thinkingLevel`/`thinkingBudget`, Grok
+ * `reasoning_effort`, OpenRouter `reasoning.effort`), spreading the scale across
+ * the provider's available range. Omitting `effort` leaves the provider default
+ * untouched, so it is safe to set across a fallback chain.
+ */
+declare const EFFORT: {
+    readonly LOWEST: "lowest";
+    readonly LOW: "low";
+    readonly MEDIUM: "medium";
+    readonly HIGH: "high";
+    readonly HIGHEST: "highest";
+};
+type LlmEffort = (typeof EFFORT)[keyof typeof EFFORT];
 declare const MODEL: {
     FABLE: string;
     OPUS: string;
@@ -11,13 +29,26 @@ declare const MODEL: {
     GEMINI_FLASH: string;
     GEMINI_FLASH_LITE: string;
     GEMINI_PRO: string;
+    SOL: string;
+    TERRA: string;
+    LUNA: string;
+    /** @deprecated use MODEL.SOL (gpt-5.6-sol) */
     GPT: string;
+    /** @deprecated use MODEL.TERRA (gpt-5.6-terra) */
     GPT_MINI: string;
+    /** @deprecated use MODEL.LUNA (gpt-5.6-luna) */
     GPT_NANO: string;
     GROK: string;
+    OPENROUTER: {
+        GLM: string;
+        LUNA: string;
+        SONNET: string;
+    };
 };
 declare const PROVIDER: {
     readonly BEDROCK: {
+        readonly DEFAULT: "amazon.nova-pro-v1:0";
+        /** @deprecated Size tiers are retired in 2.0. Use PROVIDER.BEDROCK.DEFAULT. */
         readonly MODEL: {
             readonly DEFAULT: "amazon.nova-lite-v1:0";
             readonly LARGE: "amazon.nova-pro-v1:0";
@@ -29,16 +60,18 @@ declare const PROVIDER: {
         readonly REGION: "AWS_REGION";
     };
     readonly ANTHROPIC: {
+        readonly DEFAULT: string;
         readonly MAX_TOKENS: {
             readonly DEFAULT: 16384;
         };
+        /** @deprecated Size tiers are retired in 2.0. Use PROVIDER.ANTHROPIC.DEFAULT, or pick a specific model from MODEL.*. */
         readonly MODEL: {
             readonly DEFAULT: "claude-sonnet-4-6";
             readonly LARGE: "claude-opus-4-8";
             readonly SMALL: "claude-sonnet-4-6";
             readonly TINY: "claude-haiku-4-5";
         };
-        readonly MODEL_MATCH_WORDS: readonly ["anthropic", "claude", "haiku", "opus", "sonnet"];
+        readonly MODEL_MATCH_WORDS: readonly ["anthropic", "claude", "fable", "haiku", "mythos", "opus", "sonnet"];
         readonly NAME: "anthropic";
         readonly PROMPT: {
             readonly AI: "\n\nAssistant:";
@@ -55,6 +88,8 @@ declare const PROVIDER: {
     };
     /** @deprecated Use PROVIDER.GOOGLE — "Google" is the provider; Gemini is the model family */
     readonly GEMINI: {
+        readonly DEFAULT: string;
+        /** @deprecated Size tiers are retired in 2.0. Use PROVIDER.GOOGLE.DEFAULT, or pick a specific model from MODEL.*. */
         readonly MODEL: {
             readonly DEFAULT: "gemini-3.1-pro-preview";
             readonly LARGE: "gemini-3.1-pro-preview";
@@ -69,6 +104,8 @@ declare const PROVIDER: {
         };
     };
     readonly GOOGLE: {
+        readonly DEFAULT: string;
+        /** @deprecated Size tiers are retired in 2.0. Use PROVIDER.GOOGLE.DEFAULT, or pick a specific model from MODEL.*. */
         readonly MODEL: {
             readonly DEFAULT: "gemini-3.1-pro-preview";
             readonly LARGE: "gemini-3.1-pro-preview";
@@ -83,16 +120,20 @@ declare const PROVIDER: {
         };
     };
     readonly OPENAI: {
+        readonly DEFAULT: string;
+        /** @deprecated Size tiers are retired in 2.0. Use PROVIDER.OPENAI.DEFAULT, or pick a specific model from MODEL.*. */
         readonly MODEL: {
             readonly DEFAULT: "gpt-5.4";
             readonly LARGE: "gpt-5.5";
             readonly SMALL: "gpt-5.4-mini";
             readonly TINY: "gpt-5.4-nano";
         };
-        readonly MODEL_MATCH_WORDS: readonly ["openai", "gpt", RegExp];
+        readonly MODEL_MATCH_WORDS: readonly ["gpt", "luna", "openai", "sol", "terra", RegExp];
         readonly NAME: "openai";
     };
     readonly OPENROUTER: {
+        readonly DEFAULT: string;
+        /** @deprecated Size tiers are retired in 2.0. Use PROVIDER.OPENROUTER.DEFAULT, or pick a specific route from MODEL.OPENROUTER.*. */
         readonly MODEL: {
             readonly DEFAULT: "anthropic/claude-sonnet-4-6";
             readonly LARGE: "anthropic/claude-opus-4-8";
@@ -111,6 +152,8 @@ declare const PROVIDER: {
     readonly XAI: {
         readonly API_KEY: "XAI_API_KEY";
         readonly BASE_URL: "https://api.x.ai/v1";
+        readonly DEFAULT: string;
+        /** @deprecated Size tiers are retired in 2.0. Use PROVIDER.XAI.DEFAULT, or pick a specific model from MODEL.*. */
         readonly MODEL: {
             readonly DEFAULT: "grok-latest";
             readonly LARGE: "grok-latest";
@@ -123,6 +166,7 @@ declare const PROVIDER: {
 };
 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;
 declare const DEFAULT: {
+    /** @deprecated Size tiers are retired in 2.0. Use DEFAULT.PROVIDER.DEFAULT, or pick a specific model from MODEL.*. */
     readonly MODEL: {
         readonly BASE: "gpt-5.4";
         readonly LARGE: "gpt-5.5";
@@ -130,16 +174,22 @@ declare const DEFAULT: {
         readonly TINY: "gpt-5.4-nano";
     };
     readonly PROVIDER: {
+        readonly DEFAULT: string;
+        /** @deprecated Size tiers are retired in 2.0. Use PROVIDER.OPENAI.DEFAULT, or pick a specific model from MODEL.*. */
         readonly MODEL: {
             readonly DEFAULT: "gpt-5.4";
             readonly LARGE: "gpt-5.5";
             readonly SMALL: "gpt-5.4-mini";
             readonly TINY: "gpt-5.4-nano";
         };
-        readonly MODEL_MATCH_WORDS: readonly ["openai", "gpt", RegExp];
+        readonly MODEL_MATCH_WORDS: readonly ["gpt", "luna", "openai", "sol", "terra", RegExp];
         readonly NAME: "openai";
     };
 };
+/**
+ * @deprecated Size-tier catalogs are retired in 2.0. Pick specific models from
+ * MODEL.* (grouped by provider via MODEL_MATCH_WORDS / determineModelProvider).
+ */
 declare const ALL: {
     readonly BASE: readonly ["claude-sonnet-4-6", "gemini-3.1-pro-preview", "gpt-5.4", "grok-latest"];
     readonly COMBINED: readonly ("claude-opus-4-8" | "claude-haiku-4-5" | "gemini-3.5-flash" | "gemini-3.1-flash-lite" | "gemini-3.1-pro-preview" | "gpt-5.5" | "gpt-5.4-mini" | "gpt-5.4-nano" | "grok-latest" | "claude-sonnet-4-6" | "gpt-5.4" | "grok-4-1-fast-reasoning" | "grok-4-1-fast-non-reasoning")[];
@@ -150,12 +200,14 @@ declare const ALL: {
 
 declare const constants_ALL: typeof ALL;
 declare const constants_DEFAULT: typeof DEFAULT;
+declare const constants_EFFORT: typeof EFFORT;
+type constants_LlmEffort = LlmEffort;
 type constants_LlmProviderName = LlmProviderName;
 declare const constants_MODEL: typeof MODEL;
 declare const constants_PROVIDER: typeof PROVIDER;
 declare namespace constants {
-  export { constants_ALL as ALL, constants_DEFAULT as DEFAULT, constants_MODEL as MODEL, constants_PROVIDER as PROVIDER };
-  export type { constants_LlmProviderName as LlmProviderName };
+  export { constants_ALL as ALL, constants_DEFAULT as DEFAULT, constants_EFFORT as EFFORT, constants_MODEL as MODEL, constants_PROVIDER as PROVIDER };
+  export type { constants_LlmEffort as LlmEffort, constants_LlmProviderName as LlmProviderName };
 }
 
 interface LlmTool {
@@ -273,7 +325,7 @@ declare enum LlmResponseStatus {
     Incomplete = "incomplete",
     InProgress = "in_progress"
 }
-interface LlmError {
+interface LlmError$1 {
     detail?: string;
     status: number | string;
     title: string;
@@ -461,6 +513,14 @@ interface LlmProgressEvent {
 type LlmProgressCallback = (event: LlmProgressEvent) => unknown | Promise<unknown>;
 interface LlmOperateOptions {
     data?: NaturalMap;
+    /**
+     * Provider-neutral reasoning effort (lowest | low | medium | high | highest).
+     * Each provider translates it to its native control, spreading the scale
+     * across the provider's range; omitting it leaves the provider default
+     * untouched, so it is safe across a fallback chain. Providers without
+     * reasoning control ignore it.
+     */
+    effort?: LlmEffort;
     explain?: boolean;
     /** Chain of fallback providers to try if primary fails. Set to false to disable instance-level fallback. */
     fallback?: LlmFallbackConfig[] | false;
@@ -534,6 +594,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 */
@@ -551,7 +620,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 */
@@ -577,9 +646,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.
@@ -590,23 +663,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>;
 }
 
@@ -637,6 +714,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.
  *
@@ -739,5 +897,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 { 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, 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,12 +1,16 @@
 export { default as Llm } from "./Llm.js";
 export * as LLM 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 { LlmEffort } from "./constants.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";

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

@@ -16,7 +16,8 @@ import { BaseProviderAdapter } from "./ProviderAdapter.interface.js";
  */
 type AnthropicRequestParams = Anthropic.MessageCreateParams & {
     output_config?: {
-        format: {
+        effort?: string;
+        format?: {
             type: "json_schema";
             schema: JsonObject;
         };
@@ -29,7 +30,7 @@ type AnthropicRequestParams = Anthropic.MessageCreateParams & {
  */
 export declare class AnthropicAdapter extends BaseProviderAdapter {
     readonly name: "anthropic";
-    readonly defaultModel: "claude-sonnet-4-6";
+    readonly defaultModel: string;
     private runtimeNoTemperatureModels;
     private runtimeNoStructuredOutputModels;
     rememberModelRejectsTemperature(model: string): void;

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

@@ -49,7 +49,7 @@ type AnnotatedBedrockResponse = ConverseCommandOutput & {
 };
 export declare class BedrockAdapter extends BaseProviderAdapter {
     readonly name: "bedrock";
-    readonly defaultModel: "amazon.nova-lite-v1:0";
+    readonly defaultModel: "amazon.nova-pro-v1:0";
     private _modelsFallbackToStructuredOutputTool;
     private _modelsWithoutTemperature;
     private rememberModelRejectsOutputConfig;

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

@@ -13,7 +13,7 @@ import { GeminiPart, GeminiRawResponse, GeminiRequest } from "../../providers/go
  */
 export declare class GoogleAdapter extends BaseProviderAdapter {
     readonly name: "google";
-    readonly defaultModel: "gemini-3.1-pro-preview";
+    readonly defaultModel: string;
     private runtimeNoStructuredOutputComboModels;
     rememberModelRejectsStructuredOutputCombo(model: string): void;
     clearRuntimeNoStructuredOutputComboModels(): void;

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

@@ -1,5 +1,7 @@
 import { JsonObject, NaturalSchema } from "@jaypie/types";
 import { z } from "zod/v4";
+import { type LlmEffort } from "../../constants.js";
+import { type LlmEffortMapping } from "../../util/effort.js";
 import { Toolkit } from "../../tools/Toolkit.class.js";
 import { LlmHistory, LlmOperateOptions, LlmToolResult, LlmUsageItem } from "../../types/LlmProvider.interface.js";
 import { LlmStreamChunk } from "../../types/LlmStreamChunk.interface.js";
@@ -12,11 +14,15 @@ import { BaseProviderAdapter } from "./ProviderAdapter.interface.js";
  */
 export declare class OpenAiAdapter extends BaseProviderAdapter {
     readonly name: "openai";
-    readonly defaultModel: "gpt-5.4";
+    readonly defaultModel: string;
     private runtimeNoTemperatureModels;
     rememberModelRejectsTemperature(model: string): void;
     clearRuntimeNoTemperatureModels(): void;
     private supportsTemperature;
+    /** Whether `reasoning.effort` may be sent for this model. Overridden by xAI. */
+    protected supportsReasoningEffort(model: string): boolean;
+    /** Translate a normalized effort to this provider's `reasoning.effort` value. */
+    protected mapReasoningEffort(effort: LlmEffort, model: string): LlmEffortMapping;
     buildRequest(request: OperateRequest): unknown;
     formatTools(toolkit: Toolkit, _outputSchema?: JsonObject): ProviderToolDefinition[];
     formatOutputSchema(schema: JsonObject | NaturalSchema | z.ZodType): JsonObject;

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

@@ -79,6 +79,10 @@ interface OpenRouterRequest {
     tools?: OpenRouterTool[];
     tool_choice?: "auto" | "none" | "required";
     response_format?: OpenRouterResponseFormat;
+    reasoning?: {
+        effort?: string;
+        max_tokens?: number;
+    };
     user?: string;
 }
 /**
@@ -111,7 +115,7 @@ type OpenRouterContentPart = {
  */
 export declare class OpenRouterAdapter extends BaseProviderAdapter {
     readonly name: "openrouter";
-    readonly defaultModel: "anthropic/claude-sonnet-4-6";
+    readonly defaultModel: string;
     private runtimeNoStructuredOutputModels;
     rememberModelRejectsStructuredOutput(model: string): void;
     clearRuntimeNoStructuredOutputModels(): void;

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

@@ -1,3 +1,5 @@
+import { type LlmEffort } from "../../constants.js";
+import { type LlmEffortMapping } from "../../util/effort.js";
 import { ClassifiedError } from "../types.js";
 import { OpenAiAdapter } from "./OpenAiAdapter.js";
 /**
@@ -8,7 +10,15 @@ import { OpenAiAdapter } from "./OpenAiAdapter.js";
  */
 export declare class XaiAdapter extends OpenAiAdapter {
     readonly name: "xai";
-    readonly defaultModel: "grok-latest";
+    readonly defaultModel: string;
+    /**
+     * Grok gates reasoning effort by model, not by the OpenAI `gpt-*`/`o*`
+     * patterns. Only explicit `*-reasoning` models accept `reasoning_effort`;
+     * bare grok-4 reasons implicitly and rejects it, so we stay conservative and
+     * only opt in models whose name advertises reasoning.
+     */
+    protected supportsReasoningEffort(model: string): boolean;
+    protected mapReasoningEffort(effort: LlmEffort): LlmEffortMapping;
     classifyError(error: unknown): ClassifiedError;
 }
 export declare const xaiAdapter: XaiAdapter;

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

@@ -1,4 +1,5 @@
 import { JsonObject } from "@jaypie/types";
+import { type LlmEffort } from "../constants.js";
 import { LlmHistory, LlmMessageType, LlmOperateOptions, LlmUsageItem } from "../types/LlmProvider.interface.js";
 import { Toolkit } from "../tools/Toolkit.class.js";
 /**
@@ -68,6 +69,8 @@ export interface OperateRequest {
     tools?: ProviderToolDefinition[];
     /** Structured output format */
     format?: JsonObject;
+    /** Normalized reasoning effort; adapters translate to provider-native control */
+    effort?: LlmEffort;
     /** Provider-specific options */
     providerOptions?: JsonObject;
     /** Whether the request will execute over a streaming transport */
@@ -94,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 */
@@ -113,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/google/types.d.ts

@@ -73,6 +73,11 @@ export interface GeminiGenerateContentConfig {
     responseMimeType?: string;
     responseJsonSchema?: JsonObject;
     responseSchema?: JsonObject;
+    thinkingConfig?: {
+        thinkingLevel?: string;
+        thinkingBudget?: number;
+        includeThoughts?: boolean;
+    };
     temperature?: number;
     topP?: number;
     topK?: number;

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

@@ -1,5 +1,6 @@
 import { AnyValue, JsonObject, JsonReturn, NaturalMap, NaturalSchema } from "@jaypie/types";
 import { z } from "zod/v4";
+import { type LlmEffort } from "../constants.js";
 import { LlmTool } from "./LlmTool.interface.js";
 import { LlmStreamChunk } from "./LlmStreamChunk.interface.js";
 import { Toolkit } from "../tools/Toolkit.class.js";
@@ -213,6 +214,14 @@ export interface LlmProgressEvent {
 export type LlmProgressCallback = (event: LlmProgressEvent) => unknown | Promise<unknown>;
 export interface LlmOperateOptions {
     data?: NaturalMap;
+    /**
+     * Provider-neutral reasoning effort (lowest | low | medium | high | highest).
+     * Each provider translates it to its native control, spreading the scale
+     * across the provider's range; omitting it leaves the provider default
+     * untouched, so it is safe across a fallback chain. Providers without
+     * reasoning control ignore it.
+     */
+    effort?: LlmEffort;
     explain?: boolean;
     /** Chain of fallback providers to try if primary fails. Set to false to disable instance-level fallback. */
     fallback?: LlmFallbackConfig[] | false;
@@ -286,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;