@librechat/agents 2.4.322 → 3.0.0-rc10

package/src/scripts/handoff-test.ts

@@ -0,0 +1,135 @@
+import { config } from 'dotenv';
+config();
+
+import { z } from 'zod';
+import { tool } from '@langchain/core/tools';
+import { ChatAnthropic } from '@langchain/anthropic';
+import { createReactAgent } from '@langchain/langgraph/prebuilt';
+import {
+  StateGraph,
+  MessagesAnnotation,
+  Command,
+  START,
+  getCurrentTaskInput,
+  END,
+} from '@langchain/langgraph';
+import { ToolMessage } from '@langchain/core/messages';
+
+interface CreateHandoffToolParams {
+  agentName: string;
+  description?: string;
+}
+
+const createHandoffTool = ({
+  agentName,
+  description,
+}: CreateHandoffToolParams) => {
+  const toolName = `transfer_to_${agentName}`;
+  const toolDescription = description || `Ask agent '${agentName}' for help`;
+
+  const handoffTool = tool(
+    async (_, config) => {
+      const toolMessage = new ToolMessage({
+        content: `Successfully transferred to ${agentName}`,
+        name: toolName,
+        tool_call_id: config.toolCall.id,
+      });
+
+      // inject the current agent state
+      const state =
+        getCurrentTaskInput() as (typeof MessagesAnnotation)['State'];
+      return new Command({
+        goto: agentName,
+        update: { messages: state.messages.concat(toolMessage) },
+        graph: Command.PARENT,
+      });
+    },
+    {
+      name: toolName,
+      schema: z.object({}),
+      description: toolDescription,
+    }
+  );
+
+  return handoffTool;
+};
+
+const bookHotel = tool(
+  async (input: { hotel_name: string }) => {
+    return `Successfully booked a stay at ${input.hotel_name}.`;
+  },
+  {
+    name: 'book_hotel',
+    description: 'Book a hotel',
+    schema: z.object({
+      hotel_name: z.string().describe('The name of the hotel to book'),
+    }),
+  }
+);
+
+const bookFlight = tool(
+  async (input: { from_airport: string; to_airport: string }) => {
+    return `Successfully booked a flight from ${input.from_airport} to ${input.to_airport}.`;
+  },
+  {
+    name: 'book_flight',
+    description: 'Book a flight',
+    schema: z.object({
+      from_airport: z.string().describe('The departure airport code'),
+      to_airport: z.string().describe('The arrival airport code'),
+    }),
+  }
+);
+
+const transferToHotelAssistant = createHandoffTool({
+  agentName: 'hotel_assistant',
+  description: 'Transfer user to the hotel-booking assistant.',
+});
+
+const transferToFlightAssistant = createHandoffTool({
+  agentName: 'flight_assistant',
+  description: 'Transfer user to the flight-booking assistant.',
+});
+
+const llm = new ChatAnthropic({
+  modelName: 'claude-3-5-sonnet-latest',
+  apiKey: process.env.ANTHROPIC_API_KEY,
+});
+
+const flightAssistant = createReactAgent({
+  llm,
+  tools: [bookFlight, transferToHotelAssistant],
+  prompt: 'You are a flight booking assistant',
+  name: 'flight_assistant',
+});
+
+const hotelAssistant = createReactAgent({
+  llm,
+  tools: [bookHotel, transferToFlightAssistant],
+  prompt: 'You are a hotel booking assistant',
+  name: 'hotel_assistant',
+});
+
+const multiAgentGraph = new StateGraph(MessagesAnnotation)
+  .addNode('flight_assistant', flightAssistant, {
+    ends: ['hotel_assistant', END],
+  })
+  .addNode('hotel_assistant', hotelAssistant, {
+    ends: ['flight_assistant', END],
+  })
+  .addEdge(START, 'flight_assistant')
+  .compile();
+
+const stream = await multiAgentGraph.stream({
+  messages: [
+    {
+      role: 'user',
+      content: 'book a flight from BOS to JFK and a stay at McKittrick Hotel',
+    },
+  ],
+});
+
+for await (const chunk of stream) {
+  console.log(chunk);
+  console.log('\n');
+}

