@librechat/agents 3.1.51 → 3.1.53

package/src/llm/google/index.ts

@@ -10,9 +10,8 @@ import type {
 } from '@google/generative-ai';
 import type { CallbackManagerForLLMRun } from '@langchain/core/callbacks/manager';
 import type { BaseMessage, UsageMetadata } from '@langchain/core/messages';
-import type { GeminiGenerationConfig } from '@langchain/google-common';
 import type { GeminiApiUsageMetadata, InputTokenDetails } from './types';
-import type { GoogleClientOptions } from '@/types';
+import type { GoogleClientOptions, GoogleThinkingConfig } from '@/types';
 import {
   convertResponseContentToChatGenerationChunk,
   convertBaseMessagesToContent,
@@ -20,7 +19,7 @@ import {
 } from './utils/common';
 
 export class CustomChatGoogleGenerativeAI extends ChatGoogleGenerativeAI {
-  thinkingConfig?: GeminiGenerationConfig['thinkingConfig'];
+  thinkingConfig?: GoogleThinkingConfig;
 
   /**
    * Override to add gemini-3 model support for multimodal and function calling thought signatures

package/src/llm/openrouter/index.ts

@@ -29,24 +29,135 @@ type OpenAIRoleEnum =
   | 'function'
   | 'tool';
 
-export interface ChatOpenRouterCallOptions extends ChatOpenAICallOptions {
+export type OpenRouterReasoningEffort =
+  | 'xhigh'
+  | 'high'
+  | 'medium'
+  | 'low'
+  | 'minimal'
+  | 'none';
+
+export interface OpenRouterReasoning {
+  effort?: OpenRouterReasoningEffort;
+  max_tokens?: number;
+  exclude?: boolean;
+  enabled?: boolean;
+}
+
+export interface ChatOpenRouterCallOptions
+  extends Omit<ChatOpenAICallOptions, 'reasoning'> {
+  /** @deprecated Use `reasoning` object instead */
   include_reasoning?: boolean;
+  reasoning?: OpenRouterReasoning;
   modelKwargs?: OpenAIChatInput['modelKwargs'];
 }
+
+/** invocationParams return type extended with OpenRouter reasoning */
+export type OpenRouterInvocationParams = Omit<
+  OpenAIClient.Chat.ChatCompletionCreateParams,
+  'messages'
+> & {
+  reasoning?: OpenRouterReasoning;
+};
 export class ChatOpenRouter extends ChatOpenAI {
+  private openRouterReasoning?: OpenRouterReasoning;
+  /** @deprecated Use `reasoning` object instead */
+  private includeReasoning?: boolean;
+
   constructor(_fields: Partial<ChatOpenRouterCallOptions>) {
-    const { include_reasoning, modelKwargs = {}, ...fields } = _fields;
+    const {
+      include_reasoning,
+      reasoning: openRouterReasoning,
+      modelKwargs = {},
+      ...fields
+    } = _fields;
+
+    // Extract reasoning from modelKwargs if provided there (e.g., from LLMConfig)
+    const { reasoning: mkReasoning, ...restModelKwargs } = modelKwargs as {
+      reasoning?: OpenRouterReasoning;
+    } & Record<string, unknown>;
+
     super({
       ...fields,
-      modelKwargs: {
-        ...modelKwargs,
-        include_reasoning,
-      },
+      modelKwargs: restModelKwargs,
     });
+
+    // Merge reasoning config: modelKwargs.reasoning < constructor reasoning
+    if (mkReasoning != null || openRouterReasoning != null) {
+      this.openRouterReasoning = {
+        ...mkReasoning,
+        ...openRouterReasoning,
+      };
+    }
+
+    this.includeReasoning = include_reasoning;
   }
   static lc_name(): 'LibreChatOpenRouter' {
     return 'LibreChatOpenRouter';
   }
+
+  // @ts-expect-error - OpenRouter reasoning extends OpenAI Reasoning with additional
+  // effort levels ('xhigh' | 'none' | 'minimal') not in ReasoningEffort.
+  // The parent's generic conditional return type cannot be widened in an override.
+  override invocationParams(
+    options?: this['ParsedCallOptions'],
+    extra?: { streaming?: boolean }
+  ): OpenRouterInvocationParams {
+    type MutableParams = Omit<
+      OpenAIClient.Chat.ChatCompletionCreateParams,
+      'messages'
+    > & { reasoning_effort?: string; reasoning?: OpenRouterReasoning };
+
+    const params = super.invocationParams(options, extra) as MutableParams;
+
+    // Remove the OpenAI-native reasoning_effort that the parent sets;
+    // OpenRouter uses a `reasoning` object instead
+    delete params.reasoning_effort;
+
+    // Build the OpenRouter reasoning config
+    const reasoning = this.buildOpenRouterReasoning(options);
+    if (reasoning != null) {
+      params.reasoning = reasoning;
+    } else {
+      delete params.reasoning;
+    }
+
+    return params;
+  }
+
+  private buildOpenRouterReasoning(
+    options?: this['ParsedCallOptions']
+  ): OpenRouterReasoning | undefined {
+    let reasoning: OpenRouterReasoning | undefined;
+
+    // 1. Instance-level reasoning config (from constructor)
+    if (this.openRouterReasoning != null) {
+      reasoning = { ...this.openRouterReasoning };
+    }
+
+    // 2. LangChain-style reasoning params (from parent's `this.reasoning`)
+    const lcReasoning = this.getReasoningParams(options);
+    if (lcReasoning?.effort != null) {
+      reasoning = {
+        ...reasoning,
+        effort: lcReasoning.effort as OpenRouterReasoningEffort,
+      };
+    }
+
+    // 3. Call-level reasoning override
+    const callReasoning = (options as ChatOpenRouterCallOptions | undefined)
+      ?.reasoning;
+    if (callReasoning != null) {
+      reasoning = { ...reasoning, ...callReasoning };
+    }
+
+    // 4. Legacy include_reasoning backward compatibility
+    if (reasoning == null && this.includeReasoning === true) {
+      reasoning = { enabled: true };
+    }
+
+    return reasoning;
+  }
   protected override _convertOpenAIDeltaToBaseMessageChunk(
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     delta: Record<string, any>,

package/src/llm/openrouter/reasoning.test.ts

@@ -0,0 +1,207 @@
+import { ChatOpenRouter } from './index';
+import type { OpenRouterReasoning, ChatOpenRouterCallOptions } from './index';
+import type { OpenAIChatInput } from '@langchain/openai';
+
+type CreateRouterOptions = Partial<
+  ChatOpenRouterCallOptions & Pick<OpenAIChatInput, 'model' | 'apiKey'>
+>;
+
+function createRouter(overrides: CreateRouterOptions = {}): ChatOpenRouter {
+  return new ChatOpenRouter({
+    model: 'openrouter/test-model',
+    apiKey: 'test-key',
+    ...overrides,
+  });
+}
+
+describe('ChatOpenRouter reasoning handling', () => {
+  // ---------------------------------------------------------------
+  // 1. Constructor reasoning config
+  // ---------------------------------------------------------------
+  describe('constructor reasoning config', () => {
+    it('stores reasoning when passed directly', () => {
+      const router = createRouter({ reasoning: { effort: 'high' } });
+      const params = router.invocationParams();
+      expect(params.reasoning).toEqual({ effort: 'high' });
+    });
+  });
+
+  // ---------------------------------------------------------------
+  // 2. modelKwargs reasoning extraction
+  // ---------------------------------------------------------------
+  describe('modelKwargs reasoning extraction', () => {
+    it('extracts reasoning from modelKwargs and places it into params.reasoning', () => {
+      const router = createRouter({
+        modelKwargs: { reasoning: { effort: 'medium' } },
+      });
+      const params = router.invocationParams();
+      expect(params.reasoning).toEqual({ effort: 'medium' });
+    });
+
+    it('does not leak reasoning into modelKwargs that reach the parent', () => {
+      const router = createRouter({
+        modelKwargs: {
+          reasoning: { effort: 'medium' },
+        },
+      });
+      const params = router.invocationParams();
+      // reasoning should be the structured OpenRouter object, not buried in modelKwargs
+      expect(params.reasoning).toEqual({ effort: 'medium' });
+    });
+  });
+
+  // ---------------------------------------------------------------
+  // 3. Reasoning merge precedence
+  // ---------------------------------------------------------------
+  describe('reasoning merge precedence', () => {
+    it('constructor reasoning overrides modelKwargs.reasoning', () => {
+      const router = createRouter({
+        reasoning: { effort: 'high' },
+        modelKwargs: { reasoning: { effort: 'low' } },
+      });
+      const params = router.invocationParams();
+      expect(params.reasoning).toEqual({ effort: 'high' });
+    });
+
+    it('merges non-overlapping keys from modelKwargs.reasoning and constructor reasoning', () => {
+      const router = createRouter({
+        reasoning: { effort: 'high' },
+        modelKwargs: { reasoning: { max_tokens: 5000 } },
+      });
+      const params = router.invocationParams();
+      expect(params.reasoning).toEqual({ effort: 'high', max_tokens: 5000 });
+    });
+  });
+
+  // ---------------------------------------------------------------
+  // 4. invocationParams output
+  // ---------------------------------------------------------------
+  describe('invocationParams output', () => {
+    it('includes reasoning object in params', () => {
+      const router = createRouter({ reasoning: { effort: 'high' } });
+      const params = router.invocationParams();
+      expect(params.reasoning).toBeDefined();
+      expect(params.reasoning).toEqual({ effort: 'high' });
+    });
+
+    it('does NOT include reasoning_effort in params', () => {
+      const router = createRouter({ reasoning: { effort: 'high' } });
+      const params = router.invocationParams();
+      expect(params.reasoning_effort).toBeUndefined();
+    });
+
+    it('does not include reasoning when none is configured', () => {
+      const router = createRouter();
+      const params = router.invocationParams();
+      expect(params.reasoning).toBeUndefined();
+      expect(params.reasoning_effort).toBeUndefined();
+    });
+  });
+
+  // ---------------------------------------------------------------
+  // 5. Legacy include_reasoning
+  // ---------------------------------------------------------------
+  describe('legacy include_reasoning', () => {
+    it('produces { enabled: true } when only include_reasoning is true', () => {
+      const router = createRouter({ include_reasoning: true });
+      const params = router.invocationParams();
+      expect(params.reasoning).toEqual({ enabled: true });
+    });
+
+    it('does not produce reasoning when include_reasoning is false', () => {
+      const router = createRouter({ include_reasoning: false });
+      const params = router.invocationParams();
+      expect(params.reasoning).toBeUndefined();
+    });
+  });
+
+  // ---------------------------------------------------------------
+  // 6. Legacy include_reasoning ignored when reasoning is provided
+  // ---------------------------------------------------------------
+  describe('legacy include_reasoning ignored when reasoning provided', () => {
+    it('reasoning wins over include_reasoning', () => {
+      const router = createRouter({
+        reasoning: { effort: 'medium' },
+        include_reasoning: true,
+      });
+      const params = router.invocationParams();
+      // Should use the structured reasoning, NOT fall back to { enabled: true }
+      expect(params.reasoning).toEqual({ effort: 'medium' });
+    });
+
+    it('reasoning from modelKwargs also wins over include_reasoning', () => {
+      const router = createRouter({
+        modelKwargs: { reasoning: { effort: 'low' } },
+        include_reasoning: true,
+      });
+      const params = router.invocationParams();
+      expect(params.reasoning).toEqual({ effort: 'low' });
+    });
+  });
+
+  // ---------------------------------------------------------------
+  // 7. Various effort levels (OpenRouter-specific)
+  // ---------------------------------------------------------------
+  describe('various effort levels', () => {
+    const efforts: Array<{
+      effort: OpenRouterReasoning['effort'];
+    }> = [
+      { effort: 'xhigh' },
+      { effort: 'none' },
+      { effort: 'minimal' },
+      { effort: 'high' },
+      { effort: 'medium' },
+      { effort: 'low' },
+    ];
+
+    it.each(efforts)('supports effort level "$effort"', ({ effort }) => {
+      const router = createRouter({ reasoning: { effort } });
+      const params = router.invocationParams();
+      expect(params.reasoning).toEqual({ effort });
+      expect(params.reasoning_effort).toBeUndefined();
+    });
+  });
+
+  // ---------------------------------------------------------------
+  // 8. max_tokens reasoning
+  // ---------------------------------------------------------------
+  describe('max_tokens reasoning', () => {
+    it('passes max_tokens in reasoning object', () => {
+      const router = createRouter({
+        reasoning: { max_tokens: 8000 },
+      });
+      const params = router.invocationParams();
+      expect(params.reasoning).toEqual({ max_tokens: 8000 });
+    });
+
+    it('combines max_tokens with effort', () => {
+      const router = createRouter({
+        reasoning: { effort: 'high', max_tokens: 8000 },
+      });
+      const params = router.invocationParams();
+      expect(params.reasoning).toEqual({ effort: 'high', max_tokens: 8000 });
+      expect(params.reasoning_effort).toBeUndefined();
+    });
+  });
+
+  // ---------------------------------------------------------------
+  // 9. exclude reasoning
+  // ---------------------------------------------------------------
+  describe('exclude reasoning', () => {
+    it('passes exclude flag in reasoning object', () => {
+      const router = createRouter({
+        reasoning: { effort: 'high', exclude: true },
+      });
+      const params = router.invocationParams();
+      expect(params.reasoning).toEqual({ effort: 'high', exclude: true });
+    });
+
+    it('supports exclude without effort', () => {
+      const router = createRouter({
+        reasoning: { exclude: true },
+      });
+      const params = router.invocationParams();
+      expect(params.reasoning).toEqual({ exclude: true });
+    });
+  });
+});

package/src/llm/vertexai/index.ts

@@ -6,9 +6,11 @@ import type {
   GoogleAbstractedClient,
 } from '@langchain/google-common';
 import type { BaseMessage } from '@langchain/core/messages';
-import type { VertexAIClientOptions } from '@/types';
+import type { GoogleThinkingConfig, VertexAIClientOptions } from '@/types';
 
 class CustomChatConnection extends ChatConnection<VertexAIClientOptions> {
+  thinkingConfig?: GoogleThinkingConfig;
+
   async formatData(
     input: BaseMessage[],
     parameters: GoogleAIModelRequestParams
@@ -26,6 +28,15 @@ class CustomChatConnection extends ChatConnection<VertexAIClientOptions> {
       }
       delete formattedData.generationConfig.thinkingConfig.thinkingBudget;
     }
+    if (this.thinkingConfig?.thinkingLevel) {
+      formattedData.generationConfig ??= {};
+      (
+        formattedData.generationConfig as Record<string, unknown>
+      ).thinkingConfig = {
+        ...formattedData.generationConfig.thinkingConfig,
+        thinkingLevel: this.thinkingConfig.thinkingLevel,
+      };
+    }
     return formattedData;
   }
 }
@@ -315,6 +326,7 @@ class CustomChatConnection extends ChatConnection<VertexAIClientOptions> {
 export class ChatVertexAI extends ChatGoogle {
   lc_namespace = ['langchain', 'chat_models', 'vertexai'];
   dynamicThinkingBudget = false;
+  thinkingConfig?: GoogleThinkingConfig;
 
   static lc_name(): 'LibreChatVertexAI' {
     return 'LibreChatVertexAI';
@@ -327,6 +339,7 @@ export class ChatVertexAI extends ChatGoogle {
       platformType: 'gcp',
     });
     this.dynamicThinkingBudget = dynamicThinkingBudget;
+    this.thinkingConfig = fields?.thinkingConfig;
   }
   invocationParams(
     options?: this['ParsedCallOptions'] | undefined
@@ -342,18 +355,22 @@ export class ChatVertexAI extends ChatGoogle {
     fields: VertexAIClientOptions,
     client: GoogleAbstractedClient
   ): void {
-    this.connection = new CustomChatConnection(
+    const connection = new CustomChatConnection(
       { ...fields, ...this },
       this.caller,
       client,
       false
     );
+    connection.thinkingConfig = this.thinkingConfig;
+    this.connection = connection;
 
-    this.streamedConnection = new CustomChatConnection(
+    const streamedConnection = new CustomChatConnection(
       { ...fields, ...this },
       this.caller,
       client,
       true
     );
+    streamedConnection.thinkingConfig = this.thinkingConfig;
+    this.streamedConnection = streamedConnection;
   }
 }

package/src/run.ts

@@ -45,6 +45,7 @@ export class Run<_T extends t.BaseGraphState> {
   graphRunnable?: t.CompiledStateWorkflow;
   Graph: StandardGraph | MultiAgentGraph | undefined;
   returnContent: boolean = false;
+  private skipCleanup: boolean = false;
 
   private constructor(config: Partial<t.RunConfig>) {
     const runId = config.runId ?? '';
@@ -89,6 +90,7 @@ export class Run<_T extends t.BaseGraphState> {
     }
 
     this.returnContent = config.returnContent ?? false;
+    this.skipCleanup = config.skipCleanup ?? false;
   }
 
   private createLegacyGraph(
@@ -303,9 +305,45 @@ export class Run<_T extends t.BaseGraphState> {
       }
     }
 
-    if (this.returnContent) {
-      return this.Graph.getContentParts();
+    /**
+     * Break the reference chain that keeps heavy data alive via
+     * LangGraph's internal `__pregel_scratchpad.currentTaskInput` →
+     * `@langchain/core` `RunTree.extra[lc:child_config]` →
+     * Node.js `AsyncLocalStorage` context captured by timers/promises.
+     *
+     * Without this, base64-encoded images/PDFs in message content remain
+     * reachable from lingering `Timeout` handles until GC runs.
+     */
+    if (!this.skipCleanup) {
+      if (
+        (config.configurable as Record<string, unknown> | undefined) != null
+      ) {
+        for (const key of Object.getOwnPropertySymbols(config.configurable)) {
+          const val = config.configurable[key as unknown as string] as
+            | Record<string, unknown>
+            | undefined;
+          if (
+            val != null &&
+            typeof val === 'object' &&
+            'currentTaskInput' in val
+          ) {
+            (val as Record<string, unknown>).currentTaskInput = undefined;
+          }
+          delete config.configurable[key as unknown as string];
+        }
+        config.configurable = undefined;
+      }
+      config.callbacks = undefined;
+    }
+
+    const result = this.returnContent
+      ? this.Graph.getContentParts()
+      : undefined;
+
+    if (!this.skipCleanup) {
+      this.Graph.clearHeavyState();
     }
+    return result;
   }
 
   private createSystemCallback<K extends keyof t.ClientCallbacks>(

package/src/scripts/ant_web_search.ts

@@ -98,6 +98,7 @@ async function testStandardStreaming(): Promise<void> {
       // additional_instructions: `Always address the user by their name. The user's name is ${userName} and they are located in ${location}.`,
     },
     returnContent: true,
+    skipCleanup: true,
     customHandlers,
   });
 

package/src/scripts/ant_web_search_edge_case.ts

@@ -100,6 +100,7 @@ async function testStandardStreaming(): Promise<void> {
       // additional_instructions: `Always address the user by their name. The user's name is ${userName} and they are located in ${location}.`,
     },
     returnContent: true,
+    skipCleanup: true,
     customHandlers,
   });
 

package/src/scripts/ant_web_search_error_edge_case.ts

@@ -97,6 +97,7 @@ async function testStandardStreaming(): Promise<void> {
       instructions: 'You are a helpful AI research assistant.',
     },
     returnContent: true,
+    skipCleanup: true,
     customHandlers,
   });
 

package/src/scripts/bedrock-content-aggregation-test.ts

@@ -136,6 +136,7 @@ async function testBedrockContentAggregation(): Promise<void> {
       llmConfig,
     },
     returnContent: true,
+    skipCleanup: true,
     customHandlers: customHandlers as t.RunConfig['customHandlers'],
   });
 

