@librechat/agents 1.7.8 → 1.7.9

package/src/llm/anthropic/utils/message_inputs.ts

@@ -0,0 +1,279 @@
+/**
+ * This util file contains functions for converting LangChain messages to Anthropic messages.
+ */
+import {
+  BaseMessage,
+  SystemMessage,
+  HumanMessage,
+  AIMessage,
+  ToolMessage,
+  MessageContent,
+  isAIMessage,
+} from '@langchain/core/messages';
+import { ToolCall } from '@langchain/core/messages/tool';
+import type {
+  AnthropicMessageCreateParams,
+  AnthropicToolResponse,
+} from '@/llm/anthropic/types';
+
+function _formatImage(imageUrl: string): { type: string; media_type: string; data: string } {
+  const regex = /^data:(image\/.+);base64,(.+)$/;
+  const match = imageUrl.match(regex);
+  if (match === null) {
+    throw new Error(
+      [
+        'Anthropic only supports base64-encoded images currently.',
+        'Example: data:image/png;base64,/9j/4AAQSk...',
+      ].join('\n\n')
+    );
+  }
+  return {
+    type: 'base64',
+    media_type: match[1] ?? '',
+    data: match[2] ?? '',
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  } as any;
+}
+
+function _mergeMessages(
+  messages: BaseMessage[]
+): (SystemMessage | HumanMessage | AIMessage)[] {
+  // Merge runs of human/tool messages into single human messages with content blocks.
+  const merged = [];
+  for (const message of messages) {
+    if (message._getType() === 'tool') {
+      if (typeof message.content === 'string') {
+        const previousMessage = merged[merged.length - 1] as BaseMessage | undefined;
+        if (
+          previousMessage &&
+          previousMessage._getType() === 'human' &&
+          Array.isArray(previousMessage.content) &&
+          'type' in previousMessage.content[0] &&
+          previousMessage.content[0].type === 'tool_result'
+        ) {
+          // If the previous message was a tool result, we merge this tool message into it.
+          previousMessage.content.push({
+            type: 'tool_result',
+            content: message.content,
+            tool_use_id: (message as ToolMessage).tool_call_id,
+          });
+        } else {
+          // If not, we create a new human message with the tool result.
+          merged.push(
+            new HumanMessage({
+              content: [
+                {
+                  type: 'tool_result',
+                  content: message.content,
+                  tool_use_id: (message as ToolMessage).tool_call_id,
+                },
+              ],
+            })
+          );
+        }
+      } else {
+        merged.push(
+          new HumanMessage({
+            content: [
+              {
+                type: 'tool_result',
+                content: _formatContent(message.content),
+                tool_use_id: (message as ToolMessage).tool_call_id,
+              },
+            ],
+          })
+        );
+      }
+    } else {
+      const previousMessage = merged[merged.length - 1] as BaseMessage | undefined;
+      if (
+        previousMessage &&
+        previousMessage._getType() === 'human' &&
+        message._getType() === 'human'
+      ) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        let combinedContent: Record<string, any>[];
+        if (typeof previousMessage.content === 'string') {
+          combinedContent = [{ type: 'text', text: previousMessage.content }];
+        } else {
+          combinedContent = previousMessage.content;
+        }
+        if (typeof message.content === 'string') {
+          combinedContent.push({ type: 'text', text: message.content });
+        } else {
+          combinedContent = combinedContent.concat(message.content);
+        }
+        previousMessage.content = combinedContent;
+      } else {
+        merged.push(message);
+      }
+    }
+  }
+  return merged;
+}
+
+export function _convertLangChainToolCallToAnthropic(
+  toolCall: ToolCall
+): AnthropicToolResponse {
+  if (toolCall.id === undefined) {
+    throw new Error('Anthropic requires all tool calls to have an "id".');
+  }
+  return {
+    type: 'tool_use',
+    id: toolCall.id,
+    name: toolCall.name,
+    input: toolCall.args,
+  };
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function _formatContent(content: MessageContent): string | Record<string, any>[] {
+  const toolTypes = ['tool_use', 'tool_result', 'input_json_delta'];
+  const textTypes = ['text', 'text_delta'];
+
+  if (typeof content === 'string') {
+    return content;
+  } else {
+    const contentBlocks = content.map((contentPart) => {
+      const cacheControl =
+        'cache_control' in contentPart ? contentPart.cache_control : undefined;
+
+      if (contentPart.type === 'image_url') {
+        let source;
+        if (typeof contentPart.image_url === 'string') {
+          source = _formatImage(contentPart.image_url);
+        } else {
+          source = _formatImage(contentPart.image_url.url);
+        }
+        return {
+          type: 'image' as const, // Explicitly setting the type as "image"
+          source,
+          ...(cacheControl ? { cache_control: cacheControl } : {}),
+        };
+      } else if (
+        textTypes.find((t) => t === contentPart.type) &&
+        'text' in contentPart
+      ) {
+        // Assuming contentPart is of type MessageContentText here
+        return {
+          type: 'text' as const, // Explicitly setting the type as "text"
+          text: contentPart.text,
+          ...(cacheControl ? { cache_control: cacheControl } : {}),
+        };
+      } else if (toolTypes.find((t) => t === contentPart.type)) {
+        const contentPartCopy = { ...contentPart };
+        if ('index' in contentPartCopy) {
+          // Anthropic does not support passing the index field here, so we remove it.
+          delete contentPartCopy.index;
+        }
+
+        if (contentPartCopy.type === 'input_json_delta') {
+          // `input_json_delta` type only represents yielding partial tool inputs
+          // and is not a valid type for Anthropic messages.
+          contentPartCopy.type = 'tool_use';
+        }
+
+        if ('input' in contentPartCopy) {
+          // Anthropic tool use inputs should be valid objects, when applicable.
+          try {
+            contentPartCopy.input = JSON.parse(contentPartCopy.input);
+          } catch {
+            // no-op
+          }
+        }
+
+        // TODO: Fix when SDK types are fixed
+        return {
+          ...contentPartCopy,
+          ...(cacheControl ? { cache_control: cacheControl } : {}),
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        } as any;
+      } else {
+        throw new Error('Unsupported message content format');
+      }
+    });
+    return contentBlocks;
+  }
+}
+
+/**
+ * Formats messages as a prompt for the model.
+ * Used in LangSmith, export is important here.
+ * @param messages The base messages to format as a prompt.
+ * @returns The formatted prompt.
+ */
+export function _convertMessagesToAnthropicPayload(
+  messages: BaseMessage[]
+): AnthropicMessageCreateParams {
+  const mergedMessages = _mergeMessages(messages);
+  let system;
+  if (mergedMessages.length > 0 && mergedMessages[0]._getType() === 'system') {
+    system = messages[0].content;
+  }
+  const conversationMessages =
+    system !== undefined ? mergedMessages.slice(1) : mergedMessages;
+  const formattedMessages = conversationMessages.map((message) => {
+    let role;
+    if (message._getType() === 'human') {
+      role = 'user' as const;
+    } else if (message._getType() === 'ai') {
+      role = 'assistant' as const;
+    } else if (message._getType() === 'tool') {
+      role = 'user' as const;
+    } else if (message._getType() === 'system') {
+      throw new Error(
+        'System messages are only permitted as the first passed message.'
+      );
+    } else {
+      throw new Error(`Message type "${message._getType()}" is not supported.`);
+    }
+    if (isAIMessage(message) && !!message.tool_calls?.length) {
+      if (typeof message.content === 'string') {
+        if (message.content === '') {
+          return {
+            role,
+            content: message.tool_calls.map(
+              _convertLangChainToolCallToAnthropic
+            ),
+          };
+        } else {
+          return {
+            role,
+            content: [
+              { type: 'text', text: message.content },
+              ...message.tool_calls.map(_convertLangChainToolCallToAnthropic),
+            ],
+          };
+        }
+      } else {
+        const { content } = message;
+        const hasMismatchedToolCalls = !message.tool_calls.every((toolCall) =>
+          content.find(
+            (contentPart) =>
+              (contentPart.type === 'tool_use' ||
+                contentPart.type === 'input_json_delta') &&
+              contentPart.id === toolCall.id
+          )
+        );
+        if (hasMismatchedToolCalls) {
+          console.warn(
+            'The "tool_calls" field on a message is only respected if content is a string.'
+          );
+        }
+        return {
+          role,
+          content: _formatContent(message.content),
+        };
+      }
+    } else {
+      return {
+        role,
+        content: _formatContent(message.content),
+      };
+    }
+  });
+  return {
+    messages: formattedMessages,
+    system,
+  } as AnthropicMessageCreateParams;
+}

package/src/llm/anthropic/utils/message_outputs.ts

@@ -0,0 +1,217 @@
+/**
+ * This util file contains functions for converting Anthropic messages to LangChain messages.
+ */
+import Anthropic from '@anthropic-ai/sdk';
+import {
+  AIMessage,
+  UsageMetadata,
+  AIMessageChunk,
+} from '@langchain/core/messages';
+import { ToolCall } from '@langchain/core/messages/tool';
+import { ChatGeneration } from '@langchain/core/outputs';
+import { AnthropicMessageResponse } from '../types.js';
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function extractToolCalls(content: Record<string, any>[]): ToolCall[] {
+  const toolCalls: ToolCall[] = [];
+  for (const block of content) {
+    if (block.type === 'tool_use') {
+      toolCalls.push({
+        name: block.name,
+        args: block.input,
+        id: block.id,
+        type: 'tool_call',
+      });
+    }
+  }
+  return toolCalls;
+}
+
+export function _makeMessageChunkFromAnthropicEvent(
+  data: Anthropic.Messages.RawMessageStreamEvent,
+  fields: {
+    streamUsage: boolean;
+    coerceContentToString: boolean;
+  }
+): {
+  chunk: AIMessageChunk;
+} | null {
+  if (data.type === 'message_start') {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    const { content, usage, ...additionalKwargs } = data.message;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const filteredAdditionalKwargs: Record<string, any> = {};
+    for (const [key, value] of Object.entries(additionalKwargs)) {
+      if (value !== undefined && value !== null) {
+        filteredAdditionalKwargs[key] = value;
+      }
+    }
+    const usageMetadata: UsageMetadata = {
+      input_tokens: usage.input_tokens,
+      output_tokens: usage.output_tokens,
+      total_tokens: usage.input_tokens + usage.output_tokens,
+    };
+    return {
+      chunk: new AIMessageChunk({
+        content: fields.coerceContentToString ? '' : [],
+        additional_kwargs: filteredAdditionalKwargs,
+        usage_metadata: fields.streamUsage ? usageMetadata : undefined,
+        id: data.message.id,
+      }),
+    };
+  } else if (data.type === 'message_delta') {
+    const usageMetadata: UsageMetadata = {
+      input_tokens: 0,
+      output_tokens: data.usage.output_tokens,
+      total_tokens: data.usage.output_tokens,
+    };
+    return {
+      chunk: new AIMessageChunk({
+        content: fields.coerceContentToString ? '' : [],
+        additional_kwargs: { ...data.delta },
+        usage_metadata: fields.streamUsage ? usageMetadata : undefined,
+      }),
+    };
+  } else if (
+    data.type === 'content_block_start' &&
+    data.content_block.type === 'tool_use'
+  ) {
+    const toolCallContentBlock =
+      data.content_block as Anthropic.Messages.ToolUseBlock;
+    return {
+      chunk: new AIMessageChunk({
+        content: fields.coerceContentToString
+          ? ''
+          : [
+            {
+              index: data.index,
+              ...data.content_block,
+              input: '',
+            },
+          ],
+        additional_kwargs: {},
+        tool_call_chunks: [
+          {
+            id: toolCallContentBlock.id,
+            index: data.index,
+            name: toolCallContentBlock.name,
+            args: '',
+          },
+        ],
+      }),
+    };
+  } else if (
+    data.type === 'content_block_delta' &&
+    data.delta.type === 'text_delta'
+  ) {
+    const content = data.delta.text;
+    if (content !== undefined) {
+      return {
+        chunk: new AIMessageChunk({
+          content: fields.coerceContentToString
+            ? content
+            : [
+              {
+                index: data.index,
+                ...data.delta,
+              },
+            ],
+          additional_kwargs: {},
+        }),
+      };
+    }
+  } else if (
+    data.type === 'content_block_delta' &&
+    data.delta.type === 'input_json_delta'
+  ) {
+    return {
+      chunk: new AIMessageChunk({
+        content: fields.coerceContentToString
+          ? ''
+          : [
+            {
+              index: data.index,
+              input: data.delta.partial_json,
+              type: data.delta.type,
+            },
+          ],
+        additional_kwargs: {},
+        tool_call_chunks: [
+          {
+            index: data.index,
+            args: data.delta.partial_json,
+          },
+        ],
+      }),
+    };
+  } else if (
+    data.type === 'content_block_start' &&
+    data.content_block.type === 'text'
+  ) {
+    const content = data.content_block.text;
+    if (content !== undefined) {
+      return {
+        chunk: new AIMessageChunk({
+          content: fields.coerceContentToString
+            ? content
+            : [
+              {
+                index: data.index,
+                ...data.content_block,
+              },
+            ],
+          additional_kwargs: {},
+        }),
+      };
+    }
+  }
+
+  return null;
+}
+
+export function anthropicResponseToChatMessages(
+  messages: AnthropicMessageResponse[],
+  additionalKwargs: Record<string, unknown>
+): ChatGeneration[] {
+  const usage: Record<string, number> | null | undefined =
+    additionalKwargs.usage as Record<string, number> | null | undefined;
+  const usageMetadata =
+    usage != null
+      ? {
+        input_tokens: usage.input_tokens ?? 0,
+        output_tokens: usage.output_tokens ?? 0,
+        total_tokens: (usage.input_tokens ?? 0) + (usage.output_tokens ?? 0),
+      }
+      : undefined;
+  if (messages.length === 1 && messages[0].type === 'text') {
+    return [
+      {
+        text: messages[0].text,
+        message: new AIMessage({
+          content: messages[0].text,
+          additional_kwargs: additionalKwargs,
+          usage_metadata: usageMetadata,
+          response_metadata: additionalKwargs,
+          id: additionalKwargs.id as string,
+        }),
+      },
+    ];
+  } else {
+    const toolCalls = extractToolCalls(messages);
+    const generations: ChatGeneration[] = [
+      {
+        text: '',
+        message: new AIMessage({
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          content: messages as any,
+          additional_kwargs: additionalKwargs,
+          tool_calls: toolCalls,
+          usage_metadata: usageMetadata,
+          response_metadata: additionalKwargs,
+          id: additionalKwargs.id as string,
+        }),
+      },
+    ];
+    return generations;
+  }
+}

package/src/llm/providers.ts

@@ -2,12 +2,13 @@
 import { ChatOpenAI } from '@langchain/openai';
 import { ChatOllama } from '@langchain/ollama';
 import { ChatBedrockConverse } from '@langchain/aws';
-import { ChatAnthropic } from '@langchain/anthropic';
+// import { ChatAnthropic } from '@langchain/anthropic';
 import { ChatMistralAI } from '@langchain/mistralai';
 import { ChatVertexAI } from '@langchain/google-vertexai';
 import { BedrockChat } from '@langchain/community/chat_models/bedrock/web';
 import type { ChatModelConstructorMap, ProviderOptionsMap, ChatModelMap } from '@/types';
 import { Providers } from '@/common';
+import { CustomAnthropic } from '@/llm/anthropic/llm';
 
 export const llmProviders: Partial<ChatModelConstructorMap> = {
   [Providers.OPENAI]: ChatOpenAI,
@@ -16,7 +17,8 @@ export const llmProviders: Partial<ChatModelConstructorMap> = {
   [Providers.BEDROCK_LEGACY]: BedrockChat,
   [Providers.MISTRALAI]: ChatMistralAI,
   [Providers.BEDROCK]: ChatBedrockConverse,
-  [Providers.ANTHROPIC]: ChatAnthropic,
+  [Providers.ANTHROPIC]: CustomAnthropic,
+  // [Providers.ANTHROPIC]: CustomAnthropic,
 };
 
 export const manualToolStreamProviders = new Set<Providers | string>([Providers.ANTHROPIC, Providers.BEDROCK, Providers.OLLAMA]);

package/src/llm/text.ts

@@ -0,0 +1,90 @@
+/* eslint-disable no-console */
+import { Readable } from 'stream';
+import type { ReadableOptions } from 'stream';
+export interface TextStreamOptions extends ReadableOptions {
+  minChunkSize?: number;
+  maxChunkSize?: number;
+  delay?: number;
+}
+
+export type ProgressCallback = (chunk: string) => void;
+export type PostChunkCallback = (chunk: string) => void;
+
+export class TextStream extends Readable {
+  private text: string;
+  private currentIndex: number;
+  private minChunkSize: number;
+  private maxChunkSize: number;
+  private delay: number;
+
+  constructor(text: string, options: TextStreamOptions = {}) {
+    super(options);
+    this.text = text;
+    this.currentIndex = 0;
+    this.minChunkSize = options.minChunkSize ?? 2;
+    this.maxChunkSize = options.maxChunkSize ?? 4;
+    this.delay = options.delay ?? 20; // Time in milliseconds
+  }
+
+  _read(): void {
+    const { delay, minChunkSize, maxChunkSize } = this;
+
+    if (this.currentIndex < this.text.length) {
+      setTimeout(() => {
+        const remainingChars = this.text.length - this.currentIndex;
+        const chunkSize = Math.min(this.randomInt(minChunkSize, maxChunkSize + 1), remainingChars);
+
+        const chunk = this.text.slice(this.currentIndex, this.currentIndex + chunkSize);
+        this.push(chunk);
+        this.currentIndex += chunkSize;
+      }, delay);
+    } else {
+      this.push(null); // signal end of data
+    }
+  }
+
+  private randomInt(min: number, max: number): number {
+    return Math.floor(Math.random() * (max - min)) + min;
+  }
+
+  async processTextStream(progressCallback: ProgressCallback): Promise<void> {
+    const streamPromise = new Promise<void>((resolve, reject) => {
+      this.on('data', (chunk) => {
+        progressCallback(chunk.toString());
+      });
+
+      this.on('end', () => {
+        resolve();
+      });
+
+      this.on('error', (err) => {
+        reject(err);
+      });
+    });
+
+    try {
+      await streamPromise;
+    } catch (err) {
+      console.error('[processTextStream] Error in text stream:', err);
+      // Handle the error appropriately, e.g., return an error message or throw an error
+    }
+  }
+
+  async *generateText(progressCallback?: ProgressCallback): AsyncGenerator<string, void, unknown> {
+    const { delay, minChunkSize, maxChunkSize } = this;
+
+    while (this.currentIndex < this.text.length) {
+      await new Promise(resolve => setTimeout(resolve, delay));
+
+      const remainingChars = this.text.length - this.currentIndex;
+      const chunkSize = Math.min(this.randomInt(minChunkSize, maxChunkSize + 1), remainingChars);
+
+      const chunk = this.text.slice(this.currentIndex, this.currentIndex + chunkSize);
+
+      progressCallback?.(chunk);
+
+      yield chunk;
+      this.currentIndex += chunkSize;
+    }
+  }
+}

package/src/scripts/code_exec.ts

@@ -64,7 +64,7 @@ async function testCodeExecution(): Promise<void> {
     graphConfig: {
       type: 'standard',
       llmConfig,
-      tools: [new TavilySearchResults(), createCodeExecutionTool({ apiKey: 'test' })],
+      tools: [new TavilySearchResults(), createCodeExecutionTool()],
       instructions: 'You are a friendly AI assistant with coding capabilities. Always address the user by their name.',
       additional_instructions: `The user's name is ${userName} and they are located in ${location}.`,
     },

package/src/scripts/code_exec_simple.ts

@@ -64,7 +64,7 @@ async function testCodeExecution(): Promise<void> {
     graphConfig: {
       type: 'standard',
       llmConfig,
-      tools: [new TavilySearchResults(), createCodeExecutionTool({ apiKey: 'test' })],
+      tools: [new TavilySearchResults(), createCodeExecutionTool()],
       instructions: 'You are a friendly AI assistant with coding capabilities. Always address the user by their name.',
       additional_instructions: `The user's name is ${userName} and they are located in ${location}.`,
     },