package/src/scripts/image.ts

@@ -5,14 +5,17 @@ import { HumanMessage, AIMessage, BaseMessage } from '@langchain/core/messages';
 import type { RunnableConfig } from '@langchain/core/runnables';
 import type * as t from '@/types';
 import { ChatModelStreamHandler, createContentAggregator } from '@/stream';
-import { ToolEndHandler, ModelEndHandler, createMetadataAggregator } from '@/events';
+import {
+  ToolEndHandler,
+  ModelEndHandler,
+  createMetadataAggregator,
+} from '@/events';
 import { fetchRandomImageTool, fetchRandomImageURL } from '@/tools/example';
 import { getLLMConfig } from '@/utils/llmConfig';
 import { getArgs } from '@/scripts/args';
 import { GraphEvents } from '@/common';
 import { Run } from '@/run';
 
-
 const conversationHistory: BaseMessage[] = [];
 
 async function testCodeExecution(): Promise<void> {
@@ -23,38 +26,57 @@ async function testCodeExecution(): Promise<void> {
     [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 } });
-      }
+        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.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 });
-      }
+      },
     },
   };
 
@@ -67,14 +89,19 @@ async function testCodeExecution(): Promise<void> {
       llmConfig,
       tools: [fetchRandomImageTool],
       // tools: [fetchRandomImageURL],
-      instructions: 'You are a friendly AI assistant with internet capabilities. Always address the user by their name.',
+      instructions:
+        'You are a friendly AI assistant with internet capabilities. Always address the user by their name.',
       additional_instructions: `The user's name is ${userName} and they are located in ${location}.`,
     },
     returnContent: true,
     customHandlers,
   });
 
