@librechat/agents 3.1.73 → 3.1.75-dev.0

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

@@ -4,18 +4,31 @@ 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, AnthropicOutputConfig } from '@/llm/anthropic/types';
+import type { Anthropic } from '@anthropic-ai/sdk';
+import type { AnthropicMessageCreateParams, AnthropicStreamingMessageCreateParams, AnthropicOutputConfig, AnthropicBeta, AnthropicMCPServerURLDefinition, AnthropicContextManagementConfigParam } from '@/llm/anthropic/types';
+export declare function _documentsInParams(params: AnthropicMessageCreateParams | AnthropicStreamingMessageCreateParams): boolean;
 export type CustomAnthropicInput = AnthropicInput & {
     _lc_stream_delay?: number;
     outputConfig?: AnthropicOutputConfig;
     inferenceGeo?: string;
-    contextManagement?: any;
+    contextManagement?: AnthropicContextManagementConfigParam;
 } & BaseChatModelParams;
-/**
- * A type representing additional parameters that can be passed to the
- * Anthropic API.
- */
-type Kwargs = Record<string, any>;
+export type CustomAnthropicCallOptions = {
+    outputConfig?: AnthropicOutputConfig;
+    outputFormat?: Anthropic.Messages.JSONOutputFormat;
+    inferenceGeo?: string;
+    betas?: AnthropicBeta[];
+    container?: string;
+    mcp_servers?: AnthropicMCPServerURLDefinition[];
+};
+type CustomAnthropicInvocationParams = {
+    betas?: AnthropicBeta[];
+    container?: string;
+    context_management?: AnthropicContextManagementConfigParam;
+    inference_geo?: string;
+    mcp_servers?: AnthropicMCPServerURLDefinition[];
+    output_config?: AnthropicOutputConfig;
+};
 export declare class CustomAnthropic extends ChatAnthropicMessages {
     _lc_stream_delay: number;
     private message_start;
@@ -25,13 +38,13 @@ export declare class CustomAnthropic extends ChatAnthropicMessages {
     top_k: number | undefined;
     outputConfig?: AnthropicOutputConfig;
     inferenceGeo?: string;
-    contextManagement?: any;
+    contextManagement?: AnthropicContextManagementConfigParam;
     constructor(fields?: CustomAnthropicInput);
     static lc_name(): 'LibreChatAnthropic';
     /**
      * Get the parameters used to invoke the model
      */
-    invocationParams(options?: this['ParsedCallOptions']): Omit<AnthropicMessageCreateParams | AnthropicStreamingMessageCreateParams, 'messages'> & Kwargs;
+    invocationParams(options?: this['ParsedCallOptions'] & CustomAnthropicCallOptions): Omit<AnthropicMessageCreateParams | AnthropicStreamingMessageCreateParams, 'messages'> & CustomAnthropicInvocationParams;
     /**
      * Get stream usage as returned by this client's API response.
      * @returns The stream usage object.

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

@@ -1,5 +1,7 @@
 import Anthropic from '@anthropic-ai/sdk';
-import { BindToolsInput } from '@langchain/core/language_models/chat_models';
+import type { BindToolsInput } from '@langchain/core/language_models/chat_models';
+import type { AnthropicBeta } from '@anthropic-ai/sdk/resources';
+export type { AnthropicBeta };
 export type AnthropicStreamUsage = Anthropic.Usage;
 export type AnthropicMessageDeltaEvent = Anthropic.MessageDeltaEvent;
 export type AnthropicMessageStartEvent = Anthropic.MessageStartEvent;
@@ -14,8 +16,10 @@ export type AnthropicMessageResponse = Anthropic.ContentBlock | AnthropicToolRes
 export type AnthropicMessageCreateParams = Anthropic.MessageCreateParamsNonStreaming;
 export type AnthropicStreamingMessageCreateParams = Anthropic.MessageCreateParamsStreaming;
 export type AnthropicThinkingConfigParam = Anthropic.ThinkingConfigParam;
+export type AnthropicContextManagementConfigParam = Anthropic.Beta.BetaContextManagementConfig;
 export type AnthropicMessageStreamEvent = Anthropic.MessageStreamEvent;
 export type AnthropicRequestOptions = Anthropic.RequestOptions;
+export type AnthropicMCPServerURLDefinition = Anthropic.Beta.Messages.BetaRequestMCPServerURLDefinition;
 export type AnthropicToolChoice = {
     type: 'tool';
     name: string;

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

@@ -1,10 +1,16 @@
-/**
- * This util file contains functions for converting Anthropic messages to LangChain messages.
- */
-import Anthropic from '@anthropic-ai/sdk';
+/** This util file contains functions for converting Anthropic messages to LangChain messages. */
 import { AIMessageChunk } from '@langchain/core/messages';
-import { ChatGeneration } from '@langchain/core/outputs';
-import { AnthropicMessageResponse } from '../types';
+import type Anthropic from '@anthropic-ai/sdk';
+import type { UsageMetadata } from '@langchain/core/messages';
+import type { ChatGeneration } from '@langchain/core/outputs';
+import type { AnthropicMessageResponse } from '../types';
+interface AnthropicUsageData {
+    input_tokens?: number | null;
+    output_tokens?: number | null;
+    cache_creation_input_tokens?: number | null;
+    cache_read_input_tokens?: number | null;
+}
+export declare function getAnthropicUsageMetadata(usage: AnthropicUsageData | null | undefined): UsageMetadata | undefined;
 export declare function _makeMessageChunkFromAnthropicEvent(data: Anthropic.Beta.Messages.BetaRawMessageStreamEvent, fields: {
     streamUsage: boolean;
     coerceContentToString: boolean;
@@ -12,3 +18,4 @@ export declare function _makeMessageChunkFromAnthropicEvent(data: Anthropic.Beta
     chunk: AIMessageChunk;
 } | null;
 export declare function anthropicResponseToChatMessages(messages: AnthropicMessageResponse[], additionalKwargs: Record<string, unknown>): ChatGeneration[];
+export {};

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

@@ -18,5 +18,5 @@ export declare class AnthropicToolsOutputParser<T extends Record<string, any> =
     protected _validateResult(result: unknown): Promise<T>;
     parseResult(generations: ChatGeneration[]): Promise<T>;
 }
-export declare function extractToolCalls(content: Record<string, any>[]): ToolCall[];
+export declare function extractToolCalls(content: Record<string, any>[]): ToolCall<string, Record<string, any>>[];
 export {};

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

@@ -1,20 +1,26 @@
 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 { BindToolsInput } from '@langchain/core/language_models/chat_models';
 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;
+type LibreChatOpenAIFields = t.ChatOpenAIFields & {
+    _lc_stream_delay?: number;
+    includeReasoningContent?: boolean;
+    includeReasoningDetails?: boolean;
+    convertReasoningDetailsToContent?: boolean;
+};
+type LibreChatAzureOpenAIFields = t.AzureOpenAIInput & {
+    _lc_stream_delay?: number;
+};
 /**
  * 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
@@ -41,15 +47,12 @@ 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']);
+    constructor(fields?: LibreChatOpenAIFields & t.OpenAIChatInput['modelKwargs']);
     get exposedClient(): CustomOpenAIClient;
     static lc_name(): string;
-    protected _getClientOptions(options?: OpenAICoreRequestOptions): OpenAICoreRequestOptions;
+    _getClientOptions(options?: OpenAICoreRequestOptions): OpenAICoreRequestOptions;
     /**
      * Returns backwards compatible reasoning parameters from constructor params and call options
      * @internal
@@ -57,14 +60,10 @@ export declare class ChatOpenAI extends OriginalChatOpenAI<t.ChatOpenAICallOptio
     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;
-    });
+    constructor(fields?: LibreChatAzureOpenAIFields);
     get exposedClient(): CustomOpenAIClient;
     static lc_name(): 'LibreChatAzureOpenAI';
     /**
@@ -73,16 +72,17 @@ export declare class AzureChatOpenAI extends OriginalAzureChatOpenAI {
      */
     getReasoningParams(options?: this['ParsedCallOptions']): OpenAIClient.Reasoning | undefined;
     protected _getReasoningParams(options?: this['ParsedCallOptions']): OpenAIClient.Reasoning | undefined;
-    protected _getClientOptions(options: OpenAICoreRequestOptions | undefined): OpenAICoreRequestOptions;
+    _getClientOptions(options: OpenAICoreRequestOptions | undefined): OpenAICoreRequestOptions;
     _streamResponseChunks(messages: BaseMessage[], options: this['ParsedCallOptions'], runManager?: CallbackManagerForLLMRun): AsyncGenerator<ChatGenerationChunk>;
 }
 export declare class ChatDeepSeek extends OriginalChatDeepSeek {
+    _lc_stream_delay?: number;
+    constructor(fields?: ConstructorParameters<typeof OriginalChatDeepSeek>[0] & {
+        _lc_stream_delay?: number;
+    });
     get exposedClient(): CustomOpenAIClient;
     static lc_name(): 'LibreChatDeepSeek';
-    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;
+    _getClientOptions(options?: OpenAICoreRequestOptions): OpenAICoreRequestOptions;
     _streamResponseChunks(messages: BaseMessage[], options: this['ParsedCallOptions'], runManager?: CallbackManagerForLLMRun): AsyncGenerator<ChatGenerationChunk>;
 }
 /** xAI-specific usage metadata type */
@@ -102,11 +102,8 @@ export interface XAIUsageMetadata extends OpenAIClient.Completions.CompletionUsa
     num_sources_used?: number;
 }
 export declare class ChatMoonshot extends ChatOpenAI {
+    constructor(fields?: LibreChatOpenAIFields & t.OpenAIChatInput['modelKwargs']);
     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;
@@ -121,7 +118,7 @@ export declare class ChatXAI extends OriginalChatXAI {
     });
     static lc_name(): 'LibreChatXAI';
     get exposedClient(): CustomOpenAIClient;
-    protected _getClientOptions(options?: OpenAICoreRequestOptions): OpenAICoreRequestOptions;
+    _getClientOptions(options?: OpenAICoreRequestOptions): OpenAICoreRequestOptions;
     _streamResponseChunks(messages: BaseMessage[], options: this['ParsedCallOptions'], runManager?: CallbackManagerForLLMRun): AsyncGenerator<ChatGenerationChunk>;
 }
 export {};

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

