@librechat/agents 3.0.16 → 3.0.18

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@librechat/agents",
-  "version": "3.0.16",
+  "version": "3.0.18",
   "main": "./dist/cjs/main.cjs",
   "module": "./dist/esm/main.mjs",
   "types": "./dist/types/index.d.ts",
@@ -64,6 +64,8 @@
     "multi-agent-conditional": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/multi-agent-conditional.ts",
     "multi-agent-supervisor": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/multi-agent-supervisor.ts",
     "multi-agent-list-handoff": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/test-multi-agent-list-handoff.ts",
+    "test-thinking-handoff": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/test-thinking-handoff.ts",
+    "test-thinking-handoff-bedrock": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/test-thinking-handoff-bedrock.ts",
     "multi-agent-hybrid-flow": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/multi-agent-hybrid-flow.ts",
     "test-handoff-input": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/test-handoff-input.ts",
     "test-custom-prompt-key": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/test-custom-prompt-key.ts",
@@ -128,26 +130,24 @@
     "@rollup/plugin-commonjs": "^28.0.3",
     "@rollup/plugin-json": "^6.1.0",
     "@rollup/plugin-node-resolve": "^15.2.3",
-    "@rollup/plugin-terser": "^0.4.4",
     "@rollup/plugin-typescript": "^12.1.2",
     "@swc/core": "^1.6.13",
-    "@types/jest": "^29.5.14",
+    "@types/jest": "^30.0.0",
     "@types/node": "^20.14.11",
     "@types/node-fetch": "^2.6.13",
     "@types/yargs-parser": "^21.0.3",
     "@typescript-eslint/eslint-plugin": "^8.24.0",
     "@typescript-eslint/parser": "^8.24.0",
-    "eslint": "^9.31.0",
+    "eslint": "^9.39.1",
     "eslint-import-resolver-typescript": "^3.7.0",
     "eslint-plugin-import": "^2.31.0",
     "husky": "^9.1.7",
-    "jest": "^29.7.0",
+    "jest": "^30.2.0",
     "lint-staged": "^15.2.7",
-    "prettier": "^3.5.1",
+    "prettier": "^3.6.2",
     "rollup": "^4.34.6",
     "rollup-plugin-cleandir": "^2.0.0",
-    "rollup-plugin-obfuscator": "^1.1.0",
-    "ts-jest": "^29.3.1",
+    "ts-jest": "^29.4.5",
     "ts-node": "^10.9.2",
     "tsc-alias": "^1.8.10",
     "tsconfig-paths": "^4.2.0",

package/src/graphs/Graph.ts

