@librechat/agents 3.1.51 → 3.1.53

package/src/specs/openai.simple.test.ts

@@ -131,6 +131,7 @@ describe(`${capitalizeFirstLetter(provider)} Streaming Tests`, () => {
         additional_instructions: `The user's name is ${userName} and they are located in ${location}.`,
       },
       returnContent: true,
+      skipCleanup: true,
       customHandlers,
     });
 
@@ -202,6 +203,7 @@ describe(`${capitalizeFirstLetter(provider)} Streaming Tests`, () => {
         additional_instructions: `The user's name is ${userName} and they are located in ${location}.`,
       },
       returnContent: true,
+      skipCleanup: true,
       customHandlers,
     });
 
@@ -261,6 +263,7 @@ describe(`${capitalizeFirstLetter(provider)} Streaming Tests`, () => {
         additional_instructions: `The user's name is ${userName} and they are located in ${location}.`,
       },
       returnContent: true,
+      skipCleanup: true,
       customHandlers,
     });
 

package/src/specs/openrouter.simple.test.ts

@@ -7,6 +7,7 @@ import {
   UsageMetadata,
 } from '@langchain/core/messages';
 import type * as t from '@/types';
+import type { ChatOpenRouterCallOptions } from '@/llm/openrouter';
 import { ToolEndHandler, ModelEndHandler } from '@/events';
 import { ContentTypes, GraphEvents, Providers, TitleMethod } from '@/common';
 import { capitalizeFirstLetter } from './spec.utils';
