@librechat/agents 3.0.16 → 3.0.18

package/src/messages/formatAgentMessages.test.ts

@@ -71,6 +71,66 @@ describe('formatAgentMessages', () => {
     expect((result.messages[1] as ToolMessage).tool_call_id).toBe('123');
   });
 
+  it('should handle malformed tool call entries with missing tool_call property', () => {
+    const tools = new Set(['search']);
+    const payload = [
+      {
+        role: 'assistant',
+        content: [
+          {
+            type: ContentTypes.TEXT,
+            [ContentTypes.TEXT]: 'Let me check that.',
+            tool_call_ids: ['123'],
+          },
+          {
+            type: ContentTypes.TOOL_CALL,
+            // Missing tool_call property - should not crash
+          },
+          {
+            type: ContentTypes.TOOL_CALL,
+            tool_call: {
+              id: '123',
+              name: 'search',
+              args: '{"query":"test"}',
+              output: 'Result',
+            },
+          },
+        ],
+      },
+    ];
+    // Should not throw error
+    const result = formatAgentMessages(payload, undefined, tools);
+    expect(result.messages).toBeDefined();
+    expect(result.messages.length).toBeGreaterThan(0);
+  });
+
+  it('should handle malformed tool call entries with missing name', () => {
+    const tools = new Set(['search']);
+    const payload = [
+      {
+        role: 'assistant',
+        content: [
+          {
+            type: ContentTypes.TEXT,
+            [ContentTypes.TEXT]: 'Checking...',
+          },
+          {
+            type: ContentTypes.TOOL_CALL,
+            tool_call: {
+              id: '456',
+              // Missing name property
+              args: '{}',
+            },
+          },
+        ],
+      },
+    ];
+    // Should not throw error
+    const result = formatAgentMessages(payload, undefined, tools);
+    expect(result.messages).toBeDefined();
+    expect(result.messages.length).toBeGreaterThan(0);
+  });
+
   it('should handle multiple content parts in assistant messages', () => {
     const payload = [
       {

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

@@ -6,7 +6,7 @@ config();
 import { HumanMessage, BaseMessage } from '@langchain/core/messages';
 import { Run } from '@/run';
 import { ChatModelStreamHandler, createContentAggregator } from '@/stream';
-import { Providers, GraphEvents, Constants } from '@/common';
+import { Providers, GraphEvents, Constants, StepTypes } from '@/common';
 import { ToolEndHandler, ModelEndHandler } from '@/events';
 import type * as t from '@/types';
 
@@ -230,9 +230,59 @@ async function testSupervisorListHandoff() {
         conversationHistory.push(...finalMessages);
       }
 
-      // Show summary
+      // Demo: Map contentParts to agentIds
       console.log(`\n${'─'.repeat(60)}`);
-      console.log(`Graph structure:`);
+      console.log('CONTENT PARTS TO AGENT MAPPING:');
+      console.log('─'.repeat(60));
+
+      if (run.Graph) {
+        // Get the mapping of contentPart index to agentId
+        const contentPartAgentMap = run.Graph.getContentPartAgentMap();
+
+        console.log(`\nTotal content parts: ${contentParts.length}`);
+        console.log(`\nContent Part → Agent Mapping:`);
+
+        contentPartAgentMap.forEach((agentId, index) => {
+          const contentPart = contentParts[index];
+          const contentType = contentPart?.type || 'unknown';
+          const preview =
+            contentType === 'text'
+              ? (contentPart as any).text?.slice(0, 50) || ''
+              : contentType === 'tool_call'
+                ? `Tool: ${(contentPart as any).tool_call?.name || 'unknown'}`
+                : contentType;
+
+          console.log(
+            `  [${index}] ${agentId} → ${contentType}: ${preview}${preview.length >= 50 ? '...' : ''}`
+          );
+        });
+
+        // Show agent participation summary
+        console.log(`\n${'─'.repeat(60)}`);
+        console.log('AGENT PARTICIPATION SUMMARY:');
+        console.log('─'.repeat(60));
+
+        const activeAgents = run.Graph.getActiveAgentIds();
+        console.log(`\nActive agents (${activeAgents.length}):`, activeAgents);
+
+        const stepsByAgent = run.Graph.getRunStepsByAgent();
+        stepsByAgent.forEach((steps, agentId) => {
+          const toolCallSteps = steps.filter(
+            (s) => s.type === StepTypes.TOOL_CALLS
+          ).length;
+          const messageSteps = steps.filter(
+            (s) => s.type === StepTypes.MESSAGE_CREATION
+          ).length;
+          console.log(`\n  ${agentId}:`);
+          console.log(`    - Total steps: ${steps.length}`);
+          console.log(`    - Message steps: ${messageSteps}`);
+          console.log(`    - Tool call steps: ${toolCallSteps}`);
+        });
+      }
+
+      // Show graph structure summary
+      console.log(`\n${'─'.repeat(60)}`);
+      console.log(`GRAPH STRUCTURE:`);
       console.log(`- Agents: 6 total (supervisor + 5 specialists)`);
       console.log(`- Edges: 1 edge with multiple destinations`);
       console.log(

package/src/scripts/test-thinking-handoff-bedrock.ts

@@ -0,0 +1,153 @@
+#!/usr/bin/env bun
+
+import { config } from 'dotenv';
+config();
+
+import { HumanMessage, BaseMessage } from '@langchain/core/messages';
+import { Run } from '@/run';
+import { ChatModelStreamHandler } from '@/stream';
+import { Providers, GraphEvents } from '@/common';
+import { ToolEndHandler, ModelEndHandler } from '@/events';
+import type * as t from '@/types';
+
+const conversationHistory: BaseMessage[] = [];
+
+/**
+ * Test edge case: switching from OpenAI supervisor (no thinking) to Bedrock specialist (with thinking enabled)
+ * This should not throw an error about missing thinking blocks
+ */
+async function testBedrockThinkingHandoff() {
+  console.log('Testing OpenAI → Bedrock (with thinking) handoff...\n');
+
+  // Create custom handlers
+  const customHandlers = {
+    [GraphEvents.TOOL_END]: new ToolEndHandler(),
+    [GraphEvents.CHAT_MODEL_END]: new ModelEndHandler(),
+    [GraphEvents.CHAT_MODEL_STREAM]: new ChatModelStreamHandler(),
+    [GraphEvents.TOOL_START]: {
+      handle: (_event: string, data: t.StreamEventData): void => {
+        const toolData = data as any;
+        if (toolData?.name) {
+          console.log(`\n🔧 Tool called: ${toolData.name}`);
+        }
+      },
+    },
+  };
+
+  // Create the graph configuration
+  function createGraphConfig(): t.RunConfig {
+    console.log(
+      'Creating graph with OpenAI supervisor and Bedrock specialist with thinking enabled.\n'
+    );
+
+    const agents: t.AgentInputs[] = [
+      {
+        agentId: 'supervisor',
+        provider: Providers.OPENAI,
+        clientOptions: {
+          modelName: 'gpt-4o-mini',
+          apiKey: process.env.OPENAI_API_KEY,
+        },
+        instructions: `You are a task supervisor. When the user asks about code review, use transfer_to_code_reviewer to hand off to the specialist.`,
+        maxContextTokens: 8000,
+      },
+      {
+        agentId: 'code_reviewer',
+        provider: Providers.BEDROCK,
+        clientOptions: {
+          region: process.env.BEDROCK_AWS_REGION || 'us-east-1',
+          model: 'us.anthropic.claude-3-7-sonnet-20250219-v1:0',
+          credentials: {
+            accessKeyId: process.env.BEDROCK_AWS_ACCESS_KEY_ID!,
+            secretAccessKey: process.env.BEDROCK_AWS_SECRET_ACCESS_KEY!,
+          },
+          additionalModelRequestFields: {
+            thinking: {
+              type: 'enabled',
+              budget_tokens: 2000,
+            },
+          },
+        },
+        instructions: `You are a code review specialist using Bedrock with extended thinking. Think carefully about the code quality, best practices, and potential issues. Provide thoughtful feedback.`,
+        maxContextTokens: 8000,
+      },
+    ];
+
+    const edges: t.GraphEdge[] = [
+      {
+        from: 'supervisor',
+        to: ['code_reviewer'],
+        description: 'Transfer to code review specialist',
+        edgeType: 'handoff',
+      },
+    ];
+
+    return {
+      runId: `bedrock-thinking-handoff-test-${Date.now()}`,
+      graphConfig: {
+        type: 'multi-agent',
+        agents,
+        edges,
+      },
+      customHandlers,
+      returnContent: true,
+    };
+  }
+
+  try {
+    // Test query that should trigger a handoff
+    const query =
+      'Can you review this function and tell me if there are any issues?\n\nfunction add(a, b) { return a + b; }';
+
+    console.log(`${'='.repeat(60)}`);
+    console.log(`USER QUERY: "${query}"`);
+    console.log('='.repeat(60));
+
+    // Initialize conversation
+    conversationHistory.push(new HumanMessage(query));
+
+    // Create and run the graph
+    const runConfig = createGraphConfig();
+    const run = await Run.create(runConfig);
+
+    const config = {
+      configurable: {
+        thread_id: 'bedrock-thinking-handoff-test-1',
+      },
+      streamMode: 'values',
+      version: 'v2' as const,
+    };
+
+    console.log('\nProcessing request...\n');
+
+    // Process with streaming
+    const inputs = {
+      messages: conversationHistory,
+    };
+
+    await run.processStream(inputs, config);
+    const finalMessages = run.getRunMessages();
+
+    if (finalMessages) {
+      conversationHistory.push(...finalMessages);
+    }
+
+    // Success!
+    console.log(`\n${'='.repeat(60)}`);
+    console.log('✅ TEST PASSED');
+    console.log('='.repeat(60));
+    console.log('\nSuccessfully handed off from OpenAI (no thinking) to');
+    console.log('Bedrock with thinking enabled without errors!');
+    console.log('\nThe ensureThinkingBlockInMessages() function correctly');
+    console.log('handled the transition by converting tool sequences to');
+    console.log('HumanMessages before calling the Bedrock API.');
+  } catch (error) {
+    console.error('\n❌ TEST FAILED');
+    console.error('='.repeat(60));
+    console.error('Error:', error);
+    process.exit(1);
+  }
+}
+
+// Run the test
+testBedrockThinkingHandoff();

package/src/scripts/test-thinking-handoff.ts

@@ -0,0 +1,147 @@
+#!/usr/bin/env bun
+
+import { config } from 'dotenv';
+config();
+
+import { HumanMessage, BaseMessage } from '@langchain/core/messages';
+import type * as t from '@/types';
+import { ToolEndHandler, ModelEndHandler } from '@/events';
+import { ChatModelStreamHandler } from '@/stream';
+import { Providers, GraphEvents } from '@/common';
+import { Run } from '@/run';
+
+const conversationHistory: BaseMessage[] = [];
+
+/**
+ * Test edge case: switching from OpenAI supervisor (no thinking) to Anthropic specialist (with thinking enabled)
+ * This should not throw an error about missing thinking blocks
+ */
+async function testThinkingHandoff() {
+  console.log('Testing OpenAI → Anthropic (with thinking) handoff...\n');
+
+  // Create custom handlers
+  const customHandlers = {
+    [GraphEvents.TOOL_END]: new ToolEndHandler(),
+    [GraphEvents.CHAT_MODEL_END]: new ModelEndHandler(),
+    [GraphEvents.CHAT_MODEL_STREAM]: new ChatModelStreamHandler(),
+    [GraphEvents.TOOL_START]: {
+      handle: (_event: string, data: t.StreamEventData): void => {
+        const toolData = data as any;
+        if (toolData?.name) {
+          console.log(`\n🔧 Tool called: ${toolData.name}`);
+        }
+      },
+    },
+  };
+
+  // Create the graph configuration
+  function createGraphConfig(): t.RunConfig {
+    console.log(
+      'Creating graph with OpenAI supervisor and Anthropic specialist with thinking enabled.\n'
+    );
+
+    const agents: t.AgentInputs[] = [
+      {
+        agentId: 'supervisor',
+        provider: Providers.OPENAI,
+        clientOptions: {
+          modelName: 'gpt-4o-mini',
+          apiKey: process.env.OPENAI_API_KEY,
+        },
+        instructions: `You are a task supervisor. When the user asks about code review, use transfer_to_code_reviewer to hand off to the specialist.`,
+        maxContextTokens: 8000,
+      },
+      {
+        agentId: 'code_reviewer',
+        provider: Providers.ANTHROPIC,
+        clientOptions: {
+          modelName: 'claude-3-7-sonnet-20250219',
+          apiKey: process.env.ANTHROPIC_API_KEY,
+          thinking: {
+            type: 'enabled',
+            budget_tokens: 2000,
+          },
+        },
+        instructions: `You are a code review specialist. Think carefully about the code quality, best practices, and potential issues. Provide thoughtful feedback.`,
+        maxContextTokens: 8000,
+      },
+    ];
+
+    const edges: t.GraphEdge[] = [
+      {
+        from: 'supervisor',
+        to: ['code_reviewer'],
+        description: 'Transfer to code review specialist',
+        edgeType: 'handoff',
+      },
+    ];
+
+    return {
+      runId: `thinking-handoff-test-${Date.now()}`,
+      graphConfig: {
+        type: 'multi-agent',
+        agents,
+        edges,
+      },
+      customHandlers,
+      returnContent: true,
+    };
+  }
+
+  try {
+    // Test query that should trigger a handoff
+    const query =
+      'Can you review this function and tell me if there are any issues?\n\nfunction add(a, b) { return a + b; }';
+
+    console.log(`${'='.repeat(60)}`);
+    console.log(`USER QUERY: "${query}"`);
+    console.log('='.repeat(60));
+
+    // Initialize conversation
+    conversationHistory.push(new HumanMessage(query));
+
+    // Create and run the graph
+    const runConfig = createGraphConfig();
+    const run = await Run.create(runConfig);
+
+    const config = {
+      configurable: {
+        thread_id: 'thinking-handoff-test-1',
+      },
+      streamMode: 'values',
+      version: 'v2' as const,
+    };
+
+    console.log('\nProcessing request...\n');
+
+    // Process with streaming
+    const inputs = {
+      messages: conversationHistory,
+    };
+
+    await run.processStream(inputs, config);
+    const finalMessages = run.getRunMessages();
+
+    if (finalMessages) {
+      conversationHistory.push(...finalMessages);
+    }
+
+    // Success!
+    console.log(`\n${'='.repeat(60)}`);
+    console.log('✅ TEST PASSED');
+    console.log('='.repeat(60));
+    console.log('\nSuccessfully handed off from OpenAI (no thinking) to');
+    console.log('Anthropic with thinking enabled without errors!');
+    console.log('\nThe ensureThinkingBlockInMessages() function correctly');
+    console.log('added a placeholder thinking block to the last assistant');
+    console.log('message before calling the Anthropic API.');
+  } catch (error) {
+    console.error('\n❌ TEST FAILED');
+    console.error('='.repeat(60));
+    console.error('Error:', error);
+    process.exit(1);
+  }
+}
+
+// Run the test
+testThinkingHandoff();