@librechat/agents 3.2.21 → 3.2.32

package/src/llm/anthropic/utils/message_outputs.ts

@@ -1,13 +1,11 @@
 /** This util file contains functions for converting Anthropic messages to LangChain messages. */
 import { AIMessage, AIMessageChunk } from '@langchain/core/messages';
-
-import type Anthropic from '@anthropic-ai/sdk';
-import type { UsageMetadata } from '@langchain/core/messages';
 import type { ToolCallChunk } from '@langchain/core/messages/tool';
+import type { UsageMetadata } from '@langchain/core/messages';
 import type { ChatGeneration } from '@langchain/core/outputs';
-import type { MessageContentComplex } from '@/types';
+import type Anthropic from '@anthropic-ai/sdk';
 import type { AnthropicMessageResponse } from '../types';
-
+import type { MessageContentComplex } from '@/types';
 import { toLangChainContent } from '@/messages/langchain';
 import { extractToolCalls } from './output_parsers';
 
@@ -205,10 +203,14 @@ export function _makeMessageChunkFromAnthropicEvent(
   ) {
     const content = [
       {
+        // No `type`: core's streaming aggregation merges this partial input into the
+        // sibling tool_use/server_tool_use block at the same index, keeping its type.
+        // A typed delta block won't merge under core >= 1.1.46 ("keep different block
+        // types separate"), which would orphan the input and empty the tool_use input.
         index: data.index,
         input: data.delta.partial_json,
-        type: data.delta.type,
-      },
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      } as any,
     ];
     return {
       chunk: new AIMessageChunk({

package/src/llm/anthropic/utils/output_parsers.ts

@@ -1,16 +1,16 @@
 /* eslint-disable @typescript-eslint/explicit-function-return-type */
 /* eslint-disable @typescript-eslint/no-empty-object-type */
-import {
-  BaseLLMOutputParser,
-  OutputParserException,
-} 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 {
   interopSafeParseAsync,
   InteropZodType,
 } from '@langchain/core/utils/types';
+import {
+  BaseLLMOutputParser,
+  OutputParserException,
+} from '@langchain/core/output_parsers';
+import { JsonOutputKeyToolsParserParamsInterop } from '@langchain/core/output_parsers/openai_tools';
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 interface AnthropicToolsOutputParserParams<T extends Record<string, any>>

package/src/llm/anthropic/utils/streaming-tool-input.test.ts

@@ -0,0 +1,186 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { AIMessage, HumanMessage } from '@langchain/core/messages';
+import type { BaseMessage } from '@langchain/core/messages';
+import { _convertMessagesToAnthropicPayload } from './message_inputs';
+import { _makeMessageChunkFromAnthropicEvent } from './message_outputs';
+
+/**
+ * Regression for @langchain/core >= 1.1.46 streaming aggregation: a tool call's
+ * input_json_delta is kept as a separate content block and v1-cast to a `text`
+ * block carrying `input` but no `text`, leaving the sibling tool_use block with an
+ * empty inline input. The assembled arguments live on `message.tool_calls`.
+ * Re-serializing such a message previously threw "Unsupported message content format".
+ */
+describe('_convertMessagesToAnthropicPayload — aggregated streaming tool input', () => {
+  const buildHistory = (): BaseMessage[] => [
+    new HumanMessage('what is 12345 * 6789?'),
+    new AIMessage({
+      content: [
+        { type: 'text', text: 'Let me calculate that.' },
+        // tool_use block left with empty inline input by aggregation
+        {
+          type: 'tool_use',
+          id: 'toolu_calc',
+          name: 'calculator',
+          input: '',
+          index: 0,
+        } as any,
+        // orphaned input delta, v1-cast to `text` with `input` and no `text`
+        { type: 'text', index: 0, input: '{"input": "12345 * 6789"}' } as any,
+      ],
+      tool_calls: [
+        {
+          id: 'toolu_calc',
+          name: 'calculator',
+          args: { input: '12345 * 6789' },
+          type: 'tool_call',
+        },
+      ],
+    }),
+  ];
+
+  it('does not throw on the orphaned text-with-input block', () => {
+    expect(() => _convertMessagesToAnthropicPayload(buildHistory())).not.toThrow();
+  });
+
+  it('restores tool_use input from message.tool_calls and drops the orphan block', () => {
+    const payload = _convertMessagesToAnthropicPayload(buildHistory());
+    const assistant = payload.messages.find((m: any) => m.role === 'assistant');
+    expect(assistant).toBeDefined();
+    const blocks = assistant!.content as any[];
+
+    const toolUse = blocks.find((b) => b.type === 'tool_use');
+    expect(toolUse).toMatchObject({
+      type: 'tool_use',
+      id: 'toolu_calc',
+      name: 'calculator',
+      input: { input: '12345 * 6789' },
+    });
+
+    // No leftover delta: no text block carrying `input`, no input_json_delta.
+    expect(
+      blocks.find(
+        (b) => (b.type === 'text' && 'input' in b) || b.type === 'input_json_delta'
+      )
+    ).toBeUndefined();
+
+    // The real assistant text is preserved.
+    expect(
+      blocks.some((b) => b.type === 'text' && b.text === 'Let me calculate that.')
+    ).toBe(true);
+  });
+
+  it('does not overwrite a tool_use block that already has inline input', () => {
+    const history: BaseMessage[] = [
+      new HumanMessage('hi'),
+      new AIMessage({
+        content: [
+          {
+            type: 'tool_use',
+            id: 'toolu_x',
+            name: 'calculator',
+            input: { input: '2 + 2' },
+          } as any,
+        ],
+        tool_calls: [
+          {
+            id: 'toolu_x',
+            name: 'calculator',
+            args: { input: '999' },
+            type: 'tool_call',
+          },
+        ],
+      }),
+    ];
+    const payload = _convertMessagesToAnthropicPayload(history);
+    const assistant = payload.messages.find((m: any) => m.role === 'assistant');
+    const toolUse = (assistant!.content as any[]).find((b) => b.type === 'tool_use');
+    expect(toolUse.input).toEqual({ input: '2 + 2' });
+  });
+
+  // Adapted from @langchain/anthropic's
+  // "partial tool input is correctly merged before calling Anthropic API".
+  it('merges sibling input_json_delta blocks into tool_use input (persisted, no tool_calls)', () => {
+    const messages: BaseMessage[] = [
+      new HumanMessage('What\'s the weather in Seattle tomorrow?'),
+      new AIMessage({
+        content: [
+          { type: 'text', index: 1, text: 'I need to call the get_weather tool' },
+          { type: 'tool_use', index: 2, name: 'get_weather', id: 'tool_call_id', input: '' },
+          { type: 'input_json_delta', index: 2, input: '{"city": "' },
+          { type: 'input_json_delta', index: 2, input: 'Seattle", "da' },
+          { type: 'input_json_delta', index: 2, input: 'te": "to' },
+          { type: 'input_json_delta', index: 2, input: 'morrow"}' },
+        ] as any,
+      }),
+    ];
+
+    const payload = _convertMessagesToAnthropicPayload(messages);
+    const assistant = payload.messages.find((m: any) => m.role === 'assistant');
+    const blocks = assistant!.content as any[];
+    expect(blocks.filter((b) => b.type === 'input_json_delta')).toHaveLength(0);
+    const toolUse = blocks.find((b) => b.type === 'tool_use');
+    expect(toolUse).toMatchObject({
+      type: 'tool_use',
+      name: 'get_weather',
+      id: 'tool_call_id',
+      input: { city: 'Seattle', date: 'tomorrow' },
+    });
+  });
+});
+
+describe('_makeMessageChunkFromAnthropicEvent — streamed tool input merges into content', () => {
+  const fields = { streamUsage: true, coerceContentToString: false };
+
+  it('emits input deltas without a type so aggregation merges them into the tool_use block', () => {
+    const events: any[] = [
+      {
+        type: 'content_block_start',
+        index: 0,
+        content_block: { type: 'tool_use', id: 'toolu_1', name: 'calculator', input: {} },
+      },
+      {
+        type: 'content_block_delta',
+        index: 0,
+        delta: { type: 'input_json_delta', partial_json: '{"input"' },
+      },
+      {
+        type: 'content_block_delta',
+        index: 0,
+        delta: { type: 'input_json_delta', partial_json: ': "2 + 2"}' },
+      },
+    ];
+    const chunks = events
+      .map((e) => _makeMessageChunkFromAnthropicEvent(e, fields)?.chunk)
+      .filter((c): c is NonNullable<typeof c> => c != null);
+
+    // input-delta chunks must not carry a `type` (so core merges them by index
+    // into the sibling tool_use/server_tool_use block rather than orphaning them)
+    const deltaBlocks = chunks
+      .slice(1)
+      .flatMap((c) => (Array.isArray(c.content) ? (c.content as any[]) : []))
+      .filter((b) => 'input' in b);
+    expect(deltaBlocks.length).toBeGreaterThan(0);
+    deltaBlocks.forEach((b) => expect('type' in b).toBe(false));
+
+    // aggregate the chunks the way core does during streaming
+    const merged = chunks.reduce((acc, c) => acc.concat(c));
+    const blocks = merged.content as any[];
+
+    const toolUse = blocks.find((b) => b.type === 'tool_use');
+    expect(toolUse).toMatchObject({ type: 'tool_use', id: 'toolu_1', name: 'calculator' });
+    const parsed =
+      typeof toolUse.input === 'string' ? JSON.parse(toolUse.input) : toolUse.input;
+    expect(parsed).toEqual({ input: '2 + 2' });
+
+    // no orphaned delta block survives aggregation
+    expect(blocks.filter((b) => b.type !== 'tool_use' && 'input' in b)).toHaveLength(0);
+
+    // tool_calls remain correctly aggregated
+    expect(merged.tool_calls?.[0]).toMatchObject({
+      id: 'toolu_1',
+      name: 'calculator',
+      args: { input: '2 + 2' },
+    });
+  });
+});

package/src/llm/bedrock/index.ts

@@ -22,23 +22,23 @@
  */
 
 import { ChatBedrockConverse } from '@langchain/aws';
+import { AIMessageChunk } from '@langchain/core/messages';
+import { ChatGenerationChunk, ChatResult } from '@langchain/core/outputs';
 import {
   ConverseStreamCommand,
   type GuardrailConfiguration,
   type GuardrailStreamConfiguration,
 } from '@aws-sdk/client-bedrock-runtime';
-import { AIMessageChunk } from '@langchain/core/messages';
-import { ChatGenerationChunk, ChatResult } from '@langchain/core/outputs';
 import type { CallbackManagerForLLMRun } from '@langchain/core/callbacks/manager';
-import type { ChatBedrockConverseInput } from '@langchain/aws';
 import type { BaseMessage, ResponseMetadata } from '@langchain/core/messages';
-import { insertBedrockToolCachePoint } from './toolCache';
+import type { ChatBedrockConverseInput } from '@langchain/aws';
 import {
   convertToConverseMessages,
   handleConverseStreamContentBlockStart,
   handleConverseStreamContentBlockDelta,
   handleConverseStreamMetadata,
 } from './utils';
+import { insertBedrockToolCachePoint } from './toolCache';
 
 /**
  * Service tier type for Bedrock invocations.

package/src/llm/bedrock/toolCache.test.ts

@@ -15,17 +15,30 @@ type OpenAITool = {
   };
 };
 
-function createOpenAITool(name: string): OpenAITool {
+type CreateOpenAIToolOptions = {
+  description?: string;
+  omitDescription?: boolean;
+};
+
+function createOpenAITool(
+  name: string,
+  options: CreateOpenAIToolOptions = {}
+): OpenAITool {
+  const functionDefinition: OpenAITool['function'] = {
+    name,
+    parameters: {
+      type: 'object',
+      properties: {},
+    },
+  };
+  const description = options.description ?? `${name} description`;
+  if (options.omitDescription !== true) {
+    functionDefinition.description = description;
+  }
+
   return {
     type: 'function',
-    function: {
-      name,
-      description: `${name} description`,
-      parameters: {
-        type: 'object',
-        properties: {},
-      },
-    },
+    function: functionDefinition,
   };
 }
 
@@ -40,6 +53,11 @@ function toolNames(tools: Tool[] | undefined): string[] {
   return (tools ?? []).map(toolName);
 }
 
+function getToolSpec(entry: Tool): Tool.ToolSpecMember['toolSpec'] {
+  expect(entry).toHaveProperty('toolSpec');
+  return (entry as Tool.ToolSpecMember).toolSpec;
+}
+
 describe('partitionAndMarkBedrockToolCache', () => {
   it('inserts the Bedrock cache point after the last static tool', () => {
     const tools = [
@@ -128,4 +146,25 @@ describe('partitionAndMarkBedrockToolCache', () => {
 
     expect(toolNames(result?.tools)).toEqual(['direct_tool', 'cachePoint']);
   });
+
+  it('omits empty OpenAI tool descriptions when converting for Bedrock', () => {
+    const tools = [
+      createOpenAITool('missing_description', { omitDescription: true }),
+      createOpenAITool('empty_description', { description: '' }),
+      createOpenAITool('described_tool'),
+    ] as GraphTools;
+
+    const marked = partitionAndMarkBedrockToolCache(
+      tools,
+      () => false
+    ) as Tool[];
+    const result = insertBedrockToolCachePoint({ tools: marked }, false);
+    const convertedTools = result?.tools ?? [];
+
+    expect(getToolSpec(convertedTools[0])).not.toHaveProperty('description');
+    expect(getToolSpec(convertedTools[1])).not.toHaveProperty('description');
+    expect(getToolSpec(convertedTools[2]).description).toBe(
+      'described_tool description'
+    );
+  });
 });

package/src/llm/bedrock/toolCache.ts

@@ -1,5 +1,5 @@
-import type { Tool, ToolConfiguration } from '@aws-sdk/client-bedrock-runtime';
 import type { BindToolsInput } from '@langchain/core/language_models/chat_models';
+import type { Tool, ToolConfiguration } from '@aws-sdk/client-bedrock-runtime';
 import type { OpenAIClient } from '@langchain/openai';
 import type { DocumentType } from '@smithy/types';
 import type { GraphTools } from '@/types';
@@ -60,12 +60,17 @@ function getToolName(tool: unknown): string | undefined {
 }
 
 function openAIToBedrockTool(tool: OpenAIFunctionTool): Tool.ToolSpecMember {
+  const toolSpec: NonNullable<Tool.ToolSpecMember['toolSpec']> = {
+    name: tool.function.name,
+    inputSchema: { json: tool.function.parameters as DocumentType },
+  };
+
+  if (tool.function.description != null && tool.function.description !== '') {
+    toolSpec.description = tool.function.description;
+  }
+
   return {
-    toolSpec: {
-      name: tool.function.name,
-      description: tool.function.description,
-      inputSchema: { json: tool.function.parameters as DocumentType },
-    },
+    toolSpec,
   };
 }
 

package/src/llm/fake.ts

@@ -1,9 +1,9 @@
-import { ChatGenerationChunk } from '@langchain/core/outputs';
 import { AIMessageChunk } from '@langchain/core/messages';
-import type { CallbackManagerForLLMRun } from '@langchain/core/callbacks/manager';
-import type { BaseMessage } from '@langchain/core/messages';
+import { ChatGenerationChunk } from '@langchain/core/outputs';
 import { FakeListChatModel } from '@langchain/core/utils/testing';
 import { ToolCall, ToolCallChunk } from '@langchain/core/messages/tool';
+import type { CallbackManagerForLLMRun } from '@langchain/core/callbacks/manager';
+import type { BaseMessage } from '@langchain/core/messages';
 
 type SplitStrategy = {
   type: 'regex' | 'fixed';
@@ -20,7 +20,7 @@ export class FakeChatModel extends FakeListChatModel {
     sleep,
     emitCustomEvent,
     splitStrategy = { type: 'regex', value: /(?<=\s+)|(?=\s+)/ },
-    toolCalls = []
+    toolCalls = [],
   }: {
     responses: string[];
     sleep?: number;
@@ -45,25 +45,31 @@ export class FakeChatModel extends FakeListChatModel {
       return chunks;
     }
   }
-  _createResponseChunk(text: string, tool_call_chunks?: ToolCallChunk[]): ChatGenerationChunk {
+  _createResponseChunk(
+    text: string,
+    tool_call_chunks?: ToolCallChunk[]
+  ): ChatGenerationChunk {
     return new ChatGenerationChunk({
       text,
       generationInfo: {},
       message: new AIMessageChunk({
         content: text,
         tool_call_chunks,
-        additional_kwargs: tool_call_chunks ? {
-          tool_calls: tool_call_chunks.map((toolCall) => ({
-            index: toolCall.index ?? 0,
-            id: toolCall.id ?? '',
-            type: 'function',
-            function: {
-              name: toolCall.name ?? '',
-              arguments: toolCall.args ?? '',
-            },
-          })),
-        } : undefined,
-      })});
+        additional_kwargs: tool_call_chunks
+          ? {
+            tool_calls: tool_call_chunks.map((toolCall) => ({
+              index: toolCall.index ?? 0,
+              id: toolCall.id ?? '',
+              type: 'function',
+              function: {
+                name: toolCall.name ?? '',
+                arguments: toolCall.args ?? '',
+              },
+            })),
+          }
+          : undefined,
+      }),
+    });
   }
 
   async *_streamResponseChunks(
@@ -96,7 +102,7 @@ export class FakeChatModel extends FakeListChatModel {
     await this._sleepIfRequested();
     if (this.toolCalls.length > 0 && !this.addedToolCalls) {
       this.addedToolCalls = true;
-      const toolCallChunks = this.toolCalls.map((toolCall) => {;
+      const toolCallChunks = this.toolCalls.map((toolCall) => {
         return {
           name: toolCall.name,
           args: JSON.stringify(toolCall.args),
@@ -116,13 +122,12 @@ export function createFakeStreamingLLM({
   sleep,
   splitStrategy,
   toolCalls,
-} : {
-  responses: string[],
-  sleep?: number,
-  splitStrategy?: SplitStrategy,
-  toolCalls?: ToolCall[]
-}
-): FakeChatModel {
+}: {
+  responses: string[];
+  sleep?: number;
+  splitStrategy?: SplitStrategy;
+  toolCalls?: ToolCall[];
+}): FakeChatModel {
   return new FakeChatModel({
     sleep,
     responses,

package/src/llm/google/index.ts

@@ -3,10 +3,14 @@ import { AIMessageChunk } from '@langchain/core/messages';
 import { ChatGenerationChunk } from '@langchain/core/outputs';
 import { ChatGoogleGenerativeAI } from '@langchain/google-genai';
 import { getEnvironmentVariable } from '@langchain/core/utils/env';
-import { GoogleGenerativeAI as GenerativeAI } from '@google/generative-ai';
+import {
+  FunctionCallingMode,
+  GoogleGenerativeAI as GenerativeAI,
+} from '@google/generative-ai';
 import type {
   GenerateContentRequest,
   SafetySetting,
+  ToolConfig,
 } from '@google/generative-ai';
 import type { CallbackManagerForLLMRun } from '@langchain/core/callbacks/manager';
 import type { BaseMessage, UsageMetadata } from '@langchain/core/messages';
@@ -18,8 +22,21 @@ import {
   mapGenerateContentResultToChatResult,
 } from './utils/common';
 
+type GoogleToolConfigWithServerSideInvocations = ToolConfig & {
+  includeServerSideToolInvocations?: boolean;
+  functionCallingConfig?: Omit<
+    NonNullable<ToolConfig['functionCallingConfig']>,
+    'mode'
+  > & {
+    mode?:
+      | NonNullable<ToolConfig['functionCallingConfig']>['mode']
+      | 'VALIDATED';
+  };
+};
+
 export class CustomChatGoogleGenerativeAI extends ChatGoogleGenerativeAI {
   thinkingConfig?: GoogleThinkingConfig;
+  includeServerSideToolInvocations?: boolean;
 
   /**
    * Override to add gemini-3 model support for multimodal and function calling thought signatures
@@ -92,6 +109,9 @@ export class CustomChatGoogleGenerativeAI extends ChatGoogleGenerativeAI {
     }
 
     this.thinkingConfig = fields.thinkingConfig ?? this.thinkingConfig;
+    this.includeServerSideToolInvocations =
+      fields.includeServerSideToolInvocations ??
+      this.includeServerSideToolInvocations;
 
     this.streaming = fields.streaming ?? this.streaming;
     this.json = fields.json;
@@ -191,6 +211,28 @@ export class CustomChatGoogleGenerativeAI extends ChatGoogleGenerativeAI {
         thinkingConfig: this.thinkingConfig,
       };
     }
+    if (
+      this.includeServerSideToolInvocations === true &&
+      Array.isArray(params.tools) &&
+      params.tools.length > 0
+    ) {
+      const toolConfig = params.toolConfig as
+        | GoogleToolConfigWithServerSideInvocations
+        | undefined;
+      const functionCallingConfig = toolConfig?.functionCallingConfig;
+      params.toolConfig = {
+        ...toolConfig,
+        ...(functionCallingConfig?.mode === FunctionCallingMode.AUTO
+          ? {
+            functionCallingConfig: {
+              ...functionCallingConfig,
+              mode: 'VALIDATED',
+            },
+          }
+          : {}),
+        includeServerSideToolInvocations: true,
+      } as ToolConfig;
+    }
     return params;
   }