@librechat/agents 3.0.17 → 3.0.18

package/src/messages/ensureThinkingBlock.test.ts

@@ -0,0 +1,393 @@
+import { AIMessage, HumanMessage, ToolMessage } from '@langchain/core/messages';
+import type { ExtendedMessageContent } from '@/types';
+import { ensureThinkingBlockInMessages } from './format';
+import { Providers, ContentTypes } from '@/common';
+
+describe('ensureThinkingBlockInMessages', () => {
+  describe('messages with thinking blocks (should not be modified)', () => {
+    test('should not modify AI message that already has thinking block', () => {
+      const messages = [
+        new HumanMessage({ content: 'Hello' }),
+        new AIMessage({
+          content: [
+            { type: ContentTypes.THINKING, thinking: 'Let me think...' },
+            { type: 'text', text: 'Hi there!' },
+          ],
+        }),
+      ];
+
+      const result = ensureThinkingBlockInMessages(
+        messages,
+        Providers.ANTHROPIC
+      );
+
+      expect(result).toHaveLength(2);
+      expect(result[0]).toBeInstanceOf(HumanMessage);
+      expect(result[1]).toBeInstanceOf(AIMessage);
+      expect((result[1].content as ExtendedMessageContent[])[0].type).toBe(
+        ContentTypes.THINKING
+      );
+    });
+
+    test('should not modify AI message that has redacted_thinking block', () => {
+      const messages = [
+        new HumanMessage({ content: 'Hello' }),
+        new AIMessage({
+          content: [
+            { type: 'redacted_thinking', data: 'redacted' },
+            { type: 'text', text: 'Hi there!' },
+          ],
+        }),
+      ];
+
+      const result = ensureThinkingBlockInMessages(
+        messages,
+        Providers.ANTHROPIC
+      );
+
+      expect(result).toHaveLength(2);
+      expect(result[0]).toBeInstanceOf(HumanMessage);
+      expect(result[1]).toBeInstanceOf(AIMessage);
+      expect((result[1].content as ExtendedMessageContent[])[0].type).toBe(
+        'redacted_thinking'
+      );
+    });
+  });
+
+  describe('messages with tool_calls (should be converted)', () => {
+    test('should convert AI message with tool_calls to HumanMessage', () => {
+      const messages = [
+        new HumanMessage({ content: 'What is the weather?' }),
+        new AIMessage({
+          content: 'Let me check the weather.',
+          tool_calls: [
+            {
+              id: 'call_123',
+              name: 'get_weather',
+              args: { location: 'NYC' },
+              type: 'tool_call',
+            },
+          ],
+        }),
+        new ToolMessage({
+          content: 'Sunny, 75°F',
+          tool_call_id: 'call_123',
+        }),
+      ];
+
+      const result = ensureThinkingBlockInMessages(
+        messages,
+        Providers.ANTHROPIC
+      );
+
+      // Should have 2 messages: HumanMessage + converted HumanMessage
+      expect(result).toHaveLength(2);
+      expect(result[0]).toBeInstanceOf(HumanMessage);
+      expect(result[0].content).toBe('What is the weather?');
+      expect(result[1]).toBeInstanceOf(HumanMessage);
+
+      // Check that the converted message includes the context prefix
+      expect(result[1].content).toContain('[Previous agent context]');
+      expect(result[1].content).toContain('Let me check the weather');
+      expect(result[1].content).toContain('Sunny, 75°F');
+    });
+
+    test('should convert AI message with tool_use in content to HumanMessage', () => {
+      const messages = [
+        new HumanMessage({ content: 'Search for something' }),
+        new AIMessage({
+          content: [
+            { type: 'text', text: 'Searching...' },
+            {
+              type: 'tool_use',
+              id: 'call_456',
+              name: 'search',
+              input: { query: 'test' },
+            },
+          ],
+        }),
+        new ToolMessage({
+          content: 'Found results',
+          tool_call_id: 'call_456',
+        }),
+      ];
+
+      const result = ensureThinkingBlockInMessages(
+        messages,
+        Providers.ANTHROPIC
+      );
+
+      expect(result).toHaveLength(2);
+      expect(result[0]).toBeInstanceOf(HumanMessage);
+      expect(result[1]).toBeInstanceOf(HumanMessage);
+      expect(result[1].content).toContain('[Previous agent context]');
+      expect(result[1].content).toContain('Searching...');
+      expect(result[1].content).toContain('Found results');
+    });
+
+    test('should handle multiple tool messages in sequence', () => {
+      const messages = [
+        new HumanMessage({ content: 'Do multiple things' }),
+        new AIMessage({
+          content: 'I will perform multiple actions.',
+          tool_calls: [
+            {
+              id: 'call_1',
+              name: 'action1',
+              args: { param: 'a' },
+              type: 'tool_call',
+            },
+            {
+              id: 'call_2',
+              name: 'action2',
+              args: { param: 'b' },
+              type: 'tool_call',
+            },
+          ],
+        }),
+        new ToolMessage({
+          content: 'Result 1',
+          tool_call_id: 'call_1',
+        }),
+        new ToolMessage({
+          content: 'Result 2',
+          tool_call_id: 'call_2',
+        }),
+      ];
+
+      const result = ensureThinkingBlockInMessages(
+        messages,
+        Providers.ANTHROPIC
+      );
+
+      // Should combine all tool messages into one HumanMessage
+      expect(result).toHaveLength(2);
+      expect(result[1]).toBeInstanceOf(HumanMessage);
+      expect(result[1].content).toContain('Result 1');
+      expect(result[1].content).toContain('Result 2');
+    });
+  });
+
+  describe('messages without tool calls (should pass through)', () => {
+    test('should not modify AI message without tool calls', () => {
+      const messages = [
+        new HumanMessage({ content: 'Hello' }),
+        new AIMessage({ content: 'Hi there, how can I help?' }),
+      ];
+
+      const result = ensureThinkingBlockInMessages(
+        messages,
+        Providers.ANTHROPIC
+      );
+
+      expect(result).toHaveLength(2);
+      expect(result[0]).toBeInstanceOf(HumanMessage);
+      expect(result[0].content).toBe('Hello');
+      expect(result[1]).toBeInstanceOf(AIMessage);
+      expect(result[1].content).toBe('Hi there, how can I help?');
+    });
+
+    test('should preserve HumanMessages and other message types', () => {
+      const messages = [
+        new HumanMessage({ content: 'Question 1' }),
+        new AIMessage({ content: 'Answer 1' }),
+        new HumanMessage({ content: 'Question 2' }),
+        new AIMessage({ content: 'Answer 2' }),
+      ];
+
+      const result = ensureThinkingBlockInMessages(
+        messages,
+        Providers.ANTHROPIC
+      );
+
+      expect(result).toHaveLength(4);
+      expect(result[0]).toBeInstanceOf(HumanMessage);
+      expect(result[1]).toBeInstanceOf(AIMessage);
+      expect(result[2]).toBeInstanceOf(HumanMessage);
+      expect(result[3]).toBeInstanceOf(AIMessage);
+    });
+  });
+
+  describe('mixed scenarios', () => {
+    test('should handle mix of normal and tool-using messages', () => {
+      const messages = [
+        new HumanMessage({ content: 'First question' }),
+        new AIMessage({ content: 'First answer without tools' }),
+        new HumanMessage({ content: 'Second question' }),
+        new AIMessage({
+          content: 'Using a tool',
+          tool_calls: [
+            {
+              id: 'call_abc',
+              name: 'some_tool',
+              args: {},
+              type: 'tool_call',
+            },
+          ],
+        }),
+        new ToolMessage({
+          content: 'Tool result',
+          tool_call_id: 'call_abc',
+        }),
+        new HumanMessage({ content: 'Third question' }),
+        new AIMessage({ content: 'Third answer without tools' }),
+      ];
+
+      const result = ensureThinkingBlockInMessages(
+        messages,
+        Providers.ANTHROPIC
+      );
+
+      // Original message 1: HumanMessage (preserved)
+      // Original message 2: AIMessage without tools (preserved)
+      // Original message 3: HumanMessage (preserved)
+      // Original messages 4-5: AIMessage with tool + ToolMessage (converted to 1 HumanMessage)
+      // Original message 6: HumanMessage (preserved)
+      // Original message 7: AIMessage without tools (preserved)
+      expect(result).toHaveLength(6);
+      expect(result[0]).toBeInstanceOf(HumanMessage);
+      expect(result[1]).toBeInstanceOf(AIMessage);
+      expect(result[2]).toBeInstanceOf(HumanMessage);
+      expect(result[3]).toBeInstanceOf(HumanMessage); // Converted
+      expect(result[4]).toBeInstanceOf(HumanMessage);
+      expect(result[5]).toBeInstanceOf(AIMessage);
+    });
+
+    test('should handle multiple tool-using sequences', () => {
+      const messages = [
+        new HumanMessage({ content: 'Do task 1' }),
+        new AIMessage({
+          content: 'Doing task 1',
+          tool_calls: [
+            {
+              id: 'call_1',
+              name: 'tool1',
+              args: {},
+              type: 'tool_call',
+            },
+          ],
+        }),
+        new ToolMessage({
+          content: 'Result 1',
+          tool_call_id: 'call_1',
+        }),
+        new HumanMessage({ content: 'Do task 2' }),
+        new AIMessage({
+          content: 'Doing task 2',
+          tool_calls: [
+            {
+              id: 'call_2',
+              name: 'tool2',
+              args: {},
+              type: 'tool_call',
+            },
+          ],
+        }),
+        new ToolMessage({
+          content: 'Result 2',
+          tool_call_id: 'call_2',
+        }),
+      ];
+
+      const result = ensureThinkingBlockInMessages(
+        messages,
+        Providers.ANTHROPIC
+      );
+
+      // Each tool sequence should be converted to a HumanMessage
+      expect(result).toHaveLength(4);
+      expect(result[0]).toBeInstanceOf(HumanMessage);
+      expect(result[0].content).toBe('Do task 1');
+      expect(result[1]).toBeInstanceOf(HumanMessage);
+      expect(result[1].content).toContain('Doing task 1');
+      expect(result[2]).toBeInstanceOf(HumanMessage);
+      expect(result[2].content).toBe('Do task 2');
+      expect(result[3]).toBeInstanceOf(HumanMessage);
+      expect(result[3].content).toContain('Doing task 2');
+    });
+  });
+
+  describe('edge cases', () => {
+    test('should handle empty messages array', () => {
+      const messages: never[] = [];
+
+      const result = ensureThinkingBlockInMessages(
+        messages,
+        Providers.ANTHROPIC
+      );
+
+      expect(result).toHaveLength(0);
+    });
+
+    test('should handle AI message with empty content array', () => {
+      const messages = [
+        new HumanMessage({ content: 'Hello' }),
+        new AIMessage({ content: [] }),
+      ];
+
+      const result = ensureThinkingBlockInMessages(
+        messages,
+        Providers.ANTHROPIC
+      );
+
+      expect(result).toHaveLength(2);
+      expect(result[1]).toBeInstanceOf(AIMessage);
+    });
+
+    test('should work with different providers', () => {
+      const messages = [
+        new AIMessage({
+          content: 'Using tool',
+          tool_calls: [
+            {
+              id: 'call_x',
+              name: 'test',
+              args: {},
+              type: 'tool_call',
+            },
+          ],
+        }),
+        new ToolMessage({
+          content: 'Result',
+          tool_call_id: 'call_x',
+        }),
+      ];
+
+      // Test with Anthropic
+      const resultAnthropic = ensureThinkingBlockInMessages(
+        messages,
+        Providers.ANTHROPIC
+      );
+      expect(resultAnthropic).toHaveLength(1);
+      expect(resultAnthropic[0]).toBeInstanceOf(HumanMessage);
+
+      // Test with Bedrock
+      const resultBedrock = ensureThinkingBlockInMessages(
+        messages,
+        Providers.BEDROCK
+      );
+      expect(resultBedrock).toHaveLength(1);
+      expect(resultBedrock[0]).toBeInstanceOf(HumanMessage);
+    });
+
+    test('should handle tool message without preceding AI message', () => {
+      const messages = [
+        new HumanMessage({ content: 'Hello' }),
+        new ToolMessage({
+          content: 'Unexpected tool result',
+          tool_call_id: 'call_orphan',
+        }),
+      ];
+
+      const result = ensureThinkingBlockInMessages(
+        messages,
+        Providers.ANTHROPIC
+      );
+
+      // Should preserve both messages as-is since tool message has no preceding AI message with tools
+      expect(result).toHaveLength(2);
+      expect(result[0]).toBeInstanceOf(HumanMessage);
+      expect(result[1]).toBeInstanceOf(ToolMessage);
+    });
+  });
+});

