@illuma-ai/agents 1.0.81

package/dist/types/llm/bedrock/utils/message_inputs.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Utility functions for converting LangChain messages to Bedrock Converse messages.
+ * Ported from @langchain/aws common.js
+ */
+import { type BaseMessage, MessageContentComplex } from '@langchain/core/messages';
+import type { BedrockMessage, BedrockSystemContentBlock, BedrockContentBlock, MessageContentReasoningBlock } from '../types';
+/**
+ * Convert a LangChain reasoning block to a Bedrock reasoning block.
+ */
+export declare function langchainReasoningBlockToBedrockReasoningBlock(content: MessageContentReasoningBlock): {
+    reasoningText?: {
+        text?: string;
+        signature?: string;
+    };
+    redactedContent?: Uint8Array;
+};
+/**
+ * Concatenate consecutive reasoning blocks in content array.
+ */
+export declare function concatenateLangchainReasoningBlocks(content: Array<MessageContentComplex | MessageContentReasoningBlock>): Array<MessageContentComplex | MessageContentReasoningBlock>;
+/**
+ * Extract image info from a base64 string or URL.
+ */
+export declare function extractImageInfo(base64: string): BedrockContentBlock;
+/**
+ * Convert LangChain messages to Bedrock Converse messages.
+ */
+export declare function convertToConverseMessages(messages: BaseMessage[]): {
+    converseMessages: BedrockMessage[];
+    converseSystem: BedrockSystemContentBlock[];
+};

package/dist/types/llm/bedrock/utils/message_outputs.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Utility functions for converting Bedrock Converse responses to LangChain messages.
+ * Ported from @langchain/aws common.js
+ */
+import { AIMessage } from '@langchain/core/messages';
+import { ChatGenerationChunk } from '@langchain/core/outputs';
+import type { BedrockMessage, ConverseResponse, ContentBlockDeltaEvent, ConverseStreamMetadataEvent, ContentBlockStartEvent, ReasoningContentBlock, ReasoningContentBlockDelta, MessageContentReasoningBlock, MessageContentReasoningBlockReasoningTextPartial, MessageContentReasoningBlockRedacted } from '../types';
+/**
+ * Convert a Bedrock reasoning block delta to a LangChain partial reasoning block.
+ */
+export declare function bedrockReasoningDeltaToLangchainPartialReasoningBlock(reasoningContent: ReasoningContentBlockDelta): MessageContentReasoningBlockReasoningTextPartial | MessageContentReasoningBlockRedacted;
+/**
+ * Convert a Bedrock reasoning block to a LangChain reasoning block.
+ */
+export declare function bedrockReasoningBlockToLangchainReasoningBlock(reasoningContent: ReasoningContentBlock): MessageContentReasoningBlock;
+/**
+ * Convert a Bedrock Converse message to a LangChain message.
+ */
+export declare function convertConverseMessageToLangChainMessage(message: BedrockMessage, responseMetadata: Omit<ConverseResponse, 'output'>): AIMessage;
+/**
+ * Handle a content block delta event from Bedrock Converse stream.
+ */
+export declare function handleConverseStreamContentBlockDelta(contentBlockDelta: ContentBlockDeltaEvent): ChatGenerationChunk;
+/**
+ * Handle a content block start event from Bedrock Converse stream.
+ */
+export declare function handleConverseStreamContentBlockStart(contentBlockStart: ContentBlockStartEvent): ChatGenerationChunk | null;
+/**
+ * Handle a metadata event from Bedrock Converse stream.
+ */
+export declare function handleConverseStreamMetadata(metadata: ConverseStreamMetadataEvent, extra: {
+    streamUsage: boolean;
+}): ChatGenerationChunk;

package/dist/types/llm/fake.d.ts

