@jaypie/llm 1.3.1 → 1.3.2

package/dist/cjs/index.d.cts

@@ -0,0 +1,661 @@
+import * as _jaypie_types from '@jaypie/types';
+import { JsonObject, AnyValue, NaturalMap, NaturalSchema, JsonReturn } from '@jaypie/types';
+import { z } from 'zod/v4';
+
+declare const MODEL: {
+    OPUS: string;
+    SONNET: string;
+    HAIKU: string;
+    FABLE: string;
+    MYTHOS: string;
+    GEMINI_FLASH: string;
+    GEMINI_FLASH_LITE: string;
+    GEMINI_PRO: string;
+    GPT: string;
+    GPT_MINI: string;
+    GPT_NANO: string;
+    GROK: string;
+};
+declare const PROVIDER: {
+    readonly BEDROCK: {
+        readonly MODEL: {
+            readonly DEFAULT: "amazon.nova-lite-v1:0";
+            readonly LARGE: "amazon.nova-pro-v1:0";
+            readonly SMALL: "amazon.nova-lite-v1:0";
+            readonly TINY: "amazon.nova-micro-v1:0";
+        };
+        readonly MODEL_MATCH_WORDS: readonly ["amazon.nova", "amazon.titan", "anthropic.claude", "cohere.command", "meta.llama", "mistral.mistral", "ai21."];
+        readonly NAME: "bedrock";
+        readonly REGION: "AWS_REGION";
+    };
+    readonly ANTHROPIC: {
+        readonly MAX_TOKENS: {
+            readonly DEFAULT: 4096;
+        };
+        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 NAME: "anthropic";
+        readonly PROMPT: {
+            readonly AI: "\n\nAssistant:";
+            readonly HUMAN: "\n\nHuman:";
+        };
+        readonly ROLE: {
+            readonly ASSISTANT: "assistant";
+            readonly SYSTEM: "system";
+            readonly USER: "user";
+        };
+        readonly TOOLS: {
+            readonly SCHEMA_VERSION: "v2";
+        };
+    };
+    /** @deprecated Use PROVIDER.GOOGLE — "Google" is the provider; Gemini is the model family */
+    readonly GEMINI: {
+        readonly MODEL: {
+            readonly DEFAULT: "gemini-3.1-pro-preview";
+            readonly LARGE: "gemini-3.1-pro-preview";
+            readonly SMALL: "gemini-3.5-flash";
+            readonly TINY: "gemini-3.1-flash-lite";
+        };
+        readonly MODEL_MATCH_WORDS: readonly ["gemini", "google"];
+        readonly NAME: "google";
+        readonly ROLE: {
+            readonly MODEL: "model";
+            readonly USER: "user";
+        };
+    };
+    readonly GOOGLE: {
+        readonly MODEL: {
+            readonly DEFAULT: "gemini-3.1-pro-preview";
+            readonly LARGE: "gemini-3.1-pro-preview";
+            readonly SMALL: "gemini-3.5-flash";
+            readonly TINY: "gemini-3.1-flash-lite";
+        };
+        readonly MODEL_MATCH_WORDS: readonly ["gemini", "google"];
+        readonly NAME: "google";
+        readonly ROLE: {
+            readonly MODEL: "model";
+            readonly USER: "user";
+        };
+    };
+    readonly OPENAI: {
+        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 NAME: "openai";
+    };
+    readonly OPENROUTER: {
+        readonly MODEL: {
+            readonly DEFAULT: "anthropic/claude-sonnet-4-6";
+            readonly LARGE: "anthropic/claude-opus-4-8";
+            readonly SMALL: "anthropic/claude-sonnet-4-6";
+            readonly TINY: "anthropic/claude-haiku-4-5";
+        };
+        readonly MODEL_MATCH_WORDS: readonly ["openrouter"];
+        readonly NAME: "openrouter";
+        readonly ROLE: {
+            readonly ASSISTANT: "assistant";
+            readonly SYSTEM: "system";
+            readonly TOOL: "tool";
+            readonly USER: "user";
+        };
+    };
+    readonly XAI: {
+        readonly API_KEY: "XAI_API_KEY";
+        readonly BASE_URL: "https://api.x.ai/v1";
+        readonly MODEL: {
+            readonly DEFAULT: "grok-latest";
+            readonly LARGE: "grok-4.3-latest";
+            readonly SMALL: "grok-4-1-fast-reasoning";
+            readonly TINY: "grok-4-1-fast-non-reasoning";
+        };
+        readonly MODEL_MATCH_WORDS: readonly ["grok", "xai"];
+        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;
+declare const DEFAULT: {
+    readonly MODEL: {
+        readonly BASE: "gpt-5.4";
+        readonly LARGE: "gpt-5.5";
+        readonly SMALL: "gpt-5.4-mini";
+        readonly TINY: "gpt-5.4-nano";
+    };
+    readonly PROVIDER: {
+        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 NAME: "openai";
+    };
+};
+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-sonnet-4-6" | "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" | "gpt-5.4" | "grok-4.3-latest" | "grok-4-1-fast-reasoning" | "grok-4-1-fast-non-reasoning")[];
+    readonly LARGE: readonly ["claude-opus-4-8", "gemini-3.1-pro-preview", "gpt-5.5", "grok-4.3-latest"];
+    readonly SMALL: readonly ["claude-sonnet-4-6", "gemini-3.5-flash", "gpt-5.4-mini", "grok-4-1-fast-reasoning"];
+    readonly TINY: readonly ["claude-haiku-4-5", "gemini-3.1-flash-lite", "gpt-5.4-nano", "grok-4-1-fast-non-reasoning"];
+};
+
+declare const constants_ALL: typeof ALL;
+declare const constants_DEFAULT: typeof DEFAULT;
+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 };
+}
+
+interface LlmTool {
+    description: string;
+    name: string;
+    parameters: JsonObject | z.ZodType;
+    type: "function" | string;
+    call: (args?: JsonObject) => Promise<AnyValue> | AnyValue;
+    message?: string | ((args?: JsonObject, context?: {
+        name: string;
+    }) => Promise<string> | string);
+}
+
+declare enum LlmStreamChunkType {
+    Done = "done",
+    Error = "error",
+    Text = "text",
+    ToolCall = "tool_call",
+    ToolResult = "tool_result"
+}
+interface LlmStreamChunkText {
+    type: LlmStreamChunkType.Text;
+    content: string;
+}
+interface LlmStreamChunkToolCall {
+    type: LlmStreamChunkType.ToolCall;
+    toolCall: {
+        id: string;
+        name: string;
+        arguments: string;
+        /** Provider-specific metadata preserved through tool-call roundtrip */
+        metadata?: Record<string, unknown>;
+    };
+}
+interface LlmStreamChunkToolResult {
+    type: LlmStreamChunkType.ToolResult;
+    toolResult: {
+        id: string;
+        name: string;
+        result: unknown;
+    };
+}
+interface LlmStreamChunkDone {
+    type: LlmStreamChunkType.Done;
+    usage: LlmUsage;
+}
+interface LlmStreamChunkError {
+    type: LlmStreamChunkType.Error;
+    error: {
+        detail?: string;
+        status: number | string;
+        title: string;
+    };
+}
+type LlmStreamChunk = LlmStreamChunkDone | LlmStreamChunkError | LlmStreamChunkText | LlmStreamChunkToolCall | LlmStreamChunkToolResult;
+
+type LogFunction = (message: string, context: {
+    name: string;
+    args: any;
+}) => void | Promise<void>;
+interface ToolkitOptions {
+    explain?: boolean;
+    log?: boolean | LogFunction;
+}
+declare class Toolkit {
+    private readonly _tools;
+    private readonly _options;
+    private readonly explain;
+    private readonly log;
+    constructor(tools: LlmTool[], options?: ToolkitOptions);
+    get tools(): Omit<LlmTool, "call">[];
+    call({ name, arguments: args }: {
+        name: string;
+        arguments: string;
+    }): Promise<_jaypie_types.AnyValue>;
+    extend(tools: LlmTool[], options?: {
+        warn?: boolean;
+        replace?: boolean;
+        log?: boolean | LogFunction;
+        explain?: boolean;
+    }): this;
+}
+
+declare enum LlmMessageRole {
+    Assistant = "assistant",
+    Developer = "developer",
+    System = "system",
+    User = "user"
+}
+declare enum LlmMessageType {
+    FunctionCall = "function_call",
+    FunctionCallOutput = "function_call_output",
+    InputFile = "input_file",
+    InputImage = "input_image",
+    InputText = "input_text",
+    ItemReference = "item_reference",
+    Message = "message",
+    OutputText = "output_text",
+    Refusal = "refusal"
+}
+declare enum LlmResponseStatus {
+    Completed = "completed",
+    Incomplete = "incomplete",
+    InProgress = "in_progress"
+}
+interface LlmError {
+    detail?: string;
+    status: number | string;
+    title: string;
+}
+interface LlmInputContentFile {
+    type: LlmMessageType.InputFile;
+    file_data: File | string;
+    file_id?: string;
+    filename?: string;
+}
+interface LlmInputContentImage {
+    type: LlmMessageType.InputImage;
+    detail?: File;
+    file_id?: string;
+    image_url?: string;
+}
+interface LlmInputContentText {
+    type: LlmMessageType.InputText;
+    text: string;
+}
+type LlmInputContent = LlmInputContentFile | LlmInputContentImage | LlmInputContentText;
+/**
+ * Represents the "Input message object" in the "input item list"
+ * from [OpenAI Responses API](https://platform.openai.com/docs/api-reference/responses/create)
+ */
+interface LlmInputMessage {
+    content: string | Array<LlmInputContent>;
+    role: LlmMessageRole;
+    type?: LlmMessageType.Message;
+}
+/**
+ * File input that can be loaded from local filesystem, S3, or provided as base64 data.
+ * For PDFs, specific pages can be extracted via the `pages` property.
+ * If the file extension is an image type, it will be treated as an image internally.
+ */
+interface LlmOperateInputFile {
+    /** Path or filename (extension determines type via /\.(\w+)$/) */
+    file: string;
+    /** S3 bucket name (if present, load from S3) */
+    bucket?: string;
+    /** Specific pages to extract from PDF (omit = all pages) */
+    pages?: number[];
+    /** Base64 data (if present, use directly instead of loading from file) */
+    data?: string;
+}
+/**
+ * Image input that can be loaded from local filesystem, S3, or provided as base64 data.
+ */
+interface LlmOperateInputImage {
+    /** Path or filename */
+    image: string;
+    /** S3 bucket name (if present, load from S3) */
+    bucket?: string;
+    /** Base64 data (if present, use directly instead of loading from file) */
+    data?: string;
+}
+/**
+ * Content item in LlmOperateInput array.
+ * Can be a string (text), file object, or image object.
+ */
+type LlmOperateInputContent = string | LlmOperateInputFile | LlmOperateInputImage;
+/**
+ * Simplified input format for operate() that supports automatic file resolution.
+ * Files/images are loaded from local filesystem, S3, or provided data.
+ *
+ * @example
+ * ```typescript
+ * const input: LlmOperateInput = [
+ *   "Extract text from these documents",
+ *   { file: "document.pdf", bucket: "my-bucket", pages: [1, 2, 3] },
+ *   { image: "photo.png" },  // loads from local filesystem
+ * ];
+ * ```
+ */
+type LlmOperateInput = LlmOperateInputContent[];
+interface LlmOutputContentText {
+    annotations?: AnyValue[];
+    text: string;
+    type: LlmMessageType.OutputText;
+}
+interface LlmOutputRefusal {
+    refusal: string;
+    type: LlmMessageType.Refusal;
+}
+type LlmOutputContent = LlmOutputContentText | LlmOutputRefusal;
+/**
+ * Represents the "Output message object" in the "input item list"
+ * from [OpenAI Responses API](https://platform.openai.com/docs/api-reference/responses/create)
+ */
+interface LlmOutputMessage {
+    content: string | Array<LlmOutputContent>;
+    id?: string;
+    role: LlmMessageRole.Assistant;
+    status?: LlmResponseStatus;
+    type?: LlmMessageType.Message;
+}
+type LlmOutputItem = LlmToolCall | LlmToolResult | LlmOutputMessage;
+type LlmOutput = LlmOutputItem[];
+interface LlmToolCall {
+    arguments: string;
+    call_id: string;
+    id: string;
+    name: string;
+    type: LlmMessageType.FunctionCall;
+    status: LlmResponseStatus;
+}
+interface LlmToolResult {
+    call_id: string;
+    output: string;
+    status?: LlmResponseStatus;
+    type: LlmMessageType.FunctionCallOutput;
+}
+interface LlmItemReference {
+    type: LlmMessageType.ItemReference;
+    id: string;
+}
+type LlmHistoryItem = LlmInputMessage | LlmItemReference | LlmOutputItem | LlmToolResult;
+type LlmHistory = LlmHistoryItem[];
+/**
+ * Configuration for a fallback provider.
+ * Used when the primary provider fails with an unrecoverable error.
+ */
+interface LlmFallbackConfig {
+    /** Provider name (e.g., "openai", "anthropic", "google") */
+    provider: string;
+    /** Model to use with this provider (optional, uses provider default if not specified) */
+    model?: string;
+    /** API key for this provider (optional, uses environment variable if not specified) */
+    apiKey?: string;
+}
+interface LlmMessageOptions {
+    data?: NaturalMap;
+    model?: string;
+    placeholders?: {
+        message?: boolean;
+        system?: boolean;
+    };
+    response?: NaturalSchema | z.ZodType;
+    system?: string;
+}
+interface LlmOperateOptions {
+    data?: NaturalMap;
+    explain?: boolean;
+    /** Chain of fallback providers to try if primary fails. Set to false to disable instance-level fallback. */
+    fallback?: LlmFallbackConfig[] | false;
+    format?: JsonObject | NaturalSchema | z.ZodType;
+    history?: LlmHistory;
+    hooks?: {
+        afterEachModelResponse?: ({ input, options, providerRequest, providerResponse, content, usage, }: {
+            input: string | LlmHistory | LlmInputMessage;
+            options?: LlmOperateOptions;
+            providerRequest: any;
+            providerResponse: any;
+            content: string | JsonObject;
+            usage: LlmUsage;
+        }) => unknown | Promise<unknown>;
+        afterEachTool?: ({ result, toolName, args, }: {
+            result: unknown;
+            toolName: string;
+            args: string;
+        }) => unknown | Promise<unknown>;
+        beforeEachModelRequest?: ({ input, options, providerRequest, }: {
+            input: string | LlmHistory | LlmInputMessage;
+            options?: LlmOperateOptions;
+            providerRequest: any;
+        }) => unknown | Promise<unknown>;
+        beforeEachTool?: ({ toolName, args, }: {
+            toolName: string;
+            args: string;
+        }) => unknown | Promise<unknown>;
+        onRetryableModelError?: ({ input, options, providerRequest, error, }: {
+            input: string | LlmHistory | LlmInputMessage;
+            options?: LlmOperateOptions;
+            providerRequest: any;
+            error: any;
+        }) => unknown | Promise<unknown>;
+        onToolError?: ({ error, toolName, args, }: {
+            error: Error;
+            toolName: string;
+            args: string;
+        }) => unknown | Promise<unknown>;
+        onUnrecoverableModelError?: ({ input, options, providerRequest, error, }: {
+            input: string | LlmHistory | LlmInputMessage;
+            options?: LlmOperateOptions;
+            providerRequest: any;
+            error: any;
+        }) => unknown | Promise<unknown>;
+    };
+    instructions?: string;
+    model?: string;
+    placeholders?: {
+        input?: boolean;
+        instructions?: boolean;
+        system?: boolean;
+    };
+    providerOptions?: JsonObject;
+    system?: string;
+    temperature?: number;
+    tools?: LlmTool[] | Toolkit;
+    turns?: boolean | number;
+    user?: string;
+}
+interface LlmOptions {
+    apiKey?: string;
+    /** Chain of fallback providers to try if primary fails */
+    fallback?: LlmFallbackConfig[];
+    model?: string;
+}
+interface LlmUsageItem {
+    input: number;
+    output: number;
+    reasoning: number;
+    total: number;
+    provider?: string;
+    model?: string;
+}
+type LlmUsage = LlmUsageItem[];
+interface LlmOperateResponse {
+    content?: string | JsonObject;
+    error?: LlmError;
+    /** Number of providers attempted (1 = primary only, >1 = fallback(s) used) */
+    fallbackAttempts?: number;
+    /** Whether a fallback provider was used instead of the primary */
+    fallbackUsed?: boolean;
+    history: LlmHistory;
+    model?: string;
+    output: LlmOutput;
+    /** Which provider actually handled the request */
+    provider?: string;
+    reasoning: string[];
+    responses: JsonReturn[];
+    status: LlmResponseStatus;
+    usage: LlmUsage;
+}
+interface LlmProvider {
+    operate?(input: string | LlmHistory | LlmInputMessage | LlmOperateInput, options?: LlmOperateOptions): Promise<LlmOperateResponse>;
+    send(message: string, options?: LlmMessageOptions): Promise<string | JsonObject>;
+    stream?(input: string | LlmHistory | LlmInputMessage | LlmOperateInput, options?: LlmOperateOptions): AsyncIterable<LlmStreamChunk>;
+}
+
+declare class Llm implements LlmProvider {
+    private _fallbackConfig?;
+    private _llm;
+    private _options;
+    private _provider;
+    constructor(providerName?: LlmProviderName | string, options?: LlmOptions);
+    private createProvider;
+    send(message: string, options?: LlmMessageOptions): Promise<string | JsonObject>;
+    /**
+     * Resolves the fallback chain from instance config and per-call options.
+     * Per-call options take precedence over instance config.
+     * Returns empty array if fallback is disabled.
+     */
+    private resolveFallbackChain;
+    /**
+     * 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 & {
+        llm?: LlmProviderName;
+        apiKey?: string;
+        model?: string;
+    }): Promise<string | JsonObject>;
+    static operate(input: string | LlmHistory | LlmInputMessage | LlmOperateInput, options?: LlmOperateOptions & {
+        apiKey?: string;
+        fallback?: LlmFallbackConfig[] | false;
+        llm?: LlmProviderName;
+        model?: string;
+    }): Promise<LlmOperateResponse>;
+    static stream(input: string | LlmHistory | LlmInputMessage | LlmOperateInput, options?: LlmOperateOptions & {
+        llm?: LlmProviderName;
+        apiKey?: string;
+        model?: string;
+    }): AsyncIterable<LlmStreamChunk>;
+}
+
+/**
+ * Type guard to check if an item is an LlmOperateInputFile
+ */
+declare function isLlmOperateInputFile(item: unknown): item is LlmOperateInputFile;
+/**
+ * Type guard to check if an item is an LlmOperateInputImage
+ */
+declare function isLlmOperateInputImage(item: unknown): item is LlmOperateInputImage;
+/**
+ * Type guard to check if an item is an LlmOperateInputContent
+ */
+declare function isLlmOperateInputContent(item: unknown): item is LlmOperateInputContent;
+/**
+ * Type guard to check if input is an LlmOperateInput array
+ */
+declare function isLlmOperateInput(input: unknown): input is LlmOperateInput;
+
+declare const tools: LlmTool[];
+declare class JaypieToolkit extends Toolkit {
+    readonly random: LlmTool;
+    readonly roll: LlmTool;
+    readonly time: LlmTool;
+    readonly weather: LlmTool;
+    constructor(tools: LlmTool[], options?: any);
+}
+declare const toolkit: JaypieToolkit;
+
+/**
+ * Extracts reasoning text from LLM history items.
+ *
+ * Reasoning items may have text in different locations depending on the provider:
+ * - OpenAI: `summary` array with objects containing `text` property (type: "reasoning")
+ * - OpenAI: `content` property on reasoning items (type: "reasoning")
+ * - Anthropic: `thinking` property on thinking items (type: "thinking")
+ * - OpenRouter/z-ai: `reasoning` property on message items
+ *
+ * @param history - The LLM history array to extract reasoning from
+ * @returns Array of reasoning text strings
+ */
+declare function extractReasoning(history: LlmHistory): string[];
+
+declare class BedrockProvider implements LlmProvider {
+    private model;
+    private region?;
+    private _client?;
+    private _operateLoop?;
+    private _streamLoop?;
+    private log;
+    private conversationHistory;
+    constructor(model?: string, { region }?: {
+        region?: 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?;
+    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 OpenRouterProvider 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 XaiProvider 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>;
+}
+
+export { BedrockProvider, GoogleProvider as GeminiProvider, GoogleProvider, JaypieToolkit, constants as LLM, Llm, LlmMessageRole, LlmMessageType, LlmStreamChunkType, OpenRouterProvider, Toolkit, XaiProvider, extractReasoning, isLlmOperateInput, isLlmOperateInputContent, isLlmOperateInputFile, isLlmOperateInputImage, toolkit, tools };
+export type { LlmFallbackConfig, LlmHistory, LlmInputContent, LlmInputContentFile, LlmInputContentImage, LlmInputContentText, LlmInputMessage, LlmMessageOptions, LlmOperateInput, LlmOperateInputContent, LlmOperateInputFile, LlmOperateInputImage, LlmOperateOptions, LlmOperateResponse, LlmOptions, LlmProvider, LlmStreamChunk, LlmStreamChunkDone, LlmStreamChunkError, LlmStreamChunkText, LlmStreamChunkToolCall, LlmStreamChunkToolResult, LlmTool };

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

@@ -1,9 +1,10 @@
+import { createLogger } from "@jaypie/logger";
 import type Anthropic from "@anthropic-ai/sdk";
 import { LlmMessageOptions } from "../../types/LlmProvider.interface.js";
 import { z } from "zod/v4";
 import { JsonObject, NaturalSchema } from "@jaypie/types";
 export declare function loadSdk(): Promise<typeof import("@anthropic-ai/sdk")>;
-export declare const getLogger: () => import("@jaypie/logger/dist/esm/JaypieLogger.js").default;
+export declare const getLogger: () => ReturnType<typeof createLogger>;
 export declare function initializeClient({ apiKey, }?: {
     apiKey?: string;
 }): Promise<Anthropic>;

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

@@ -1,6 +1,7 @@
+import { createLogger } from "@jaypie/logger";
 import type { BedrockRuntimeClient } from "@aws-sdk/client-bedrock-runtime";
 export declare function loadSdk(): Promise<typeof import("@aws-sdk/client-bedrock-runtime")>;
-export declare const getLogger: () => import("@jaypie/logger/dist/esm/JaypieLogger").default;
+export declare const getLogger: () => ReturnType<typeof createLogger>;
 export declare function initializeClient({ region, }?: {
     region?: string;
 }): Promise<BedrockRuntimeClient>;

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

@@ -1,7 +1,8 @@
+import { createLogger } from "@jaypie/logger";
 import type { GoogleGenAI } from "@google/genai";
 import { LlmMessageOptions } from "../../types/LlmProvider.interface.js";
 export declare function loadSdk(): Promise<typeof import("@google/genai")>;
-export declare const getLogger: () => import("@jaypie/logger/dist/esm/JaypieLogger.js").default;
+export declare const getLogger: () => ReturnType<typeof createLogger>;
 export declare function initializeClient({ apiKey, }?: {
     apiKey?: string;
 }): Promise<GoogleGenAI>;