@librechat/agents 3.0.0-rc9 → 3.0.0

package/src/utils/handlers.ts

@@ -0,0 +1,107 @@
+/**
+ * Multi-Agent Handler Utilities
+ *
+ * Provides a simple helper to create handlers with content aggregation for multi-agent scripts.
+ *
+ * Usage:
+ * ```typescript
+ * const { contentParts, aggregateContent, handlers } = createHandlers();
+ *
+ * // With callbacks
+ * const { contentParts, aggregateContent, handlers } = createHandlers({
+ *   onRunStep: (event, data) => console.log('Step:', data),
+ *   onRunStepCompleted: (event, data) => console.log('Completed:', data)
+ * });
+ * ```
+ */
+
+import { GraphEvents } from '@/common';
+import { ChatModelStreamHandler, createContentAggregator } from '@/stream';
+import { ToolEndHandler, ModelEndHandler } from '@/events';
+import type * as t from '@/types';
+
+interface HandlerCallbacks {
+  onRunStep?: (event: GraphEvents.ON_RUN_STEP, data: t.StreamEventData) => void;
+  onRunStepCompleted?: (
+    event: GraphEvents.ON_RUN_STEP_COMPLETED,
+    data: t.StreamEventData
+  ) => void;
+  onRunStepDelta?: (
+    event: GraphEvents.ON_RUN_STEP_DELTA,
+    data: t.StreamEventData
+  ) => void;
+  onMessageDelta?: (
+    event: GraphEvents.ON_MESSAGE_DELTA,
+    data: t.StreamEventData
+  ) => void;
+}
+
+/**
+ * Creates handlers with content aggregation for multi-agent scripts
+ */
+export function createHandlers(callbacks?: HandlerCallbacks): {
+  contentParts: Array<t.MessageContentComplex | undefined>;
+  aggregateContent: ReturnType<
+    typeof createContentAggregator
+  >['aggregateContent'];
+  handlers: Record<string, t.EventHandler>;
+} {
+  // Set up content aggregator
+  const { contentParts, aggregateContent } = createContentAggregator();
+
+  // Create the handlers object
+  const handlers = {
+    [GraphEvents.TOOL_END]: new ToolEndHandler(),
+    [GraphEvents.CHAT_MODEL_END]: new ModelEndHandler(),
+    [GraphEvents.CHAT_MODEL_STREAM]: new ChatModelStreamHandler(),
+
+    [GraphEvents.ON_RUN_STEP]: {
+      handle: (
+        event: GraphEvents.ON_RUN_STEP,
+        data: t.StreamEventData
+      ): void => {
+        aggregateContent({ event, data: data as t.RunStep });
+        callbacks?.onRunStep?.(event, data);
+      },
+    },
+
+    [GraphEvents.ON_RUN_STEP_COMPLETED]: {
+      handle: (
+        event: GraphEvents.ON_RUN_STEP_COMPLETED,
+        data: t.StreamEventData
+      ): void => {
+        aggregateContent({
+          event,
+          data: data as unknown as { result: t.ToolEndEvent },
+        });
+        callbacks?.onRunStepCompleted?.(event, data);
+      },
+    },
+
+    [GraphEvents.ON_RUN_STEP_DELTA]: {
+      handle: (
+        event: GraphEvents.ON_RUN_STEP_DELTA,
+        data: t.StreamEventData
+      ): void => {
+        aggregateContent({ event, data: data as t.RunStepDeltaEvent });
+        callbacks?.onRunStepDelta?.(event, data);
+      },
+    },
+
+    [GraphEvents.ON_MESSAGE_DELTA]: {
+      handle: (
+        event: GraphEvents.ON_MESSAGE_DELTA,
+        data: t.StreamEventData
+      ): void => {
+        aggregateContent({ event, data: data as t.MessageDeltaEvent });
+        callbacks?.onMessageDelta?.(event, data);
+      },
+    },
+  };
+
+  return {
+    contentParts,
+    aggregateContent,
+    handlers,
+  };
+}

package/src/utils/index.ts

@@ -1,5 +1,6 @@
 export * from './graph';
 export * from './llm';
 export * from './misc';
+export * from './handlers';
 export * from './run';
-export * from './tokens';
+export * from './tokens';

package/src/utils/llmConfig.ts

@@ -12,6 +12,30 @@ export const llmConfigs: Record<string, t.LLMConfig | undefined> = {
     streamUsage: true,
     // disableStreaming: true,
   },
