@librechat/agents 2.4.322 → 3.0.0-rc1

package/src/scripts/multi-agent-test.ts

@@ -0,0 +1,186 @@
+import { config } from 'dotenv';
+config();
+
+import { HumanMessage, BaseMessage } from '@langchain/core/messages';
+import { Run } from '@/run';
+import { Providers, GraphEvents } from '@/common';
+import { ChatModelStreamHandler, createContentAggregator } from '@/stream';
+import { ToolEndHandler, ModelEndHandler } from '@/events';
+import type * as t from '@/types';
+
+const conversationHistory: BaseMessage[] = [];
+
+async function testMultiAgentHandoff() {
+  console.log('Testing Multi-Agent Handoff System...\n');
+
+  // Set up content aggregator
+  const { contentParts, aggregateContent } = createContentAggregator();
+
+  // Define agent configurations
+  const agents: t.AgentInputs[] = [
+    {
+      agentId: 'flight_assistant',
+      provider: Providers.ANTHROPIC,
+      clientOptions: {
+        modelName: 'claude-3-5-sonnet-latest',
+        apiKey: process.env.ANTHROPIC_API_KEY,
+      },
+      instructions:
+        'You are a flight booking assistant. Help users book flights between airports.',
+      maxContextTokens: 28000,
+    },
+    {
+      agentId: 'hotel_assistant',
+      provider: Providers.ANTHROPIC,
+      clientOptions: {
+        modelName: 'claude-3-5-sonnet-latest',
+        apiKey: process.env.ANTHROPIC_API_KEY,
+      },
+      instructions:
+        'You are a hotel booking assistant. Help users book hotel stays.',
+      maxContextTokens: 28000,
+    },
+  ];
+
+  // Define edges (handoff relationships)
+  // These edges create handoff tools that agents can use to transfer control dynamically
+  const edges: t.GraphEdge[] = [
+    {
+      from: 'flight_assistant',
+      to: 'hotel_assistant',
+      description:
+        'Transfer to hotel booking assistant when user needs hotel assistance',
+      // edgeType defaults to 'handoff' for single-to-single edges
+    },
+    {
+      from: 'hotel_assistant',
+      to: 'flight_assistant',
+      description:
+        'Transfer to flight booking assistant when user needs flight assistance',
+      // edgeType defaults to 'handoff' for single-to-single edges
+    },
+  ];
+
+  // Create custom handlers similar to examples
+  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.ON_REASONING_DELTA]: {
+      handle: (
+        event: GraphEvents.ON_REASONING_DELTA,
+        data: t.StreamEventData
+      ): void => {
+        console.log('====== ON_REASONING_DELTA ======');
+        console.dir(data, { depth: null });
+        aggregateContent({ event, data: data as t.ReasoningDeltaEvent });
+      },
+    },
+    [GraphEvents.TOOL_START]: {
+      handle: (
+        _event: string,
+        data: t.StreamEventData,
+        metadata?: Record<string, unknown>
+      ): void => {
+        console.log('====== TOOL_START ======');
+        console.dir(data, { depth: null });
+      },
+    },
+  };
+
+  // Create multi-agent run configuration
+  const runConfig: t.RunConfig = {
+    runId: `multi-agent-test-${Date.now()}`,
+    graphConfig: {
+      type: 'multi-agent',
+      agents,
+      edges,
+    },
+    customHandlers,
+    returnContent: true,
+  };
+
+  try {
+    // Create and execute the run
+    const run = await Run.create(runConfig);
+
+    const userMessage =
+      'I need to book a flight from Boston to New York, and also need a hotel near Times Square.';
+    conversationHistory.push(new HumanMessage(userMessage));
+
+    console.log('Invoking multi-agent graph...\n');
+
+    const config = {
+      configurable: {
+        thread_id: 'multi-agent-conversation-1',
+      },
+      streamMode: 'values',
+      version: 'v2' as const,
+    };
+
+    // Process with streaming
+    const inputs = {
+      messages: conversationHistory,
+    };
+
+    const finalContentParts = await run.processStream(inputs, config);
+    const finalMessages = run.getRunMessages();
+
+    if (finalMessages) {
+      conversationHistory.push(...finalMessages);
+      console.log('\n\nConversation history:');
+      console.dir(conversationHistory, { depth: null });
+    }
+
+    console.log('\n\nFinal content parts:');
+    console.dir(contentParts, { depth: null });
+  } catch (error) {
+    console.error('Error in multi-agent test:', error);
+  }
+}
+
+// Run the test
+testMultiAgentHandoff();