@@ -0,0 +1,31 @@
+import { ChatGenerationChunk } from '@langchain/core/outputs';
+import type { CallbackManagerForLLMRun } from '@langchain/core/callbacks/manager';
+import type { BaseMessage } from '@langchain/core/messages';
+import { FakeListChatModel } from '@langchain/core/utils/testing';
+import { ToolCall, ToolCallChunk } from '@langchain/core/messages/tool';
+type SplitStrategy = {
+    type: 'regex' | 'fixed';
+    value: RegExp | number;
+};
+export declare class FakeChatModel extends FakeListChatModel {
+    private splitStrategy;
+    private toolCalls;
+    private addedToolCalls;
+    constructor({ responses, sleep, emitCustomEvent, splitStrategy, toolCalls }: {
+        responses: string[];
+        sleep?: number;
+        emitCustomEvent?: boolean;
+        splitStrategy?: SplitStrategy;
+        toolCalls?: ToolCall[];
+    });
+    private splitText;
+    _createResponseChunk(text: string, tool_call_chunks?: ToolCallChunk[]): ChatGenerationChunk;
+    _streamResponseChunks(_messages: BaseMessage[], options: this['ParsedCallOptions'], runManager?: CallbackManagerForLLMRun): AsyncGenerator<ChatGenerationChunk>;
+}
+export declare function createFakeStreamingLLM({ responses, sleep, splitStrategy, toolCalls, }: {
+    responses: string[];
+    sleep?: number;
+    splitStrategy?: SplitStrategy;
+    toolCalls?: ToolCall[];
+}): FakeChatModel;
+export {};

package/dist/types/llm/google/index.d.ts

@@ -0,0 +1,24 @@
+import { ChatGenerationChunk } from '@langchain/core/outputs';
+import { ChatGoogleGenerativeAI } from '@langchain/google-genai';
+import type { GenerateContentRequest } from '@google/generative-ai';
+import type { CallbackManagerForLLMRun } from '@langchain/core/callbacks/manager';
+import type { BaseMessage } from '@langchain/core/messages';
+import type { GeminiGenerationConfig } from '@langchain/google-common';
+import type { GoogleClientOptions } from '@/types';
+export declare class CustomChatGoogleGenerativeAI extends ChatGoogleGenerativeAI {
+    thinkingConfig?: GeminiGenerationConfig['thinkingConfig'];
+    /**
+     * Override to add gemini-3 model support for multimodal and function calling thought signatures
+     */
+    get _isMultimodalModel(): boolean;
+    constructor(fields: GoogleClientOptions);
+    static lc_name(): 'IllumaGoogleGenerativeAI';
+    /**
+     * Helper function to convert Gemini API usage metadata to LangChain format
+     * Includes support for cached tokens and tier-based tracking for gemini-3-pro-preview
+     */
+    private _convertToUsageMetadata;
+    invocationParams(options?: this['ParsedCallOptions']): Omit<GenerateContentRequest, 'contents'>;
+    _generate(messages: BaseMessage[], options: this['ParsedCallOptions'], runManager?: CallbackManagerForLLMRun): Promise<import('@langchain/core/outputs').ChatResult>;
+    _streamResponseChunks(messages: BaseMessage[], options: this['ParsedCallOptions'], runManager?: CallbackManagerForLLMRun): AsyncGenerator<ChatGenerationChunk>;
+}

package/dist/types/llm/google/types.d.ts

