@librechat/agents 1.4.8 → 1.5.0

package/src/run.ts

@@ -1,28 +1,27 @@
 // src/run.ts
-import type { BaseCallbackHandler, CallbackHandlerMethods } from '@langchain/core/callbacks/base';
+import { PromptTemplate } from '@langchain/core/prompts';
+
 import type { BaseMessage, MessageContentComplex } from '@langchain/core/messages';
 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 { createTitleRunnable } from '@/utils/title';
 import { StandardGraph } from '@/graphs/Graph';
 import { HandlerRegistry } from '@/events';
-import { sleep } from '@/utils';
 
 export class Run<T extends t.BaseGraphState> {
   graphRunnable?: t.CompiledWorkflow<T, Partial<T>, string>;
   // private collab!: CollabGraph;
   // private taskManager!: TaskManager;
   private handlerRegistry: HandlerRegistry;
-  private Graph: StandardGraph | undefined;
+  Graph: StandardGraph | undefined;
   provider: Providers | undefined;
   run_id: string | undefined;
   returnContent: boolean = false;
-  streamRate: number | undefined;
 
   private constructor(config: t.RunConfig) {
     const handlerRegistry = new HandlerRegistry();
-    this.streamRate = config.streamRate;
 
     if (config.customHandlers) {
       for (const [eventType, handler] of Object.entries(config.customHandlers)) {
@@ -44,7 +43,7 @@ export class Run<T extends t.BaseGraphState> {
   }
 
   private createStandardGraph(config: t.StandardGraphConfig): t.CompiledWorkflow<t.IState, Partial<t.IState>, string> {
-    const { runId, llmConfig, instructions, additional_instructions, tools = [] } = config;
+    const { runId, llmConfig, instructions, additional_instructions, streamRate, streamBuffer, tools = [] } = config;
     const { provider, ...clientOptions } = llmConfig;
 
     const standardGraph = new StandardGraph({
@@ -54,6 +53,8 @@ export class Run<T extends t.BaseGraphState> {
       instructions,
       clientOptions,
       additional_instructions,
+      streamBuffer,
+      streamRate,
     });
     this.Graph = standardGraph;
     return standardGraph.createWorkflow();
@@ -87,7 +88,7 @@ export class Run<T extends t.BaseGraphState> {
     const hasTools = this.Graph.tools ? this.Graph.tools.length > 0 : false;
     if (clientCallbacks) {
       /* TODO: conflicts with callback manager */
-      const callbacks = config.callbacks as (BaseCallbackHandler | CallbackHandlerMethods)[] || [];
+      const callbacks = config.callbacks as t.ProvidedCallbacks ?? [];
       config.callbacks = callbacks.concat(this.getCallbacks(clientCallbacks));
     }
     const stream = this.graphRunnable.streamEvents(inputs, config);
@@ -112,9 +113,6 @@ export class Run<T extends t.BaseGraphState> {
       if (handler) {
         handler.handle(eventName, data, metadata, this.Graph);
       }
-      if (this.streamRate != null) {
-        await sleep(this.streamRate);
-      }
     }
 
     if (this.returnContent) {
@@ -141,4 +139,36 @@ export class Run<T extends t.BaseGraphState> {
       [Callback.TOOL_END]: this.createSystemCallback(clientCallbacks, Callback.TOOL_END),
     };
   }
+
+  async generateTitle({
+    inputText,
+    contentParts,
+    titlePrompt,
+    clientOptions,
+    chainOptions,
+    skipLanguage,
+  } : {
+    inputText: string;
+    contentParts: (t.MessageContentComplex | undefined)[];
+    titlePrompt?: string;
+    skipLanguage?: boolean;
+    clientOptions?: t.ClientOptions;
+    chainOptions?: Partial<RunnableConfig> | undefined;
+  }): Promise<{ language: string; title: string }> {
+    const convoTemplate = PromptTemplate.fromTemplate('User: {input}\nAI: {output}');
+    const response = contentParts.map((part) => {
+      if (part?.type === 'text') return part.text;
+      return '';
+    }).join('\n');
+    const convo = (await convoTemplate.invoke({ input: inputText, output: response })).value;
+    const model = this.Graph?.getNewModel({
+      clientOptions,
+      omitOriginalOptions: ['streaming'],
+    });
+    if (!model) {
+      return { language: '', title: '' };
+    }
+    const chain = await createTitleRunnable(model, titlePrompt);
+    return await chain.invoke({ convo, inputText, skipLanguage }, chainOptions) as { language: string; title: string };
+  }
 }

package/src/scripts/simple.ts

@@ -1,4 +1,3 @@
-/* eslint-disable no-console */
 // src/scripts/cli.ts
 import { config } from 'dotenv';
 config();
@@ -6,15 +5,14 @@ import { HumanMessage, BaseMessage } from '@langchain/core/messages';
 import { TavilySearchResults } from '@langchain/community/tools/tavily_search';
 import type * as t from '@/types';
 import { ChatModelStreamHandler, createContentAggregator } from '@/stream';
-import { ToolEndHandler } from '@/events';
-
-
+import { ToolEndHandler, createMetadataAggregator } from '@/events';
+import { getLLMConfig } from '@/utils/llmConfig';
 import { getArgs } from '@/scripts/args';
+import { GraphEvents } from '@/common';
 import { Run } from '@/run';
-import { GraphEvents, Callback } from '@/common';
-import { getLLMConfig } from '@/utils/llmConfig';
 
 const conversationHistory: BaseMessage[] = [];
+
 async function testStandardStreaming(): Promise<void> {
   const { userName, location, provider, currentDate } = await getArgs();
   const { contentParts, aggregateContent } = createContentAggregator();
@@ -98,7 +96,19 @@ async function testStandardStreaming(): Promise<void> {
   }
   // console.dir(finalContentParts, { depth: null });
   console.log('\n\n====================\n\n');
-  // console.dir(contentParts, { depth: null });
+  console.dir(contentParts, { depth: null });
+  const { handleLLMEnd, collected } = createMetadataAggregator();
+  const titleResult = await run.generateTitle({
+    inputText: userMessage,
+    contentParts,
+    chainOptions: {
+      callbacks: [{
+        handleLLMEnd,
+      }],
+    },
+  });
+  console.log('Generated Title:', titleResult);
+  console.log('Collected metadata:', collected);
 }
 
 process.on('unhandledRejection', (reason, promise) => {

package/src/scripts/stream.ts

@@ -0,0 +1,122 @@
+/* eslint-disable no-console */
+// src/scripts/cli.ts
+import { config } from 'dotenv';
+config();
+import { HumanMessage, BaseMessage } from '@langchain/core/messages';
+import { TavilySearchResults } from '@langchain/community/tools/tavily_search';
+import type * as t from '@/types';
+import { ChatModelStreamHandler, createContentAggregator } from '@/stream';
+import { ToolEndHandler } from '@/events';
+
+
+import { getArgs } from '@/scripts/args';
+import { Run } from '@/run';
+import { GraphEvents, Callback } from '@/common';
+import { getLLMConfig } from '@/utils/llmConfig';
+
+const conversationHistory: BaseMessage[] = [];
+async function testStandardStreaming(): Promise<void> {
+  const { userName, location, provider, currentDate } = await getArgs();
+  const { contentParts, aggregateContent } = createContentAggregator();
+  const customHandlers = {
+    [GraphEvents.TOOL_END]: new ToolEndHandler(),
+    // [GraphEvents.CHAT_MODEL_END]: new ModelEndHandler(),
+    [GraphEvents.CHAT_MODEL_STREAM]: new ChatModelStreamHandler(),
+    [GraphEvents.ON_RUN_STEP_COMPLETED]: {
+      handle: (event: GraphEvents.ON_RUN_STEP_COMPLETED, data: t.StreamEventData): void => {
+        console.log('====== ON_RUN_STEP_COMPLETED ======');
+        // console.dir(data, { depth: null });
+        aggregateContent({ event, data: data as unknown as { result: t.ToolEndEvent } });
+      }
+    },
+    [GraphEvents.ON_RUN_STEP]: {
+      handle: (event: GraphEvents.ON_RUN_STEP, data: t.StreamEventData): void => {
+        console.log('====== ON_RUN_STEP ======');
+        console.dir(data, { depth: null });
+        aggregateContent({ event, data: data as t.RunStep });
+      }
+    },
+    [GraphEvents.ON_RUN_STEP_DELTA]: {
+      handle: (event: GraphEvents.ON_RUN_STEP_DELTA, data: t.StreamEventData): void => {
+        console.log('====== ON_RUN_STEP_DELTA ======');
+        console.dir(data, { depth: null });
+        aggregateContent({ event, data: data as t.RunStepDeltaEvent });
+      }
+    },
+    [GraphEvents.ON_MESSAGE_DELTA]: {
+      handle: (event: GraphEvents.ON_MESSAGE_DELTA, data: t.StreamEventData): void => {
+        console.log('====== ON_MESSAGE_DELTA ======');
+        console.dir(data, { depth: null });
+        aggregateContent({ event, data: data as t.MessageDeltaEvent });
+      }
+    },
+    [GraphEvents.TOOL_START]: {
+      handle: (_event: string, data: t.StreamEventData, metadata?: Record<string, unknown>): void => {
+        console.log('====== TOOL_START ======');
+        // console.dir(data, { depth: null });
+      }
+    },
+  };
+
+  const llmConfig = getLLMConfig(provider);
+
+  const run = await Run.create<t.IState>({
+    graphConfig: {
+      type: 'standard',
+      llmConfig,
+      tools: [new TavilySearchResults()],
+      instructions: 'You are a friendly AI assistant. Always address the user by their name.',
+      additional_instructions: `The user's name is ${userName} and they are located in ${location}.`,
+      streamBuffer: 3000,
+      streamRate: 30,
+    },
+    returnContent: true,
+    customHandlers,
+  });
+
+  const config = {
+    configurable: {
+      provider,
+      thread_id: 'conversation-num-1',
+    },
+    streamMode: 'values',
+    version: 'v2' as const,
+  };
+
+  console.log('Test 1: Weather query (content parts test)');
+
+  const userMessage = `
+  Make a search for the weather in ${location} today, which is ${currentDate}.
+  Before making the search, please let me know what you're about to do, then immediately start searching without hesitation.
+  Make sure to always refer to me by name, which is ${userName}.
+  After giving me a thorough summary, tell me a joke about the weather forecast we went over.
+  `;
+
+  conversationHistory.push(new HumanMessage(userMessage));
+
+  const inputs = {
+    messages: conversationHistory,
+  };
+  const finalContentParts = await run.processStream(inputs, config);
+  const finalMessages = run.getRunMessages();
+  if (finalMessages) {
+    conversationHistory.push(...finalMessages);
+    console.dir(conversationHistory, { depth: null });
+  }
+  // console.dir(finalContentParts, { depth: null });
+  console.log('\n\n====================\n\n');
+  // console.dir(contentParts, { depth: null });
+}
+
+process.on('unhandledRejection', (reason, promise) => {
+  console.error('Unhandled Rejection at:', promise, 'reason:', reason);
+  console.log('Conversation history:');
+  process.exit(1);
+});
+
+testStandardStreaming().catch((err) => {
+  console.error(err);
+  console.log('Conversation history:');
+  console.dir(conversationHistory, { depth: null });
+  process.exit(1);
+});

package/src/types/run.ts

@@ -2,6 +2,7 @@
 import type * as z from 'zod';
 import type { BaseMessage } from '@langchain/core/messages';
 import type { StructuredTool } from '@langchain/core/tools';
+import type { BaseCallbackHandler, CallbackHandlerMethods } from '@langchain/core/callbacks/base';
 import type * as e from '@/common/enum';
 import type * as g from '@/types/graph';
 import type * as t from '@/types/tools';
@@ -20,6 +21,7 @@ export type StandardGraphConfig = {
   toolMap?: t.ToolMap;
   additional_instructions?: string;
   streamBuffer?: number;
+  streamRate?: number;
   clientOptions?: Record<string, unknown>;
 };
 
@@ -54,7 +56,7 @@ export type RunConfig = {
   graphConfig: StandardGraphConfig | CollaborativeGraphConfig | TaskManagerGraphConfig;
   customHandlers?: Record<string, g.EventHandler>;
   returnContent?: boolean;
-  /** The rate at which to process stream events */
-  streamRate?: number;
   runId?: string;
 };
+
+export type ProvidedCallbacks = (BaseCallbackHandler | CallbackHandlerMethods)[] | undefined;

package/src/types/stream.ts

@@ -1,8 +1,21 @@
 // src/types/stream.ts
-import type { MessageContentImageUrl, MessageContentText, ToolMessage } from '@langchain/core/messages';
+import type { MessageContentImageUrl, MessageContentText, ToolMessage, BaseMessage } from '@langchain/core/messages';
 import type { ToolCall, ToolCallChunk } from '@langchain/core/messages/tool';
+import type { LLMResult, Generation } from '@langchain/core/outputs';
 import { StepTypes, ContentTypes } from '@/common/enum';
 
+export type HandleLLMEnd = (output: LLMResult, runId: string, parentRunId?: string, tags?: string[]) => void;
+
+export type MetadataAggregatorResult = {
+  handleLLMEnd: HandleLLMEnd;
+  collected: Record<string, unknown>[];
+};
+
+export type StreamGeneration = Generation & {
+  text?: string;
+  message?: BaseMessage
+};
+
 /** Event names are of the format: on_[runnable_type]_(start|stream|end).
 
 Runnable types are one of:

package/src/utils/title.ts

@@ -0,0 +1,51 @@
+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}`;
+
+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 languagePrompt = ChatPromptTemplate.fromTemplate(languageInstructions);
+
+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'),
+});
+
+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);
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  /* @ts-ignore */
+  const titleLLM = model.withStructuredOutput(titleSchema);
+
+  const languageChain = languagePrompt.pipe(languageLLM);
+
+  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 }> => {
+      if (input.skipLanguage) {
+        return await titlePrompt.pipe(titleLLM).invoke({
+          convo: input.convo
+        }) as { title: string };
+      }
+      const languageResult = await languageChain.invoke({ text: input.inputText }) as { language: string };
+      const language = languageResult.language;
+      const titleResult = await titlePrompt.pipe(titleLLM).invoke({
+        language,
+        convo: input.convo
+      }) as { title: string };
+      return { language, title: titleResult.title };
+    },
+  });
+};