@librechat/agents 3.2.2 → 3.2.31

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/custom-chat-models.smoke.test.ts

@@ -135,6 +135,22 @@ type OpenRouterReasoningStreamChoice = Omit<
 > & {
   delta: OpenRouterReasoningStreamDelta;
 };
+type OpenAICompatibleReasoningStreamDelta =
+  OpenAIClient.Chat.Completions.ChatCompletionChunk.Choice.Delta & {
+    reasoning?: string;
+    reasoning_details?: Array<{
+      type: 'reasoning.text';
+      text?: string;
+      format?: string;
+      index?: number;
+    }>;
+  };
+type OpenAICompatibleReasoningStreamChoice = Omit<
+  OpenAIClient.Chat.Completions.ChatCompletionChunk.Choice,
+  'delta'
+> & {
+  delta: OpenAICompatibleReasoningStreamDelta;
+};
 type PromptTokensDetailsWithCacheWrite = NonNullable<
   OpenAIClient.Completions.CompletionUsage['prompt_tokens_details']
 > & {
@@ -472,6 +488,104 @@ describe('custom chat model class smoke tests', () => {
     );
   });
 
+  it('preserves OpenAI-compatible reasoning deltas during OpenAI streaming', async () => {
+    const model = new ChatOpenAI({
+      model: 'openai/gpt-oss-120b',
+      apiKey: 'test-key',
+      streaming: true,
+    });
+    const completions = (model as unknown as StreamingCompletionBackedModel)
+      .completions;
+    const createChunk = (
+      choice: OpenAICompatibleReasoningStreamChoice
+    ): OpenAIClient.Chat.Completions.ChatCompletionChunk => ({
+      id: 'chatcmpl-openai-compatible-reasoning',
+      object: 'chat.completion.chunk',
+      created: 0,
+      model: 'openai/gpt-oss-120b',
+      choices: [choice],
+    });
+
+    async function* streamChunks(): AsyncGenerator<OpenAIClient.Chat.Completions.ChatCompletionChunk> {
+      yield createChunk({
+        index: 0,
+        delta: {
+          role: 'assistant',
+          content: '',
+        },
+        finish_reason: null,
+      });
+      yield createChunk({
+        index: 0,
+        delta: {
+          reasoning: 'Think ',
+          reasoning_details: [
+            {
+              type: 'reasoning.text',
+              text: 'Think ',
+              format: 'text',
+              index: 0,
+            },
+          ],
+        },
+        finish_reason: null,
+      });
+      yield createChunk({
+        index: 0,
+        delta: {
+          reasoning: 'hard',
+          reasoning_details: [
+            {
+              type: 'reasoning.text',
+              text: 'hard',
+              format: 'text',
+              index: 0,
+            },
+          ],
+        },
+        finish_reason: null,
+      });
+      yield createChunk({
+        index: 0,
+        delta: { content: 'answer' },
+        finish_reason: 'stop',
+      });
+    }
+
+    completions.completionWithRetry = async (): Promise<
+      AsyncIterable<OpenAIClient.Chat.Completions.ChatCompletionChunk>
+    > => streamChunks();
+
+    const chunks: AIMessageChunk[] = [];
+    const stream = await model.stream([new HumanMessage('think')]);
+    for await (const chunk of stream) {
+      chunks.push(chunk);
+    }
+
+    expect(
+      chunks
+        .map((chunk) => chunk.additional_kwargs.reasoning_content)
+        .filter((reasoningContent) => reasoningContent != null)
+    ).toEqual(['Think ', 'hard']);
+    expect(chunks[1].additional_kwargs.reasoning_details).toEqual([
+      {
+        type: 'reasoning.text',
+        text: 'Think ',
+        format: 'text',
+        index: 0,
+      },
+    ]);
+    expect(chunks[2].additional_kwargs.reasoning_details).toEqual([
+      {
+        type: 'reasoning.text',
+        text: 'hard',
+        format: 'text',
+        index: 0,
+      },
+    ]);
+    expect(chunks.at(-1)?.content).toBe('answer');
+  });
+
   it('skips custom OpenAI-compatible SSE events during Azure streaming', async () => {
     await expectCustomSSEEventsSkipped(
       new AzureChatOpenAI({

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

package/src/llm/google/llm.spec.ts

@@ -29,7 +29,12 @@ import type {
 } from '@google/generative-ai';
 import type { ContentBlock } from '@langchain/core/messages';
 import { CustomChatGoogleGenerativeAI as ChatGoogleGenerativeAI } from './index';
-import { _FUNCTION_CALL_THOUGHT_SIGNATURES_MAP_KEY } from './utils/common';
+import {
+  convertMessageContentToParts,
+  convertResponseContentToChatGenerationChunk,
+  mapGenerateContentResultToChatResult,
+  _FUNCTION_CALL_THOUGHT_SIGNATURES_MAP_KEY,
+} from './utils/common';
 
 // Save the original value of the 'LANGCHAIN_CALLBACKS_BACKGROUND' environment variable
 const originalBackground = process.env.LANGCHAIN_CALLBACKS_BACKGROUND;
@@ -731,6 +736,173 @@ test('Invoke with JSON mode', async () => {
   );
 });
 
+test('Includes server-side tool invocation config when enabled', () => {
+  const model = new ChatGoogleGenerativeAI({
+    apiKey: 'test-key',
+    model: 'gemini-3.5-flash',
+    includeServerSideToolInvocations: true,
+  });
+  const getWeather = {
+    name: 'get_weather',
+    description: 'Get the weather',
+  };
+
+  const request = model.invocationParams({
+    tools: [{ googleSearch: {} }, { functionDeclarations: [getWeather] }],
+  });
+
+  expect(request.toolConfig).toEqual(
+    expect.objectContaining({
+      includeServerSideToolInvocations: true,
+    })
+  );
+});
+
+test('Normalizes auto tool choice when server-side tool invocation config is enabled', () => {
+  const model = new ChatGoogleGenerativeAI({
+    apiKey: 'test-key',
+    model: 'gemini-3.5-flash',
+    includeServerSideToolInvocations: true,
+  });
+  const getWeather = {
+    name: 'get_weather',
+    description: 'Get the weather',
+  };
+
+  const request = model.invocationParams({
+    tools: [{ googleSearch: {} }, { functionDeclarations: [getWeather] }],
+    tool_choice: 'auto',
+  });
+  const toolConfig = request.toolConfig as
+    | {
+        includeServerSideToolInvocations?: boolean;
+        functionCallingConfig?: { mode?: string };
+      }
+    | undefined;
+
+  expect(toolConfig).toEqual(
+    expect.objectContaining({
+      includeServerSideToolInvocations: true,
+    })
+  );
+  expect(toolConfig?.functionCallingConfig?.mode).toBe('VALIDATED');
+});
+
+test('Preserves Gemini server-side tool context parts in history', () => {
+  const toolCallPart = {
+    type: 'toolCall',
+    agentId: 'agent_1',
+    groupId: 1,
+    thoughtSignature: 'signature-1',
+    toolCall: {
+      id: 'server-search-1',
+      name: 'google_search',
+      args: {},
+    },
+  } as const;
+  const toolResponsePart = {
+    type: 'toolResponse',
+    agentId: 'agent_1',
+    groupId: 1,
+    toolResponse: {
+      id: 'server-search-1',
+      name: 'google_search',
+      response: { results: [] },
+    },
+  } as const;
+  const message = new AIMessage({
+    content: [toolCallPart, toolResponsePart],
+  });
+
+  expect(convertMessageContentToParts(message, true, [])).toEqual([
+    {
+      toolCall: toolCallPart.toolCall,
+      thoughtSignature: 'signature-1',
+    },
+    {
+      toolResponse: toolResponsePart.toolResponse,
+    },
+  ]);
+});
+
+test('Preserves Gemini function-call ids in history', () => {
+  const aiMessage = new AIMessage({
+    content: '',
+    tool_calls: [
+      {
+        id: 'call_weather_1',
+        name: 'get_weather',
+        args: { city: 'NYC' },
+      },
+    ],
+  });
+  const toolMessage = new ToolMessage({
+    content: 'sunny',
+    name: 'get_weather',
+    tool_call_id: 'call_weather_1',
+  });
+
+  expect(convertMessageContentToParts(aiMessage, true, [])).toEqual([
+    {
+      functionCall: {
+        id: 'call_weather_1',
+        name: 'get_weather',
+        args: { city: 'NYC' },
+      },
+    },
+  ]);
+  expect(convertMessageContentToParts(toolMessage, true, [aiMessage])).toEqual([
+    {
+      functionResponse: {
+        id: 'call_weather_1',
+        name: 'get_weather',
+        response: { result: 'sunny' },
+      },
+    },
+  ]);
+});
+
+test('Preserves Gemini server-side tool context parts from responses', () => {
+  const toolCallPart = {
+    toolCall: {
+      id: 'server-search-1',
+      name: 'google_search',
+      args: {},
+    },
+  };
+  const toolResponsePart = {
+    toolResponse: {
+      id: 'server-search-1',
+      name: 'google_search',
+      response: { results: [] },
+    },
+  };
+  const response = {
+    candidates: [
+      {
+        content: {
+          role: 'model',
+          parts: [toolCallPart, toolResponsePart],
+        },
+      },
+    ],
+  } as unknown as Parameters<
+    typeof convertResponseContentToChatGenerationChunk
+  >[0];
+
+  const chunk = convertResponseContentToChatGenerationChunk(response, {
+    index: 0,
+  });
+  const result = mapGenerateContentResultToChatResult(response);
+
+  const expectedContent = [
+    { ...toolCallPart, type: 'toolCall' },
+    { ...toolResponsePart, type: 'toolResponse' },
+  ];
+  expect(chunk?.message.content).toEqual(expectedContent);
+  expect(result.generations[0].message.content).toEqual(expectedContent);
+});
+
 test('Supports tool_choice', async () => {
   const model = createGoogleModel({
     model: 'gemini-2.0-flash',

package/src/llm/google/types.ts

@@ -1,9 +1,9 @@
+import { BindToolsInput } from '@langchain/core/language_models/chat_models';
 import {
   CodeExecutionTool,
   FunctionDeclarationsTool as GoogleGenerativeAIFunctionDeclarationsTool,
   GoogleSearchRetrievalTool,
 } from '@google/generative-ai';
-import { BindToolsInput } from '@langchain/core/language_models/chat_models';
 
 /** New GoogleSearch tool for Gemini 2.0+ models */
 export interface GoogleSearchTool {