@librechat/agents 3.0.34 → 3.0.36

package/src/llm/openai/index.ts

@@ -643,6 +643,132 @@ export class ChatDeepSeek extends OriginalChatDeepSeek {
     } as OpenAICoreRequestOptions;
     return requestOptions;
   }
+
+  async *_streamResponseChunks(
+    messages: BaseMessage[],
+    options: this['ParsedCallOptions'],
+    runManager?: CallbackManagerForLLMRun
+  ): AsyncGenerator<ChatGenerationChunk> {
+    const messagesMapped: OpenAICompletionParam[] =
+      _convertMessagesToOpenAIParams(messages, this.model, {
+        includeReasoningContent: true,
+      });
+
+    const params = {
+      ...this.invocationParams(options, {
+        streaming: true,
+      }),
+      messages: messagesMapped,
+      stream: true as const,
+    };
+    let defaultRole: OpenAIRoleEnum | undefined;
+
+    const streamIterable = await this.completionWithRetry(params, options);
+    let usage: OpenAIClient.Completions.CompletionUsage | undefined;
+    for await (const data of streamIterable) {
+      const choice = data.choices[0] as
+        | Partial<OpenAIClient.Chat.Completions.ChatCompletionChunk.Choice>
+        | undefined;
+      if (data.usage) {
+        usage = data.usage;
+      }
+      if (!choice) {
+        continue;
+      }
+
+      const { delta } = choice;
+      if (!delta) {
+        continue;
+      }
+      const chunk = this._convertOpenAIDeltaToBaseMessageChunk(
+        delta,
+        data,
+        defaultRole
+      );
+      if ('reasoning_content' in delta) {
+        chunk.additional_kwargs.reasoning_content = delta.reasoning_content;
+      }
+      defaultRole = delta.role ?? defaultRole;
+      const newTokenIndices = {
+        prompt: (options as OpenAIChatCallOptions).promptIndex ?? 0,
+        completion: choice.index ?? 0,
+      };
+      if (typeof chunk.content !== 'string') {
+        // eslint-disable-next-line no-console
+        console.log(
+          '[WARNING]: Received non-string content from OpenAI. This is currently not supported.'
+        );
+        continue;
+      }
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      const generationInfo: Record<string, any> = { ...newTokenIndices };
+      if (choice.finish_reason != null) {
+        generationInfo.finish_reason = choice.finish_reason;
+        generationInfo.system_fingerprint = data.system_fingerprint;
+        generationInfo.model_name = data.model;
+        generationInfo.service_tier = data.service_tier;
+      }
+      if (this.logprobs == true) {
+        generationInfo.logprobs = choice.logprobs;
+      }
+      const generationChunk = new ChatGenerationChunk({
+        message: chunk,
+        text: chunk.content,
+        generationInfo,
+      });
+      yield generationChunk;
+      await runManager?.handleLLMNewToken(
+        generationChunk.text || '',
+        newTokenIndices,
+        undefined,
+        undefined,
+        undefined,
+        { chunk: generationChunk }
+      );
+    }
+    if (usage) {
+      const inputTokenDetails = {
+        ...(usage.prompt_tokens_details?.audio_tokens != null && {
+          audio: usage.prompt_tokens_details.audio_tokens,
+        }),
+        ...(usage.prompt_tokens_details?.cached_tokens != null && {
+          cache_read: usage.prompt_tokens_details.cached_tokens,
+        }),
+      };
+      const outputTokenDetails = {
+        ...(usage.completion_tokens_details?.audio_tokens != null && {
+          audio: usage.completion_tokens_details.audio_tokens,
+        }),
+        ...(usage.completion_tokens_details?.reasoning_tokens != null && {
+          reasoning: usage.completion_tokens_details.reasoning_tokens,
+        }),
+      };
+      const generationChunk = new ChatGenerationChunk({
+        message: new AIMessageChunk({
+          content: '',
+          response_metadata: {
+            usage: { ...usage },
+          },
+          usage_metadata: {
+            input_tokens: usage.prompt_tokens,
+            output_tokens: usage.completion_tokens,
+            total_tokens: usage.total_tokens,
+            ...(Object.keys(inputTokenDetails).length > 0 && {
+              input_token_details: inputTokenDetails,
+            }),
+            ...(Object.keys(outputTokenDetails).length > 0 && {
+              output_token_details: outputTokenDetails,
+            }),
+          },
+        }),
+        text: '',
+      });
+      yield generationChunk;
+    }
+    if (options.signal?.aborted === true) {
+      throw new Error('AbortError');
+    }
+  }
 }
 
 /** xAI-specific usage metadata type */