@@ -1,7 +1,7 @@
 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 { BaseMessage } from '@langchain/core/messages';
+import type { ChatGenerationChunk } from '@langchain/core/outputs';
+import type { CallbackManagerForLLMRun } from '@langchain/core/callbacks/manager';
 import type { ChatOpenAICallOptions, OpenAIChatInput, OpenAIClient } from '@langchain/openai';
 export type OpenRouterReasoningEffort = 'xhigh' | 'high' | 'medium' | 'low' | 'minimal' | 'none';
 export interface OpenRouterReasoning {
@@ -16,20 +16,22 @@ export interface ChatOpenRouterCallOptions extends Omit<ChatOpenAICallOptions, '
     reasoning?: OpenRouterReasoning;
     modelKwargs?: OpenAIChatInput['modelKwargs'];
 }
+export type ChatOpenRouterInput = Partial<ChatOpenRouterCallOptions & OpenAIChatInput>;
 /** invocationParams return type extended with OpenRouter reasoning */
 export type OpenRouterInvocationParams = Omit<OpenAIClient.Chat.ChatCompletionCreateParams, 'messages'> & {
     reasoning?: OpenRouterReasoning;
 };
+type InvocationParamsExtra = {
+    streaming?: boolean;
+};
 export declare class ChatOpenRouter extends ChatOpenAI {
     private openRouterReasoning?;
     /** @deprecated Use `reasoning` object instead */
     private includeReasoning?;
-    constructor(_fields: Partial<ChatOpenRouterCallOptions>);
+    constructor(_fields: ChatOpenRouterInput);
     static lc_name(): 'LibreChatOpenRouter';
-    invocationParams(options?: this['ParsedCallOptions'], extra?: {
-        streaming?: boolean;
-    }): OpenRouterInvocationParams;
+    invocationParams(options?: this['ParsedCallOptions'], extra?: InvocationParamsExtra): OpenRouterInvocationParams;
     private buildOpenRouterReasoning;
-    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>;
+    _streamResponseChunks(messages: BaseMessage[], options: this['ParsedCallOptions'], runManager?: CallbackManagerForLLMRun): AsyncGenerator<ChatGenerationChunk>;
 }
