@librechat/agents 2.4.322 → 3.0.0-rc2

package/dist/types/graphs/Graph.d.ts

@@ -1,29 +1,23 @@
 import { ToolNode } from '@langchain/langgraph/prebuilt';
-import { START } from '@langchain/langgraph';
 import { Runnable, RunnableConfig } from '@langchain/core/runnables';
-import { SystemMessage } from '@langchain/core/messages';
-import type { BaseMessage, UsageMetadata } from '@langchain/core/messages';
-import type * as t from '@/types';
-import { Providers, GraphNodeKeys, Callback, ContentTypes } from '@/common';
+import type { UsageMetadata, BaseMessage } from '@langchain/core/messages';
 import type { ToolCall } from '@langchain/core/messages/tool';
+import type * as t from '@/types';
+import { Providers } from '@/common';
 import { ToolNode as CustomToolNode } from '@/tools/ToolNode';
-import { createPruneMessages } from '@/messages';
+import { AgentContext } from '@/agents/AgentContext';
 import { HandlerRegistry } from '@/events';
-export type GraphNode = GraphNodeKeys | typeof START;
-export type ClientCallback<T extends unknown[]> = (graph: StandardGraph, ...args: T) => void;
-export type ClientCallbacks = {
-    [Callback.TOOL_ERROR]?: ClientCallback<[Error, string]>;
-    [Callback.TOOL_START]?: ClientCallback<unknown[]>;
-    [Callback.TOOL_END]?: ClientCallback<unknown[]>;
-};
-export type SystemCallbacks = {
-    [K in keyof ClientCallbacks]: ClientCallbacks[K] extends ClientCallback<infer Args> ? (...args: Args) => void : never;
-};
-export declare abstract class Graph<T extends t.BaseGraphState = t.BaseGraphState, TNodeName extends string = string> {
+export declare abstract class Graph<T extends t.BaseGraphState = t.BaseGraphState, _TNodeName extends string = string> {
     abstract resetValues(): void;
-    abstract createGraphState(): t.GraphStateChannels<T>;
-    abstract initializeTools(): CustomToolNode<T> | ToolNode<T>;
-    abstract initializeModel(): Runnable;
+    abstract initializeTools({ currentTools, currentToolMap, }: {
+        currentTools?: t.GraphTools;
+        currentToolMap?: t.ToolMap;
+    }): CustomToolNode<T> | ToolNode<T>;
+    abstract initializeModel({ currentModel, tools, clientOptions, }: {
+        currentModel?: t.ChatModel;
+        tools?: t.GraphTools;
+        clientOptions?: t.ClientOptions;
+    }): Runnable;
     abstract getRunMessages(): BaseMessage[] | undefined;
     abstract getContentParts(): t.MessageContentComplex[] | undefined;
     abstract generateStepId(stepKey: string): [string, number];
@@ -32,17 +26,12 @@ export declare abstract class Graph<T extends t.BaseGraphState = t.BaseGraphStat
     abstract checkKeyList(keyList: (string | number | undefined)[]): boolean;
     abstract getStepIdByKey(stepKey: string, index?: number): string;
     abstract getRunStep(stepId: string): t.RunStep | undefined;
-    abstract dispatchRunStep(stepKey: string, stepDetails: t.StepDetails): string;
-    abstract dispatchRunStepDelta(id: string, delta: t.ToolCallDelta): void;
-    abstract dispatchMessageDelta(id: string, delta: t.MessageDelta): void;
-    abstract dispatchReasoningDelta(stepId: string, delta: t.ReasoningDelta): void;
-    abstract handleToolCallCompleted(data: t.ToolEndData, metadata?: Record<string, unknown>): void;
-    abstract createCallModel(): (state: T, config?: RunnableConfig) => Promise<Partial<T>>;
-    abstract createWorkflow(): t.CompiledWorkflow<T>;
-    lastToken?: string;
-    tokenTypeSwitch?: 'reasoning' | 'content';
-    reasoningKey: 'reasoning_content' | 'reasoning';
-    currentTokenType: ContentTypes.TEXT | ContentTypes.THINK | 'think_and_text';
+    abstract dispatchRunStep(stepKey: string, stepDetails: t.StepDetails): Promise<string>;
+    abstract dispatchRunStepDelta(id: string, delta: t.ToolCallDelta): Promise<void>;
+    abstract dispatchMessageDelta(id: string, delta: t.MessageDelta): Promise<void>;
+    abstract dispatchReasoningDelta(stepId: string, delta: t.ReasoningDelta): Promise<void>;
+    abstract handleToolCallCompleted(data: t.ToolEndData, metadata?: Record<string, unknown>, omitOutput?: boolean): Promise<void>;
+    abstract createCallModel(agentId?: string, currentModel?: t.ChatModel): (state: T, config?: RunnableConfig) => Promise<Partial<T>>;
     messageStepHasToolCalls: Map<string, boolean>;
     messageIdsByStepKey: Map<string, string>;
     prelimMessageIdsByStepKey: Map<string, string>;
@@ -51,34 +40,27 @@ export declare abstract class Graph<T extends t.BaseGraphState = t.BaseGraphStat
     stepKeyIds: Map<string, string[]>;
     contentIndexMap: Map<string, number>;
     toolCallStepIds: Map<string, string>;
-    currentUsage: Partial<UsageMetadata> | undefined;
-    indexTokenCountMap: Record<string, number | undefined>;
-    maxContextTokens: number | undefined;
-    pruneMessages?: ReturnType<typeof createPruneMessages>;
-    /** The amount of time that should pass before another consecutive API call */
-    streamBuffer: number | undefined;
-    tokenCounter?: t.TokenCounter;
     signal?: AbortSignal;
-}
-export declare class StandardGraph extends Graph<t.BaseGraphState, GraphNode> {
-    private graphState;
-    clientOptions: t.ClientOptions;
-    boundModel?: Runnable;
-    /** The last recorded timestamp that a stream API call was invoked */
-    lastStreamCall: number | undefined;
+    /** Set of invoked tool call IDs from non-message run steps completed mid-run, if any */
+    invokedToolIds?: Set<string>;
     handlerRegistry: HandlerRegistry | undefined;
-    systemMessage: SystemMessage | undefined;
+}
+export declare class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
+    overrideModel?: t.ChatModel;
+    /** Optional compile options passed into workflow.compile() */
+    compileOptions?: t.CompileOptions | undefined;
     messages: BaseMessage[];
     runId: string | undefined;
-    tools?: t.GenericTool[];
-    toolMap?: t.ToolMap;
     startIndex: number;
-    provider: Providers;
-    toolEnd: boolean;
     signal?: AbortSignal;
-    constructor({ runId, tools, signal, toolMap, provider, streamBuffer, instructions, reasoningKey, clientOptions, toolEnd, additional_instructions, }: t.StandardGraphInput);
+    /** Map of agent contexts by agent ID */
+    agentContexts: Map<string, AgentContext>;
+    /** Default agent ID to use */
+    defaultAgentId: string;
+    constructor({ runId, signal, agents, tokenCounter, indexTokenCountMap, }: t.StandardGraphInput);
     resetValues(keepContent?: boolean): void;
     getRunStep(stepId: string): t.RunStep | undefined;
+    getAgentContext(metadata: Record<string, unknown> | undefined): AgentContext;
     getStepKey(metadata: Record<string, unknown> | undefined): string;
     getStepIdByKey(stepKey: string, index?: number): string;
     generateStepId(stepKey: string): [string, number];
@@ -86,34 +68,49 @@ export declare class StandardGraph extends Graph<t.BaseGraphState, GraphNode> {
     checkKeyList(keyList: (string | number | undefined)[]): boolean;
     getRunMessages(): BaseMessage[] | undefined;
     getContentParts(): t.MessageContentComplex[] | undefined;
-    createGraphState(): t.GraphStateChannels<t.BaseGraphState>;
-    initializeTools(): CustomToolNode<t.BaseGraphState> | ToolNode<t.BaseGraphState>;
-    initializeModel(): Runnable;
+    createSystemRunnable({ provider, clientOptions, instructions, additional_instructions, }: {
+        provider?: Providers;
+        clientOptions?: t.ClientOptions;
+        instructions?: string;
+        additional_instructions?: string;
+    }): t.SystemRunnable | undefined;
+    initializeTools({ currentTools, currentToolMap, }: {
+        currentTools?: t.GraphTools;
+        currentToolMap?: t.ToolMap;
+    }): CustomToolNode<t.BaseGraphState> | ToolNode<t.BaseGraphState>;
+    initializeModel({ provider, tools, clientOptions, }: {
+        provider: Providers;
+        tools?: t.GraphTools;
+        clientOptions?: t.ClientOptions;
+    }): Runnable;
     overrideTestModel(responses: string[], sleep?: number, toolCalls?: ToolCall[]): void;
-    getNewModel({ clientOptions, omitOriginalOptions, }: {
+    getNewModel({ provider, clientOptions, }: {
+        provider: Providers;
         clientOptions?: t.ClientOptions;
-        omitOriginalOptions?: Set<string>;
     }): t.ChatModelInstance;
-    storeUsageMetadata(finalMessage?: BaseMessage): void;
-    cleanupSignalListener(): void;
-    createCallModel(): (state: t.BaseGraphState, config?: RunnableConfig) => Promise<Partial<t.BaseGraphState>>;
-    createWorkflow(): t.CompiledWorkflow<t.BaseGraphState>;
+    getUsageMetadata(finalMessage?: BaseMessage): Partial<UsageMetadata> | undefined;
+    /** Execute model invocation with streaming support */
+    private attemptInvoke;
+    cleanupSignalListener(currentModel?: t.ChatModel): void;
+    createCallModel(agentId?: string, currentModel?: t.ChatModel): (state: t.BaseGraphState, config?: RunnableConfig) => Promise<Partial<t.BaseGraphState>>;
+    createAgentNode(agentId: string): t.CompiledAgentWorfklow;
+    createWorkflow(): t.CompiledStateWorkflow;
     /**
      * Dispatches a run step to the client, returns the step ID
      */
-    dispatchRunStep(stepKey: string, stepDetails: t.StepDetails): string;
-    handleToolCallCompleted(data: t.ToolEndData, metadata?: Record<string, unknown>): void;
+    dispatchRunStep(stepKey: string, stepDetails: t.StepDetails): Promise<string>;
+    handleToolCallCompleted(data: t.ToolEndData, metadata?: Record<string, unknown>, omitOutput?: boolean): Promise<void>;
     /**
      * Static version of handleToolCallError to avoid creating strong references
      * that prevent garbage collection
      */
-    static handleToolCallErrorStatic(graph: StandardGraph, data: t.ToolErrorData, metadata?: Record<string, unknown>): void;
+    static handleToolCallErrorStatic(graph: StandardGraph, data: t.ToolErrorData, metadata?: Record<string, unknown>): Promise<void>;
     /**
      * Instance method that delegates to the static method
      * Kept for backward compatibility
      */
-    handleToolCallError(data: t.ToolErrorData, metadata?: Record<string, unknown>): void;
-    dispatchRunStepDelta(id: string, delta: t.ToolCallDelta): void;
-    dispatchMessageDelta(id: string, delta: t.MessageDelta): void;
-    dispatchReasoningDelta: (stepId: string, delta: t.ReasoningDelta) => void;
+    handleToolCallError(data: t.ToolErrorData, metadata?: Record<string, unknown>): Promise<void>;
+    dispatchRunStepDelta(id: string, delta: t.ToolCallDelta): Promise<void>;
+    dispatchMessageDelta(id: string, delta: t.MessageDelta): Promise<void>;
+    dispatchReasoningDelta: (stepId: string, delta: t.ReasoningDelta) => Promise<void>;
 }

package/dist/types/graphs/MultiAgentGraph.d.ts

@@ -0,0 +1,37 @@
+import type * as t from '@/types';
+import { StandardGraph } from './Graph';
+/**
+ * MultiAgentGraph extends StandardGraph to support dynamic multi-agent workflows
+ * with handoffs, fan-in/fan-out, and other composable patterns
+ */
+export declare class MultiAgentGraph extends StandardGraph {
+    private edges;
+    private startingNodes;
+    private directEdges;
+    private handoffEdges;
+    constructor(input: t.MultiAgentGraphInput);
+    /**
+     * Categorize edges into handoff and direct types
+     */
+    private categorizeEdges;
+    /**
+     * Analyze graph structure to determine starting nodes and connections
+     */
+    private analyzeGraph;
+    /**
+     * Create handoff tools for agents based on handoff edges only
+     */
+    private createHandoffTools;
+    /**
+     * Create handoff tools for an edge (handles multiple destinations)
+     */
+    private createHandoffToolsForEdge;
+    /**
+     * Create a complete agent subgraph (similar to createReactAgent)
+     */
+    private createAgentSubgraph;
+    /**
+     * Create the multi-agent workflow with dynamic handoffs
+     */
+    createWorkflow(): t.CompiledMultiAgentWorkflow;
+}

package/dist/types/graphs/index.d.ts

@@ -1 +1,2 @@
 export * from './Graph';
+export * from './MultiAgentGraph';

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

@@ -4,9 +4,15 @@ import type { BaseChatModelParams } from '@langchain/core/language_models/chat_m
 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;
@@ -14,6 +20,10 @@ export declare class CustomAnthropic extends ChatAnthropicMessages {
     private tools_in_params?;
     private emitted_usage?;
     constructor(fields?: CustomAnthropicInput);
+    /**
+     * 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.
@@ -23,3 +33,4 @@ export declare class CustomAnthropic extends ChatAnthropicMessages {
     private createGenerationChunk;
     _streamResponseChunks(messages: BaseMessage[], options: this['ParsedCallOptions'], runManager?: CallbackManagerForLLMRun): AsyncGenerator<ChatGenerationChunk>;
 }
+export {};

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

@@ -1,15 +1,15 @@
 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 AnthropicStreamUsage = Anthropic.Usage;
 export type AnthropicMessageParam = Anthropic.MessageParam;
-export type AnthropicMessageDeltaEvent = Anthropic.MessageDeltaEvent;
-export type AnthropicMessageStartEvent = Anthropic.MessageStartEvent;
 export type AnthropicMessageResponse = Anthropic.ContentBlock | AnthropicToolResponse;
 export type AnthropicMessageCreateParams = Anthropic.MessageCreateParamsNonStreaming;
 export type AnthropicStreamingMessageCreateParams = Anthropic.MessageCreateParamsStreaming;
@@ -28,4 +28,10 @@ export type AnthropicToolResultBlockParam = Anthropic.Messages.ToolResultBlockPa
 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

@@ -3,7 +3,7 @@
  */
 import { type BaseMessage } from '@langchain/core/messages';
 import { ToolCall } from '@langchain/core/messages/tool';
-import type { AnthropicMessageCreateParams, AnthropicToolResponse } from '@/llm/anthropic/types';
+import { AnthropicMessageCreateParams, AnthropicToolResponse } from '../types';
 export declare function _convertLangChainToolCallToAnthropic(toolCall: ToolCall): AnthropicToolResponse;
 /**
  * Formats messages as a prompt for the model.

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

@@ -1,9 +1,9 @@
-import { z } from 'zod';
 import { BaseLLMOutputParser } from '@langchain/core/output_parsers';
-import { JsonOutputKeyToolsParserParams } from '@langchain/core/output_parsers/openai_tools';
+import { JsonOutputKeyToolsParserParamsInterop } from '@langchain/core/output_parsers/openai_tools';
 import { ChatGeneration } from '@langchain/core/outputs';
 import { ToolCall } from '@langchain/core/messages/tool';
-interface AnthropicToolsOutputParserParams<T extends Record<string, any>> extends JsonOutputKeyToolsParserParams<T> {
+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;
@@ -13,7 +13,7 @@ export declare class AnthropicToolsOutputParser<T extends Record<string, any> =
     keyName: string;
     /** Whether to return only the first tool call. */
     returnSingle: boolean;
-    zodSchema?: z.ZodType<T>;
+    zodSchema?: InteropZodType<T>;
     constructor(params: AnthropicToolsOutputParserParams<T>);
     protected _validateResult(result: unknown): Promise<T>;
     parseResult(generations: ChatGeneration[]): Promise<T>;

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/google/index.d.ts

@@ -0,0 +1,13 @@
+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);
+    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,7 @@
+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 {
+    _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

@@ -1,9 +1,35 @@
 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 { OpenAICoreRequestOptions } from 'node_modules/@langchain/deepseek/node_modules/@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>;
@@ -12,19 +38,62 @@ 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;
-    protected _getClientOptions(options?: t.OpenAICoreRequestOptions): t.OpenAICoreRequestOptions;
+    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;
-    protected _getClientOptions(options: t.OpenAICoreRequestOptions | undefined): t.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;
+    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;
     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;
+        };
+    });
     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/text.d.ts

@@ -17,5 +17,5 @@ export declare class TextStream {
     private randomInt;
     private static readonly BOUNDARIES;
     private findFirstWordBoundary;
-    generateText(progressCallback?: ProgressCallback): AsyncGenerator<string, void, unknown>;
+    generateText(signal?: AbortSignal, progressCallback?: ProgressCallback): AsyncGenerator<string, void, unknown>;
 }