-  const config: Partial<RunnableConfig> & { version: 'v1' | 'v2'; run_id?: string; streamMode: string } = {
+  const config: Partial<RunnableConfig> & {
+    version: 'v1' | 'v2';
+    run_id?: string;
+    streamMode: string;
+  } = {
     configurable: {
       provider,
       thread_id: 'conversation-num-1',
@@ -109,7 +136,9 @@ async function testCodeExecution(): Promise<void> {
   inputs = {
     messages: conversationHistory,
   };
-  const finalContentParts2 = await run.processStream(inputs, config, { keepContent: true });
+  const finalContentParts2 = await run.processStream(inputs, config, {
+    keepContent: true,
+  });
   const finalMessages2 = run.getRunMessages();
   if (finalMessages2) {
     conversationHistory.push(...finalMessages2);
@@ -119,12 +148,15 @@ async function testCodeExecution(): Promise<void> {
 
   const { handleLLMEnd, collected } = createMetadataAggregator();
   const titleResult = await run.generateTitle({
+    provider,
     inputText: userMessage2,
     contentParts,
     chainOptions: {
-      callbacks: [{
-        handleLLMEnd,
-      }],
+      callbacks: [
+        {
+          handleLLMEnd,
+        },
+      ],
     },
   });
   console.log('Generated Title:', titleResult);
@@ -143,4 +175,4 @@ testCodeExecution().catch((err) => {
   console.log('Conversation history:');
   console.dir(conversationHistory, { depth: null });
   process.exit(1);
-});
+});

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

@@ -0,0 +1,278 @@
+import { config } from 'dotenv';
+config();
+
+import {
+  HumanMessage,
+  BaseMessage,
+  getBufferString,
+} 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';
+
+/**
+ * Helper function to create sequential chain edges with buffer string prompts
+ *
+ * @param agentIds - Array of agent IDs in order of execution
+ * @returns Array of edges configured for sequential chain with buffer prompts
+ */
+function createSequentialChainEdges(agentIds: string[]): t.GraphEdge[] {
+  const edges: t.GraphEdge[] = [];
+
+  for (let i = 0; i < agentIds.length - 1; i++) {
+    const fromAgent = agentIds[i];
+    const toAgent = agentIds[i + 1];
+
+    edges.push({
+      from: fromAgent,
+      to: toAgent,
+      edgeType: 'direct',
+      // Use a prompt function to create the buffer string from all previous results
+      prompt: (messages: BaseMessage[], startIndex: number) => {
+        // Get only the messages from this run (after startIndex)
+        const runMessages = messages.slice(startIndex);
+
+        // Create buffer string from run messages
+        const bufferString = getBufferString(runMessages);
+
+        // Format the prompt for the next agent
+        return `Based on the following conversation and analysis from previous agents, please provide your insights:\n\n${bufferString}\n\nPlease add your specific expertise and perspective to this discussion.`;
+      },
+      // Critical: exclude previous results so only the prompt is passed
+      excludeResults: true,
+      description: `Sequential chain from ${fromAgent} to ${toAgent}`,
+    });
+  }
+
+  return edges;
+}
+
+const conversationHistory: BaseMessage[] = [];
+
+/**
+ * Example of sequential agent chain mimicking the old chain behavior
+ *
+ * Graph structure:
+ * START -> researcher -> analyst -> reviewer -> summarizer -> END
+ *
+ * Each agent receives a buffer string of all previous results
+ */
+async function testSequentialAgentChain() {
+  console.log('Testing Sequential Agent Chain (Old Chain Pattern)...\n');
+
+  // Set up content aggregator
+  const { contentParts, aggregateContent } = createContentAggregator();
+
+  // Define four agents with specific roles
+  const agents: t.AgentInputs[] = [
+    {
+      agentId: 'researcher',
+      provider: Providers.ANTHROPIC,
+      clientOptions: {
+        modelName: 'claude-3-5-sonnet-latest',
+        apiKey: process.env.ANTHROPIC_API_KEY,
+      },
+      instructions: `You are a Research Agent specializing in gathering initial information.
+      Your role is to:
+      1. Identify key aspects of the user's query
+      2. List important factors to consider
+      3. Provide initial research findings
+      
+      Format your response with clear sections and bullet points.
+      Start with "RESEARCH FINDINGS:" and be thorough but concise.`,
+      maxContextTokens: 8000,
+    },
+    {
+      agentId: 'analyst',
+      provider: Providers.ANTHROPIC,
+      clientOptions: {
+        modelName: 'claude-3-5-sonnet-latest',
+        apiKey: process.env.ANTHROPIC_API_KEY,
+      },
+      instructions: `You are an Analysis Agent that builds upon research findings.
+      Your role is to:
+      1. Analyze the research provided by the previous agent
+      2. Identify patterns, risks, and opportunities
+      3. Provide deeper analytical insights
+      
+      Start with "ANALYSIS:" and structure your response with clear categories.
+      Reference specific points from the research when relevant.`,
+      maxContextTokens: 8000,
+    },
+    {
+      agentId: 'reviewer',
+      provider: Providers.ANTHROPIC,
+      clientOptions: {
+        modelName: 'claude-3-5-sonnet-latest',
+        apiKey: process.env.ANTHROPIC_API_KEY,
+      },
+      instructions: `You are a Critical Review Agent that evaluates the work done so far.
+      Your role is to:
+      1. Review the research and analysis from previous agents
+      2. Identify any gaps or areas that need more attention
+      3. Suggest improvements or additional considerations
+      
+      Start with "CRITICAL REVIEW:" and be constructive in your feedback.
+      Highlight both strengths and areas for improvement.`,
+      maxContextTokens: 8000,
+    },
+    {
+      agentId: 'summarizer',
+      provider: Providers.ANTHROPIC,
+      clientOptions: {
+        modelName: 'claude-3-5-sonnet-latest',
+        apiKey: process.env.ANTHROPIC_API_KEY,
+      },
+      instructions: `You are a Summary Agent that creates the final comprehensive output.
+      Your role is to:
+      1. Synthesize all insights from the researcher, analyst, and reviewer
+      2. Create a cohesive, actionable summary
+      3. Provide clear recommendations or conclusions
+      
+      Start with "EXECUTIVE SUMMARY:" followed by key sections.
+      End with "KEY RECOMMENDATIONS:" or "CONCLUSIONS:" as appropriate.`,
+      maxContextTokens: 8000,
+    },
+  ];
+
+  // Create sequential chain edges using our helper function
+  const agentIds = agents.map((a) => a.agentId);
+  const edges = createSequentialChainEdges(agentIds);
+
+  // Track agent progression
+  let currentAgent = '';
+
+  // Create custom handlers
+  const customHandlers = {
+    [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 => {
+        const runStepData = data as any;
+        if (runStepData?.name) {
+          currentAgent = runStepData.name;
+          console.log(`\n→ ${currentAgent} is processing...`);
+        }
+        aggregateContent({ event, data: data as t.RunStep });
+      },
+    },
+    [GraphEvents.ON_RUN_STEP_COMPLETED]: {
+      handle: (
+        event: GraphEvents.ON_RUN_STEP_COMPLETED,
+        data: t.StreamEventData
+      ): void => {
+        const runStepData = data as any;
+        if (runStepData?.name) {
+          console.log(`✓ ${runStepData.name} completed`);
+        }
+        aggregateContent({
+          event,
+          data: data as unknown as { result: t.ToolEndEvent },
+        });
+      },
+    },
+    [GraphEvents.ON_RUN_STEP_DELTA]: {
+      handle: (
+        event: GraphEvents.ON_RUN_STEP_DELTA,
+        data: t.StreamEventData
+      ): void => {
+        aggregateContent({ event, data: data as t.RunStepDeltaEvent });
+      },
+    },
+    [GraphEvents.ON_MESSAGE_DELTA]: {
+      handle: (
+        event: GraphEvents.ON_MESSAGE_DELTA,
+        data: t.StreamEventData
+      ): void => {
+        aggregateContent({ event, data: data as t.MessageDeltaEvent });
+      },
+    },
+  };
+
+  // Create multi-agent run configuration
+  const runConfig: t.RunConfig = {
+    runId: `sequential-chain-${Date.now()}`,
+    graphConfig: {
+      type: 'multi-agent',
+      agents,
+      edges,
+    },
+    customHandlers,
+    returnContent: true,
+  };
+
+  try {
+    // Create and execute the run
+    const run = await Run.create(runConfig);
+
+    // Test with a complex question that benefits from multiple perspectives
+    const userMessage =
+      'I want to launch a new mobile app for personal finance management. What should I consider?';
+    conversationHistory.push(new HumanMessage(userMessage));
+
+    console.log(`User: "${userMessage}"\n`);
+    console.log('Starting sequential agent chain...\n');
+
+    const config = {
+      configurable: {
+        thread_id: 'sequential-chain-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\n=== Final Output ===');
+    console.log('Sequential chain completed successfully!');
+    console.log(`Total content parts: ${contentParts.length}`);
+
+    // Display the buffer accumulation
+    console.log('\n=== Agent Outputs (Buffer Accumulation) ===');
+
+    const aiMessages = conversationHistory.filter(
+      (msg) => msg._getType() === 'ai'
+    );
+
+    aiMessages.forEach((msg, index) => {
+      console.log(`\n--- Agent ${index + 1}: ${agentIds[index]} ---`);
+      console.log(msg.content);
+
+      // Show buffer preview for next agent (except last)
+      if (index < aiMessages.length - 1) {
+        const bufferSoFar = getBufferString(aiMessages.slice(0, index + 1));
+        console.log(
+          `\n[Buffer passed to ${agentIds[index + 1]}]: ${bufferSoFar.slice(0, 150)}...`
+        );
+      }
+    });
+
+    // Demonstrate that each agent built upon previous results
+    console.log('\n=== Chain Analysis ===');
+    console.log('1. Researcher provided initial findings');
+    console.log('2. Analyst built upon research with deeper insights');
+    console.log('3. Reviewer critiqued and identified gaps');
+    console.log('4. Summarizer synthesized everything into actionable output');
+  } catch (error) {
+    console.error('Error in sequential agent chain test:', error);
+  }
+}
+
+// Run the test
+testSequentialAgentChain();