@@ -0,0 +1,42 @@
+import { CodeExecutionTool, FunctionDeclarationsTool as GoogleGenerativeAIFunctionDeclarationsTool, GoogleSearchRetrievalTool } from '@google/generative-ai';
+import { BindToolsInput } from '@langchain/core/language_models/chat_models';
+/** New GoogleSearch tool for Gemini 2.0+ models */
+export interface GoogleSearchTool {
+    googleSearch: Record<string, never>;
+}
+export type GoogleGenerativeAIToolType = BindToolsInput | GoogleGenerativeAIFunctionDeclarationsTool | CodeExecutionTool | GoogleSearchRetrievalTool | GoogleSearchTool;
+/** Enum for content modality types */
+declare enum Modality {
+    MODALITY_UNSPECIFIED = "MODALITY_UNSPECIFIED",
+    TEXT = "TEXT",
+    IMAGE = "IMAGE",
+    VIDEO = "VIDEO",
+    AUDIO = "AUDIO",
+    DOCUMENT = "DOCUMENT"
+}
+/** Interface for modality token count */
+interface ModalityTokenCount {
+    modality: Modality;
+    tokenCount: number;
+}
+/** Interface for input token details with cache and tier tracking */
+export interface InputTokenDetails {
+    cache_read?: number;
+    over_200k?: number;
+    cache_read_over_200k?: number;
+}
+/** Main interface for Gemini API usage metadata */
+export interface GeminiApiUsageMetadata {
+    promptTokenCount?: number;
+    totalTokenCount?: number;
+    thoughtsTokenCount?: number;
+    candidatesTokenCount?: number;
+    toolUsePromptTokenCount?: number;
+    cachedContentTokenCount?: number;
+    promptTokensDetails: ModalityTokenCount[];
+    candidatesTokensDetails?: ModalityTokenCount[];
+    cacheTokensDetails?: ModalityTokenCount[];
+    toolUsePromptTokensDetails?: ModalityTokenCount[];
+    trafficType?: string;
+}
+export {};

package/dist/types/llm/google/utils/common.d.ts

@@ -0,0 +1,34 @@
+import { POSSIBLE_ROLES, type Part, type Content, type EnhancedGenerateContentResponse, type FunctionDeclarationsTool as GoogleGenerativeAIFunctionDeclarationsTool } from '@google/generative-ai';
+import { BaseMessage, UsageMetadata } from '@langchain/core/messages';
+import { ChatGenerationChunk } from '@langchain/core/outputs';
+import type { ChatResult } from '@langchain/core/outputs';
+import { GoogleGenerativeAIToolType } from '../types';
+export declare const _FUNCTION_CALL_THOUGHT_SIGNATURES_MAP_KEY = "__gemini_function_call_thought_signatures__";
+/**
+ * Executes a function immediately and returns its result.
+ * Functional utility similar to an Immediately Invoked Function Expression (IIFE).
+ * @param fn The function to execute.
+ * @returns The result of invoking fn.
+ */
+export declare const iife: <T>(fn: () => T) => T;
+export declare function getMessageAuthor(message: BaseMessage): string;
+/**
+ * Maps a message type to a Google Generative AI chat author.
+ * @param message The message to map.
+ * @param model The model to use for mapping.
+ * @returns The message type mapped to a Google Generative AI chat author.
+ */
+export declare function convertAuthorToRole(author: string): (typeof POSSIBLE_ROLES)[number];
+export declare function convertMessageContentToParts(message: BaseMessage, isMultimodalModel: boolean, previousMessages: BaseMessage[], model?: string): Part[];
+export declare function convertBaseMessagesToContent(messages: BaseMessage[], isMultimodalModel: boolean, convertSystemMessageToHumanContent?: boolean, model?: string): Content[] | undefined;
+export declare function convertResponseContentToChatGenerationChunk(response: EnhancedGenerateContentResponse, extra: {
+    usageMetadata?: UsageMetadata | undefined;
+    index: number;
+}): ChatGenerationChunk | null;
+/**
+ * Maps a Google GenerateContentResult to a LangChain ChatResult
+ */
+export declare function mapGenerateContentResultToChatResult(response: EnhancedGenerateContentResponse, extra?: {
+    usageMetadata: UsageMetadata | undefined;
+}): ChatResult;
+export declare function convertToGenerativeAITools(tools: GoogleGenerativeAIToolType[]): GoogleGenerativeAIFunctionDeclarationsTool[];

package/dist/types/llm/google/utils/tools.d.ts

@@ -0,0 +1,10 @@
+import { Tool as GenerativeAITool, ToolConfig } from '@google/generative-ai';
+import { ToolChoice } from '@langchain/core/language_models/chat_models';
+import { GoogleGenerativeAIToolType } from '../types';
+export declare function convertToolsToGenAI(tools: GoogleGenerativeAIToolType[], extra?: {
+    toolChoice?: ToolChoice;
+    allowedFunctionNames?: string[];
+}): {
+    tools: GenerativeAITool[];
+    toolConfig?: ToolConfig;
+};

