illuma-agents 1.0.2

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

@@ -0,0 +1,39 @@
+import { ChatAnthropicMessages } from '@langchain/anthropic';
+import { ChatGenerationChunk } from '@langchain/core/outputs';
+import type { BaseChatModelParams } from '@langchain/core/language_models/chat_models';
+import type { BaseMessage, UsageMetadata } from '@langchain/core/messages';
+import type { CallbackManagerForLLMRun } from '@langchain/core/callbacks/manager';
+import type { AnthropicInput } from '@langchain/anthropic';
+import type { AnthropicMessageCreateParams, AnthropicStreamingMessageCreateParams } from '@/llm/anthropic/types';
+export type CustomAnthropicInput = AnthropicInput & {
+    _lc_stream_delay?: number;
+} & BaseChatModelParams;
+/**
+ * A type representing additional parameters that can be passed to the
+ * Anthropic API.
+ */
+type Kwargs = Record<string, any>;
+export declare class CustomAnthropic extends ChatAnthropicMessages {
+    _lc_stream_delay: number;
+    private message_start;
+    private message_delta;
+    private tools_in_params?;
+    private emitted_usage?;
+    top_k: number | undefined;
+    constructor(fields?: CustomAnthropicInput);
+    static lc_name(): 'IllumaAnthropic';
+    /**
+     * Get the parameters used to invoke the model
+     */
+    invocationParams(options?: this['ParsedCallOptions']): Omit<AnthropicMessageCreateParams | AnthropicStreamingMessageCreateParams, 'messages'> & Kwargs;
+    /**
+     * Get stream usage as returned by this client's API response.
+     * @returns The stream usage object.
+     */
+    getStreamUsage(): UsageMetadata | undefined;
+    resetTokenEvents(): void;
+    setDirectFields(fields?: CustomAnthropicInput): void;
+    private createGenerationChunk;
+    _streamResponseChunks(messages: BaseMessage[], options: this['ParsedCallOptions'], runManager?: CallbackManagerForLLMRun): AsyncGenerator<ChatGenerationChunk>;
+}
+export {};

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

@@ -0,0 +1,37 @@
+import Anthropic from '@anthropic-ai/sdk';
+import { BindToolsInput } from '@langchain/core/language_models/chat_models';
+export type AnthropicStreamUsage = Anthropic.Usage;
+export type AnthropicMessageDeltaEvent = Anthropic.MessageDeltaEvent;
+export type AnthropicMessageStartEvent = Anthropic.MessageStartEvent;
+export type AnthropicToolResponse = {
+    type: 'tool_use';
+    id: string;
+    name: string;
+    input: Record<string, any>;
+};
+export type AnthropicMessageParam = Anthropic.MessageParam;
+export type AnthropicMessageResponse = Anthropic.ContentBlock | AnthropicToolResponse;
+export type AnthropicMessageCreateParams = Anthropic.MessageCreateParamsNonStreaming;
+export type AnthropicStreamingMessageCreateParams = Anthropic.MessageCreateParamsStreaming;
+export type AnthropicThinkingConfigParam = Anthropic.ThinkingConfigParam;
+export type AnthropicMessageStreamEvent = Anthropic.MessageStreamEvent;
+export type AnthropicRequestOptions = Anthropic.RequestOptions;
+export type AnthropicToolChoice = {
+    type: 'tool';
+    name: string;
+} | 'any' | 'auto' | 'none' | string;
+export type ChatAnthropicToolType = Anthropic.Messages.Tool | BindToolsInput;
+export type AnthropicTextBlockParam = Anthropic.Messages.TextBlockParam;
+export type AnthropicImageBlockParam = Anthropic.Messages.ImageBlockParam;
+export type AnthropicToolUseBlockParam = Anthropic.Messages.ToolUseBlockParam;
+export type AnthropicToolResultBlockParam = Anthropic.Messages.ToolResultBlockParam;
+export type AnthropicDocumentBlockParam = Anthropic.Messages.DocumentBlockParam;
+export type AnthropicThinkingBlockParam = Anthropic.Messages.ThinkingBlockParam;
+export type AnthropicRedactedThinkingBlockParam = Anthropic.Messages.RedactedThinkingBlockParam;
+export type AnthropicServerToolUseBlockParam = Anthropic.Messages.ServerToolUseBlockParam;
+export type AnthropicWebSearchToolResultBlockParam = Anthropic.Messages.WebSearchToolResultBlockParam;
+export type AnthropicWebSearchResultBlockParam = Anthropic.Messages.WebSearchResultBlockParam;
+export type AnthropicSearchResultBlockParam = Anthropic.Beta.BetaSearchResultBlockParam;
+export type AnthropicContentBlock = AnthropicTextBlockParam | AnthropicImageBlockParam | AnthropicToolUseBlockParam | AnthropicToolResultBlockParam | AnthropicDocumentBlockParam | AnthropicThinkingBlockParam | AnthropicRedactedThinkingBlockParam | AnthropicServerToolUseBlockParam | AnthropicWebSearchToolResultBlockParam | AnthropicWebSearchResultBlockParam;
+export type ChatAnthropicContentBlock = AnthropicTextBlockParam | AnthropicImageBlockParam | AnthropicToolUseBlockParam | AnthropicToolResultBlockParam | AnthropicDocumentBlockParam | AnthropicThinkingBlockParam | AnthropicRedactedThinkingBlockParam | AnthropicServerToolUseBlockParam | AnthropicWebSearchToolResultBlockParam | AnthropicWebSearchResultBlockParam | AnthropicSearchResultBlockParam;
+export declare function isAnthropicImageBlockParam(block: unknown): block is AnthropicImageBlockParam;

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

