@librechat/agents 3.4.7 → 3.5.0

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

@@ -1,217 +0,0 @@
-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[] = [];
-
-/**
- * Example of simple sequential multi-agent system
- *
- * Graph structure:
- * START -> agent_a -> agent_b -> agent_c -> END
- *
- * No conditions, no tools, just automatic sequential flow
- */
-async function testSequentialMultiAgent() {
-  console.log('Testing Sequential Multi-Agent System (A → B → C)...\n');
-
-  // Set up content aggregator
-  const { contentParts, aggregateContent, stepMap } = createContentAggregator();
-
-  // Define three simple agents
-  const agents: t.AgentInputs[] = [
-    {
-      agentId: 'agent_a',
-      provider: Providers.ANTHROPIC,
-      clientOptions: {
-        modelName: 'claude-haiku-4-5',
-        apiKey: process.env.ANTHROPIC_API_KEY,
-      },
-      instructions: `You are Agent A, the first agent in a sequential workflow.
-      Your job is to:
-      1. Receive the initial user request
-      2. Process it and add your perspective (keep it brief, 2-3 sentences)
-      3. Pass it along to Agent B
-      
-      Start your response with "AGENT A:" and end with "Passing to Agent B..."`,
-      maxContextTokens: 8000,
-    },
-    {
-      agentId: 'agent_b',
-      provider: Providers.ANTHROPIC,
-      clientOptions: {
-        modelName: 'claude-haiku-4-5',
-        apiKey: process.env.ANTHROPIC_API_KEY,
-      },
-      instructions: `You are Agent B, the second agent in a sequential workflow.
-      Your job is to:
-      1. Receive the context from Agent A
-      2. Add your own analysis or perspective (keep it brief, 2-3 sentences)
-      3. Pass it along to Agent C
-      
-      Start your response with "AGENT B:" and end with "Passing to Agent C..."`,
-      maxContextTokens: 8000,
-    },
-    {
-      agentId: 'agent_c',
-      provider: Providers.ANTHROPIC,
-      clientOptions: {
-        modelName: 'claude-haiku-4-5',
-        apiKey: process.env.ANTHROPIC_API_KEY,
-      },
-      instructions: `You are Agent C, the final agent in a sequential workflow.
-      Your job is to:
-      1. Receive the context from Agents A and B
-      2. Provide a final summary or conclusion based on all previous inputs
-      3. Complete the workflow
-      
-      Start your response with "AGENT C:" and end with "Workflow complete."`,
-      maxContextTokens: 8000,
-    },
-  ];
-
-  // Define sequential edges using 'direct' type to avoid tool creation
-  // This creates automatic transitions without requiring agents to call tools
-  const edges: t.GraphEdge[] = [
-    {
-      from: 'agent_a',
-      to: 'agent_b',
-      edgeType: 'direct', // This creates direct edges without tools
-      description: 'Automatic transition from A to B',
-    },
-    {
-      from: 'agent_b',
-      to: 'agent_c',
-      edgeType: 'direct', // This creates direct edges without tools
-      description: 'Automatic transition from B to C',
-    },
-  ];
-
-  // 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-multi-agent-${Date.now()}`,
-    graphConfig: {
-      type: 'multi-agent',
-      agents,
-      edges,
-    },
-    customHandlers,
-    returnContent: true,
-    skipCleanup: true,
-  };
-
-  try {
-    // Create and execute the run
-    const run = await Run.create(runConfig);
-
-    // Test with a simple question
-    const userMessage =
-      'What are the key considerations for building a recommendation system?';
-    conversationHistory.push(new HumanMessage(userMessage));
-
-    console.log(`User: "${userMessage}"\n`);
-    console.log('Starting sequential workflow...\n');
-
-    const config = {
-      configurable: {
-        thread_id: 'sequential-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\n=== Final Output ===');
-    console.log('Sequential flow completed successfully!');
-    console.log(`Total content parts: ${contentParts.length}`);
-    console.log('\n=== Content Parts (clean, no metadata) ===');
-    console.dir(contentParts, { depth: null });
-    console.log('\n=== Step Map (separate from content) ===');
-    console.dir(Object.fromEntries(stepMap), { depth: null });
-
-    // Display the sequential responses
-    const aiMessages = conversationHistory.filter(
-      (msg) => msg._getType() === 'ai'
-    );
-    aiMessages.forEach((msg, index) => {
-      console.log(`\n--- Response ${index + 1} ---`);
-      console.log(msg.content);
-    });
-  } catch (error) {
-    console.error('Error in sequential multi-agent test:', error);
-  }
-}
-
-// Run the test
-testSequentialMultiAgent();

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