package/src/scripts/search.ts

@@ -39,8 +39,6 @@ async function testStandardStreaming(): Promise<void> {
         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 });
       },
     },
@@ -49,8 +47,6 @@ async function testStandardStreaming(): Promise<void> {
         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 });
       },
     },
@@ -59,8 +55,6 @@ async function testStandardStreaming(): Promise<void> {
         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 });
       },
     },
@@ -133,9 +127,7 @@ async function testStandardStreaming(): Promise<void> {
 }
 
 process.on('unhandledRejection', (reason, promise) => {
-  console.error('Unhandled Rejection at:', promise, 'reason:', reason);
-  console.log('Conversation history:');
-  process.exit(1);
+  console.warn('Unhandled Rejection (non-fatal):', reason);
 });
 
 testStandardStreaming().catch((err) => {

package/src/scripts/simple.ts

@@ -1,7 +1,12 @@
 // src/scripts/cli.ts
 import { config } from 'dotenv';
+import { v4 as uuidv4 } from 'uuid';
 config();
-import { HumanMessage, BaseMessage } from '@langchain/core/messages';
+import {
+  HumanMessage,
+  BaseMessage,
+  UsageMetadata,
+} from '@langchain/core/messages';
 import { TavilySearchResults } from '@langchain/community/tools/tavily_search';
 import type * as t from '@/types';
 import { ChatModelStreamHandler, createContentAggregator } from '@/stream';
@@ -10,21 +15,27 @@ import {
   ModelEndHandler,
   createMetadataAggregator,
 } from '@/events';
+import { GraphEvents, Providers, TitleMethod } from '@/common';
 import { getLLMConfig } from '@/utils/llmConfig';
 import { getArgs } from '@/scripts/args';
-import { GraphEvents, Providers } from '@/common';
 import { Run } from '@/run';
 
 const conversationHistory: BaseMessage[] = [];
 let _contentParts: t.MessageContentComplex[] = [];
+let collectedUsage: UsageMetadata[] = [];
 
 async function testStandardStreaming(): Promise<void> {
-  const { userName, location, provider, currentDate } = await getArgs();
+  const {
+    userName,
+    location,
+    provider: _provider,
+    currentDate,
+  } = await getArgs();
   const { contentParts, aggregateContent } = createContentAggregator();
   _contentParts = contentParts as t.MessageContentComplex[];
   const customHandlers = {
     [GraphEvents.TOOL_END]: new ToolEndHandler(),
-    [GraphEvents.CHAT_MODEL_END]: new ModelEndHandler(),
+    [GraphEvents.CHAT_MODEL_END]: new ModelEndHandler(collectedUsage),
     [GraphEvents.CHAT_MODEL_STREAM]: new ChatModelStreamHandler(),
     [GraphEvents.ON_RUN_STEP_COMPLETED]: {
       handle: (
@@ -32,7 +43,7 @@ async function testStandardStreaming(): Promise<void> {
         data: t.StreamEventData
       ): void => {
         console.log('====== ON_RUN_STEP_COMPLETED ======');
-        // console.dir(data, { depth: null });
+        console.dir(data, { depth: null });
         aggregateContent({
           event,
           data: data as unknown as { result: t.ToolEndEvent },
@@ -91,7 +102,7 @@ async function testStandardStreaming(): Promise<void> {
     },
   };
 
-  const llmConfig = getLLMConfig(provider);
+  const llmConfig = getLLMConfig(_provider);
   if (
     'configuration' in llmConfig &&
     (llmConfig as t.OpenAIClientOptions).configuration != null
@@ -99,7 +110,7 @@ async function testStandardStreaming(): Promise<void> {
     const openAIConfig = llmConfig as t.OpenAIClientOptions;
     if (openAIConfig.configuration) {
       openAIConfig.configuration.fetch = (
-        url: RequestInfo,
+        url: string | URL | Request,
         init?: RequestInit
       ) => {
         console.log('Fetching:', url);
@@ -107,6 +118,7 @@ async function testStandardStreaming(): Promise<void> {
       };
     }
   }
+  const provider = llmConfig.provider;
 
   if (provider === Providers.ANTHROPIC) {
     (llmConfig as t.AnthropicClientOptions).clientOptions = {
@@ -118,12 +130,12 @@ async function testStandardStreaming(): Promise<void> {
   }
 
   const run = await Run.create<t.IState>({
-    runId: 'test-run-id',
+    runId: uuidv4(),
     graphConfig: {
       type: 'standard',
       llmConfig,
       // tools: [new TavilySearchResults()],
-      reasoningKey: 'reasoning',
+      // reasoningKey: 'reasoning',
       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}.`,
@@ -160,8 +172,10 @@ async function testStandardStreaming(): Promise<void> {
   console.dir(contentParts, { depth: null });
   const { handleLLMEnd, collected } = createMetadataAggregator();
   const titleOptions: t.RunTitleOptions = {
+    provider,
     inputText: userMessage,
     contentParts,
+    // titleMethod: TitleMethod.STRUCTURED,
     chainOptions: {
       callbacks: [
         {
@@ -176,8 +190,9 @@ async function testStandardStreaming(): Promise<void> {
     };
   }
   const titleResult = await run.generateTitle(titleOptions);
+  console.log('Collected usage metadata:', collectedUsage);
   console.log('Generated Title:', titleResult);
-  console.log('Collected metadata:', collected);
+  console.log('Collected title usage metadata:', collected);
 }
 
 process.on('unhandledRejection', (reason, promise) => {

package/src/scripts/tools.ts

@@ -8,7 +8,6 @@ import type * as t from '@/types';
 import { ChatModelStreamHandler, createContentAggregator } from '@/stream';
 import { ToolEndHandler, ModelEndHandler } from '@/events';
 
-
 import { getArgs } from '@/scripts/args';
 import { Run } from '@/run';
 import { GraphEvents, Callback } from '@/common';
@@ -19,42 +18,73 @@ async function testStandardStreaming(): Promise<void> {
   const { userName, location, provider, currentDate } = await getArgs();
   const { contentParts, aggregateContent } = createContentAggregator();
   const customHandlers = {
-    [GraphEvents.TOOL_END]: new ToolEndHandler(),
+    [GraphEvents.TOOL_END]: new ToolEndHandler(undefined, (name?: string) => {
+      return true;
+    }),
     [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 => {
+      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 } });
-      }
+        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 => {
+      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 => {
+      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 => {
+      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.ON_REASONING_DELTA]: {
+      handle: (
+        event: GraphEvents.ON_REASONING_DELTA,
+        data: t.StreamEventData
+      ) => {
+        console.log('====== ON_REASONING_DELTA ======');
+        console.dir(data, { depth: null });
+        aggregateContent({ event, data: data as t.ReasoningDeltaEvent });
+      },
     },
     [GraphEvents.TOOL_START]: {
-      handle: (_event: string, data: t.StreamEventData, metadata?: Record<string, unknown>): void => {
+      handle: (
+        _event: string,
+        data: t.StreamEventData,
+        metadata?: Record<string, unknown>
+      ): void => {
         console.log('====== TOOL_START ======');
-        // console.dir(data, { depth: null });
-      }
+        console.dir(data, { depth: null });
+      },
     },
   };
 
@@ -66,7 +96,8 @@ async function testStandardStreaming(): Promise<void> {
       type: 'standard',
       llmConfig,
       tools: [new TavilySearchResults()],
-      instructions: 'You are a friendly AI assistant. Always address the user by their name.',
+      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}.`,
     },
     returnContent: true,
@@ -86,7 +117,6 @@ async function testStandardStreaming(): Promise<void> {
 
   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.
   `;
@@ -102,7 +132,7 @@ async function testStandardStreaming(): Promise<void> {
     conversationHistory.push(...finalMessages);
     console.dir(conversationHistory, { depth: null });
   }
-  // console.dir(finalContentParts, { depth: null });
+  console.dir(finalContentParts, { depth: null });
   console.log('\n\n====================\n\n');
   // console.dir(contentParts, { depth: null });
 }