@librechat/agents 3.1.32 → 3.1.34

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

@@ -4,9 +4,12 @@ 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';
+import type { AnthropicMessageCreateParams, AnthropicStreamingMessageCreateParams, AnthropicOutputConfig } from '@/llm/anthropic/types';
 export type CustomAnthropicInput = AnthropicInput & {
     _lc_stream_delay?: number;
+    outputConfig?: AnthropicOutputConfig;
+    inferenceGeo?: string;
+    contextManagement?: any;
 } & BaseChatModelParams;
 /**
  * A type representing additional parameters that can be passed to the
@@ -20,6 +23,9 @@ export declare class CustomAnthropic extends ChatAnthropicMessages {
     private tools_in_params?;
     private emitted_usage?;
     top_k: number | undefined;
+    outputConfig?: AnthropicOutputConfig;
+    inferenceGeo?: string;
+    contextManagement?: any;
     constructor(fields?: CustomAnthropicInput);
     static lc_name(): 'LibreChatAnthropic';
     /**

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

@@ -32,6 +32,9 @@ export type AnthropicServerToolUseBlockParam = Anthropic.Messages.ServerToolUseB
 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 type AnthropicCompactionBlockParam = Anthropic.Beta.BetaCompactionBlockParam;
+export type AnthropicOutputConfig = Anthropic.Messages.OutputConfig;
+export type ChatAnthropicOutputFormat = Anthropic.Messages.JSONOutputFormat;
+export type AnthropicContentBlock = AnthropicTextBlockParam | AnthropicImageBlockParam | AnthropicToolUseBlockParam | AnthropicToolResultBlockParam | AnthropicDocumentBlockParam | AnthropicThinkingBlockParam | AnthropicRedactedThinkingBlockParam | AnthropicServerToolUseBlockParam | AnthropicWebSearchToolResultBlockParam | AnthropicWebSearchResultBlockParam | AnthropicCompactionBlockParam;
+export type ChatAnthropicContentBlock = AnthropicTextBlockParam | AnthropicImageBlockParam | AnthropicToolUseBlockParam | AnthropicToolResultBlockParam | AnthropicDocumentBlockParam | AnthropicThinkingBlockParam | AnthropicRedactedThinkingBlockParam | AnthropicServerToolUseBlockParam | AnthropicWebSearchToolResultBlockParam | AnthropicWebSearchResultBlockParam | AnthropicSearchResultBlockParam | AnthropicCompactionBlockParam;
 export declare function isAnthropicImageBlockParam(block: unknown): block is AnthropicImageBlockParam;

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

@@ -5,7 +5,7 @@ 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: {
+export declare function _makeMessageChunkFromAnthropicEvent(data: Anthropic.Beta.Messages.BetaRawMessageStreamEvent, fields: {
     streamUsage: boolean;
     coerceContentToString: boolean;
 }): {

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

@@ -20,11 +20,11 @@ export declare class ToolNode<T = any> extends RunnableCallable<T, T> {
     private sessions?;
     /** When true, dispatches ON_TOOL_EXECUTE events instead of invoking tools directly */
     private eventDrivenMode;
-    /** Tool definitions for event-driven mode */
-    private toolDefinitions?;
     /** Agent ID for event-driven mode */
     private agentId?;
-    constructor({ tools, toolMap, name, tags, errorHandler, toolCallStepIds, handleToolErrors, loadRuntimeTools, toolRegistry, sessions, eventDrivenMode, toolDefinitions, agentId, }: t.ToolNodeConstructorParams);
+    /** Tool names that bypass event dispatch and execute directly (e.g., graph-managed handoff tools) */
+    private directToolNames?;
+    constructor({ tools, toolMap, name, tags, errorHandler, toolCallStepIds, handleToolErrors, loadRuntimeTools, toolRegistry, sessions, eventDrivenMode, agentId, directToolNames, }: t.ToolNodeConstructorParams);
     /**
      * Returns cached programmatic tools, computing once on first access.
      * Single iteration builds both toolMap and toolDefs simultaneously.
@@ -39,6 +39,11 @@ export declare class ToolNode<T = any> extends RunnableCallable<T, T> {
      * Runs a single tool call with error handling
      */
     protected runTool(call: ToolCall, config: RunnableConfig): Promise<BaseMessage | Command>;