package/dist/types/llm/google/utils/zod_to_genai_parameters.d.ts

@@ -0,0 +1,14 @@
+import { type FunctionDeclarationSchema as GenerativeAIFunctionDeclarationSchema, type SchemaType as FunctionDeclarationSchemaType } from '@google/generative-ai';
+import { InteropZodType } from '@langchain/core/utils/types';
+import { type JsonSchema7Type } from '@langchain/core/utils/json_schema';
+export interface GenerativeAIJsonSchema extends Record<string, unknown> {
+    properties?: Record<string, GenerativeAIJsonSchema>;
+    type: FunctionDeclarationSchemaType;
+}
+export interface GenerativeAIJsonSchemaDirty extends GenerativeAIJsonSchema {
+    properties?: Record<string, GenerativeAIJsonSchemaDirty>;
+    additionalProperties?: boolean;
+}
+export declare function removeAdditionalProperties(obj: Record<string, any>): GenerativeAIJsonSchema;
+export declare function schemaToGenerativeAIParameters<RunOutput extends Record<string, any> = Record<string, any>>(schema: InteropZodType<RunOutput> | JsonSchema7Type): GenerativeAIFunctionDeclarationSchema;
+export declare function jsonSchemaToGeminiParameters(schema: Record<string, any>): GenerativeAIFunctionDeclarationSchema;

package/dist/types/llm/openai/index.d.ts