@@ -0,0 +1,14 @@
+/**
+ * This util file contains functions for converting LangChain messages to Anthropic messages.
+ */
+import { type BaseMessage } from '@langchain/core/messages';
+import { ToolCall } from '@langchain/core/messages/tool';
+import { AnthropicMessageCreateParams, AnthropicToolResponse } from '../types';
+export declare function _convertLangChainToolCallToAnthropic(toolCall: ToolCall): AnthropicToolResponse;
+/**
+ * Formats messages as a prompt for the model.
+ * Used in LangSmith, export is important here.
+ * @param messages The base messages to format as a prompt.
+ * @returns The formatted prompt.
+ */
+export declare function _convertMessagesToAnthropicPayload(messages: BaseMessage[]): AnthropicMessageCreateParams;

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

@@ -0,0 +1,14 @@
+/**
+ * This util file contains functions for converting Anthropic messages to LangChain messages.
+ */
+import Anthropic from '@anthropic-ai/sdk';
+import { AIMessageChunk } from '@langchain/core/messages';
+import { ChatGeneration } from '@langchain/core/outputs';
+import { AnthropicMessageResponse } from '../types';
+export declare function _makeMessageChunkFromAnthropicEvent(data: Anthropic.Messages.RawMessageStreamEvent, fields: {
+    streamUsage: boolean;
+    coerceContentToString: boolean;
+}): {
+    chunk: AIMessageChunk;
+} | null;
+export declare function anthropicResponseToChatMessages(messages: AnthropicMessageResponse[], additionalKwargs: Record<string, unknown>): ChatGeneration[];

package/dist/types/llm/anthropic/utils/output_parsers.d.ts

@@ -0,0 +1,22 @@
+import { BaseLLMOutputParser } from '@langchain/core/output_parsers';
+import { JsonOutputKeyToolsParserParamsInterop } from '@langchain/core/output_parsers/openai_tools';
+import { ChatGeneration } from '@langchain/core/outputs';
+import { ToolCall } from '@langchain/core/messages/tool';
+import { InteropZodType } from '@langchain/core/utils/types';
+interface AnthropicToolsOutputParserParams<T extends Record<string, any>> extends JsonOutputKeyToolsParserParamsInterop<T> {
+}
+export declare class AnthropicToolsOutputParser<T extends Record<string, any> = Record<string, any>> extends BaseLLMOutputParser<T> {
+    static lc_name(): string;
+    lc_namespace: string[];
+    returnId: boolean;
+    /** The type of tool calls to return. */
+    keyName: string;
+    /** Whether to return only the first tool call. */
+    returnSingle: boolean;
+    zodSchema?: InteropZodType<T>;
+    constructor(params: AnthropicToolsOutputParserParams<T>);
+    protected _validateResult(result: unknown): Promise<T>;
+    parseResult(generations: ChatGeneration[]): Promise<T>;
+}
+export declare function extractToolCalls(content: Record<string, any>[]): ToolCall[];
+export {};

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