@@ -1,246 +0,0 @@
-import { config } from 'dotenv';
-config();
-
-import { HumanMessage } from '@langchain/core/messages';
-import type { BaseMessage } from '@langchain/core/messages';
-import type * as t from '@/types';
-import { ChatModelStreamHandler, createContentAggregator } from '@/stream';
-import { ToolEndHandler, ModelEndHandler } from '@/events';
-import { Providers, GraphEvents, Constants } from '@/common';
-import { Run } from '@/run';
-
-/**
- * Manual verification script for the subagent primitive.
- *
- * Configures a supervisor agent with two subagent types (researcher, coder),
- * sends a query, and confirms:
- * 1. The parent agent delegates to a subagent via the `subagent` tool
- * 2. The child executes with isolated context (fresh message history)
- * 3. Only the filtered text result returns to the parent
- * 4. The parent incorporates the result and responds
- *
- * Usage:
- *   OPENAI_API_KEY=... npx ts-node -r tsconfig-paths/register src/scripts/multi-agent-subagent.ts
- *
- * Or with Anthropic:
- *   ANTHROPIC_API_KEY=... npx ts-node -r tsconfig-paths/register src/scripts/multi-agent-subagent.ts --provider anthropic
- */
-
-const useAnthropic =
-  process.argv.includes('--provider') &&
-  process.argv[process.argv.indexOf('--provider') + 1] === 'anthropic';
-
-const provider = useAnthropic ? Providers.ANTHROPIC : Providers.OPENAI;
-const apiKey = useAnthropic
-  ? process.env.ANTHROPIC_API_KEY
-  : process.env.OPENAI_API_KEY;
-const modelName = useAnthropic ? 'claude-sonnet-4-20250514' : 'gpt-5.4';
-
-if (!apiKey) {
-  console.error(
-    `Missing ${useAnthropic ? 'ANTHROPIC_API_KEY' : 'OPENAI_API_KEY'} environment variable`
-  );
-  process.exit(1);
-}
-
-async function testSubagentPrimitive() {
-  console.log('=== Subagent Primitive Manual Verification ===\n');
-  console.log(`Provider: ${provider}`);
-  console.log(`Model: ${modelName}\n`);
-
-  const { aggregateContent } = createContentAggregator();
-
-  const parentAgent: t.AgentInputs = {
-    agentId: 'supervisor',
-    provider,
-    clientOptions: { modelName, apiKey },
-    instructions: `You are a supervisor agent. You have access to specialized subagents.
-
-When the user asks a research question, delegate it to the "researcher" subagent.
-When the user asks for code, delegate it to the "coder" subagent.
-
-After receiving the subagent's result, synthesize it into a clear final answer for the user.
-Always use a subagent for research or coding tasks — do not answer directly.`,
-    maxContextTokens: 16000,
-    subagentConfigs: [
-      {
-        type: 'researcher',
-        name: 'Research Specialist',
-        description:
-          'Researches topics and provides detailed summaries with sources.',
-        agentInputs: {
-          agentId: 'researcher',
-          provider,
-          clientOptions: { modelName, apiKey },
-          instructions: `You are a research specialist working in an isolated context.
-You receive a single task description and must answer it thoroughly.
-Be concise but comprehensive. Include key facts and details.`,
-          maxContextTokens: 8000,
-        },
-      },
-      {
-        type: 'coder',
-        name: 'Coding Specialist',
-        description:
-          'Writes, reviews, and explains code in any programming language.',
-        agentInputs: {
-          agentId: 'coder',
-          provider,
-          clientOptions: { modelName, apiKey },
-          instructions: `You are a coding specialist working in an isolated context.
-You receive a single task description and must provide working code.
-Include brief explanations. Use clean, idiomatic code.`,
-          maxContextTokens: 8000,
-        },
-      },
-    ],
-  };
-
-  const customHandlers: Record<string, t.EventHandler> = {
-    [GraphEvents.CHAT_MODEL_STREAM]: new ChatModelStreamHandler(),
-    [GraphEvents.TOOL_END]: new ToolEndHandler(),
-    [GraphEvents.CHAT_MODEL_END]: new ModelEndHandler(),
-    [GraphEvents.ON_RUN_STEP_COMPLETED]: {
-      handle: (event: string, data: t.StreamEventData): void => {
-        aggregateContent({
-          event: event as GraphEvents,
-          data: data as t.RunStep,
-        });
-      },
-    },
-    [GraphEvents.ON_RUN_STEP]: {
-      handle: (event: string, data: t.StreamEventData): void => {
-        aggregateContent({
-          event: event as GraphEvents,
-          data: data as t.RunStep,
-        });
-      },
-    },
-    [GraphEvents.ON_RUN_STEP_DELTA]: {
-      handle: (event: string, data: t.StreamEventData): void => {
-        aggregateContent({
-          event: event as GraphEvents,
-          data: data as t.RunStepDeltaEvent,
-        });
-      },
-    },
-    [GraphEvents.ON_MESSAGE_DELTA]: {
-      handle: (event: string, data: t.StreamEventData): void => {
-        aggregateContent({
-          event: event as GraphEvents,
-          data: data as t.MessageDeltaEvent,
-        });
-      },
-    },
-  };
-
-  const run = await Run.create<t.IState>({
-    runId: `subagent-manual-${Date.now()}`,
-    graphConfig: {
-      type: 'standard',
-      agents: [parentAgent],
-    },
-    returnContent: true,
-    customHandlers,
-  });
-
-  console.log('--- Run created ---');
-  console.log(
-    `Subagent tool present: ${
-      (
-        (run.Graph as import('@/graphs/Graph').StandardGraph).agentContexts.get(
-          'supervisor'
-        )?.graphTools as t.GenericTool[] | undefined
-      )?.some((t) => 'name' in t && t.name === Constants.SUBAGENT) ?? false
-    }\n`
-  );
-
-  const conversationHistory: BaseMessage[] = [];
-
-  // Turn 1: Research question (should delegate to researcher subagent)
-  console.log('=== Turn 1: Research Question ===\n');
-  console.log(
-    'User: What are the three laws of thermodynamics? Explain briefly.\n'
-  );
-
-  const userMessage = new HumanMessage(
-    'What are the three laws of thermodynamics? Explain briefly.'
-  );
-  conversationHistory.push(userMessage);
-
-  const callerConfig = {
-    configurable: { thread_id: 'subagent-verify' },
-    streamMode: 'values' as const,
-    version: 'v2' as const,
-  };
-
-  console.log('--- Streaming response ---\n');
-  const result = await run.processStream(
-    { messages: conversationHistory },
-    callerConfig
-  );
-
-  const runMessages = run.getRunMessages();
-  console.log('\n\n--- Run Messages ---\n');
-
-  if (runMessages) {
-    for (const msg of runMessages) {
-      const type = msg._getType();
-      if (type === 'tool') {
-        const name = 'name' in msg ? msg.name : 'unknown';
-        const rawContent =
-          typeof msg.content === 'string'
-            ? msg.content
-            : JSON.stringify(msg.content);
-        const content = rawContent.slice(0, 200);
-        const truncated = rawContent.length > 200 ? '...' : '';
-        console.log(`[ToolMessage] name=${name}`);
-        console.log(`  content: ${content}${truncated}\n`);
-      } else if (type === 'ai') {
-        const content =
-          typeof msg.content === 'string'
-            ? msg.content.slice(0, 300)
-            : JSON.stringify(msg.content).slice(0, 300);
-        const toolCalls = 'tool_calls' in msg ? msg.tool_calls : undefined;
-        console.log(`[AIMessage]`);
-        if (toolCalls && Array.isArray(toolCalls) && toolCalls.length > 0) {
-          for (const tc of toolCalls) {
-            console.log(
-              `  tool_call: ${tc.name}(${JSON.stringify(tc.args).slice(0, 100)}...)`
-            );
-          }
-        }
-        console.log(
-          `  content: ${content}${content.length >= 300 ? '...' : ''}\n`
-        );
-      }
-    }
-
-    const subagentToolMessages = runMessages.filter(
-      (msg) =>
-        msg._getType() === 'tool' &&
-        'name' in msg &&
-        msg.name === Constants.SUBAGENT
-    );
-    console.log(`\n--- Verification ---`);
-    console.log(`Subagent tool calls found: ${subagentToolMessages.length}`);
-    console.log(`Total run messages: ${runMessages.length}`);
-    console.log(`Result content parts: ${result?.length ?? 0}`);
-
-    if (subagentToolMessages.length > 0) {
-      console.log(
-        '\nSUCCESS: Subagent was invoked and returned a filtered result.'
-      );
-      console.log(
-        'The child context was isolated — only the final text came back.'
-      );
-    } else {
-      console.log('\nNOTE: No subagent tool calls detected.');
-      console.log('The LLM may have answered directly without delegating.');
-    }
-  }
-
-  console.log('\n=== Done ===');
-}
-
-testSubagentPrimitive().catch(console.error);