@@ -0,0 +1,127 @@
+import { AzureOpenAI as AzureOpenAIClient } from 'openai';
+import { ChatXAI as OriginalChatXAI } from '@langchain/xai';
+import { ChatGenerationChunk } from '@langchain/core/outputs';
+import { AIMessage } from '@langchain/core/messages';
+import { ChatDeepSeek as OriginalChatDeepSeek } from '@langchain/deepseek';
+import { CallbackManagerForLLMRun } from '@langchain/core/callbacks/manager';
+import { OpenAIClient, ChatOpenAI as OriginalChatOpenAI, AzureChatOpenAI as OriginalAzureChatOpenAI } from '@langchain/openai';
+import type { HeaderValue, HeadersLike } from './types';
+import type { BindToolsInput } from '@langchain/core/language_models/chat_models';
+import type { BaseMessage } from '@langchain/core/messages';
+import type { ChatResult } from '@langchain/core/outputs';
+import type { ChatXAIInput } from '@langchain/xai';
+import type * as t from '@langchain/openai';
+export declare function isHeaders(headers: unknown): headers is Headers;
+export declare function normalizeHeaders(headers: HeadersLike): Record<string, HeaderValue | readonly HeaderValue[]>;
+type OpenAICompletionParam = OpenAIClient.Chat.Completions.ChatCompletionMessageParam;
+type OpenAICoreRequestOptions = OpenAIClient.RequestOptions;
+/**
+ * Formats a tool in either OpenAI format, or LangChain structured tool format
+ * into an OpenAI tool format. If the tool is already in OpenAI format, return without
+ * any changes. If it is in LangChain structured tool format, convert it to OpenAI tool format
+ * using OpenAI's `zodFunction` util, falling back to `convertToOpenAIFunction` if the parameters
+ * returned from the `zodFunction` util are not defined.
+ *
+ * @param {BindToolsInput} tool The tool to convert to an OpenAI tool.
+ * @param {Object} [fields] Additional fields to add to the OpenAI tool.
+ * @returns {ToolDefinition} The inputted tool in OpenAI tool format.
+ */
+export declare function _convertToOpenAITool(tool: BindToolsInput, fields?: {
+    /**
+     * If `true`, model output is guaranteed to exactly match the JSON Schema
+     * provided in the function definition.
+     */
+    strict?: boolean;
+}): OpenAIClient.ChatCompletionTool;
+export declare class CustomOpenAIClient extends OpenAIClient {
+    abortHandler?: () => void;
+    fetchWithTimeout(url: RequestInfo, init: RequestInit | undefined, ms: number, controller: AbortController): Promise<Response>;
+}
+export declare class CustomAzureOpenAIClient extends AzureOpenAIClient {
+    abortHandler?: () => void;
+    fetchWithTimeout(url: RequestInfo, init: RequestInit | undefined, ms: number, controller: AbortController): Promise<Response>;
+}
+/** @ts-expect-error We are intentionally overriding `getReasoningParams` */
+export declare class ChatOpenAI extends OriginalChatOpenAI<t.ChatOpenAICallOptions> {
+    _lc_stream_delay?: number;
+    constructor(fields?: t.ChatOpenAICallOptions & {
+        _lc_stream_delay?: number;
+    } & t.OpenAIChatInput['modelKwargs']);
+    get exposedClient(): CustomOpenAIClient;
+    static lc_name(): string;
+    protected _getClientOptions(options?: OpenAICoreRequestOptions): OpenAICoreRequestOptions;
+    /**
+     * Returns backwards compatible reasoning parameters from constructor params and call options
+     * @internal
+     */
+    getReasoningParams(options?: this['ParsedCallOptions']): OpenAIClient.Reasoning | undefined;
+    protected _getReasoningParams(options?: this['ParsedCallOptions']): OpenAIClient.Reasoning | undefined;
+    _streamResponseChunks(messages: BaseMessage[], options: this['ParsedCallOptions'], runManager?: CallbackManagerForLLMRun): AsyncGenerator<ChatGenerationChunk>;
+    _streamResponseChunks2(messages: BaseMessage[], options: this['ParsedCallOptions'], runManager?: CallbackManagerForLLMRun): AsyncGenerator<ChatGenerationChunk>;
+}
+/** @ts-expect-error We are intentionally overriding `getReasoningParams` */
+export declare class AzureChatOpenAI extends OriginalAzureChatOpenAI {
+    _lc_stream_delay?: number;
+    constructor(fields?: t.AzureOpenAIInput & {
+        _lc_stream_delay?: number;
+    });
+    get exposedClient(): CustomOpenAIClient;
+    static lc_name(): 'IllumaAzureOpenAI';
+    /**
+     * Returns backwards compatible reasoning parameters from constructor params and call options
+     * @internal
+     */
+    getReasoningParams(options?: this['ParsedCallOptions']): OpenAIClient.Reasoning | undefined;
+    protected _getReasoningParams(options?: this['ParsedCallOptions']): OpenAIClient.Reasoning | undefined;
+    protected _getClientOptions(options: OpenAICoreRequestOptions | undefined): OpenAICoreRequestOptions;
+    _streamResponseChunks(messages: BaseMessage[], options: this['ParsedCallOptions'], runManager?: CallbackManagerForLLMRun): AsyncGenerator<ChatGenerationChunk>;
+}
+export declare class ChatDeepSeek extends OriginalChatDeepSeek {
+    get exposedClient(): CustomOpenAIClient;
+    static lc_name(): 'IllumaDeepSeek';
+    protected _convertMessages(messages: BaseMessage[]): OpenAICompletionParam[];
+    _generate(messages: BaseMessage[], options: this['ParsedCallOptions'] | undefined, runManager?: CallbackManagerForLLMRun): Promise<ChatResult>;
+    protected _convertResponseToMessage(choice: OpenAIClient.Chat.Completions.ChatCompletion.Choice, data: OpenAIClient.Chat.Completions.ChatCompletion): AIMessage;
+    protected _getClientOptions(options?: OpenAICoreRequestOptions): OpenAICoreRequestOptions;
+    _streamResponseChunks(messages: BaseMessage[], options: this['ParsedCallOptions'], runManager?: CallbackManagerForLLMRun): AsyncGenerator<ChatGenerationChunk>;
+}
+/** xAI-specific usage metadata type */
+export interface XAIUsageMetadata extends OpenAIClient.Completions.CompletionUsage {
+    prompt_tokens_details?: {
+        audio_tokens?: number;
+        cached_tokens?: number;
+        text_tokens?: number;
+        image_tokens?: number;
+    };
+    completion_tokens_details?: {
+        audio_tokens?: number;
+        reasoning_tokens?: number;
+        accepted_prediction_tokens?: number;
+        rejected_prediction_tokens?: number;
+    };
+    num_sources_used?: number;
+}
+export declare class ChatMoonshot extends ChatOpenAI {
+    static lc_name(): 'LibreChatMoonshot';
+    protected _convertMessages(messages: BaseMessage[]): OpenAICompletionParam[];
+    _generate(messages: BaseMessage[], options: this['ParsedCallOptions'], runManager?: CallbackManagerForLLMRun): Promise<ChatResult>;
+    protected _convertResponseToMessage(choice: OpenAIClient.Chat.Completions.ChatCompletion.Choice, data: OpenAIClient.Chat.Completions.ChatCompletion): AIMessage;
+    _streamResponseChunks(messages: BaseMessage[], options: this['ParsedCallOptions'], runManager?: CallbackManagerForLLMRun): AsyncGenerator<ChatGenerationChunk>;
+}
+export declare class ChatXAI extends OriginalChatXAI {
+    _lc_stream_delay?: number;
+    constructor(fields?: Partial<ChatXAIInput> & {
+        configuration?: {
+            baseURL?: string;
+        };
+        clientConfig?: {
+            baseURL?: string;
+        };
+        _lc_stream_delay?: number;
+    });
+    static lc_name(): 'IllumaXAI';
+    get exposedClient(): CustomOpenAIClient;
+    protected _getClientOptions(options?: OpenAICoreRequestOptions): OpenAICoreRequestOptions;
+    _streamResponseChunks(messages: BaseMessage[], options: this['ParsedCallOptions'], runManager?: CallbackManagerForLLMRun): AsyncGenerator<ChatGenerationChunk>;
+}
+export {};