@@ -0,0 +1,3 @@
+import type { Anthropic } from '@anthropic-ai/sdk';
+import { AnthropicToolChoice } from '../types.js';
+export declare function handleToolChoice(toolChoice?: AnthropicToolChoice): Anthropic.Messages.ToolChoiceAuto | Anthropic.Messages.ToolChoiceAny | Anthropic.Messages.ToolChoiceTool | undefined;

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,14 @@
+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'];
+    constructor(fields: GoogleClientOptions);
+    static lc_name(): 'IllumaGoogleGenerativeAI';
+    invocationParams(options?: this['ParsedCallOptions']): Omit<GenerateContentRequest, 'contents'>;
+    _streamResponseChunks(messages: BaseMessage[], options: this['ParsedCallOptions'], runManager?: CallbackManagerForLLMRun): AsyncGenerator<ChatGenerationChunk>;
+}

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

@@ -0,0 +1,32 @@
+import { CodeExecutionTool, FunctionDeclarationsTool as GoogleGenerativeAIFunctionDeclarationsTool, GoogleSearchRetrievalTool } from '@google/generative-ai';
+import { BindToolsInput } from '@langchain/core/language_models/chat_models';
+export type GoogleGenerativeAIToolType = BindToolsInput | GoogleGenerativeAIFunctionDeclarationsTool | CodeExecutionTool | GoogleSearchRetrievalTool;
+/** 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;
+}
+/** 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,19 @@
+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 { GoogleGenerativeAIToolType } from '../types';
+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[]): Part[];
+export declare function convertBaseMessagesToContent(messages: BaseMessage[], isMultimodalModel: boolean, convertSystemMessageToHumanContent?: boolean): Content[] | undefined;
+export declare function convertResponseContentToChatGenerationChunk(response: EnhancedGenerateContentResponse, extra: {
+    usageMetadata?: UsageMetadata | undefined;
+    index: number;
+}): ChatGenerationChunk | null;
+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/ollama/index.d.ts

@@ -0,0 +1,8 @@
+import { ChatGenerationChunk } from '@langchain/core/outputs';
+import { ChatOllama as BaseChatOllama } from '@langchain/ollama';
+import { CallbackManagerForLLMRun } from '@langchain/core/callbacks/manager';
+import type { BaseMessage } from '@langchain/core/messages';
+export declare class ChatOllama extends BaseChatOllama {
+    static lc_name(): 'IllumaOllama';
+    _streamResponseChunks(messages: BaseMessage[], options: this['ParsedCallOptions'], runManager?: CallbackManagerForLLMRun): AsyncGenerator<ChatGenerationChunk>;
+}

package/dist/types/llm/ollama/utils.d.ts

@@ -0,0 +1,7 @@
+import { AIMessageChunk, BaseMessage, UsageMetadata } from '@langchain/core/messages';
+import type { Message as OllamaMessage } from 'ollama';
+export declare function convertOllamaMessagesToLangChain(messages: OllamaMessage, extra?: {
+    responseMetadata?: Record<string, any>;
+    usageMetadata?: UsageMetadata;
+}): AIMessageChunk;
+export declare function convertToOllamaMessages(messages: BaseMessage[]): OllamaMessage[];

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

@@ -0,0 +1,103 @@
+import { AzureOpenAI as AzureOpenAIClient } from 'openai';
+import { ChatXAI as OriginalChatXAI } from '@langchain/xai';
+import { ChatGenerationChunk } from '@langchain/core/outputs';
+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 { 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 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> {
+    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 {
+    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 _getClientOptions(options?: OpenAICoreRequestOptions): OpenAICoreRequestOptions;
+}
+/** 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 ChatXAI extends OriginalChatXAI {
+    constructor(fields?: Partial<ChatXAIInput> & {
+        configuration?: {
+            baseURL?: string;
+        };
+        clientConfig?: {
+            baseURL?: string;
+        };
+    });
+    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,20 @@
+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;
+export declare function _convertMessagesToOpenAIParams(messages: BaseMessage[], model?: string): 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,12 @@
+import { ChatOpenAI } from '@/llm/openai';
+import type { FunctionMessageChunk, SystemMessageChunk, HumanMessageChunk, ToolMessageChunk, ChatMessageChunk, AIMessageChunk } 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;
+}

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