+    /**
+     * Dispatches tool calls to the host via ON_TOOL_EXECUTE event and returns raw ToolMessages.
+     * Core logic for event-driven execution, separated from output shaping.
+     */
+    private dispatchToolEvents;
     /**
      * Execute all tool calls via ON_TOOL_EXECUTE event dispatch.
      * Used in event-driven mode where the host handles actual tool execution.

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

@@ -37,6 +37,8 @@ export type ToolNodeOptions = {
     toolDefinitions?: Map<string, LCTool>;
     /** Agent ID for event-driven mode (used to identify which agent's context to use) */
     agentId?: string;
+    /** Tool names that must be executed directly (via runTool) even in event-driven mode (e.g., graph-managed handoff tools) */
+    directToolNames?: Set<string>;
 };
 export type ToolNodeConstructorParams = ToolRefs & ToolNodeOptions;
 export type ToolEndEvent = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@librechat/agents",
-  "version": "3.1.32",
+  "version": "3.1.34",
   "main": "./dist/cjs/main.cjs",
   "module": "./dist/esm/main.mjs",
   "types": "./dist/types/index.d.ts",
@@ -83,6 +83,7 @@
     "test-parallel-agent-labeling": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/test-parallel-agent-labeling.ts",
     "test-thinking-handoff": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/test-thinking-handoff.ts",
     "test-thinking-handoff-bedrock": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/test-thinking-handoff-bedrock.ts",
+    "test-thinking-to-thinking-handoff-bedrock": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/test-thinking-to-thinking-handoff-bedrock.ts",
     "multi-agent-hybrid-flow": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/multi-agent-hybrid-flow.ts",
     "test-handoff-input": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/test-handoff-input.ts",
     "test-custom-prompt-key": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/test-custom-prompt-key.ts",