package/src/messages/format.ts

@@ -1,6 +1,7 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import {
   AIMessage,
+  AIMessageChunk,
   ToolMessage,
   BaseMessage,
   HumanMessage,
@@ -10,6 +11,7 @@ import {
 import type { MessageContentImageUrl } from '@langchain/core/messages';
 import type { ToolCall } from '@langchain/core/messages/tool';
 import type {
+  ExtendedMessageContent,
   MessageContentComplex,
   ToolCallPart,
   TPayload,
@@ -609,3 +611,82 @@ export function shiftIndexTokenCountMap(
 
   return shiftedMap;
 }
+
+/**
+ * Ensures compatibility when switching from a non-thinking agent to a thinking-enabled agent.
+ * Converts AI messages with tool calls (that lack thinking blocks) into buffer strings,
+ * avoiding the thinking block signature requirement.
+ *
+ * @param messages - Array of messages to process
+ * @param provider - The provider being used (unused but kept for future compatibility)
+ * @returns The messages array with tool sequences converted to buffer strings if necessary
+ */
+export function ensureThinkingBlockInMessages(
+  messages: BaseMessage[],
+  _provider: Providers
+): BaseMessage[] {
+  const result: BaseMessage[] = [];
+  let i = 0;
+
+  while (i < messages.length) {
+    const msg = messages[i];
+    const isAI = msg instanceof AIMessage || msg instanceof AIMessageChunk;
+
+    if (!isAI) {
+      result.push(msg);
+      i++;
+      continue;
+    }
+
+    const aiMsg = msg as AIMessage | AIMessageChunk;
+    const hasToolCalls = aiMsg.tool_calls && aiMsg.tool_calls.length > 0;
+    const contentIsArray = Array.isArray(aiMsg.content);
+
+    // Check if the message has tool calls or tool_use content
+    let hasToolUse = hasToolCalls ?? false;
+    let firstContentType: string | undefined;
+
+    if (contentIsArray && aiMsg.content.length > 0) {
+      const content = aiMsg.content as ExtendedMessageContent[];
+      firstContentType = content[0]?.type;
+      hasToolUse =
+        hasToolUse ||
+        content.some((c) => typeof c === 'object' && c.type === 'tool_use');
+    }
+
+    // If message has tool use but no thinking block, convert to buffer string
+    if (
+      hasToolUse &&
+      firstContentType !== ContentTypes.THINKING &&
+      firstContentType !== 'redacted_thinking'
+    ) {
+      // Collect the AI message and any following tool messages
+      const toolSequence: BaseMessage[] = [msg];
+      let j = i + 1;
+
+      // Look ahead for tool messages that belong to this AI message
+      while (j < messages.length && messages[j] instanceof ToolMessage) {
+        toolSequence.push(messages[j]);
+        j++;
+      }
+
+      // Convert the sequence to a buffer string and wrap in a HumanMessage
+      // This avoids the thinking block requirement which only applies to AI messages
+      const bufferString = getBufferString(toolSequence);
+      result.push(
+        new HumanMessage({
+          content: `[Previous agent context]\n${bufferString}`,
+        })
+      );
+
+      // Skip the messages we've processed
+      i = j;
+    } else {
+      // Keep the message as is
+      result.push(msg);
+      i++;
+    }
+  }
+
+  return result;
+}

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(