@@ -33,6 +34,8 @@ describeIf(`${capitalizeFirstLetter(provider)} Streaming Tests`, () => {
     version: 'v2' as const,
   };
 
+  const baseLLMConfig = getLLMConfig(provider);
+
   beforeEach(async () => {
     conversationHistory = [];
     collectedUsage = [];
@@ -56,21 +59,87 @@ describeIf(`${capitalizeFirstLetter(provider)} Streaming Tests`, () => {
     [GraphEvents.CHAT_MODEL_END]: new ModelEndHandler(collectedUsage),
   });
 
+  /**
+   * Helper: run a reasoning test against a specific model with the given reasoning config.
+   * Asserts that reasoning tokens are reported and content is produced.
+   */
+  // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+  async function runReasoningTest(opts: {
+    model: string;
+    reasoning?: ChatOpenRouterCallOptions['reasoning'];
+    threadId: string;
+    runId: string;
+  }) {
+    const { reasoning: _baseReasoning, ...baseWithoutReasoning } =
+      baseLLMConfig as unknown as Record<string, unknown>;
+    const llmConfig = {
+      ...baseWithoutReasoning,
+      model: opts.model,
+      ...(opts.reasoning != null ? { reasoning: opts.reasoning } : {}),
+    } as t.LLMConfig;
+    const customHandlers = setupCustomHandlers();
+
+    run = await Run.create<t.IState>({
+      runId: opts.runId,
+      graphConfig: {
+        type: 'standard',
+        llmConfig,
+        instructions: 'You are a helpful AI assistant. Think step by step.',
+      },
+      returnContent: true,
+      skipCleanup: true,
+      customHandlers,
+    });
+
+    const userMessage = 'What is 15 * 37 + 128 / 4? Show your work.';
+    conversationHistory.push(new HumanMessage(userMessage));
+
+    const finalContentParts = await run.processStream(
+      { messages: conversationHistory },
+      { ...configV2, configurable: { thread_id: opts.threadId } }
+    );
+
+    expect(finalContentParts).toBeDefined();
+    expect(finalContentParts?.length).toBeGreaterThan(0);
+
+    // Verify usage metadata was collected
+    expect(collectedUsage.length).toBeGreaterThan(0);
+    const usage = collectedUsage[0];
+    expect(usage.input_tokens).toBeGreaterThan(0);
+    expect(usage.output_tokens).toBeGreaterThan(0);
+
+    // Verify reasoning tokens are reported in output_token_details
+    const reasoningTokens =
+      (usage.output_token_details as Record<string, number> | undefined)
+        ?.reasoning ?? 0;
+    expect(reasoningTokens).toBeGreaterThan(0);
+
+    // Verify the final message has content
+    const finalMessages = run.getRunMessages();
+    expect(finalMessages).toBeDefined();
+    expect(finalMessages?.length).toBeGreaterThan(0);
+    const assistantMsg = finalMessages?.[0];
+    expect(typeof assistantMsg?.content).toBe('string');
+    expect((assistantMsg?.content as string).length).toBeGreaterThan(0);
+
+    return { usage, reasoningTokens, finalMessages };
+  }
+
   test(`${capitalizeFirstLetter(provider)}: simple stream + title`, async () => {
     const { userName, location } = await getArgs();
-    const llmConfig = getLLMConfig(provider);
     const customHandlers = setupCustomHandlers();
 
     run = await Run.create<t.IState>({
       runId: 'or-run-1',
       graphConfig: {
         type: 'standard',
-        llmConfig,
+        llmConfig: baseLLMConfig,
         tools: [new Calculator()],
         instructions: 'You are a friendly AI assistant.',
         additional_instructions: `The user's name is ${userName} and they are located in ${location}.`,
       },
       returnContent: true,
+      skipCleanup: true,
       customHandlers,
     });
 
@@ -103,4 +172,97 @@ describeIf(`${capitalizeFirstLetter(provider)} Streaming Tests`, () => {
     });
     expect(titleRes.title).toBeDefined();
   });
+
+  test(`${capitalizeFirstLetter(provider)}: Anthropic does NOT reason by default (no config)`, async () => {
+    const { reasoning: _baseReasoning, ...baseWithoutReasoning } =
+      baseLLMConfig as unknown as Record<string, unknown>;
+    const llmConfig = {
+      ...baseWithoutReasoning,
+      model: 'anthropic/claude-sonnet-4',
+    } as t.LLMConfig;
+    const customHandlers = setupCustomHandlers();
+
+    run = await Run.create<t.IState>({
+      runId: 'or-anthropic-default-1',
+      graphConfig: {
+        type: 'standard',
+        llmConfig,
+        instructions: 'You are a helpful AI assistant.',
+      },
+      returnContent: true,
+      skipCleanup: true,
+      customHandlers,
+    });
+
+    conversationHistory.push(
+      new HumanMessage('What is 15 * 37 + 128 / 4? Show your work.')
+    );
+
+    await run.processStream(
+      { messages: conversationHistory },
+      { ...configV2, configurable: { thread_id: 'or-anthropic-default-1' } }
+    );
+
+    expect(collectedUsage.length).toBeGreaterThan(0);
+    const usage = collectedUsage[0];
+    // Anthropic requires explicit reasoning config — no reasoning tokens by default
+    const reasoningTokens =
+      (usage.output_token_details as Record<string, number> | undefined)
+        ?.reasoning ?? 0;
+    expect(reasoningTokens).toBe(0);
+  });
+
+  test(`${capitalizeFirstLetter(provider)}: Gemini 3 reasons by default (no config)`, async () => {
+    await runReasoningTest({
+      model: 'google/gemini-3-pro-preview',
+      reasoning: undefined,
+      threadId: 'or-gemini-default-1',
+      runId: 'or-gemini-default-1',
+    });
+  });
+
+  test(`${capitalizeFirstLetter(provider)}: Gemini reasoning with max_tokens`, async () => {
+    await runReasoningTest({
+      model: 'google/gemini-3-pro-preview',
+      reasoning: { max_tokens: 4000 },
+      threadId: 'or-gemini-reasoning-1',
+      runId: 'or-gemini-reasoning-1',
+    });
+  });
+
+  test(`${capitalizeFirstLetter(provider)}: Gemini reasoning with effort`, async () => {
+    await runReasoningTest({
+      model: 'google/gemini-3-flash-preview',
+      reasoning: { effort: 'low' },
+      threadId: 'or-gemini-effort-1',
+      runId: 'or-gemini-effort-1',
+    });
+  });
+
+  test(`${capitalizeFirstLetter(provider)}: Anthropic reasoning with max_tokens`, async () => {
+    await runReasoningTest({
+      model: 'anthropic/claude-sonnet-4',
+      reasoning: { max_tokens: 4000 },
+      threadId: 'or-anthropic-reasoning-1',
+      runId: 'or-anthropic-reasoning-1',
+    });
+  });
+
+  test(`${capitalizeFirstLetter(provider)}: Anthropic sonnet-4 reasoning with effort`, async () => {
+    await runReasoningTest({
+      model: 'anthropic/claude-sonnet-4',
+      reasoning: { effort: 'medium' },
+      threadId: 'or-anthropic-effort-s4-1',
+      runId: 'or-anthropic-effort-s4-1',
+    });
+  });
+
+  test(`${capitalizeFirstLetter(provider)}: Anthropic sonnet-4-6 reasoning with effort`, async () => {
+    await runReasoningTest({
+      model: 'anthropic/claude-sonnet-4-6',
+      reasoning: { effort: 'medium' },
+      threadId: 'or-anthropic-effort-s46-1',
+      runId: 'or-anthropic-effort-s46-1',
+    });
+  });
 });

package/src/specs/prune.test.ts

@@ -728,6 +728,7 @@ describe('Prune Messages Tests', () => {
           maxContextTokens: 1000,
         },
         returnContent: true,
+        skipCleanup: true,
         tokenCounter,
         indexTokenCountMap: {},
       });

package/src/specs/reasoning.test.ts

@@ -158,6 +158,7 @@ describe(`${capitalizeFirstLetter(provider)} Streaming Tests`, () => {
         additional_instructions: `The user's name is ${userName} and they are located in ${location}.`,
       },
       returnContent: true,
+      skipCleanup: true,
       customHandlers,
     });
 

