@librechat/agents 3.1.32 → 3.1.34

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

@@ -0,0 +1,165 @@
+#!/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 Bedrock supervisor (with thinking) to Bedrock specialist (with thinking)
+ * Both agents use extended thinking, validating that thinking blocks are properly
+ * handled across the handoff boundary when both sides produce them.
+ */
+async function testThinkingToThinkingHandoffBedrock() {
+  console.log(
+    'Testing Bedrock (with thinking) → Bedrock (with thinking) handoff...\n'
+  );
+
+  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}`);
+        }
+      },
+    },
+    [GraphEvents.ON_RUN_STEP]: {
+      handle: (_event: string, data: t.StreamEventData): void => {
+        const runStep = data as t.RunStep;
+        console.log(
+          `\n📍 ON_RUN_STEP: agentId=${runStep.agentId}, groupId=${runStep.groupId}`
+        );
+      },
+    },
+  };
+
+  function createGraphConfig(): t.RunConfig {
+    console.log(
+      'Creating graph with Bedrock supervisor (thinking) and Bedrock specialist (thinking).\n'
+    );
+
+    const agents: t.AgentInputs[] = [
+      {
+        agentId: 'supervisor',
+        provider: Providers.BEDROCK,
+        clientOptions: {
+          region: process.env.BEDROCK_AWS_REGION || 'us-east-1',
+          model: 'us.anthropic.claude-sonnet-4-5-20250929-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 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-sonnet-4-5-20250929-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: `thinking-to-thinking-bedrock-test-${Date.now()}`,
+      graphConfig: {
+        type: 'multi-agent',
+        agents,
+        edges,
+      },
+      customHandlers,
+      returnContent: true,
+    };
+  }
+
+  try {
+    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));
+
+    conversationHistory.push(new HumanMessage(query));
+
+    const runConfig = createGraphConfig();
+    const run = await Run.create(runConfig);
+
+    const streamConfig = {
+      configurable: {
+        thread_id: 'thinking-to-thinking-bedrock-test-1',
+      },
+      streamMode: 'values',
+      version: 'v2' as const,
+    };
+
+    console.log('\nProcessing request...\n');
+
+    const inputs = {
+      messages: conversationHistory,
+    };
+
+    await run.processStream(inputs, streamConfig);
+    const finalMessages = run.getRunMessages();
+
+    if (finalMessages) {
+      conversationHistory.push(...finalMessages);
+    }
+
+    console.log(`\n${'='.repeat(60)}`);
+    console.log('✅ TEST PASSED');
+    console.log('='.repeat(60));
+    console.log('\nSuccessfully handed off from Bedrock (with thinking) to');
+    console.log('Bedrock (with thinking) without errors!');
+    console.log('\nThinking blocks were properly managed across the handoff');
+    console.log('boundary when both agents produce them.');
+  } catch (error) {
+    console.error('\n❌ TEST FAILED');
+    console.error('='.repeat(60));
+    console.error('Error:', error);
+    process.exit(1);
+  }
+}
+
+testThinkingToThinkingHandoffBedrock();

package/src/specs/agent-handoffs.test.ts

@@ -106,11 +106,11 @@ describe('Agent Handoffs Tests', () => {
         'agent_a'
       );
       expect(agentAContext).toBeDefined();
-      expect(agentAContext?.tools).toBeDefined();
+      expect(agentAContext?.graphTools).toBeDefined();
 
       // Check that handoff tool was created
       const handoffTool = findToolByName(
-        agentAContext?.tools,
+        agentAContext?.graphTools,
         `${Constants.LC_TRANSFER_TO_}agent_b`
       );
       expect(handoffTool).toBeDefined();
@@ -203,7 +203,7 @@ describe('Agent Handoffs Tests', () => {
       expect(agentBContext).toBeDefined();
 
       // Agent B should not have handoff tools (no outgoing edges)
-      const handoffTools = agentBContext?.tools?.filter((tool) => {
+      const handoffTools = agentBContext?.graphTools?.filter((tool) => {
         const name = getToolName(tool);
         return name?.startsWith(Constants.LC_TRANSFER_TO_) ?? false;
       });
@@ -244,14 +244,14 @@ describe('Agent Handoffs Tests', () => {
 
       // Agent A should have tool to transfer to B
       const agentAHandoffTool = findToolByName(
-        agentAContext?.tools,
+        agentAContext?.graphTools,
         `${Constants.LC_TRANSFER_TO_}agent_b`
       );
       expect(agentAHandoffTool).toBeDefined();
 
       // Agent B should have tool to transfer to A
       const agentBHandoffTool = findToolByName(
-        agentBContext?.tools,
+        agentBContext?.graphTools,
         `${Constants.LC_TRANSFER_TO_}agent_a`
       );
       expect(agentBHandoffTool).toBeDefined();
@@ -359,7 +359,7 @@ describe('Agent Handoffs Tests', () => {
       // Agent A should have tool to transfer to B
       expect(
         findToolByName(
-          agentAContext?.tools,
+          agentAContext?.graphTools,
           `${Constants.LC_TRANSFER_TO_}agent_b`
         )
       ).toBeDefined();
@@ -367,13 +367,13 @@ describe('Agent Handoffs Tests', () => {
       // Agent B should have tool to transfer to C
       expect(
         findToolByName(
-          agentBContext?.tools,
+          agentBContext?.graphTools,
           `${Constants.LC_TRANSFER_TO_}agent_c`
         )
       ).toBeDefined();
 
       // Agent C should have no handoff tools
-      const agentCHandoffTools = agentCContext?.tools?.filter((tool) => {
+      const agentCHandoffTools = agentCContext?.graphTools?.filter((tool) => {
         const name = getToolName(tool);
         return name?.startsWith(Constants.LC_TRANSFER_TO_) ?? false;
       });
@@ -419,7 +419,7 @@ describe('Agent Handoffs Tests', () => {
       expect(routerContext).toBeDefined();
 
       // Router should have 3 handoff tools
-      const handoffTools = routerContext?.tools?.filter((tool) => {
+      const handoffTools = routerContext?.graphTools?.filter((tool) => {
         const name = getToolName(tool);
         return name?.startsWith(Constants.LC_TRANSFER_TO_) ?? false;
       });
@@ -531,7 +531,7 @@ describe('Agent Handoffs Tests', () => {
         'agent_a'
       );
       const handoffTool = findToolByName(
-        agentAContext?.tools,
+        agentAContext?.graphTools,
         `${Constants.LC_TRANSFER_TO_}agent_b`
       );
 
@@ -562,7 +562,7 @@ describe('Agent Handoffs Tests', () => {
         'agent_a'
       );
       const handoffTool = findToolByName(
-        agentAContext?.tools,
+        agentAContext?.graphTools,
         `${Constants.LC_TRANSFER_TO_}agent_b`
       );
 
@@ -664,7 +664,7 @@ describe('Agent Handoffs Tests', () => {
       const agentAContext = (run.Graph as StandardGraph).agentContexts.get(
         'agent_a'
       );
-      const handoffTools = agentAContext?.tools?.filter((tool) => {
+      const handoffTools = agentAContext?.graphTools?.filter((tool) => {
         const name = getToolName(tool);
         return name?.startsWith(Constants.LC_TRANSFER_TO_) ?? false;
       });
@@ -734,14 +734,12 @@ describe('Agent Handoffs Tests', () => {
         'agent_a'
       );
 
-      // Agent A should have both custom tool and handoff tool
-      expect(agentAContext?.tools?.length).toBeGreaterThanOrEqual(2);
-
+      // Agent A should have custom tool in tools and handoff tool in graphTools
       expect(findToolByName(agentAContext?.tools, 'custom_tool')).toBeDefined();
 
       expect(
         findToolByName(
-          agentAContext?.tools,
+          agentAContext?.graphTools,
           `${Constants.LC_TRANSFER_TO_}agent_b`
         )
       ).toBeDefined();
@@ -845,7 +843,7 @@ describe('Agent Handoffs Tests', () => {
         'flight_assistant'
       );
       const handoffTool = findToolByName(
-        flightContext?.tools,
+        flightContext?.graphTools,
         `${Constants.LC_TRANSFER_TO_}hotel_assistant`
       );
 
@@ -875,7 +873,7 @@ describe('Agent Handoffs Tests', () => {
         'agent_with_underscores'
       );
       const handoffTool = findToolByName(
-        agentContext?.tools,
+        agentContext?.graphTools,
         `${Constants.LC_TRANSFER_TO_}AgentWithCamelCase`
       );
 

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

@@ -484,14 +484,14 @@ describe('Thinking-Enabled Agent Handoff Tests', () => {
 
       // Verify handoff tools exist
       expect(
-        routerContext?.tools?.find(
+        routerContext?.graphTools?.find(
           (tool) =>
             (tool as { name?: string }).name ===
             `${Constants.LC_TRANSFER_TO_}processor`
         )
       ).toBeDefined();
       expect(
-        processorContext?.tools?.find(
+        processorContext?.graphTools?.find(
           (tool) =>
             (tool as { name?: string }).name ===
             `${Constants.LC_TRANSFER_TO_}reviewer`

package/src/tools/ToolNode.ts

@@ -47,10 +47,10 @@ export class ToolNode<T = any> extends RunnableCallable<T, T> {
   private sessions?: t.ToolSessionMap;
   /** When true, dispatches ON_TOOL_EXECUTE events instead of invoking tools directly */
   private eventDrivenMode: boolean = false;
-  /** Tool definitions for event-driven mode */
-  private toolDefinitions?: Map<string, t.LCTool>;
   /** Agent ID for event-driven mode */
   private agentId?: string;
+  /** Tool names that bypass event dispatch and execute directly (e.g., graph-managed handoff tools) */
+  private directToolNames?: Set<string>;
 
   constructor({
     tools,
@@ -64,8 +64,8 @@ export class ToolNode<T = any> extends RunnableCallable<T, T> {
     toolRegistry,
     sessions,
     eventDrivenMode,
-    toolDefinitions,
     agentId,
+    directToolNames,
   }: t.ToolNodeConstructorParams) {
     super({ name, tags, func: (input, config) => this.run(input, config) });
     this.toolMap = toolMap ?? new Map(tools.map((tool) => [tool.name, tool]));
@@ -77,8 +77,8 @@ export class ToolNode<T = any> extends RunnableCallable<T, T> {
     this.toolRegistry = toolRegistry;
     this.sessions = sessions;
     this.eventDrivenMode = eventDrivenMode ?? false;
-    this.toolDefinitions = toolDefinitions;
     this.agentId = agentId;
+    this.directToolNames = directToolNames;
   }
 
   /**
@@ -257,15 +257,13 @@ export class ToolNode<T = any> extends RunnableCallable<T, T> {
   }
 
   /**
-   * Execute all tool calls via ON_TOOL_EXECUTE event dispatch.
-   * Used in event-driven mode where the host handles actual tool execution.
+   * Dispatches tool calls to the host via ON_TOOL_EXECUTE event and returns raw ToolMessages.
+   * Core logic for event-driven execution, separated from output shaping.
    */
-  private async executeViaEvent(
+  private async dispatchToolEvents(
     toolCalls: ToolCall[],
-    config: RunnableConfig,
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    input: any
-  ): Promise<T> {
+    config: RunnableConfig
+  ): Promise<ToolMessage[]> {
     const requests: t.ToolCallRequest[] = toolCalls.map((call) => {
       const turn = this.toolUsageCount.get(call.name) ?? 0;
       this.toolUsageCount.set(call.name, turn + 1);
@@ -296,7 +294,7 @@ export class ToolNode<T = any> extends RunnableCallable<T, T> {
       }
     );
 
-    const outputs: ToolMessage[] = results.map((result) => {
+    return results.map((result) => {
       const request = requests.find((r) => r.id === result.toolCallId);
       const toolName = request?.name ?? 'unknown';
       const stepId = this.toolCallStepIds?.get(result.toolCallId) ?? '';
@@ -354,7 +352,19 @@ export class ToolNode<T = any> extends RunnableCallable<T, T> {
 
       return toolMessage;
     });
+  }
 
+  /**
+   * Execute all tool calls via ON_TOOL_EXECUTE event dispatch.
+   * Used in event-driven mode where the host handles actual tool execution.
+   */
+  private async executeViaEvent(
+    toolCalls: ToolCall[],
+    config: RunnableConfig,
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    input: any
+  ): Promise<T> {
+    const outputs = await this.dispatchToolEvents(toolCalls, config);
     return (Array.isArray(input) ? outputs : { messages: outputs }) as T;
   }
 
@@ -363,7 +373,8 @@ export class ToolNode<T = any> extends RunnableCallable<T, T> {
     let outputs: (BaseMessage | Command)[];
 
     if (this.isSendInput(input)) {
-      if (this.eventDrivenMode) {
+      const isDirectTool = this.directToolNames?.has(input.lg_tool_call.name);
+      if (this.eventDrivenMode && isDirectTool !== true) {
         return this.executeViaEvent([input.lg_tool_call], config, input);
       }
       outputs = [await this.runTool(input.lg_tool_call, config)];
@@ -422,12 +433,35 @@ export class ToolNode<T = any> extends RunnableCallable<T, T> {
         }) ?? [];
 
       if (this.eventDrivenMode && filteredCalls.length > 0) {
-        return this.executeViaEvent(filteredCalls, config, input);
-      }
+        if (!this.directToolNames || this.directToolNames.size === 0) {
+          return this.executeViaEvent(filteredCalls, config, input);
+        }
 
-      outputs = await Promise.all(
-        filteredCalls.map((call) => this.runTool(call, config))
-      );
+        const directCalls = filteredCalls.filter((c) =>
+          this.directToolNames!.has(c.name)
+        );
+        const eventCalls = filteredCalls.filter(
+          (c) => !this.directToolNames!.has(c.name)
+        );
+
+        const directOutputs: (BaseMessage | Command)[] =
+          directCalls.length > 0
+            ? await Promise.all(
+              directCalls.map((call) => this.runTool(call, config))
+            )
+            : [];
+
+        const eventOutputs: ToolMessage[] =
+          eventCalls.length > 0
+            ? await this.dispatchToolEvents(eventCalls, config)
+            : [];
+
+        outputs = [...directOutputs, ...eventOutputs];
+      } else {
+        outputs = await Promise.all(
+          filteredCalls.map((call) => this.runTool(call, config))
+        );
+      }
     }
 
     if (!outputs.some(isCommand)) {

package/src/types/tools.ts

@@ -47,6 +47,8 @@ export type ToolNodeOptions = {
   toolDefinitions?: Map<string, LCTool>;
   /** Agent ID for event-driven mode (used to identify which agent's context to use) */
   agentId?: string;
+  /** Tool names that must be executed directly (via runTool) even in event-driven mode (e.g., graph-managed handoff tools) */
+  directToolNames?: Set<string>;
 };
 
 export type ToolNodeConstructorParams = ToolRefs & ToolNodeOptions;

package/src/utils/llmConfig.ts

@@ -177,7 +177,8 @@ export const llmConfigs: Record<string, t.LLMConfig | undefined> = {
     // model: 'anthropic.claude-3-sonnet-20240229-v1:0',
     // model: 'us.anthropic.claude-3-5-sonnet-20241022-v2:0',
     // model: 'us.amazon.nova-pro-v1:0',
-    model: 'us.anthropic.claude-sonnet-4-20250514-v1:0',
+    // model: 'us.anthropic.claude-sonnet-4-20250514-v1:0',
+    model: 'us.anthropic.claude-sonnet-4-5-20250929-v1:0',
     // additionalModelRequestFields: { thinking: { type: 'enabled', budget_tokens: 2000 } },
     region: process.env.BEDROCK_AWS_REGION,
     credentials: {