package/dist/types/llm/openai/types.d.ts

@@ -0,0 +1,10 @@
+import type { OpenAICallOptions } from '@langchain/openai';
+export interface OpenAIChatCallOptions extends OpenAICallOptions {
+    promptIndex?: number;
+}
+export type OpenAIRoleEnum = 'system' | 'developer' | 'assistant' | 'user' | 'function' | 'tool';
+export type HeaderValue = string | undefined | null;
+export type HeadersLike = Headers | readonly HeaderValue[][] | Record<string, HeaderValue | readonly HeaderValue[]> | undefined | null | {
+    values: Headers;
+    [key: string]: unknown;
+};

package/dist/types/llm/openai/utils/index.d.ts

@@ -0,0 +1,29 @@
+import { type OpenAI as OpenAIClient } from 'openai';
+import { type BaseMessage } from '@langchain/core/messages';
+import { ChatGenerationChunk } from '@langchain/core/outputs';
+import type { OpenAICallOptions, OpenAIChatInput } from '@langchain/openai';
+export type { OpenAICallOptions, OpenAIChatInput };
+type ExtractAsyncIterableType<T> = T extends AsyncIterable<infer U> ? U : never;
+type ExcludeNonController<T> = T extends {
+    controller: unknown;
+} ? T : never;
+type ResponsesCreate = OpenAIClient.Responses['create'];
+type ResponsesInputItem = OpenAIClient.Responses.ResponseInputItem;
+type ResponsesCreateStream = ExcludeNonController<Awaited<ReturnType<ResponsesCreate>>>;
+export type ResponseReturnStreamEvents = ExtractAsyncIterableType<ResponsesCreateStream>;
+type OpenAIRoleEnum = 'system' | 'developer' | 'assistant' | 'user' | 'function' | 'tool';
+type OpenAICompletionParam = OpenAIClient.Chat.Completions.ChatCompletionMessageParam;
+export declare function messageToOpenAIRole(message: BaseMessage): OpenAIRoleEnum;
+/** Options for converting messages to OpenAI params */
+export interface ConvertMessagesOptions {
+    /** Include reasoning_content field for DeepSeek thinking mode with tool calls */
+    includeReasoningContent?: boolean;
+    /** Include reasoning_details field for OpenRouter/Gemini thinking mode with tool calls */
+    includeReasoningDetails?: boolean;
+    /** Convert reasoning_details to content blocks for Claude (requires content array format) */
+    convertReasoningDetailsToContent?: boolean;
+}
+export declare function _convertMessagesToOpenAIParams(messages: BaseMessage[], model?: string, options?: ConvertMessagesOptions): OpenAICompletionParam[];
+export declare function _convertMessagesToOpenAIResponsesParams(messages: BaseMessage[], model?: string, zdrEnabled?: boolean): ResponsesInputItem[];
+export declare function isReasoningModel(model?: string): boolean;
+export declare function _convertOpenAIResponsesDeltaToBaseMessageChunk(chunk: ResponseReturnStreamEvents): ChatGenerationChunk | null;