@@ -38,6 +38,7 @@ import {
 } from '@/common';
 import {
   formatAnthropicArtifactContent,
+  ensureThinkingBlockInMessages,
   convertMessagesToContent,
   addBedrockCacheControl,
   modifyDeltaProperties,
@@ -96,7 +97,8 @@ export abstract class Graph<
   abstract getRunStep(stepId: string): t.RunStep | undefined;
   abstract dispatchRunStep(
     stepKey: string,
-    stepDetails: t.StepDetails
+    stepDetails: t.StepDetails,
+    metadata?: Record<string, unknown>
   ): Promise<string>;
   abstract dispatchRunStepDelta(
     id: string,
@@ -327,6 +329,62 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
     return convertMessagesToContent(this.messages.slice(this.startIndex));
   }
 
+  /**
+   * Get all run steps, optionally filtered by agent ID
+   */
+  getRunSteps(agentId?: string): t.RunStep[] {
+    if (!agentId) {
+      return [...this.contentData];
+    }
+    return this.contentData.filter((step) => step.agentId === agentId);
+  }
+
+  /**
+   * Get run steps grouped by agent ID
+   */
+  getRunStepsByAgent(): Map<string, t.RunStep[]> {
+    const stepsByAgent = new Map<string, t.RunStep[]>();
+
+    for (const step of this.contentData) {
+      if (!step.agentId) continue;
+
+      const steps = stepsByAgent.get(step.agentId) ?? [];
+      steps.push(step);
+      stepsByAgent.set(step.agentId, steps);
+    }
+
+    return stepsByAgent;
+  }
+
+  /**
+   * Get agent IDs that participated in this run
+   */
+  getActiveAgentIds(): string[] {
+    const agentIds = new Set<string>();
+    for (const step of this.contentData) {
+      if (step.agentId) {
+        agentIds.add(step.agentId);
+      }
+    }
+    return Array.from(agentIds);
+  }
+
+  /**
+   * Maps contentPart indices to agent IDs for post-run analysis
+   * Returns a map where key is the contentPart index and value is the agentId
+   */
+  getContentPartAgentMap(): Map<number, string> {
+    const contentPartAgentMap = new Map<number, string>();
+
+    for (const step of this.contentData) {
+      if (step.agentId && step.index != null) {
+        contentPartAgentMap.set(step.index, step.agentId);
+      }
+    }
+
+    return contentPartAgentMap;
+  }
+
   /* Graph */
 
   createSystemRunnable({
@@ -672,6 +730,26 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
         }
       }
 
+      /**
+       * Handle edge case: when switching from a non-thinking agent to a thinking-enabled agent,
+       * convert AI messages with tool calls to HumanMessages to avoid thinking block requirements.
+       * This is required by Anthropic/Bedrock when thinking is enabled.
+       */
+      const isAnthropicWithThinking =
+        (agentContext.provider === Providers.ANTHROPIC &&
+          (agentContext.clientOptions as t.AnthropicClientOptions).thinking !=
+            null) ||
+        (agentContext.provider === Providers.BEDROCK &&
+          (agentContext.clientOptions as t.BedrockAnthropicInput)
+            .additionalModelRequestFields?.['thinking'] != null);
+
+      if (isAnthropicWithThinking) {
+        finalMessages = ensureThinkingBlockInMessages(
+          finalMessages,
+          agentContext.provider
+        );
+      }
+
       if (
         agentContext.lastStreamCall != null &&
         agentContext.streamBuffer != null
@@ -837,7 +915,8 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
    */
   async dispatchRunStep(
     stepKey: string,
-    stepDetails: t.StepDetails
+    stepDetails: t.StepDetails,
+    metadata?: Record<string, unknown>
   ): Promise<string> {
     if (!this.config) {
       throw new Error('No config provided');
@@ -868,6 +947,20 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
       runStep.runId = runId;
     }
 
+    /**
+     * Extract and store agentId from metadata
+     */
+    if (metadata) {
+      try {
+        const agentContext = this.getAgentContext(metadata);
+        if (agentContext.agentId) {
+          runStep.agentId = agentContext.agentId;
+        }
+      } catch (_e) {
+        /** If we can't get agent context, that's okay - agentId remains undefined */
+      }
+    }
+
     this.contentData.push(runStep);
     this.contentIndexMap.set(stepId, runStep.index);
     await safeDispatchCustomEvent(

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,
@@ -310,6 +312,11 @@ function formatAssistantMessage(
         });
         formattedMessages.push(lastAIMessage);
       } else if (part.type === ContentTypes.TOOL_CALL) {
+        // Skip malformed tool call entries without tool_call property
+        if (!part.tool_call) {
+          continue;
+        }
+
         // Note: `tool_calls` list is defined when constructed by `AIMessage` class, and outputs should be excluded from it
         const {
           output,
@@ -454,6 +461,15 @@ export const formatAgentMessages = (
               hasInvalidTool = true;
               break;
             }
+            // Protect against malformed tool call entries
+            if (
+              !part.tool_call ||
+              part.tool_call.name == null ||
+              part.tool_call.name === ''
+            ) {
+              hasInvalidTool = true;
+              continue;
+            }
             const toolName = part.tool_call.name;
             toolNames.push(toolName);
             if (!tools.has(toolName)) {
@@ -595,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;
+}