@librechat/agents 3.0.0-rc10 → 3.0.0-rc12

package/src/llm/anthropic/index.ts

@@ -135,12 +135,18 @@ export class CustomAnthropic extends ChatAnthropicMessages {
   private message_delta: AnthropicMessageDeltaEvent | undefined;
   private tools_in_params?: boolean;
   private emitted_usage?: boolean;
+  top_k: number | undefined;
   constructor(fields?: CustomAnthropicInput) {
     super(fields);
     this.resetTokenEvents();
+    this.setDirectFields(fields);
     this._lc_stream_delay = fields?._lc_stream_delay ?? 25;
   }
 
+  static lc_name(): 'LibreChatAnthropic' {
+    return 'LibreChatAnthropic';
+  }
+
   /**
    * Get the parameters used to invoke the model
    */
@@ -158,7 +164,7 @@ export class CustomAnthropic extends ChatAnthropicMessages {
       | undefined = handleToolChoice(options?.tool_choice);
 
     if (this.thinking.type === 'enabled') {
-      if (this.topK !== -1 && (this.topK as number | undefined) != null) {
+      if (this.top_k !== -1 && (this.top_k as number | undefined) != null) {
         throw new Error('topK is not supported when thinking is enabled');
       }
       if (this.topP !== -1 && (this.topP as number | undefined) != null) {
@@ -187,7 +193,7 @@ export class CustomAnthropic extends ChatAnthropicMessages {
     return {
       model: this.model,
       temperature: this.temperature,
-      top_k: this.topK,
+      top_k: this.top_k,
       top_p: this.topP,
       stop_sequences: options?.stop ?? this.stopSequences,
       stream: this.streaming,
@@ -244,6 +250,21 @@ export class CustomAnthropic extends ChatAnthropicMessages {
     this.tools_in_params = undefined;
   }
 
+  setDirectFields(fields?: CustomAnthropicInput): void {
+    this.temperature = fields?.temperature ?? undefined;
+    this.topP = fields?.topP ?? undefined;
+    this.top_k = fields?.topK;
+    if (this.temperature === -1 || this.temperature === 1) {
+      this.temperature = undefined;
+    }
+    if (this.topP === -1) {
+      this.topP = undefined;
+    }
+    if (this.top_k === -1) {
+      this.top_k = undefined;
+    }
+  }
+
   private createGenerationChunk({
     token,
     chunk,

package/src/llm/google/index.ts

@@ -107,6 +107,10 @@ export class CustomChatGoogleGenerativeAI extends ChatGoogleGenerativeAI {
     this.streamUsage = fields.streamUsage ?? this.streamUsage;
   }
 
+  static lc_name(): 'LibreChatGoogleGenerativeAI' {
+    return 'LibreChatGoogleGenerativeAI';
+  }
+
   invocationParams(
     options?: this['ParsedCallOptions']
   ): Omit<GenerateContentRequest, 'contents'> {

package/src/llm/google/utils/common.ts

@@ -301,6 +301,20 @@ function _convertLangChainContentToPart(
         mimeType,
       },
     };
+  } else if (
+    content.type === 'document' ||
+    content.type === 'audio' ||
+    content.type === 'video'
+  ) {
+    if (!isMultimodalModel) {
+      throw new Error(`This model does not support ${content.type}s`);
+    }
+    return {
+      inlineData: {
+        data: content.data,
+        mimeType: content.mimeType,
+      },
+    };
   } else if (content.type === 'media') {
     return messageContentMedia(content);
   } else if (content.type === 'tool_use') {

package/src/llm/ollama/index.ts

@@ -13,6 +13,9 @@ import {
 } from './utils';
 
 export class ChatOllama extends BaseChatOllama {
+  static lc_name(): 'LibreChatOllama' {
+    return 'LibreChatOllama';
+  }
   async *_streamResponseChunks(
     messages: BaseMessage[],
     options: this['ParsedCallOptions'],

package/src/llm/openai/index.ts

@@ -210,6 +210,9 @@ export class ChatOpenAI extends OriginalChatOpenAI<t.ChatOpenAICallOptions> {
   public get exposedClient(): CustomOpenAIClient {
     return this.client;
   }
+  static lc_name(): string {
+    return 'LibreChatOpenAI';
+  }
   protected _getClientOptions(
     options?: OpenAICoreRequestOptions
   ): OpenAICoreRequestOptions {
@@ -245,7 +248,8 @@ export class ChatOpenAI extends OriginalChatOpenAI<t.ChatOpenAICallOptions> {
   getReasoningParams(
     options?: this['ParsedCallOptions']
   ): OpenAIClient.Reasoning | undefined {
-    if (!isReasoningModel(this.model)) {
+    const lc_name = (this.constructor as typeof ChatOpenAI).lc_name();
+    if (lc_name === 'LibreChatOpenAI' && !isReasoningModel(this.model)) {
       return;
     }
 
@@ -360,6 +364,10 @@ export class ChatOpenAI extends OriginalChatOpenAI<t.ChatOpenAICallOptions> {
       } else if ('reasoning' in delta) {
         chunk.additional_kwargs.reasoning_content = delta.reasoning;
       }
+      if ('provider_specific_fields' in delta) {
+        chunk.additional_kwargs.provider_specific_fields =
+          delta.provider_specific_fields;
+      }
       defaultRole = delta.role ?? defaultRole;
       const newTokenIndices = {
         prompt: options.promptIndex ?? 0,
@@ -463,6 +471,9 @@ export class AzureChatOpenAI extends OriginalAzureChatOpenAI {
   public get exposedClient(): CustomOpenAIClient {
     return this.client;
   }
+  static lc_name(): 'LibreChatAzureOpenAI' {
+    return 'LibreChatAzureOpenAI';
+  }
   /**
    * Returns backwards compatible reasoning parameters from constructor params and call options
    * @internal
@@ -607,6 +618,9 @@ export class ChatDeepSeek extends OriginalChatDeepSeek {
   public get exposedClient(): CustomOpenAIClient {
     return this.client;
   }
+  static lc_name(): 'LibreChatDeepSeek' {
+    return 'LibreChatDeepSeek';
+  }
   protected _getClientOptions(
     options?: OpenAICoreRequestOptions
   ): OpenAICoreRequestOptions {
@@ -679,6 +693,10 @@ export class ChatXAI extends OriginalChatXAI {
     }
   }
 
+  static lc_name(): 'LibreChatXAI' {
+    return 'LibreChatXAI';
+  }
+
   public get exposedClient(): CustomOpenAIClient {
     return this.client;
   }

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

@@ -298,10 +298,16 @@ export function _convertMessagesToOpenAIParams(
       role = 'developer';
     }
 
+    let hasAnthropicThinkingBlock: boolean = false;
+
     const content =
       typeof message.content === 'string'
         ? message.content
         : message.content.map((m) => {
+          if ('type' in m && m.type === 'thinking') {
+            hasAnthropicThinkingBlock = true;
+            return m;
+          }
           if (isDataContentBlock(m)) {
             return convertToProviderContentBlock(
               m,
@@ -326,7 +332,7 @@ export function _convertMessagesToOpenAIParams(
       completionParam.tool_calls = message.tool_calls.map(
         convertLangChainToolCallToOpenAI
       );
-      completionParam.content = '';
+      completionParam.content = hasAnthropicThinkingBlock ? content : '';
     } else {
       if (message.additional_kwargs.tool_calls != null) {
         completionParam.tool_calls = message.additional_kwargs.tool_calls;

package/src/llm/openrouter/index.ts

@@ -1,27 +1,36 @@
-import type { ChatOpenAICallOptions, OpenAIClient } from '@langchain/openai';
+import { ChatOpenAI } from '@/llm/openai';
 import type {
-  AIMessageChunk,
-  HumanMessageChunk,
-  SystemMessageChunk,
   FunctionMessageChunk,
+  SystemMessageChunk,
+  HumanMessageChunk,
   ToolMessageChunk,
   ChatMessageChunk,
+  AIMessageChunk,
 } from '@langchain/core/messages';
-import { ChatOpenAI } from '@/llm/openai';
+import type {
+  ChatOpenAICallOptions,
+  OpenAIChatInput,
+  OpenAIClient,
+} from '@langchain/openai';
 
 export interface ChatOpenRouterCallOptions extends ChatOpenAICallOptions {
   include_reasoning?: boolean;
+  modelKwargs?: OpenAIChatInput['modelKwargs'];
 }
 export class ChatOpenRouter extends ChatOpenAI {
   constructor(_fields: Partial<ChatOpenRouterCallOptions>) {
-    const { include_reasoning, ...fields } = _fields;
+    const { include_reasoning, modelKwargs = {}, ...fields } = _fields;
     super({
       ...fields,
       modelKwargs: {
+        ...modelKwargs,
         include_reasoning,
       },
     });
   }
+  static lc_name(): 'LibreChatOpenRouter' {
+    return 'LibreChatOpenRouter';
+  }
   protected override _convertOpenAIDeltaToBaseMessageChunk(
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     delta: Record<string, any>,

package/src/llm/vertexai/index.ts

@@ -313,8 +313,8 @@ export class ChatVertexAI extends ChatGoogle {
   lc_namespace = ['langchain', 'chat_models', 'vertexai'];
   dynamicThinkingBudget = false;
 
-  static lc_name(): 'ChatVertexAI' {
-    return 'ChatVertexAI';
+  static lc_name(): 'LibreChatVertexAI' {
+    return 'LibreChatVertexAI';
   }
 
   constructor(fields?: VertexAIClientOptions) {

package/src/messages/cache.test.ts

@@ -0,0 +1,262 @@
+import type Anthropic from '@anthropic-ai/sdk';
+import type { AnthropicMessages } from '@/types/messages';
+import { addCacheControl } from './cache';
+
+describe('addCacheControl', () => {
+  test('should add cache control to the last two user messages with array content', () => {
+    const messages: AnthropicMessages = [
+      { role: 'user', content: [{ type: 'text', text: 'Hello' }] },
+      { role: 'assistant', content: [{ type: 'text', text: 'Hi there' }] },
+      { role: 'user', content: [{ type: 'text', text: 'How are you?' }] },
+      {
+        role: 'assistant',
+        content: [{ type: 'text', text: 'I\'m doing well, thanks!' }],
+      },
+      { role: 'user', content: [{ type: 'text', text: 'Great!' }] },
+    ];
+
+    const result = addCacheControl(messages);
+
+    expect(result[0].content[0]).not.toHaveProperty('cache_control');
+    expect(
+      (result[2].content[0] as Anthropic.TextBlockParam).cache_control
+    ).toEqual({ type: 'ephemeral' });
+    expect(
+      (result[4].content[0] as Anthropic.TextBlockParam).cache_control
+    ).toEqual({ type: 'ephemeral' });
+  });
+
+  test('should add cache control to the last two user messages with string content', () => {
+    const messages: AnthropicMessages = [
+      { role: 'user', content: 'Hello' },
+      { role: 'assistant', content: 'Hi there' },
+      { role: 'user', content: 'How are you?' },
+      { role: 'assistant', content: 'I\'m doing well, thanks!' },
+      { role: 'user', content: 'Great!' },
+    ];
+
+    const result = addCacheControl(messages);
+
+    expect(result[0].content).toBe('Hello');
+    expect(result[2].content[0]).toEqual({
+      type: 'text',
+      text: 'How are you?',
+      cache_control: { type: 'ephemeral' },
+    });
+    expect(result[4].content[0]).toEqual({
+      type: 'text',
+      text: 'Great!',
+      cache_control: { type: 'ephemeral' },
+    });
+  });
+
+  test('should handle mixed string and array content', () => {
+    const messages: AnthropicMessages = [
+      { role: 'user', content: 'Hello' },
+      { role: 'assistant', content: 'Hi there' },
+      { role: 'user', content: [{ type: 'text', text: 'How are you?' }] },
+    ];
+
+    const result = addCacheControl(messages);
+
+    expect(result[0].content[0]).toEqual({
+      type: 'text',
+      text: 'Hello',
+      cache_control: { type: 'ephemeral' },
+    });
+    expect(
+      (result[2].content[0] as Anthropic.TextBlockParam).cache_control
+    ).toEqual({ type: 'ephemeral' });
+  });
+
+  test('should handle less than two user messages', () => {
+    const messages: AnthropicMessages = [
+      { role: 'user', content: 'Hello' },
+      { role: 'assistant', content: 'Hi there' },
+    ];
+
+    const result = addCacheControl(messages);
+
+    expect(result[0].content[0]).toEqual({
+      type: 'text',
+      text: 'Hello',
+      cache_control: { type: 'ephemeral' },
+    });
+    expect(result[1].content).toBe('Hi there');
+  });
+
+  test('should return original array if no user messages', () => {
+    const messages: AnthropicMessages = [
+      { role: 'assistant', content: 'Hi there' },
+      { role: 'assistant', content: 'How can I help?' },
+    ];
+
+    const result = addCacheControl(messages);
+
+    expect(result).toEqual(messages);
+  });
+
+  test('should handle empty array', () => {
+    const messages: AnthropicMessages = [];
+    const result = addCacheControl(messages);
+    expect(result).toEqual([]);
+  });
+
+  test('should handle non-array input', () => {
+    const messages = 'not an array';
+    /** @ts-expect-error - This is a test */
+    const result = addCacheControl(messages);
+    expect(result).toBe('not an array');
+  });
+
+  test('should not modify assistant messages', () => {
+    const messages: AnthropicMessages = [
+      { role: 'user', content: 'Hello' },
+      { role: 'assistant', content: 'Hi there' },
+      { role: 'user', content: 'How are you?' },
+    ];
+
+    const result = addCacheControl(messages);
+
+    expect(result[1].content).toBe('Hi there');
+  });
+
+  test('should handle multiple content items in user messages', () => {
+    const messages: AnthropicMessages = [
+      {
+        role: 'user',
+        content: [
+          { type: 'text', text: 'Hello' },
+          {
+            type: 'image',
+            source: { type: 'url', url: 'http://example.com/image.jpg' },
+          },
+          { type: 'text', text: 'This is an image' },
+        ],
+      },
+      { role: 'assistant', content: 'Hi there' },
+      { role: 'user', content: 'How are you?' },
+    ];
+
+    const result = addCacheControl(messages);
+
+    expect(result[0].content[0]).not.toHaveProperty('cache_control');
+    expect(result[0].content[1]).not.toHaveProperty('cache_control');
+    expect(
+      (result[0].content[2] as Anthropic.TextBlockParam).cache_control
+    ).toEqual({ type: 'ephemeral' });
+    expect(result[2].content[0]).toEqual({
+      type: 'text',
+      text: 'How are you?',
+      cache_control: { type: 'ephemeral' },
+    });
+  });
+
+  test('should handle an array with mixed content types', () => {
+    const messages: AnthropicMessages = [
+      { role: 'user', content: 'Hello' },
+      { role: 'assistant', content: 'Hi there' },
+      { role: 'user', content: [{ type: 'text', text: 'How are you?' }] },
+      { role: 'assistant', content: 'I\'m doing well, thanks!' },
+      { role: 'user', content: 'Great!' },
+    ];
+
+    const result = addCacheControl(messages);
+
+    expect(result[0].content).toEqual('Hello');
+    expect(result[2].content[0]).toEqual({
+      type: 'text',
+      text: 'How are you?',
+      cache_control: { type: 'ephemeral' },
+    });
+    expect(result[4].content).toEqual([
+      {
+        type: 'text',
+        text: 'Great!',
+        cache_control: { type: 'ephemeral' },
+      },
+    ]);
+    expect(result[1].content).toBe('Hi there');
+    expect(result[3].content).toBe('I\'m doing well, thanks!');
+  });
+
+  test('should handle edge case with multiple content types', () => {
+    const messages: AnthropicMessages = [
+      {
+        role: 'user',
+        content: [
+          {
+            type: 'image',
+            source: {
+              type: 'base64',
+              media_type: 'image/png',
+              data: 'some_base64_string',
+            },
+          },
+          {
+            type: 'image',
+            source: {
+              type: 'base64',
+              media_type: 'image/png',
+              data: 'another_base64_string',
+            },
+          },
+          { type: 'text', text: 'what do all these images have in common' },
+        ],
+      },
+      { role: 'assistant', content: 'I see multiple images.' },
+      { role: 'user', content: 'Correct!' },
+    ];
+
+    const result = addCacheControl(messages);
+
+    expect(result[0].content[0]).not.toHaveProperty('cache_control');
+    expect(result[0].content[1]).not.toHaveProperty('cache_control');
+    expect(
+      (result[0].content[2] as Anthropic.ImageBlockParam).cache_control
+    ).toEqual({ type: 'ephemeral' });
+    expect(result[2].content[0]).toEqual({
+      type: 'text',
+      text: 'Correct!',
+      cache_control: { type: 'ephemeral' },
+    });
+  });
+
+  test('should handle user message with no text block', () => {
+    const messages: AnthropicMessages = [
+      {
+        role: 'user',
+        content: [
+          {
+            type: 'image',
+            source: {
+              type: 'base64',
+              media_type: 'image/png',
+              data: 'some_base64_string',
+            },
+          },
+          {
+            type: 'image',
+            source: {
+              type: 'base64',
+              media_type: 'image/png',
+              data: 'another_base64_string',
+            },
+          },
+        ],
+      },
+      { role: 'assistant', content: 'I see two images.' },
+      { role: 'user', content: 'Correct!' },
+    ];
+
+    const result = addCacheControl(messages);
+
+    expect(result[0].content[0]).not.toHaveProperty('cache_control');
+    expect(result[0].content[1]).not.toHaveProperty('cache_control');
+    expect(result[2].content[0]).toEqual({
+      type: 'text',
+      text: 'Correct!',
+      cache_control: { type: 'ephemeral' },
+    });
+  });
+});

package/src/messages/cache.ts

@@ -0,0 +1,56 @@
+import type { AnthropicMessage } from '@/types/messages';
+import type Anthropic from '@anthropic-ai/sdk';
+import { BaseMessage } from '@langchain/core/messages';
+
+/**
+ * Anthropic API: Adds cache control to the appropriate user messages in the payload.
+ * @param messages - The array of message objects.
+ * @returns - The updated array of message objects with cache control added.
+ */
+export function addCacheControl<T extends AnthropicMessage | BaseMessage>(
+  messages: T[]
+): T[] {
+  if (!Array.isArray(messages) || messages.length < 2) {
+    return messages;
+  }
+
+  const updatedMessages = [...messages];
+  let userMessagesModified = 0;
+
+  for (
+    let i = updatedMessages.length - 1;
+    i >= 0 && userMessagesModified < 2;
+    i--
+  ) {
+    const message = updatedMessages[i];
+    if ('getType' in message && message.getType() !== 'human') {
+      continue;
+    } else if ('role' in message && message.role !== 'user') {
+      continue;
+    }
+
+    if (typeof message.content === 'string') {
+      message.content = [
+        {
+          type: 'text',
+          text: message.content,
+          cache_control: { type: 'ephemeral' },
+        },
+      ];
+      userMessagesModified++;
+    } else if (Array.isArray(message.content)) {
+      for (let j = message.content.length - 1; j >= 0; j--) {
+        const contentPart = message.content[j];
+        if ('type' in contentPart && contentPart.type === 'text') {
+          (contentPart as Anthropic.TextBlockParam).cache_control = {
+            type: 'ephemeral',
+          };
+          userMessagesModified++;
+          break;
+        }
+      }
+    }
+  }
+
+  return updatedMessages;
+}