package/src/specs/thinking-handoff.test.ts

@@ -40,6 +40,7 @@ describe('Thinking-Enabled Agent Handoff Tests', () => {
       edges,
     },
     returnContent: true,
+    skipCleanup: true,
   });
 
   describe('OpenAI to Anthropic with Thinking', () => {

package/src/specs/tool-error.test.ts

@@ -150,6 +150,7 @@ describe('Tool Error Handling Tests', () => {
         additional_instructions: `The user's name is ${userName} and they are located in ${location}.`,
       },
       returnContent: true,
+      skipCleanup: true,
       customHandlers,
     });
 

package/src/types/llm.ts

@@ -11,7 +11,6 @@ import type {
   ClientOptions as OAIClientOptions,
 } from '@langchain/openai';
 import type { GoogleGenerativeAIChatInput } from '@langchain/google-genai';
-import type { GeminiGenerationConfig } from '@langchain/google-common';
 import type { ChatVertexAIInput } from '@langchain/google-vertexai';
 import type { ChatDeepSeekCallOptions } from '@langchain/deepseek';
 import type { ChatOpenRouterCallOptions } from '@/llm/openrouter';
@@ -55,6 +54,11 @@ export type AnthropicReasoning = {
   thinking?: ThinkingConfig | boolean;
   thinkingBudget?: number;
 };
+export type GoogleThinkingConfig = {
+  thinkingBudget?: number;
+  includeThoughts?: boolean;
+  thinkingLevel?: string;
+};
 export type OpenAIClientOptions = ChatOpenAIFields;
 export type AnthropicClientOptions = AnthropicInput & {
   promptCache?: boolean;
@@ -62,6 +66,7 @@ export type AnthropicClientOptions = AnthropicInput & {
 export type MistralAIClientOptions = ChatMistralAIInput;
 export type VertexAIClientOptions = ChatVertexAIInput & {
   includeThoughts?: boolean;
+  thinkingConfig?: GoogleThinkingConfig;
 };
 export type BedrockAnthropicInput = ChatBedrockConverseInput & {
   additionalModelRequestFields?: ChatBedrockConverseInput['additionalModelRequestFields'] &
@@ -72,7 +77,7 @@ export type BedrockConverseClientOptions = ChatBedrockConverseInput;
 export type BedrockAnthropicClientOptions = BedrockAnthropicInput;
 export type GoogleClientOptions = GoogleGenerativeAIChatInput & {
   customHeaders?: RequestOptions['customHeaders'];
-  thinkingConfig?: GeminiGenerationConfig['thinkingConfig'];
+  thinkingConfig?: GoogleThinkingConfig;
 };
 export type DeepSeekClientOptions = ChatDeepSeekCallOptions;
 export type XAIClientOptions = ChatXAIInput;

package/src/types/run.ts

@@ -115,6 +115,8 @@ export type RunConfig = {
   returnContent?: boolean;
   tokenCounter?: TokenCounter;
   indexTokenCountMap?: Record<string, number>;
+  /** Skip post-stream cleanup (clearHeavyState) — useful for tests that inspect graph state after processStream */
+  skipCleanup?: boolean;
 };
 
 export type ProvidedCallbacks =

package/src/utils/llmConfig.ts

@@ -67,11 +67,10 @@ export const llmConfigs: Record<string, t.LLMConfig | undefined> = {
         'X-Title': 'LibreChat',
       },
     },
-    include_reasoning: true,
+    reasoning: {
+      max_tokens: 8000,
+    },
     modelKwargs: {
-      reasoning: {
-        max_tokens: 8000,
-      },
       max_tokens: 10000,
     },
   } as or.ChatOpenRouterCallOptions & t.LLMConfig,

package/src/utils/run.ts

@@ -56,7 +56,7 @@ export class RunnableCallable<I = unknown, O = unknown> extends Runnable<I, O> {
     runManager?: CallbackManagerForChainRun
   ): Promise<O> {
     return new Promise<O>((resolve, reject) => {
-      const childConfig = patchConfig(config, {
+      let childConfig: Partial<RunnableConfig> | null = patchConfig(config, {
         callbacks: runManager?.getChild(),
       });
       void AsyncLocalStorageProviderSingleton.runWithConfig(
@@ -64,8 +64,10 @@ export class RunnableCallable<I = unknown, O = unknown> extends Runnable<I, O> {
         async () => {
           try {
             const output = await this.func(input, childConfig);
+            childConfig = null;
             resolve(output);
           } catch (e) {
+            childConfig = null;
             reject(e);
           }
         }
@@ -98,4 +100,4 @@ export class RunnableCallable<I = unknown, O = unknown> extends Runnable<I, O> {
 
     return returnValue;
   }
-}
+}