package/src/llm/openai/utils/index.ts

@@ -286,10 +286,21 @@ const completionsApiContentBlockConverter: StandardContentBlockConverter<{
   },
 };
 
+/** Options for converting messages to OpenAI params */
+export interface ConvertMessagesOptions {
+  /** Include reasoning_content field for DeepSeek thinking mode with tool calls */
+  includeReasoningContent?: boolean;
+  /** Include reasoning_details field for OpenRouter/Gemini thinking mode with tool calls */
+  includeReasoningDetails?: boolean;
+  /** Convert reasoning_details to content blocks for Claude (requires content array format) */
+  convertReasoningDetailsToContent?: boolean;
+}
+
 // Used in LangSmith, export is important here
 export function _convertMessagesToOpenAIParams(
   messages: BaseMessage[],
-  model?: string
+  model?: string,
+  options?: ConvertMessagesOptions
 ): OpenAICompletionParam[] {
   // TODO: Function messages do not support array content, fix cast
   return messages.flatMap((message) => {
@@ -333,9 +344,113 @@ export function _convertMessagesToOpenAIParams(
         convertLangChainToolCallToOpenAI
       );
       completionParam.content = hasAnthropicThinkingBlock ? content : '';
+      if (
+        options?.includeReasoningContent === true &&
+        message.additional_kwargs.reasoning_content != null
+      ) {
+        completionParam.reasoning_content =
+          message.additional_kwargs.reasoning_content;
+      }
+      if (
+        options?.includeReasoningDetails === true &&
+        message.additional_kwargs.reasoning_details != null
+      ) {
+        // For Claude via OpenRouter, convert reasoning_details to content blocks
+        const isClaudeModel =
+          model?.includes('claude') === true ||
+          model?.includes('anthropic') === true;
+        if (
+          options.convertReasoningDetailsToContent === true &&
+          isClaudeModel
+        ) {
+          const reasoningDetails = message.additional_kwargs
+            .reasoning_details as Record<string, unknown>[];
+          const contentBlocks = [];
+
+          // Add thinking blocks from reasoning_details
+          for (const detail of reasoningDetails) {
+            if (detail.type === 'reasoning.text' && detail.text != null) {
+              contentBlocks.push({
+                type: 'thinking',
+                thinking: detail.text,
+              });
+            } else if (
+              detail.type === 'reasoning.encrypted' &&
+              detail.data != null
+            ) {
+              contentBlocks.push({
+                type: 'redacted_thinking',
+                data: detail.data,
+                id: detail.id,
+              });
+            }
+          }
+
+          // Set content to array with thinking blocks
+          if (contentBlocks.length > 0) {
+            completionParam.content = contentBlocks;
+          }
+        } else {
+          // For non-Claude models, pass as separate field
+          completionParam.reasoning_details =
+            message.additional_kwargs.reasoning_details;
+        }
+      }
     } else {
       if (message.additional_kwargs.tool_calls != null) {
         completionParam.tool_calls = message.additional_kwargs.tool_calls;
+        if (
+          options?.includeReasoningContent === true &&
+          message.additional_kwargs.reasoning_content != null
+        ) {
+          completionParam.reasoning_content =
+            message.additional_kwargs.reasoning_content;
+        }
+        if (
+          options?.includeReasoningDetails === true &&
+          message.additional_kwargs.reasoning_details != null
+        ) {
+          // For Claude via OpenRouter, convert reasoning_details to content blocks
+          const isClaudeModel =
+            model?.includes('claude') === true ||
+            model?.includes('anthropic') === true;
+          if (
+            options.convertReasoningDetailsToContent === true &&
+            isClaudeModel
+          ) {
+            const reasoningDetails = message.additional_kwargs
+              .reasoning_details as Record<string, unknown>[];
+            const contentBlocks = [];
+
+            // Add thinking blocks from reasoning_details
+            for (const detail of reasoningDetails) {
+              if (detail.type === 'reasoning.text' && detail.text != null) {
+                contentBlocks.push({
+                  type: 'thinking',
+                  thinking: detail.text,
+                });
+              } else if (
+                detail.type === 'reasoning.encrypted' &&
+                detail.data != null
+              ) {
+                contentBlocks.push({
+                  type: 'redacted_thinking',
+                  data: detail.data,
+                  id: detail.id,
+                });
+              }
+            }
+
+            // Set content to array with thinking blocks
+            if (contentBlocks.length > 0) {
+              completionParam.content = contentBlocks;
+            }
+          } else {
+            // For non-Claude models, pass as separate field
+            completionParam.reasoning_details =
+              message.additional_kwargs.reasoning_details;
+          }
+        }
       }
       if ((message as ToolMessage).tool_call_id != null) {
         completionParam.tool_call_id = (message as ToolMessage).tool_call_id;

package/src/llm/openrouter/index.ts

@@ -1,4 +1,7 @@
 import { ChatOpenAI } from '@/llm/openai';
+import { ChatGenerationChunk } from '@langchain/core/outputs';
+import { CallbackManagerForLLMRun } from '@langchain/core/callbacks/manager';
+import { AIMessageChunk as AIMessageChunkClass } from '@langchain/core/messages';
 import type {
   FunctionMessageChunk,
   SystemMessageChunk,
@@ -6,12 +9,25 @@ import type {
   ToolMessageChunk,
   ChatMessageChunk,
   AIMessageChunk,
+  BaseMessage,
 } from '@langchain/core/messages';
 import type {
   ChatOpenAICallOptions,
   OpenAIChatInput,
   OpenAIClient,
 } from '@langchain/openai';
+import { _convertMessagesToOpenAIParams } from '@/llm/openai/utils';
+
+type OpenAICompletionParam =
+  OpenAIClient.Chat.Completions.ChatCompletionMessageParam;
+
+type OpenAIRoleEnum =
+  | 'system'
+  | 'developer'
+  | 'assistant'
+  | 'user'
+  | 'function'
+  | 'tool';
 
 export interface ChatOpenRouterCallOptions extends ChatOpenAICallOptions {
   include_reasoning?: boolean;
@@ -54,7 +70,212 @@ export class ChatOpenRouter extends ChatOpenAI {
       rawResponse,
       defaultRole
     );
-    messageChunk.additional_kwargs.reasoning = delta.reasoning;
+    if (delta.reasoning != null) {
+      messageChunk.additional_kwargs.reasoning = delta.reasoning;
+    }
+    if (delta.reasoning_details != null) {
+      messageChunk.additional_kwargs.reasoning_details =
+        delta.reasoning_details;
+    }
     return messageChunk;
   }
+
+  async *_streamResponseChunks2(
+    messages: BaseMessage[],
+    options: this['ParsedCallOptions'],
+    runManager?: CallbackManagerForLLMRun
+  ): AsyncGenerator<ChatGenerationChunk> {
+    const messagesMapped: OpenAICompletionParam[] =
+      _convertMessagesToOpenAIParams(messages, this.model, {
+        includeReasoningDetails: true,
+        convertReasoningDetailsToContent: true,
+      });
+
+    const params = {
+      ...this.invocationParams(options, {
+        streaming: true,
+      }),
+      messages: messagesMapped,
+      stream: true as const,
+    };
+    let defaultRole: OpenAIRoleEnum | undefined;
+
+    const streamIterable = await this.completionWithRetry(params, options);
+    let usage: OpenAIClient.Completions.CompletionUsage | undefined;
+
+    // Store reasoning_details keyed by unique identifier to prevent incorrect merging
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const reasoningTextByIndex: Map<number, Record<string, any>> = new Map();
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const reasoningEncryptedById: Map<string, Record<string, any>> = new Map();
+
+    for await (const data of streamIterable) {
+      const choice = data.choices[0] as
+        | Partial<OpenAIClient.Chat.Completions.ChatCompletionChunk.Choice>
+        | undefined;
+      if (data.usage) {
+        usage = data.usage;
+      }
+      if (!choice) {
+        continue;
+      }
+
+      const { delta } = choice;
+      if (!delta) {
+        continue;
+      }
+
+      // Accumulate reasoning_details from each delta
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      const deltaAny = delta as Record<string, any>;
+      if (
+        deltaAny.reasoning_details != null &&
+        Array.isArray(deltaAny.reasoning_details)
+      ) {
+        for (const detail of deltaAny.reasoning_details) {
+          // For encrypted reasoning (thought signatures), store by ID - MUST be separate
+          if (detail.type === 'reasoning.encrypted' && detail.id) {
+            reasoningEncryptedById.set(detail.id, {
+              type: detail.type,
+              id: detail.id,
+              data: detail.data,
+              format: detail.format,
+              index: detail.index,
+            });
+          } else if (detail.type === 'reasoning.text') {
+            // For text reasoning, accumulate text by index
+            const idx = detail.index ?? 0;
+            const existing = reasoningTextByIndex.get(idx);
+            if (existing) {
+              // Only append text, keep other fields from first entry
+              existing.text = (existing.text || '') + (detail.text || '');
+            } else {
+              reasoningTextByIndex.set(idx, {
+                type: detail.type,
+                text: detail.text || '',
+                format: detail.format,
+                index: idx,
+              });
+            }
+          }
+        }
+      }
+
+      const chunk = this._convertOpenAIDeltaToBaseMessageChunk(
+        delta,
+        data,
+        defaultRole
+      );
+
+      // IMPORTANT: Only set reasoning_details on the FINAL chunk to prevent
+      // LangChain's chunk concatenation from corrupting the array
+      // Check if this is the final chunk (has finish_reason)
+      if (choice.finish_reason != null) {
+        // Build properly structured reasoning_details array
+        // Text entries first (but we only need the encrypted ones for thought signatures)
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const finalReasoningDetails: Record<string, any>[] = [
+          ...reasoningTextByIndex.values(),
+          ...reasoningEncryptedById.values(),
+        ];
+
+        if (finalReasoningDetails.length > 0) {
+          chunk.additional_kwargs.reasoning_details = finalReasoningDetails;
+        }
+      } else {
+        // Clear reasoning_details from intermediate chunks to prevent concatenation issues
+        delete chunk.additional_kwargs.reasoning_details;
+      }
+
+      defaultRole = delta.role ?? defaultRole;
+      const newTokenIndices = {
+        prompt: options.promptIndex ?? 0,
+        completion: choice.index ?? 0,
+      };
+      if (typeof chunk.content !== 'string') {
+        // eslint-disable-next-line no-console
+        console.log(
+          '[WARNING]: Received non-string content from OpenAI. This is currently not supported.'
+        );
+        continue;
+      }
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      const generationInfo: Record<string, any> = { ...newTokenIndices };
+      if (choice.finish_reason != null) {
+        generationInfo.finish_reason = choice.finish_reason;
+        generationInfo.system_fingerprint = data.system_fingerprint;
+        generationInfo.model_name = data.model;
+        generationInfo.service_tier = data.service_tier;
+      }
+      if (this.logprobs == true) {
+        generationInfo.logprobs = choice.logprobs;
+      }
+      const generationChunk = new ChatGenerationChunk({
+        message: chunk,
+        text: chunk.content,
+        generationInfo,
+      });
+      yield generationChunk;
+      if (this._lc_stream_delay != null) {
+        await new Promise((resolve) =>
+          setTimeout(resolve, this._lc_stream_delay)
+        );
+      }
+      await runManager?.handleLLMNewToken(
+        generationChunk.text || '',
+        newTokenIndices,
+        undefined,
+        undefined,
+        undefined,
+        { chunk: generationChunk }
+      );
+    }
+    if (usage) {
+      const inputTokenDetails = {
+        ...(usage.prompt_tokens_details?.audio_tokens != null && {
+          audio: usage.prompt_tokens_details.audio_tokens,
+        }),
+        ...(usage.prompt_tokens_details?.cached_tokens != null && {
+          cache_read: usage.prompt_tokens_details.cached_tokens,
+        }),
+      };
+      const outputTokenDetails = {
+        ...(usage.completion_tokens_details?.audio_tokens != null && {
+          audio: usage.completion_tokens_details.audio_tokens,
+        }),
+        ...(usage.completion_tokens_details?.reasoning_tokens != null && {
+          reasoning: usage.completion_tokens_details.reasoning_tokens,
+        }),
+      };
+      const generationChunk = new ChatGenerationChunk({
+        message: new AIMessageChunkClass({
+          content: '',
+          response_metadata: {
+            usage: { ...usage },
+          },
+          usage_metadata: {
+            input_tokens: usage.prompt_tokens,
+            output_tokens: usage.completion_tokens,
+            total_tokens: usage.total_tokens,
+            ...(Object.keys(inputTokenDetails).length > 0 && {
+              input_token_details: inputTokenDetails,
+            }),
+            ...(Object.keys(outputTokenDetails).length > 0 && {
+              output_token_details: outputTokenDetails,
+            }),
+          },
+        }),
+        text: '',
+      });
+      yield generationChunk;
+      if (this._lc_stream_delay != null) {
+        await new Promise((resolve) =>
+          setTimeout(resolve, this._lc_stream_delay)
+        );
+      }
+    }
+    if (options.signal?.aborted === true) {
+      throw new Error('AbortError');
+    }
+  }
 }

package/src/stream.ts

@@ -107,6 +107,25 @@ export function getChunkContent({
         | undefined
     )?.summary?.[0]?.text;
   }
+  if (
+    provider === Providers.OPENROUTER &&
+    chunk?.additional_kwargs?.reasoning_details != null &&
+    Array.isArray(chunk.additional_kwargs.reasoning_details)
+  ) {
+    // Extract text from reasoning_details array (for Gemini, DeepSeek, etc.)
+    const textEntries = chunk.additional_kwargs.reasoning_details
+      .filter(
+        (detail) =>
+          detail.type === 'reasoning.text' &&
+          detail.text != null &&
+          detail.text !== ''
+      )
+      .map((detail) => detail.text)
+      .join('');
+    if (textEntries) {
+      return textEntries;
+    }
+  }
   return (
     ((chunk?.additional_kwargs?.[reasoningKey] as string | undefined) ?? '') ||
     chunk?.content
@@ -355,6 +374,13 @@ hasToolCallChunks: ${hasToolCallChunks}
       reasoning_content.summary[0].text
     ) {
       reasoning_content = 'valid';
+    } else if (
+      agentContext.provider === Providers.OPENROUTER &&
+      chunk.additional_kwargs?.reasoning_details != null &&
+      Array.isArray(chunk.additional_kwargs.reasoning_details) &&
+      chunk.additional_kwargs.reasoning_details.length > 0
+    ) {
+      reasoning_content = 'valid';
     }
     if (
       reasoning_content != null &&

package/src/utils/llmConfig.ts

@@ -56,8 +56,8 @@ export const llmConfigs: Record<string, t.LLMConfig | undefined> = {
     provider: Providers.OPENROUTER,
     streaming: true,
     streamUsage: true,
-    model: 'openai/gpt-4.1',
-    openAIApiKey: process.env.OPENROUTER_API_KEY,
+    model: 'anthropic/claude-sonnet-4',
+    apiKey: process.env.OPENROUTER_API_KEY,
     configuration: {
       baseURL: process.env.OPENROUTER_BASE_URL,
       defaultHeaders: {
@@ -66,6 +66,12 @@ export const llmConfigs: Record<string, t.LLMConfig | undefined> = {
       },
     },
     include_reasoning: true,
+    modelKwargs: {
+      reasoning: {
+        max_tokens: 8000,
+      },
+      max_tokens: 10000,
+    },
   } as or.ChatOpenRouterCallOptions & t.LLMConfig,
   [Providers.AZURE]: {
     provider: Providers.AZURE,