+export {};

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

@@ -288,6 +288,7 @@ export declare class ChatVertexAI extends ChatGoogle {
     dynamicThinkingBudget: boolean;
     thinkingConfig?: GoogleThinkingConfig;
     static lc_name(): 'LibreChatVertexAI';
+    constructor(model: string, fields?: Omit<VertexAIClientOptions, 'model'>);
     constructor(fields?: VertexAIClientOptions);
     invocationParams(options?: this['ParsedCallOptions'] | undefined): GoogleAIModelRequestParams;
     buildConnection(fields: VertexAIClientOptions | undefined, client: GoogleAbstractedClient): void;

package/dist/types/messages/cache.d.ts

@@ -36,5 +36,8 @@ export declare function stripBedrockCacheControl<T extends MessageWithContent>(m
  * @param messages - The array of message objects.
  * @returns - A new array of message objects with cache points added.
  */
-export declare function addBedrockCacheControl<T extends Partial<BaseMessage> & MessageWithContent>(messages: T[]): T[];
+export declare function addBedrockCacheControl<T extends MessageWithContent & {
+    getType?: () => string;
+    role?: string;
+}>(messages: T[]): T[];
 export {};

package/dist/types/messages/langchain.d.ts

@@ -0,0 +1,27 @@
+import type { MessageContent } from '@langchain/core/messages';
+import type * as t from '@/types';
+type LibreChatMessageContent = MessageContent | string | t.MessageContentComplex[] | t.ExtendedMessageContent[];
+type WithLangChainContent<T extends {
+    content: LibreChatMessageContent;
+}> = Omit<T, 'content'> & {
+    content: MessageContent;
+};
+/**
+ * Bridges LibreChat's extended content blocks to LangChain 1.x MessageContent.
+ *
+ * LangChain 1.x narrowed message constructor types around ContentBlock, while
+ * LibreChat still carries provider-specific blocks through the same content
+ * field. This helper keeps the runtime shape unchanged during the dependency
+ * upgrade; tracking issue: https://github.com/danny-avila/agents/issues/130.
+ */
+export declare function toLangChainContent(content: LibreChatMessageContent): MessageContent;
+/**
+ * Applies the same LangChain 1.x content bridge to message constructor fields.
+ *
+ * Keep this cast-only helper local to constructor boundaries so follow-up work
+ * can replace it with aligned content types or explicit conversion logic.
+ */
+export declare function toLangChainMessageFields<T extends {
+    content: LibreChatMessageContent;
+}>(message: T): WithLangChainContent<T>;
+export {};

package/dist/types/tools/CodeExecutor.d.ts

@@ -3,6 +3,12 @@ import type * as t from '@/types';
 import { Constants } from '@/common';
 export declare const imageExtRegex: RegExp;
 export declare const getCodeBaseURL: () => string;
+/**
+ * Renders one section of the post-execution file listing. Used by the
+ * code/bash tool formatters to keep generated outputs and inherited
+ * inputs visually separated. See BashExecutor for full docs.
+ */
+export declare function renderFileSection(header: string, files: t.FileRefs, defaultMessage: string): string;
 export declare const CodeExecutionToolSchema: {
     readonly type: "object";
     readonly properties: {

package/dist/types/types/graph.d.ts

@@ -1,4 +1,4 @@
-import type { START, StateType, UpdateType, StateGraph, StateGraphArgs, StateDefinition, CompiledStateGraph, BinaryOperatorAggregate } from '@langchain/langgraph';
+import type { START, StateGraph, StateGraphArgs } from '@langchain/langgraph';
 import type { BindToolsInput } from '@langchain/core/language_models/chat_models';
 import type { BaseMessage, AIMessageChunk, SystemMessage } from '@langchain/core/messages';
 import type { RunnableConfig, Runnable } from '@langchain/core/runnables';
@@ -51,51 +51,36 @@ export interface EventHandler {
 }
 export type GraphStateChannels<T extends BaseGraphState> = StateGraphArgs<T>['channels'];
 export type Workflow<T extends BaseGraphState = BaseGraphState, U extends Partial<T> = Partial<T>, N extends string = string> = StateGraph<T, U, N>;
-export type CompiledWorkflow<T extends BaseGraphState = BaseGraphState, U extends Partial<T> = Partial<T>, N extends string = string> = CompiledStateGraph<T, U, N>;
-export type CompiledStateWorkflow = CompiledStateGraph<StateType<{
-    messages: BinaryOperatorAggregate<BaseMessage[], BaseMessage[]>;
-}>, UpdateType<{
-    messages: BinaryOperatorAggregate<BaseMessage[], BaseMessage[]>;
-}>, string, {
-    messages: BinaryOperatorAggregate<BaseMessage[], BaseMessage[]>;
-}, {
-    messages: BinaryOperatorAggregate<BaseMessage[], BaseMessage[]>;
-}, StateDefinition>;
-export type CompiledMultiAgentWorkflow = CompiledStateGraph<StateType<{
-    messages: BinaryOperatorAggregate<BaseMessage[], BaseMessage[]>;
-    agentMessages: BinaryOperatorAggregate<BaseMessage[], BaseMessage[]>;
-}>, UpdateType<{
-    messages: BinaryOperatorAggregate<BaseMessage[], BaseMessage[]>;
-    agentMessages: BinaryOperatorAggregate<BaseMessage[], BaseMessage[]>;
-}>, string, {
-    messages: BinaryOperatorAggregate<BaseMessage[], BaseMessage[]>;
-    agentMessages: BinaryOperatorAggregate<BaseMessage[], BaseMessage[]>;
-}, {
-    messages: BinaryOperatorAggregate<BaseMessage[], BaseMessage[]>;
-    agentMessages: BinaryOperatorAggregate<BaseMessage[], BaseMessage[]>;
-}, StateDefinition>;
-export type CompiledAgentWorfklow = CompiledStateGraph<AgentSubgraphState, Partial<AgentSubgraphState>, '__start__' | `agent=${string}` | `tools=${string}` | `summarize=${string}`, {
-    messages: BinaryOperatorAggregate<BaseMessage[], BaseMessage[]>;
-    summarizationRequest: BinaryOperatorAggregate<SummarizationNodeInput | undefined, SummarizationNodeInput | undefined>;
-}, {
-    messages: BinaryOperatorAggregate<BaseMessage[], BaseMessage[]>;
-    summarizationRequest: BinaryOperatorAggregate<SummarizationNodeInput | undefined, SummarizationNodeInput | undefined>;
-}, StateDefinition, {
-    [x: `agent=${string}`]: Partial<BaseGraphState>;
-    [x: `tools=${string}`]: any;
-    [x: `summarize=${string}`]: any;
-}>;
+type LangChainEventStreamCallbackHandlerInput = NonNullable<Parameters<Runnable['streamEvents']>[2]>;
+export type EventStreamCallbackHandlerInput = LangChainEventStreamCallbackHandlerInput & {
+    autoClose?: boolean;
+    raiseError?: boolean;
+    ignoreCustomEvent?: boolean;
+};
+export type WorkflowValuesStreamConfig = RunnableConfig & {
+    streamMode: 'values';
+};
+/**
+ * LangGraph stream output is mode-dependent (`values`, `updates`, SSE, etc.).
+ * Keep the base Runnable stream output as unknown and narrow at callsites that
+ * choose a concrete streamMode.
+ */
+export type CompiledWorkflow<TInput extends BaseGraphState = BaseGraphState, TOutput extends BaseGraphState = TInput> = Omit<Runnable<TInput, unknown>, 'invoke'> & {
+    invoke(input: TInput, config?: RunnableConfig): Promise<TOutput>;
+};
+export type CompiledStateWorkflow = CompiledWorkflow;
+export type CompiledMultiAgentWorkflow = CompiledWorkflow<MultiAgentGraphState>;
+export type CompiledAgentWorfklow = CompiledWorkflow<AgentSubgraphState, AgentSubgraphState>;
 export type SystemRunnable = Runnable<BaseMessage[], (BaseMessage | SystemMessage)[], RunnableConfig<Record<string, unknown>>> | undefined;
 /**
  * Optional compile options passed to workflow.compile().
  * These are intentionally untyped to avoid coupling to library internals.
  */
 export type CompileOptions = {
-    checkpointer?: any;
+    checkpointer?: unknown;
     interruptBefore?: string[];
     interruptAfter?: string[];
 };
-export type EventStreamCallbackHandlerInput = Parameters<CompiledWorkflow['streamEvents']>[2] extends Omit<infer T, 'autoClose'> ? T : never;
 export type StreamChunk = (ChatGenerationChunk & {
     message: AIMessageChunk;
 }) | AIMessageChunk;
@@ -311,10 +296,12 @@ export interface AgentInputs {
     toolMap?: ToolMap;
     tools?: GraphTools;
     provider: Providers;
+    /** Stable/cacheable system instructions. */
     instructions?: string;
     streamBuffer?: number;
     maxContextTokens?: number;
     clientOptions?: ClientOptions;
+    /** Dynamic system tail appended after stable instructions without provider cache markers. */
     additional_instructions?: string;
     reasoningKey?: 'reasoning_content' | 'reasoning';
     /** Format content blocks as strings (for legacy compatibility i.e. Ollama/Azure Serverless) */
@@ -340,7 +327,7 @@ export interface AgentInputs {
     summarizationEnabled?: boolean;
     summarizationConfig?: SummarizationConfig;
     /** Cross-run summary from a previous run, forwarded from formatAgentMessages.
-     *  Injected into the system message via AgentContext.buildInstructionsString(). */
+     *  Injected into the dynamic system tail via AgentContext. */
     initialSummary?: {
         text: string;
         tokenCount: number;
@@ -370,3 +357,4 @@ export interface ContextPruningConfig {
         placeholder?: string;
     };
 }
+export {};

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

@@ -3,7 +3,7 @@ import type { BindToolsInput, BaseChatModelParams } from '@langchain/core/langua
 import type { OpenAIChatInput, ChatOpenAIFields, AzureOpenAIInput, ClientOptions as OAIClientOptions } from '@langchain/openai';
 import type { GoogleGenerativeAIChatInput } from '@langchain/google-genai';
 import type { ChatVertexAIInput } from '@langchain/google-vertexai';
-import type { ChatDeepSeekCallOptions } from '@langchain/deepseek';
+import type { ChatDeepSeekInput } from '@langchain/deepseek';
 import type { ChatOpenRouterCallOptions } from '@/llm/openrouter';
 import type { ChatBedrockConverseInput } from '@langchain/aws';
 import type { ChatMistralAIInput } from '@langchain/mistralai';
@@ -49,7 +49,7 @@ export type AnthropicReasoning = {
 export type GoogleThinkingConfig = {
     thinkingBudget?: number;
     includeThoughts?: boolean;
-    thinkingLevel?: string;
+    thinkingLevel?: 'THINKING_LEVEL_UNSPECIFIED' | 'LOW' | 'MEDIUM' | 'HIGH';
 };
 export type OpenAIClientOptions = ChatOpenAIFields;
 export type AnthropicClientOptions = Omit<AnthropicInput, 'thinking'> & {
@@ -71,7 +71,7 @@ export type GoogleClientOptions = GoogleGenerativeAIChatInput & {
     customHeaders?: RequestOptions['customHeaders'];
     thinkingConfig?: GoogleThinkingConfig;
 };
-export type DeepSeekClientOptions = ChatDeepSeekCallOptions;
+export type DeepSeekClientOptions = Partial<ChatDeepSeekInput>;
 export type XAIClientOptions = ChatXAIInput;
 export type ClientOptions = OpenAIClientOptions | AzureClientOptions | AnthropicClientOptions | MistralAIClientOptions | VertexAIClientOptions | BedrockConverseClientOptions | GoogleClientOptions | DeepSeekClientOptions | XAIClientOptions;
 export type SharedLLMConfig = {

package/dist/types/types/run.d.ts

@@ -63,7 +63,9 @@ export interface AgentStateChannels {
     messages: BaseMessage[];
     next: string;
     [key: string]: unknown;
+    /** Stable/cacheable system instructions. */
     instructions?: string;
+    /** Dynamic system tail appended after stable instructions. */
     additional_instructions?: string;
 }
 export interface Member {

package/dist/types/types/stream.d.ts

@@ -138,7 +138,7 @@ export interface ExtendedMessageContent {
     type?: string;
     text?: string;
     input?: string;
-    index?: number;
+    index?: string | number;
     id?: string;
     name?: string;
 }

package/dist/types/types/tools.d.ts

@@ -96,6 +96,15 @@ export type FileRef = {
     path?: string;
     /** Session ID this file belongs to (for multi-session file tracking) */
     session_id?: string;
+    /**
+     * `true` when the codeapi sandbox echoed this entry as an unchanged
+     * passthrough of an input the caller already owns (skill files,
+     * downloaded inputs whose hash matched the baseline, inherited
+     * `.dirkeep` markers). The tool-result formatter renders these as
+     * "Available files" rather than "Generated files" so the LLM doesn't
+     * conflate infrastructure inputs with newly-produced outputs.
+     */
+    inherited?: true;
 };
 export type FileRefs = FileRef[];
 export type ExecuteResult = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@librechat/agents",
-  "version": "3.1.73",
+  "version": "3.1.75-dev.0",
   "main": "./dist/cjs/main.cjs",
   "module": "./dist/esm/main.mjs",
   "types": "./dist/types/index.d.ts",
@@ -27,7 +27,7 @@
   ],
   "packageManager": "npm@10.5.2",
   "engines": {
-    "node": ">=14.0.0"
+    "node": ">=20.0.0"
   },
   "files": [
     "dist",
@@ -111,7 +111,7 @@
     "format": "prettier --write ."
   },
   "overrides": {
-    "@langchain/openai": "0.5.18",
+    "@langchain/openai": "1.4.5",
     "@anthropic-ai/sdk": "$@anthropic-ai/sdk",
     "@browserbasehq/stagehand": {
       "openai": "$openai"
@@ -121,19 +121,19 @@
     "minimatch": "3.1.4"
   },
   "dependencies": {
-    "@anthropic-ai/sdk": "^0.73.0",
+    "@anthropic-ai/sdk": "^0.92.0",
     "@aws-sdk/client-bedrock-runtime": "^3.1013.0",
-    "@langchain/anthropic": "^0.3.26",
-    "@langchain/aws": "^0.1.15",
-    "@langchain/core": "^0.3.80",
-    "@langchain/deepseek": "^0.0.2",
-    "@langchain/google-genai": "^0.2.18",
-    "@langchain/google-vertexai": "^0.2.18",
-    "@langchain/langgraph": "^0.4.9",
-    "@langchain/mistralai": "^0.2.1",
-    "@langchain/openai": "0.5.18",
-    "@langchain/textsplitters": "^0.1.0",
-    "@langchain/xai": "^0.0.3",
+    "@langchain/anthropic": "^1.3.28",
+    "@langchain/aws": "^1.3.5",
+    "@langchain/core": "^1.1.42",
+    "@langchain/deepseek": "^1.0.25",
+    "@langchain/google-genai": "^2.1.29",
+    "@langchain/google-vertexai": "^2.1.29",
+    "@langchain/langgraph": "^1.2.9",
+    "@langchain/mistralai": "^1.0.8",
+    "@langchain/openai": "1.4.5",
+    "@langchain/textsplitters": "^1.0.1",
+    "@langchain/xai": "^1.3.17",
     "@langfuse/langchain": "^4.3.0",
     "@langfuse/otel": "^4.3.0",
     "@langfuse/tracing": "^4.3.0",
@@ -147,7 +147,8 @@
     "mathjs": "^15.2.0",
     "nanoid": "^3.3.7",
     "okapibm25": "^1.4.1",
-    "openai": "5.8.2"
+    "openai": "^6.35.0",
+    "uuid": "^11.1.1"
   },
   "imports": {
     "@/*": "./src/*",