@librechat/agents 3.0.17 → 3.0.19

package/dist/types/types/stream.d.ts

@@ -37,6 +37,7 @@ export type RunStep = {
     type: StepTypes;
     id: string;
     runId?: string;
+    agentId?: string;
     index: number;
     stepIndex?: number;
     stepDetails: StepDetails;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@librechat/agents",
-  "version": "3.0.17",
+  "version": "3.0.19",
   "main": "./dist/cjs/main.cjs",
   "module": "./dist/esm/main.mjs",
   "types": "./dist/types/index.d.ts",
@@ -64,6 +64,9 @@
     "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-parallel-agent-labeling": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/test-parallel-agent-labeling.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 +131,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,66 @@ 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 == null || 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 == null || 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 != null && 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 != null &&
+        step.agentId !== '' &&
+        Number.isFinite(step.index)
+      ) {
+        contentPartAgentMap.set(step.index, step.agentId);
+      }
+    }
+
+    return contentPartAgentMap;
+  }
+
   /* Graph */
 
   createSystemRunnable({
@@ -672,6 +734,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 +919,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 +951,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);
+    });
+  });
+});