@librechat/agents 1.7.2 → 1.7.5

package/src/llm/providers.ts

@@ -1,27 +1,34 @@
 // src/llm/providers.ts
 import { ChatOpenAI } from '@langchain/openai';
+import { ChatOllama } from '@langchain/ollama';
 import { ChatBedrockConverse } from '@langchain/aws';
 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 * as t from '@/types';
+import type { ChatModelConstructorMap, ProviderOptionsMap, ChatModelMap } from '@/types';
 import { Providers } from '@/common';
 
-export const llmProviders: Record<Providers, t.ChatModelConstructor> = {
+export const llmProviders: Partial<ChatModelConstructorMap> = {
   [Providers.OPENAI]: ChatOpenAI,
+  [Providers.OLLAMA]: ChatOllama,
   [Providers.VERTEXAI]: ChatVertexAI,
-  [Providers.BEDROCK_LEGACY]: BedrockChat as unknown as t.ChatModelConstructor,
+  [Providers.BEDROCK_LEGACY]: BedrockChat,
   [Providers.MISTRALAI]: ChatMistralAI,
-  [Providers.BEDROCK]: ChatBedrockConverse as unknown as t.ChatModelConstructor,
+  [Providers.BEDROCK]: ChatBedrockConverse,
   [Providers.ANTHROPIC]: ChatAnthropic,
 };
 
-export const getChatModelClass = (provider: Providers): t.ChatModelConstructor => {
+export const doubleCallProviders = new Set<Providers | string>([Providers.ANTHROPIC, Providers.BEDROCK]);
+export const manualToolStreamProviders = new Set<Providers | string>([Providers.ANTHROPIC, Providers.BEDROCK, Providers.OLLAMA]);
+
+export const getChatModelClass = <P extends Providers>(
+  provider: P
+): new (config: ProviderOptionsMap[P]) => ChatModelMap[P] => {
   const ChatModelClass = llmProviders[provider];
   if (!ChatModelClass) {
     throw new Error(`Unsupported LLM provider: ${provider}`);
   }
 
   return ChatModelClass;
-};
+};

package/src/run.ts

@@ -6,6 +6,7 @@ import type { RunnableConfig } from '@langchain/core/runnables';
 import type { ClientCallbacks, SystemCallbacks } from '@/graphs/Graph';
 import type * as t from '@/types';
 import { GraphEvents, Providers, Callback } from '@/common';
+import { doubleCallProviders } from '@/llm/providers';
 import { createTitleRunnable } from '@/utils/title';
 import { StandardGraph } from '@/graphs/Graph';
 import { HandlerRegistry } from '@/events';
@@ -54,7 +55,7 @@ export class Run<T extends t.BaseGraphState> {
   }
 
   private createStandardGraph(config: t.StandardGraphConfig): t.CompiledWorkflow<t.IState, Partial<t.IState>, string> {
-    const { llmConfig, instructions, additional_instructions, streamBuffer, tools = [] } = config;
+    const { llmConfig, instructions, additional_instructions, streamBuffer, toolEnd, tools = [] } = config;
     const { provider, ...clientOptions } = llmConfig;
 
     const standardGraph = new StandardGraph({
@@ -65,6 +66,7 @@ export class Run<T extends t.BaseGraphState> {
       clientOptions,
       additional_instructions,
       streamBuffer,
+      toolEnd,
     });
     this.Graph = standardGraph;
     return standardGraph.createWorkflow();
@@ -115,9 +117,8 @@ export class Run<T extends t.BaseGraphState> {
       const { data, name, metadata, ...info } = event;
 
       let eventName: t.EventName = info.event;
-      const isDoubleCallProvider = provider === Providers.ANTHROPIC || provider === Providers.BEDROCK;
-      if (hasTools && isDoubleCallProvider && eventName === GraphEvents.CHAT_MODEL_STREAM) {
-        /* Skipping CHAT_MODEL_STREAM event for Anthropic due to double-call edge case */
+      if (hasTools && doubleCallProviders.has(provider) && eventName === GraphEvents.CHAT_MODEL_STREAM) {
+        /* Skipping CHAT_MODEL_STREAM event due to double-call edge case */
         continue;
       }
 

package/src/scripts/args.ts

@@ -20,7 +20,7 @@ export async function getArgs(): Promise<{ userName: string; location: string; p
       alias: 'p',
       type: 'string',
       description: 'LLM provider',
-      choices: ['openAI', 'anthropic', 'mistralai', 'vertexai', 'bedrock'],
+      choices: ['openAI', 'anthropic', 'mistralai', 'vertexai', 'bedrock', 'ollama'],
       default: 'openAI'
     })
     .help()

package/src/scripts/memory.ts

@@ -48,8 +48,8 @@ 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.',
-      toolEnd: false,
+      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,
   });
@@ -65,7 +65,7 @@ async function testStandardStreaming(): Promise<void> {
 
   console.log('Test 1: Simple message test');
 
-  const userMessage = `hi my name is ${userName}`;
+  const userMessage = `hi`;
 
   conversationHistory.push(new HumanMessage(userMessage));
 

package/src/tools/ToolNode.ts

@@ -1,16 +1,14 @@
-import { END } from '@langchain/langgraph';
+import { END, MessagesAnnotation } from '@langchain/langgraph';
 import { ToolMessage, isBaseMessage } from '@langchain/core/messages';
 import type { RunnableConfig, RunnableToolLike } from '@langchain/core/runnables';
-import type { MessagesState } from '@langchain/langgraph/dist/graph/message';
 import type { BaseMessage, AIMessage } from '@langchain/core/messages';
 import type { StructuredToolInterface } from '@langchain/core/tools';
 import type * as t from '@/types';
 import{ RunnableCallable } from '@/utils';
 import { GraphNodeKeys } from '@/common';
 
-export class ToolNode<
-  T extends BaseMessage[] | MessagesState
-> extends RunnableCallable<T, T> {
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export class ToolNode<T = any> extends RunnableCallable<T, T> {
   tools: t.GenericTool[];
   private toolMap: Map<string, StructuredToolInterface | RunnableToolLike>;
   private loadRuntimeTools?: t.ToolRefGenerator;
@@ -31,10 +29,8 @@ export class ToolNode<
     this.loadRuntimeTools = loadRuntimeTools;
   }
 
-  private async run(
-    input: BaseMessage[] | MessagesState,
-    config: RunnableConfig
-  ): Promise<BaseMessage[] | MessagesState> {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  protected async run(input: any, config: RunnableConfig): Promise<T> {
     const message = Array.isArray(input)
       ? input[input.length - 1]
       : input.messages[input.messages.length - 1];
@@ -86,13 +82,13 @@ export class ToolNode<
       }) ?? []
     );
 
-    return Array.isArray(input) ? outputs : { messages: outputs };
+    return (Array.isArray(input) ? outputs : { messages: outputs }) as T;
   }
 }
 
 export function toolsCondition(
-  state: BaseMessage[] | MessagesState
-): GraphNodeKeys.TOOLS | typeof END {
+  state: BaseMessage[] | typeof MessagesAnnotation.State
+): 'tools' | typeof END {
   const message = Array.isArray(state)
     ? state[state.length - 1]
     : state.messages[state.messages.length - 1];

package/src/types/llm.ts

@@ -1,38 +1,67 @@
 // src/types/llm.ts
 import { ChatOpenAI } from '@langchain/openai';
+import { ChatOllama } from '@langchain/ollama';
 import { ChatAnthropic } from '@langchain/anthropic';
 import { ChatMistralAI } from '@langchain/mistralai';
 import { ChatBedrockConverse } from '@langchain/aws';
 import { ChatVertexAI } from '@langchain/google-vertexai';
-import { BedrockChat, BedrockChatFields } from '@langchain/community/chat_models/bedrock/web';
+import { BedrockChat } from '@langchain/community/chat_models/bedrock/web';
+import type { Runnable } from '@langchain/core/runnables';
+import type { StructuredTool } from '@langchain/core/tools';
+import type { BindToolsInput } from '@langchain/core/language_models/chat_models';
+import type { BedrockChatFields } from '@langchain/community/chat_models/bedrock/web';
+import type { ChatOpenAIFields } from '@langchain/openai';
+import type { OpenAI as OpenAIClient } from 'openai';
 import type { ChatVertexAIInput } from '@langchain/google-vertexai';
 import type { ChatBedrockConverseInput } from '@langchain/aws';
 import type { ChatMistralAIInput } from '@langchain/mistralai';
 import type { AnthropicInput } from '@langchain/anthropic';
-import type { OpenAIInput } from '@langchain/openai';
+import type { ChatOllamaInput } from '@langchain/ollama';
 import { Providers } from '@/common';
 
-export type OpenAIClientOptions = Partial<OpenAIInput>;
-export type AnthropicClientOptions = Partial<AnthropicInput>;
-export type MistralAIClientOptions = Partial<ChatMistralAIInput>;
-export type VertexAIClientOptions = Partial<ChatVertexAIInput>;
-export type BedrockClientOptions = Partial<BedrockChatFields>;
-export type BedrockConverseClientOptions = Partial<ChatBedrockConverseInput>;
+export type ChatOpenAIToolType = BindToolsInput | OpenAIClient.ChatCompletionTool;
+export type CommonToolType = StructuredTool | ChatOpenAIToolType;
 
-export type ClientOptions =
-  | OpenAIClientOptions
-  | AnthropicClientOptions
-  | MistralAIClientOptions
-  | VertexAIClientOptions
-  | BedrockClientOptions
-  | BedrockConverseClientOptions;
+export type OpenAIClientOptions = ChatOpenAIFields;
+export type OllamaClientOptions = ChatOllamaInput;
+export type AnthropicClientOptions = AnthropicInput;
+export type MistralAIClientOptions = ChatMistralAIInput;
+export type VertexAIClientOptions = ChatVertexAIInput;
+export type BedrockClientOptions = BedrockChatFields;
+export type BedrockConverseClientOptions = ChatBedrockConverseInput;
 
-export type ChatModel = typeof ChatAnthropic | typeof ChatOpenAI | typeof ChatMistralAI | typeof ChatVertexAI | typeof BedrockChat | typeof ChatBedrockConverse;
+export type ClientOptions = OpenAIClientOptions | OllamaClientOptions | AnthropicClientOptions | MistralAIClientOptions | VertexAIClientOptions | BedrockClientOptions | BedrockConverseClientOptions;
 
 export type LLMConfig = {
   provider: Providers;
 } & ClientOptions;
 
-export type ChatModelInstance = ChatOpenAI | ChatAnthropic | ChatMistralAI | ChatVertexAI | BedrockChat | ChatBedrockConverse;
+export type ProviderOptionsMap = {
+  [Providers.OPENAI]: OpenAIClientOptions;
+  [Providers.OLLAMA]: OllamaClientOptions;
+  [Providers.ANTHROPIC]: AnthropicClientOptions;
+  [Providers.MISTRALAI]: MistralAIClientOptions;
+  [Providers.VERTEXAI]: VertexAIClientOptions;
+  [Providers.BEDROCK_LEGACY]: BedrockClientOptions;
+  [Providers.BEDROCK]: BedrockConverseClientOptions;
+};
 
-export type ChatModelConstructor = new (config: ClientOptions) => ChatModelInstance;
+export type ChatModelMap = {
+  [Providers.OPENAI]: ChatOpenAI;
+  [Providers.OLLAMA]: ChatOllama;
+  [Providers.ANTHROPIC]: ChatAnthropic;
+  [Providers.MISTRALAI]: ChatMistralAI;
+  [Providers.VERTEXAI]: ChatVertexAI;
+  [Providers.BEDROCK_LEGACY]: BedrockChat;
+  [Providers.BEDROCK]: ChatBedrockConverse;
+};
+
+export type ChatModelConstructorMap = {
+  [P in Providers]: new (config: ProviderOptionsMap[P]) => ChatModelMap[P];
+};
+
+export type ChatModelInstance = ChatModelMap[Providers];
+
+export type ModelWithTools = ChatModelInstance & {
+  bindTools(tools: CommonToolType[]): Runnable;
+}

package/src/utils/llmConfig.ts

@@ -10,6 +10,13 @@ const llmConfigs: Record<string, t.LLMConfig | undefined> = {
     streaming: true,
     streamUsage: true,
   },
+  [Providers.OLLAMA]: {
+    provider: Providers.OLLAMA,
+    model: 'llama3.2',
+    streaming: true,
+    streamUsage: true,
+    baseUrl: 'http://host.docker.internal:11434'
+  },
   [Providers.ANTHROPIC]: {
     provider: Providers.ANTHROPIC,
     model: 'claude-3-5-sonnet-20240620',
@@ -43,7 +50,7 @@ const llmConfigs: Record<string, t.LLMConfig | undefined> = {
 
 export function getLLMConfig(provider: string): t.LLMConfig {
   const config = llmConfigs[provider];
-  if (!config) {
+  if (config === undefined) {
     throw new Error(`Unsupported provider: ${provider}`);
   }
   return config;