package/dist/types/llm/openrouter/index.d.ts

@@ -0,0 +1,15 @@
+import { ChatOpenAI } from '@/llm/openai';
+import { ChatGenerationChunk } from '@langchain/core/outputs';
+import { CallbackManagerForLLMRun } from '@langchain/core/callbacks/manager';
+import type { FunctionMessageChunk, SystemMessageChunk, HumanMessageChunk, ToolMessageChunk, ChatMessageChunk, AIMessageChunk, BaseMessage } from '@langchain/core/messages';
+import type { ChatOpenAICallOptions, OpenAIChatInput, OpenAIClient } from '@langchain/openai';
+export interface ChatOpenRouterCallOptions extends ChatOpenAICallOptions {
+    include_reasoning?: boolean;
+    modelKwargs?: OpenAIChatInput['modelKwargs'];
+}
+export declare class ChatOpenRouter extends ChatOpenAI {
+    constructor(_fields: Partial<ChatOpenRouterCallOptions>);
+    static lc_name(): 'IllumaOpenRouter';
+    protected _convertOpenAIDeltaToBaseMessageChunk(delta: Record<string, any>, rawResponse: OpenAIClient.ChatCompletionChunk, defaultRole?: 'function' | 'user' | 'system' | 'developer' | 'assistant' | 'tool'): AIMessageChunk | HumanMessageChunk | SystemMessageChunk | FunctionMessageChunk | ToolMessageChunk | ChatMessageChunk;
+    _streamResponseChunks2(messages: BaseMessage[], options: this['ParsedCallOptions'], runManager?: CallbackManagerForLLMRun): AsyncGenerator<ChatGenerationChunk>;
+}

package/dist/types/llm/providers.d.ts

@@ -0,0 +1,5 @@
+import type { ChatModelConstructorMap, ProviderOptionsMap, ChatModelMap } from '@/types';
+import { Providers } from '@/common';
+export declare const llmProviders: Partial<ChatModelConstructorMap>;
+export declare const manualToolStreamProviders: Set<string>;
+export declare const getChatModelClass: <P extends Providers>(provider: P) => new (config: ProviderOptionsMap[P]) => ChatModelMap[P];

package/dist/types/llm/text.d.ts

@@ -0,0 +1,21 @@
+export interface TextStreamOptions {
+    minChunkSize?: number;
+    maxChunkSize?: number;
+    delay?: number;
+    firstWordChunk?: boolean;
+}
+export type ProgressCallback = (chunk: string) => void;
+export type PostChunkCallback = (chunk: string) => void;
+export declare class TextStream {
+    private text;
+    private currentIndex;
+    private minChunkSize;
+    private maxChunkSize;
+    private delay;
+    private firstWordChunk;
+    constructor(text: string, options?: TextStreamOptions);
+    private randomInt;
+    private static readonly BOUNDARIES;
+    private findFirstWordBoundary;
+    generateText(signal?: AbortSignal, progressCallback?: ProgressCallback): AsyncGenerator<string, void, unknown>;
+}