@@ -107,12 +108,14 @@
   },
   "overrides": {
     "@langchain/openai": "0.5.18",
+    "@anthropic-ai/sdk": "$@anthropic-ai/sdk",
     "@browserbasehq/stagehand": {
       "openai": "$openai"
     },
     "fast-xml-parser": "5.3.4"
   },
   "dependencies": {
+    "@anthropic-ai/sdk": "^0.73.0",
     "@aws-sdk/client-bedrock-runtime": "^3.980.0",
     "@langchain/anthropic": "^0.3.26",
     "@langchain/aws": "^0.1.15",

package/src/agents/AgentContext.ts

@@ -116,6 +116,8 @@ export class AgentContext {
   lastStreamCall?: number;
   /** Tools available to this agent */
   tools?: t.GraphTools;
+  /** Graph-managed tools (e.g., handoff tools created by MultiAgentGraph) that bypass event-driven dispatch */
+  graphTools?: t.GraphTools;
   /** Tool map for this agent */
   toolMap?: t.ToolMap;
   /**
@@ -595,17 +597,22 @@ export class AgentContext {
     }
 
     /** Traditional mode: filter actual tool instances */
-    if (!this.tools || !this.toolRegistry) {
-      return this.tools;
+    const filtered =
+      !this.tools || !this.toolRegistry
+        ? this.tools
+        : this.filterToolsForBinding(this.tools);
+
+    if (this.graphTools && this.graphTools.length > 0) {
+      return [...(filtered ?? []), ...this.graphTools];
     }
 
-    return this.filterToolsForBinding(this.tools);
+    return filtered;
   }
 
   /** Creates schema-only tools from toolDefinitions for event-driven mode */
   private getEventDrivenToolsForBinding(): t.GraphTools {
     if (!this.toolDefinitions) {
-      return [];
+      return this.graphTools ?? [];
     }
 
     const defsToInclude = this.toolDefinitions.filter((def) => {
@@ -622,7 +629,13 @@ export class AgentContext {
       return true;
     });
 
-    return createSchemaOnlyTools(defsToInclude) as t.GraphTools;
+    const schemaTools = createSchemaOnlyTools(defsToInclude) as t.GraphTools;
+
+    if (this.graphTools && this.graphTools.length > 0) {
+      return [...schemaTools, ...this.graphTools];
+    }
+
+    return schemaTools;
   }
 
   /** Filters tool instances for binding based on registry config */

package/src/graphs/Graph.ts

@@ -461,24 +461,60 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
     if (eventDrivenMode) {
       const schemaTools = createSchemaOnlyTools(toolDefinitions);
       const toolDefMap = new Map(toolDefinitions.map((def) => [def.name, def]));
+      const graphTools = agentContext?.graphTools as
+        | t.GenericTool[]
+        | undefined;
+
+      const directToolNames = new Set<string>();
+      const allTools = [...schemaTools] as t.GenericTool[];
+      const allToolMap: t.ToolMap = new Map(
+        schemaTools.map((tool) => [tool.name, tool])
+      );
+
+      if (graphTools && graphTools.length > 0) {
+        for (const tool of graphTools) {
+          if ('name' in tool) {
+            allTools.push(tool);
+            allToolMap.set(tool.name, tool);
+            directToolNames.add(tool.name);
+          }
+        }
+      }
 
       return new CustomToolNode<t.BaseGraphState>({
-        tools: schemaTools as t.GenericTool[],
-        toolMap: new Map(schemaTools.map((tool) => [tool.name, tool])),
-        toolCallStepIds: this.toolCallStepIds,
-        errorHandler: (data, metadata) =>
-          StandardGraph.handleToolCallErrorStatic(this, data, metadata),
-        toolRegistry: agentContext?.toolRegistry,
-        sessions: this.sessions,
+        tools: allTools,
+        toolMap: allToolMap,
         eventDrivenMode: true,
+        sessions: this.sessions,
         toolDefinitions: toolDefMap,
         agentId: agentContext?.agentId,
+        toolCallStepIds: this.toolCallStepIds,
+        toolRegistry: agentContext?.toolRegistry,
+        directToolNames: directToolNames.size > 0 ? directToolNames : undefined,
+        errorHandler: (data, metadata) =>
+          StandardGraph.handleToolCallErrorStatic(this, data, metadata),
       });
     }
 
+    const graphTools = agentContext?.graphTools as t.GenericTool[] | undefined;
+    const baseTools = (currentTools as t.GenericTool[] | undefined) ?? [];
+    const allTraditionalTools =
+      graphTools && graphTools.length > 0
+        ? [...baseTools, ...graphTools]
+        : baseTools;
+    const traditionalToolMap =
+      graphTools && graphTools.length > 0
+        ? new Map([
+          ...(currentToolMap ?? new Map()),
+          ...graphTools
+            .filter((t): t is t.GenericTool & { name: string } => 'name' in t)
+            .map((t) => [t.name, t] as [string, t.GenericTool]),
+        ])
+        : currentToolMap;
+
     return new CustomToolNode<t.BaseGraphState>({
-      tools: (currentTools as t.GenericTool[] | undefined) ?? [],
-      toolMap: currentToolMap,
+      tools: allTraditionalTools,
+      toolMap: traditionalToolMap,
       toolCallStepIds: this.toolCallStepIds,
       errorHandler: (data, metadata) =>
         StandardGraph.handleToolCallErrorStatic(this, data, metadata),

package/src/graphs/MultiAgentGraph.ts

@@ -255,11 +255,10 @@ export class MultiAgentGraph extends StandardGraph {
         );
       }
 
-      // Add handoff tools to the agent's existing tools
-      if (!agentContext.tools) {
-        agentContext.tools = [];
+      if (!agentContext.graphTools) {
+        agentContext.graphTools = [];
       }
-      agentContext.tools.push(...handoffTools);
+      agentContext.graphTools.push(...handoffTools);
     }
   }
 

package/src/llm/anthropic/index.ts

@@ -16,6 +16,7 @@ import type {
   AnthropicStreamUsage,
   AnthropicMessageStartEvent,
   AnthropicMessageDeltaEvent,
+  AnthropicOutputConfig,
 } from '@/llm/anthropic/types';
 import { _makeMessageChunkFromAnthropicEvent } from './utils/message_outputs';
 import { _convertMessagesToAnthropicPayload } from './utils/message_inputs';
@@ -39,6 +40,7 @@ function _documentsInParams(
         typeof block === 'object' &&
         block != null &&
         block.type === 'document' &&
+        block.citations != null &&
         typeof block.citations === 'object' &&
         block.citations.enabled
       ) {
@@ -52,7 +54,20 @@ function _documentsInParams(
 function _thinkingInParams(
   params: AnthropicMessageCreateParams | AnthropicStreamingMessageCreateParams
 ): boolean {
-  return !!(params.thinking && params.thinking.type === 'enabled');
+  return !!(
+    params.thinking &&
+    (params.thinking.type === 'enabled' || params.thinking.type === 'adaptive')
+  );
+}
+
+function _compactionInParams(
+  params: AnthropicMessageCreateParams | AnthropicStreamingMessageCreateParams
+): boolean {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const cm = (params as any).context_management;
+  return !!cm?.edits?.some(
+    (e: { type: string }) => e.type === 'compact_20260112'
+  );
 }
 
 function extractToken(
@@ -120,6 +135,10 @@ function cloneChunk(
 
 export type CustomAnthropicInput = AnthropicInput & {
   _lc_stream_delay?: number;
+  outputConfig?: AnthropicOutputConfig;
+  inferenceGeo?: string;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  contextManagement?: any;
 } & BaseChatModelParams;
 
 /**
@@ -136,11 +155,18 @@ export class CustomAnthropic extends ChatAnthropicMessages {
   private tools_in_params?: boolean;
   private emitted_usage?: boolean;
   top_k: number | undefined;
+  outputConfig?: AnthropicOutputConfig;
+  inferenceGeo?: string;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  contextManagement?: any;
   constructor(fields?: CustomAnthropicInput) {
     super(fields);
     this.resetTokenEvents();
     this.setDirectFields(fields);
     this._lc_stream_delay = fields?._lc_stream_delay ?? 25;
+    this.outputConfig = fields?.outputConfig;
+    this.inferenceGeo = fields?.inferenceGeo;
+    this.contextManagement = fields?.contextManagement;
   }
 
   static lc_name(): 'LibreChatAnthropic' {
@@ -163,7 +189,36 @@ export class CustomAnthropic extends ChatAnthropicMessages {
       | Anthropic.Messages.ToolChoiceTool
       | undefined = handleToolChoice(options?.tool_choice);
 
-    if (this.thinking.type === 'enabled') {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const callOptions = options as Record<string, any> | undefined;
+    const mergedOutputConfig: AnthropicOutputConfig | undefined = (():
+      | AnthropicOutputConfig
+      | undefined => {
+      const base = {
+        ...this.outputConfig,
+        ...callOptions?.outputConfig,
+      };
+      if (callOptions?.outputFormat && !base.format) {
+        base.format = callOptions.outputFormat;
+      }
+      return Object.keys(base).length > 0 ? base : undefined;
+    })();
+
+    const inferenceGeo = callOptions?.inferenceGeo ?? this.inferenceGeo;
+
+    const contextManagement = this.contextManagement;
+
+    const sharedParams = {
+      tools: this.formatStructuredToolToAnthropic(options?.tools),
+      tool_choice,
+      thinking: this.thinking,
+      ...(mergedOutputConfig ? { output_config: mergedOutputConfig } : {}),
+      ...(inferenceGeo ? { inference_geo: inferenceGeo } : {}),
+      ...(contextManagement ? { context_management: contextManagement } : {}),
+      ...this.invocationKwargs,
+    };
+
+    if (this.thinking.type === 'enabled' || this.thinking.type === 'adaptive') {
       if (this.top_k !== -1 && (this.top_k as number | undefined) != null) {
         throw new Error('topK is not supported when thinking is enabled');
       }
@@ -184,10 +239,7 @@ export class CustomAnthropic extends ChatAnthropicMessages {
         stop_sequences: options?.stop ?? this.stopSequences,
         stream: this.streaming,
         max_tokens: this.maxTokens,
-        tools: this.formatStructuredToolToAnthropic(options?.tools),
-        tool_choice,
-        thinking: this.thinking,
-        ...this.invocationKwargs,
+        ...sharedParams,
       };
     }
     return {
@@ -198,10 +250,7 @@ export class CustomAnthropic extends ChatAnthropicMessages {
       stop_sequences: options?.stop ?? this.stopSequences,
       stream: this.streaming,
       max_tokens: this.maxTokens,
-      tools: this.formatStructuredToolToAnthropic(options?.tools),
-      tool_choice,
-      thinking: this.thinking,
-      ...this.invocationKwargs,
+      ...sharedParams,
     };
   }
 
@@ -309,7 +358,8 @@ export class CustomAnthropic extends ChatAnthropicMessages {
     const coerceContentToString =
       !_toolsInParams(payload) &&
       !_documentsInParams(payload) &&
-      !_thinkingInParams(payload);
+      !_thinkingInParams(payload) &&
+      !_compactionInParams(payload);
 
     const stream = await this.createStreamWithRetry(payload, {
       headers: options.headers,
@@ -334,10 +384,13 @@ export class CustomAnthropic extends ChatAnthropicMessages {
         usageMetadata = this.getStreamUsage();
       }
 
-      const result = _makeMessageChunkFromAnthropicEvent(data, {
-        streamUsage: shouldStreamUsage,
-        coerceContentToString,
-      });
+      const result = _makeMessageChunkFromAnthropicEvent(
+        data as Anthropic.Beta.Messages.BetaRawMessageStreamEvent,
+        {
+          streamUsage: shouldStreamUsage,
+          coerceContentToString,
+        }
+      );
       if (!result) continue;
 
       const { chunk } = result;