+  anthropicLITELLM: {
+    provider: Providers.OPENAI,
+    streaming: true,
+    streamUsage: false,
+    apiKey: 'sk-1234',
+    model: 'claude-sonnet-4',
+    maxTokens: 8192,
+    modelKwargs: {
+      metadata: {
+        user_id: 'some_user_id',
+      },
+      thinking: {
+        type: 'enabled',
+        budget_tokens: 2000,
+      },
+    },
+    configuration: {
+      baseURL: 'http://host.docker.internal:4000/v1',
+      defaultHeaders: {
+        'anthropic-beta': 'prompt-caching-2024-07-31,context-1m-2025-08-07',
+      },
+    },
+    // disableStreaming: true,
+  },
   [Providers.XAI]: {
     provider: Providers.XAI,
     model: 'grok-2-latest',
@@ -70,6 +94,16 @@ export const llmConfigs: Record<string, t.LLMConfig | undefined> = {
       baseURL: 'http://192.168.254.183:1233/v1',
     },
   },
+  zhipu: {
+    provider: Providers.OPENAI,
+    streaming: true,
+    streamUsage: false,
+    model: 'glm-4.5-air',
+    apiKey: process.env.ZHIPU_API_KEY,
+    configuration: {
+      baseURL: 'https://open.bigmodel.cn/api/paas/v4',
+    },
+  },
   [Providers.DEEPSEEK]: {
     provider: Providers.DEEPSEEK,
     model: 'deepseek-reasoner',
@@ -78,7 +112,7 @@ export const llmConfigs: Record<string, t.LLMConfig | undefined> = {
   },
   [Providers.ANTHROPIC]: {
     provider: Providers.ANTHROPIC,
-    model: 'claude-3-5-sonnet-20240620',
+    model: 'claude-sonnet-4-5',
     streaming: true,
     streamUsage: true,
   },

package/src/utils/misc.ts

@@ -1,26 +1,31 @@
+export function isPresent(value: string | null | undefined): value is string {
+  return value != null && value !== '';
+}
+
 /**
  * Unescapes a c-escaped string
  * @param str The string to unescape
  * @returns The unescaped string
  */
-const unescapeString = (string: string): string => string.replace(/\\(.)/g, (_, char) => {
-  switch (char) {
-  case 'n':
-    return '\n';
-  case 't':
-    return '\t';
-  case 'r':
-    return '\r';
-  case '"':
-    return '"';
-  case '\'':
-    return '\'';
-  case '\\':
-    return '\\';
-  default:
-    return char;
-  }
-});
+const unescapeString = (string: string): string =>
+  string.replace(/\\(.)/g, (_, char) => {
+    switch (char) {
+    case 'n':
+      return '\n';
+    case 't':
+      return '\t';
+    case 'r':
+      return '\r';
+    case '"':
+      return '"';
+    case '\'':
+      return '\'';
+    case '\\':
+      return '\\';
+    default:
+      return char;
+    }
+  });
 
 /**
  * Recursively unescapes all string values in an object
@@ -36,10 +41,17 @@ export function unescapeObject(obj: unknown, key?: string): unknown {
     return unescaped;
   }
   if (Array.isArray(obj)) {
-    return obj.map((value) => unescapeObject(value, key === 'contextPaths' ? 'filePath' : ''));
+    return obj.map((value) =>
+      unescapeObject(value, key === 'contextPaths' ? 'filePath' : '')
+    );
   }
   if (typeof obj === 'object' && obj !== null) {
-    return Object.fromEntries(Object.entries(obj).map(([key, value]) => [key, unescapeObject(value, key)]));
+    return Object.fromEntries(
+      Object.entries(obj).map(([key, value]) => [
+        key,
+        unescapeObject(value, key),
+      ])
+    );
   }
   return obj;
-}
+}

package/src/utils/title.ts

@@ -1,7 +1,8 @@
 import { z } from 'zod';
-import { RunnableLambda } from '@langchain/core/runnables';
 import { ChatPromptTemplate } from '@langchain/core/prompts';
+import { RunnableLambda, RunnableSequence } from '@langchain/core/runnables';
 import type { Runnable, RunnableConfig } from '@langchain/core/runnables';
+import type { AIMessage } from '@langchain/core/messages';
 import type * as t from '@/types';
 import { ContentTypes } from '@/common';
 
@@ -42,7 +43,55 @@ export const createTitleRunnable = async (
 
   const titlePrompt = ChatPromptTemplate.fromTemplate(
     _titlePrompt ?? defaultTitlePrompt
-  );
+  ).withConfig({ runName: 'TitlePrompt' });
+
+  const titleOnlyInnerChain = RunnableSequence.from([titlePrompt, titleLLM]);
+  const combinedInnerChain = RunnableSequence.from([titlePrompt, combinedLLM]);
+
+  /** Wrap titleOnlyChain in RunnableLambda to create parent span */
+  const titleOnlyChain = new RunnableLambda({
+    func: async (
+      input: { convo: string },
+      config?: Partial<RunnableConfig>
+    ): Promise<{ title: string }> => {
+      return await titleOnlyInnerChain.invoke(input, config);
+    },
+  }).withConfig({ runName: 'TitleOnlyChain' });
+
+  /** Wrap combinedChain in RunnableLambda to create parent span */
+  const combinedChain = new RunnableLambda({
+    func: async (
+      input: { convo: string },
+      config?: Partial<RunnableConfig>
+    ): Promise<{ language: string; title: string }> => {
+      return await combinedInnerChain.invoke(input, config);
+    },
+  }).withConfig({ runName: 'TitleLanguageChain' });
+
+  /** Runnable to add default values if needed */
+  const addDefaults = new RunnableLambda({
+    func: (
+      result: { language: string; title: string } | undefined
+    ): { language: string; title: string } => ({
+      language: result?.language ?? 'English',
+      title: result?.title ?? '',
+    }),
+  }).withConfig({ runName: 'AddDefaults' });
+
+  const combinedChainInner = RunnableSequence.from([
+    combinedChain,
+    addDefaults,
+  ]);
+
+  /** Wrap combinedChainWithDefaults in RunnableLambda to create parent span */
+  const combinedChainWithDefaults = new RunnableLambda({
+    func: async (
+      input: { convo: string },
+      config?: Partial<RunnableConfig>
+    ): Promise<{ language: string; title: string }> => {
+      return await combinedChainInner.invoke(input, config);
+    },
+  }).withConfig({ runName: 'CombinedChainWithDefaults' });
 
   return new RunnableLambda({
     func: async (
@@ -53,28 +102,17 @@ export const createTitleRunnable = async (
       },
       config?: Partial<RunnableConfig>
     ): Promise<{ language: string; title: string } | { title: string }> => {
+      const invokeInput = { convo: input.convo };
+
       if (input.skipLanguage) {
-        return (await titlePrompt.pipe(titleLLM).invoke(
-          {
-            convo: input.convo,
-          },
-          config
-        )) as { title: string };
+        return (await titleOnlyChain.invoke(invokeInput, 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 ?? '',
-      };
+      return await combinedChainWithDefaults.invoke(invokeInput, config);
     },
-  });
+  }).withConfig({ runName: 'TitleGenerator' });
 };
 
 const defaultCompletionPrompt = `Provide a concise, 5-word-or-less title for the conversation, using title case conventions. Only return the title itself.
@@ -88,22 +126,11 @@ export const createCompletionTitleRunnable = async (
 ): Promise<Runnable> => {
   const completionPrompt = ChatPromptTemplate.fromTemplate(
     titlePrompt ?? defaultCompletionPrompt
-  );
+  ).withConfig({ runName: 'CompletionTitlePrompt' });
 
-  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);
+  /** Runnable to extract content from model response */
+  const extractContent = new RunnableLambda({
+    func: (response: AIMessage): { title: string } => {
       let content = '';
       if (typeof response.content === 'string') {
         content = response.content;
@@ -116,10 +143,23 @@ export const createCompletionTitleRunnable = async (
           .map((part) => part.text)
           .join('');
       }
-      const title = content.trim();
-      return {
-        title,
-      };
+      return { title: content.trim() };
+    },
+  }).withConfig({ runName: 'ExtractTitle' });
+
+  const innerChain = RunnableSequence.from([
+    completionPrompt,
+    model,
+    extractContent,
+  ]);
+
+  /** Wrap in RunnableLambda to create a parent span for LangFuse */
+  return new RunnableLambda({
+    func: async (
+      input: { convo: string },
+      config?: Partial<RunnableConfig>
+    ): Promise<{ title: string }> => {
+      return await innerChain.invoke(input, config);
     },
-  });
+  }).withConfig({ runName: 'CompletionTitleChain' });
 };