@librechat/agents 2.4.321 → 3.0.0-rc1

package/src/types/tools.ts

@@ -1,6 +1,6 @@
 // src/types/tools.ts
-import type { RunnableToolLike } from '@langchain/core/runnables';
 import type { StructuredToolInterface } from '@langchain/core/tools';
+import type { RunnableToolLike } from '@langchain/core/runnables';
 import type { ToolCall } from '@langchain/core/messages/tool';
 import type { ToolErrorData } from './stream';
 import { EnvVar } from '@/common';
@@ -13,9 +13,10 @@ export type CustomToolCall = {
   id?: string;
   type?: 'tool_call';
   output?: string;
-}
+};
 
 export type GenericTool = StructuredToolInterface | RunnableToolLike;
+
 export type ToolMap = Map<string, GenericTool>;
 export type ToolRefs = {
   tools: GenericTool[];
@@ -30,7 +31,10 @@ export type ToolNodeOptions = {
   handleToolErrors?: boolean;
   loadRuntimeTools?: ToolRefGenerator;
   toolCallStepIds?: Map<string, string>;
-  errorHandler?: (data: ToolErrorData, metadata?: Record<string, unknown>) => void
+  errorHandler?: (
+    data: ToolErrorData,
+    metadata?: Record<string, unknown>
+  ) => void;
 };
 
 export type ToolNodeConstructorParams = ToolRefs & ToolNodeOptions;
@@ -50,13 +54,15 @@ export type CodeEnvFile = {
   session_id: string;
 };
 
-export type CodeExecutionToolParams = undefined | {
-  session_id?: string;
-  user_id?: string;
-  apiKey?: string;
-  files?: CodeEnvFile[];
-  [EnvVar.CODE_API_KEY]?: string;
-}
+export type CodeExecutionToolParams =
+  | undefined
+  | {
+      session_id?: string;
+      user_id?: string;
+      apiKey?: string;
+      files?: CodeEnvFile[];
+      [EnvVar.CODE_API_KEY]?: string;
+    };
 
 export type FileRef = {
   id: string;

package/src/utils/events.ts

@@ -0,0 +1,32 @@
+/* eslint-disable no-console */
+// src/utils/events.ts
+import { dispatchCustomEvent } from '@langchain/core/callbacks/dispatch';
+import type { RunnableConfig } from '@langchain/core/runnables';
+
+/**
+ * Safely dispatches a custom event and properly awaits it to avoid
+ * race conditions where events are dispatched after run cleanup.
+ */
+export async function safeDispatchCustomEvent(
+  event: string,
+  payload: unknown,
+  config?: RunnableConfig
+): Promise<void> {
+  try {
+    await dispatchCustomEvent(event, payload, config);
+  } catch (e) {
+    // Check if this is the known EventStreamCallbackHandler error
+    if (
+      e instanceof Error &&
+      e.message.includes('handleCustomEvent: Run ID') &&
+      e.message.includes('not found in run map')
+    ) {
+      // Suppress this specific error - it's expected during parallel execution
+      // when EventStreamCallbackHandler loses track of run IDs
+      // console.debug('Suppressed error dispatching custom event:', e);
+      return;
+    }
+    // Log other errors
+    console.error('Error dispatching custom event:', e);
+  }
+}

package/src/utils/llmConfig.ts

@@ -6,8 +6,8 @@ import type * as t from '@/types';
 export const llmConfigs: Record<string, t.LLMConfig | undefined> = {
   [Providers.OPENAI]: {
     provider: Providers.OPENAI,
-    model: 'gpt-4o-mini',
-    temperature: 0.7,
+    model: 'gpt-4.1',
+    // temperature: 0.7,
     streaming: true,
     streamUsage: true,
     // disableStreaming: true,
@@ -32,7 +32,7 @@ export const llmConfigs: Record<string, t.LLMConfig | undefined> = {
     provider: Providers.OPENROUTER,
     streaming: true,
     streamUsage: true,
-    model: 'deepseek/deepseek-r1',
+    model: 'openai/gpt-4.1',
     openAIApiKey: process.env.OPENROUTER_API_KEY,
     configuration: {
       baseURL: process.env.OPENROUTER_BASE_URL,
@@ -56,10 +56,19 @@ export const llmConfigs: Record<string, t.LLMConfig | undefined> = {
   },
   [Providers.OLLAMA]: {
     provider: Providers.OLLAMA,
-    model: 'llama3.2',
+    model: 'gpt-oss:20b',
     streaming: true,
     streamUsage: true,
-    baseUrl: 'http://host.docker.internal:11434',
+    baseUrl: 'http://localhost:11434',
+  },
+  lmstudio: {
+    provider: Providers.OPENAI,
+    model: 'gpt-oss-20b',
+    streaming: true,
+    streamUsage: true,
+    configuration: {
+      baseURL: 'http://192.168.254.183:1233/v1',
+    },
   },
   [Providers.DEEPSEEK]: {
     provider: Providers.DEEPSEEK,
@@ -93,21 +102,24 @@ export const llmConfigs: Record<string, t.LLMConfig | undefined> = {
   },
   [Providers.VERTEXAI]: {
     provider: Providers.VERTEXAI,
-    modelName: 'gemini-2.0-flash-001',
+    model: 'gemini-2.5-flash',
     streaming: true,
     streamUsage: true,
     keyFile: process.env.VERTEXAI_KEY_FILE,
   } as t.VertexAIClientOptions & t.LLMConfig,
   [Providers.GOOGLE]: {
     provider: Providers.GOOGLE,
-    model: 'gemini-2.5-pro-exp-03-25',
+    model: 'gemini-2.5-flash',
     streaming: true,
     streamUsage: true,
   },
   [Providers.BEDROCK]: {
     provider: Providers.BEDROCK,
     // model: 'anthropic.claude-3-sonnet-20240229-v1:0',
-    model: 'us.anthropic.claude-3-5-sonnet-20241022-v2:0',
+    // model: 'us.anthropic.claude-3-5-sonnet-20241022-v2:0',
+    // model: 'us.amazon.nova-pro-v1:0',
+    model: 'us.anthropic.claude-sonnet-4-20250514-v1:0',
+    // additionalModelRequestFields: { thinking: { type: 'enabled', budget_tokens: 2000 } },
     region: process.env.BEDROCK_AWS_REGION,
     credentials: {
       accessKeyId: process.env.BEDROCK_AWS_ACCESS_KEY_ID!,

package/src/utils/title.ts

@@ -1,51 +1,125 @@
 import { z } from 'zod';
-import { ChatPromptTemplate } from '@langchain/core/prompts';
 import { RunnableLambda } from '@langchain/core/runnables';
-import type { Runnable } from '@langchain/core/runnables';
-import * as t from '@/types';
-
-const defaultTitlePrompt = `Write a concise title for this conversation in the detected language. Title in 5 Words or Less. No Punctuation or Quotation.
-{convo}`;
+import { ChatPromptTemplate } from '@langchain/core/prompts';
+import type { Runnable, RunnableConfig } from '@langchain/core/runnables';
+import type * as t from '@/types';
+import { ContentTypes } from '@/common';
 
-const languageInstructions = 'Detect the language used in the following text. Note: words may be misspelled or cut off; use context clues to identify the language:\n{text}';
+const defaultTitlePrompt = `Analyze this conversation and provide:
+1. The detected language of the conversation
+2. A concise title in the detected language (5 words or less, no punctuation or quotation)
 
-const languagePrompt = ChatPromptTemplate.fromTemplate(languageInstructions);
+{convo}`;
 
-const languageSchema = z.object({
-  language: z.string().describe('The detected language of the conversation')
+const titleSchema = z.object({
+  title: z
+    .string()
+    .describe(
+      'A concise title for the conversation in 5 words or less, without punctuation or quotation'
+    ),
 });
 
-const titleSchema = z.object({
-  title: z.string().describe('A concise title for the conversation in 5 words or less, without punctuation or quotation'),
+const combinedSchema = z.object({
+  language: z.string().describe('The detected language of the conversation'),
+  title: z
+    .string()
+    .describe(
+      'A concise title for the conversation in 5 words or less, without punctuation or quotation'
+    ),
 });
 
-export const createTitleRunnable = async (model: t.ChatModelInstance, _titlePrompt?: string): Promise<Runnable> => {
+export const createTitleRunnable = async (
+  model: t.ChatModelInstance,
+  _titlePrompt?: string
+): Promise<Runnable> => {
   // Disabled since this works fine
   // eslint-disable-next-line @typescript-eslint/ban-ts-comment
   /* @ts-ignore */
-  const languageLLM = model.withStructuredOutput(languageSchema);
+  const titleLLM = model.withStructuredOutput(titleSchema);
   // eslint-disable-next-line @typescript-eslint/ban-ts-comment
   /* @ts-ignore */
-  const titleLLM = model.withStructuredOutput(titleSchema);
+  const combinedLLM = model.withStructuredOutput(combinedSchema);
 
-  const languageChain = languagePrompt.pipe(languageLLM);
-
-  const titlePrompt = ChatPromptTemplate.fromTemplate(_titlePrompt ?? defaultTitlePrompt);
+  const titlePrompt = ChatPromptTemplate.fromTemplate(
+    _titlePrompt ?? defaultTitlePrompt
+  );
 
   return new RunnableLambda({
-    func: async (input: { convo: string, inputText: string, skipLanguage: boolean }): Promise<{ language: string; title: string } | { title: string }> => {
+    func: async (
+      input: {
+        convo: string;
+        inputText: string;
+        skipLanguage: boolean;
+      },
+      config?: Partial<RunnableConfig>
+    ): Promise<{ language: string; title: string } | { title: string }> => {
       if (input.skipLanguage) {
-        return await titlePrompt.pipe(titleLLM).invoke({
-          convo: input.convo
-        }) as { title: string };
+        return (await titlePrompt.pipe(titleLLM).invoke(
+          {
+            convo: input.convo,
+          },
+          config
+        )) as { title: string };
+      }
+
+      const result = (await titlePrompt.pipe(combinedLLM).invoke(
+        {
+          convo: input.convo,
+        },
+        config
+      )) as { language: string; title: string } | undefined;
+
+      return {
+        language: result?.language ?? 'English',
+        title: result?.title ?? '',
+      };
+    },
+  });
+};
+
+const defaultCompletionPrompt = `Provide a concise, 5-word-or-less title for the conversation, using title case conventions. Only return the title itself.
+
+Conversation:
+{convo}`;
+
+export const createCompletionTitleRunnable = async (
+  model: t.ChatModelInstance,
+  titlePrompt?: string
+): Promise<Runnable> => {
+  const completionPrompt = ChatPromptTemplate.fromTemplate(
+    titlePrompt ?? defaultCompletionPrompt
+  );
+
+  return new RunnableLambda({
+    func: async (
+      input: {
+        convo: string;
+        inputText: string;
+        skipLanguage: boolean;
+      },
+      config?: Partial<RunnableConfig>
+    ): Promise<{ title: string }> => {
+      const promptOutput = await completionPrompt.invoke({
+        convo: input.convo,
+      });
+
+      const response = await model.invoke(promptOutput, config);
+      let content = '';
+      if (typeof response.content === 'string') {
+        content = response.content;
+      } else if (Array.isArray(response.content)) {
+        content = response.content
+          .filter(
+            (part): part is { type: ContentTypes.TEXT; text: string } =>
+              part.type === ContentTypes.TEXT
+          )
+          .map((part) => part.text)
+          .join('');
       }
-      const languageResult = await languageChain.invoke({ text: input.inputText }) as { language: string } | undefined;
-      const language = languageResult?.language ?? 'English';
-      const titleResult = await titlePrompt.pipe(titleLLM).invoke({
-        language,
-        convo: input.convo
-      }) as { title: string } | undefined;
-      return { language, title: titleResult?.title ?? '' };
+      const title = content.trim();
+      return {
+        title,
+      };
     },
   });
-};
+};

package/src/utils/tokens.ts

@@ -2,7 +2,10 @@ import { Tiktoken } from 'js-tiktoken/lite';
 import type { BaseMessage } from '@langchain/core/messages';
 import { ContentTypes } from '@/common/enum';
 
-export function getTokenCountForMessage(message: BaseMessage, getTokenCount: (text: string) => number): number {
+export function getTokenCountForMessage(
+  message: BaseMessage,
+  getTokenCount: (text: string) => number
+): number {
   const tokensPerMessage = 3;
 
   const processValue = (value: unknown): void => {
@@ -57,14 +60,70 @@ export function getTokenCountForMessage(message: BaseMessage, getTokenCount: (te
   return numTokens;
 }
 
-export const createTokenCounter = async () => {
-  const res = await fetch('https://tiktoken.pages.dev/js/o200k_base.json');
-  const o200k_base = await res.json();
+let encoderPromise: Promise<Tiktoken> | undefined;
+let tokenCounterPromise: Promise<(message: BaseMessage) => number> | undefined;
 
-  const countTokens = (text: string): number => {
-    const enc = new Tiktoken(o200k_base);
-    return enc.encode(text).length;
-  };
+async function getSharedEncoder(): Promise<Tiktoken> {
+  if (encoderPromise) {
+    return encoderPromise;
+  }
+  encoderPromise = (async (): Promise<Tiktoken> => {
+    const res = await fetch('https://tiktoken.pages.dev/js/o200k_base.json');
+    const o200k_base = await res.json();
+    return new Tiktoken(o200k_base);
+  })();
+  return encoderPromise;
+}
+
+/**
+ * Creates a singleton token counter function that reuses the same encoder instance.
+ * This avoids creating multiple function closures and prevents potential memory issues.
+ */
+export const createTokenCounter = async (): Promise<
+  (message: BaseMessage) => number
+> => {
+  if (tokenCounterPromise) {
+    return tokenCounterPromise;
+  }
+
+  tokenCounterPromise = (async (): Promise<
+    (message: BaseMessage) => number
+  > => {
+    const enc = await getSharedEncoder();
+    const countTokens = (text: string): number => enc.encode(text).length;
+    return (message: BaseMessage): number =>
+      getTokenCountForMessage(message, countTokens);
+  })();
+
+  return tokenCounterPromise;
+};
+
+/**
+ * Utility to manage the token encoder lifecycle explicitly.
+ * Useful for applications that need fine-grained control over resource management.
+ */
+export const TokenEncoderManager = {
+  /**
+   * Pre-initializes the encoder. This can be called during app startup
+   * to avoid lazy loading delays later.
+   */
+  async initialize(): Promise<void> {
+    await getSharedEncoder();
+  },
+
+  /**
+   * Clears the cached encoder and token counter.
+   * Useful for testing or when you need to force a fresh reload.
+   */
+  reset(): void {
+    encoderPromise = undefined;
+    tokenCounterPromise = undefined;
+  },
 
-  return (message: BaseMessage): number => getTokenCountForMessage(message, countTokens);
-};
+  /**
+   * Checks if the encoder has been initialized.
+   */
+  isInitialized(): boolean {
+    return encoderPromise !== undefined;
+  },
+};