package/src/scripts/bedrock-parallel-tools-test.ts

@@ -123,6 +123,7 @@ async function testParallelToolCalls(): Promise<void> {
       llmConfig,
     },
     returnContent: true,
+    skipCleanup: true,
     customHandlers: customHandlers as t.RunConfig['customHandlers'],
   });
 

package/src/scripts/caching.ts

@@ -74,6 +74,7 @@ ${CACHED_TEXT}`;
       llmConfig,
     },
     returnContent: true,
+    skipCleanup: true,
     customHandlers,
   });
 

package/src/scripts/code_exec.ts

@@ -93,6 +93,7 @@ async function testCodeExecution(): Promise<void> {
       additional_instructions: `The user's name is ${userName} and they are located in ${location}.`,
     },
     returnContent: true,
+    skipCleanup: true,
     customHandlers,
   });
 

package/src/scripts/code_exec_files.ts

@@ -127,6 +127,7 @@ async function testCodeExecution(): Promise<void> {
       additional_instructions: `The user's name is ${userName} and they are located in ${location}. The current date is ${currentDate}.`,
     },
     returnContent: true,
+    skipCleanup: true,
     customHandlers,
   });
 

package/src/scripts/code_exec_multi_session.ts

@@ -73,6 +73,7 @@ When reading files, print their contents.
 Be concise in responses.`,
     },
     returnContent: true,
+    skipCleanup: true,
     customHandlers,
   });
 

package/src/scripts/code_exec_ptc.ts

@@ -217,6 +217,7 @@ async function testProgrammaticToolCalling(): Promise<void> {
       ],
     },
     returnContent: true,
+    skipCleanup: true,
     customHandlers,
   });
 

package/src/scripts/code_exec_session.ts

@@ -141,6 +141,7 @@ When writing Python code:
       additional_instructions: `User: ${userName}, Location: ${location}, Date: ${currentDate}.`,
     },
     returnContent: true,
+    skipCleanup: true,
     customHandlers,
   });
 

package/src/scripts/code_exec_simple.ts

@@ -101,6 +101,7 @@ async function testCodeExecution(): Promise<void> {
       maxContextTokens: 8000,
     },
     returnContent: true,
+    skipCleanup: true,
     customHandlers,
     indexTokenCountMap,
     tokenCounter,

package/src/scripts/content.ts

@@ -88,6 +88,7 @@ async function testStandardStreaming(): Promise<void> {
       additional_instructions: `The user's name is ${userName} and they are located in ${location}.`,
     },
     returnContent: true,
+    skipCleanup: true,
     customHandlers,
   });
 

package/src/scripts/image.ts

@@ -94,6 +94,7 @@ async function testCodeExecution(): Promise<void> {
       additional_instructions: `The user's name is ${userName} and they are located in ${location}.`,
     },
     returnContent: true,
+    skipCleanup: true,
     customHandlers,
   });
 

package/src/scripts/memory.ts

@@ -17,19 +17,27 @@ const memoryKv: Record<string, string> = {};
 const setMemory = tool(
   async ({ key, value }) => {
     if (!/^[a-z_]+$/.test(key)) {
-      throw new Error('Key must only contain lowercase letters and underscores');
+      throw new Error(
+        'Key must only contain lowercase letters and underscores'
+      );
     }
-    
+
     memoryKv[key] = value;
-    
+
     return { ok: true };
   },
   {
     name: 'set_memory',
     description: 'Saves important data about the user into memory.',
     schema: z.object({
-      key: z.string().describe('The key of the memory value. Always use lowercase and underscores, no other characters.'),
-      value: z.string().describe('Value can be anything represented as a string')
+      key: z
+        .string()
+        .describe(
+          'The key of the memory value. Always use lowercase and underscores, no other characters.'
+        ),
+      value: z
+        .string()
+        .describe('Value can be anything represented as a string'),
     }),
   }
 );
@@ -48,10 +56,12 @@ async function testStandardStreaming(): Promise<void> {
         streaming: false,
       },
       tools: [setMemory],
-      instructions: 'You can use the `set_memory` tool to save important data about the user into memory. If there is nothing to note about the user specifically, respond with `nothing`.',
+      instructions:
+        'You can use the `set_memory` tool to save important data about the user into memory. If there is nothing to note about the user specifically, respond with `nothing`.',
       toolEnd: true,
     },
     returnContent: true,
+    skipCleanup: true,
   });
 
   const config = {