@librechat/agents 3.0.776 → 3.1.1

package/src/scripts/thinking-bedrock.ts

@@ -0,0 +1,159 @@
+// src/scripts/thinking-bedrock.ts
+import { config } from 'dotenv';
+config();
+import { HumanMessage, BaseMessage } from '@langchain/core/messages';
+import type { UsageMetadata } from '@langchain/core/messages';
+import * as t from '@/types';
+import { ChatModelStreamHandler, createContentAggregator } from '@/stream';
+import { createCodeExecutionTool } from '@/tools/CodeExecutor';
+import { ToolEndHandler, ModelEndHandler } from '@/events';
+import { GraphEvents, Providers } from '@/common';
+import { getLLMConfig } from '@/utils/llmConfig';
+import { getArgs } from '@/scripts/args';
+import { Run } from '@/run';
+
+const conversationHistory: BaseMessage[] = [];
+let _contentParts: t.MessageContentComplex[] = [];
+const collectedUsage: UsageMetadata[] = [];
+
+async function testBedrockThinking(): Promise<void> {
+  const { userName } = await getArgs();
+  const instructions = `You are a helpful AI assistant for ${userName}. When answering questions, be thorough in your reasoning.`;
+  const { contentParts, aggregateContent } = createContentAggregator();
+  _contentParts = contentParts as t.MessageContentComplex[];
+
+  // Set up event handlers
+  const customHandlers = {
+    [GraphEvents.TOOL_END]: new ToolEndHandler(),
+    [GraphEvents.CHAT_MODEL_END]: new ModelEndHandler(collectedUsage),
+    [GraphEvents.CHAT_MODEL_STREAM]: new ChatModelStreamHandler(),
+    [GraphEvents.ON_RUN_STEP_COMPLETED]: {
+      handle: (
+        event: GraphEvents.ON_RUN_STEP_COMPLETED,
+        data: t.StreamEventData
+      ): void => {
+        console.log('====== ON_RUN_STEP_COMPLETED ======');
+        aggregateContent({
+          event,
+          data: data as unknown as { result: t.ToolEndEvent },
+        });
+      },
+    },
+    [GraphEvents.ON_RUN_STEP]: {
+      handle: (event: GraphEvents.ON_RUN_STEP, data: t.RunStep) => {
+        aggregateContent({ event, data });
+      },
+    },
+    [GraphEvents.ON_RUN_STEP_DELTA]: {
+      handle: (
+        event: GraphEvents.ON_RUN_STEP_DELTA,
+        data: t.RunStepDeltaEvent
+      ) => {
+        aggregateContent({ event, data });
+      },
+    },
+    [GraphEvents.ON_MESSAGE_DELTA]: {
+      handle: (
+        event: GraphEvents.ON_MESSAGE_DELTA,
+        data: t.MessageDeltaEvent
+      ) => {
+        aggregateContent({ event, data });
+      },
+    },
+    [GraphEvents.ON_REASONING_DELTA]: {
+      handle: (
+        event: GraphEvents.ON_REASONING_DELTA,
+        data: t.ReasoningDeltaEvent
+      ) => {
+        aggregateContent({ event, data });
+      },
+    },
+  };
+
+  const baseLlmConfig = getLLMConfig(Providers.BEDROCK);
+
+  // Enable thinking with token budget for Bedrock
+  const llmConfig = {
+    ...baseLlmConfig,
+    model: 'us.anthropic.claude-3-7-sonnet-20250219-v1:0',
+    maxTokens: 5000,
+    additionalModelRequestFields: {
+      thinking: { type: 'enabled', budget_tokens: 2000 },
+    },
+  };
+
+  const run = await Run.create<t.IState>({
+    runId: 'test-bedrock-thinking-id',
+    graphConfig: {
+      instructions,
+      type: 'standard',
+      tools: [createCodeExecutionTool()],
+      llmConfig,
+    },
+    returnContent: true,
+    customHandlers: customHandlers as t.RunConfig['customHandlers'],
+  });
+
+  const config = {
+    configurable: {
+      thread_id: 'bedrock-thinking-test-thread',
+    },
+    streamMode: 'values',
+    version: 'v2' as const,
+  };
+
+  // Test 1: Regular thinking mode
+  console.log('\n\nTest 1: Bedrock Regular thinking mode');
+  const userMessage1 = `Please print 'hello world' in python`;
+  conversationHistory.push(new HumanMessage(userMessage1));
+
+  console.log('Running first query with Bedrock thinking enabled...');
+  const firstInputs = { messages: [...conversationHistory] };
+  await run.processStream(firstInputs, config);
+
+  // Extract and display thinking blocks
+  const finalMessages = run.getRunMessages();
+  console.log('\n\nFinal messages after Test 1:');
+  console.dir(finalMessages, { depth: null });
+
+  // Test 2: Try multi-turn conversation
+  console.log(
+    '\n\nTest 2: Multi-turn conversation with Bedrock thinking enabled'
+  );
+  const userMessage2 = `Given your previous analysis, what would be the most significant technical challenges in making this transition?`;
+  conversationHistory.push(new HumanMessage(userMessage2));
+
+  console.log('Running second query with Bedrock thinking enabled...');
+  const secondInputs = { messages: [...conversationHistory] };
+  await run.processStream(secondInputs, config);
+
+  // Display thinking blocks for second response
+  const finalMessages2 = run.getRunMessages();
+  console.log('\n\nBedrock thinking feature test completed!');
+  console.dir(finalMessages2, { depth: null });
+
+  console.log('\n\nContent parts:');
+  console.dir(_contentParts, { depth: null });
+}
+
+process.on('unhandledRejection', (reason, promise) => {
+  console.error('Unhandled Rejection at:', promise, 'reason:', reason);
+  console.log('Conversation history:');
+  console.dir(conversationHistory, { depth: null });
+  console.log('Content parts:');
+  console.dir(_contentParts, { depth: null });
+  process.exit(1);
+});
+
+process.on('uncaughtException', (err) => {
+  console.error('Uncaught Exception:', err);
+});
+
+testBedrockThinking().catch((err) => {
+  console.error(err);
+  console.log('Conversation history:');
+  console.dir(conversationHistory, { depth: null });
+  console.log('Content parts:');
+  console.dir(_contentParts, { depth: null });
+  process.exit(1);
+});

package/src/scripts/thinking.ts

@@ -1,7 +1,11 @@
 // src/scripts/test-thinking.ts
 import { config } from 'dotenv';
 config();
-import { HumanMessage, SystemMessage, BaseMessage } from '@langchain/core/messages';
+import {
+  HumanMessage,
+  SystemMessage,
+  BaseMessage,
+} from '@langchain/core/messages';
 import type { UsageMetadata } from '@langchain/core/messages';
 import * as t from '@/types';
 import { ChatModelStreamHandler, createContentAggregator } from '@/stream';
@@ -21,17 +25,23 @@ async function testThinking(): Promise<void> {
   const instructions = `You are a helpful AI assistant for ${userName}. When answering questions, be thorough in your reasoning.`;
   const { contentParts, aggregateContent } = createContentAggregator();
   _contentParts = contentParts as t.MessageContentComplex[];
-  
+
   // Set up event handlers
   const customHandlers = {
     [GraphEvents.TOOL_END]: new ToolEndHandler(),
     [GraphEvents.CHAT_MODEL_END]: new ModelEndHandler(collectedUsage),
     [GraphEvents.CHAT_MODEL_STREAM]: new ChatModelStreamHandler(),
     [GraphEvents.ON_RUN_STEP_COMPLETED]: {
-      handle: (event: GraphEvents.ON_RUN_STEP_COMPLETED, data: t.StreamEventData): void => {
+      handle: (
+        event: GraphEvents.ON_RUN_STEP_COMPLETED,
+        data: t.StreamEventData
+      ): void => {
         console.log('====== ON_RUN_STEP_COMPLETED ======');
-        aggregateContent({ event, data: data as unknown as { result: t.ToolEndEvent } });
-      }
+        aggregateContent({
+          event,
+          data: data as unknown as { result: t.ToolEndEvent },
+        });
+      },
     },
     [GraphEvents.ON_RUN_STEP]: {
       handle: (event: GraphEvents.ON_RUN_STEP, data: t.RunStep) => {
@@ -39,29 +49,38 @@ async function testThinking(): Promise<void> {
       },
     },
     [GraphEvents.ON_RUN_STEP_DELTA]: {
-      handle: (event: GraphEvents.ON_RUN_STEP_DELTA, data: t.RunStepDeltaEvent) => {
+      handle: (
+        event: GraphEvents.ON_RUN_STEP_DELTA,
+        data: t.RunStepDeltaEvent
+      ) => {
         aggregateContent({ event, data });
       },
     },
     [GraphEvents.ON_MESSAGE_DELTA]: {
-      handle: (event: GraphEvents.ON_MESSAGE_DELTA, data: t.MessageDeltaEvent) => {
+      handle: (
+        event: GraphEvents.ON_MESSAGE_DELTA,
+        data: t.MessageDeltaEvent
+      ) => {
         aggregateContent({ event, data });
       },
     },
     [GraphEvents.ON_REASONING_DELTA]: {
-      handle: (event: GraphEvents.ON_REASONING_DELTA, data: t.ReasoningDeltaEvent) => {
+      handle: (
+        event: GraphEvents.ON_REASONING_DELTA,
+        data: t.ReasoningDeltaEvent
+      ) => {
         aggregateContent({ event, data });
       },
     },
   };
 
   const baseLlmConfig: t.LLMConfig = getLLMConfig(Providers.ANTHROPIC);
-  
+
   // Enable thinking with token budget
   const llmConfig = {
     ...baseLlmConfig,
     model: 'claude-3-7-sonnet-latest',
-    thinking: { type: "enabled", budget_tokens: 2000 }
+    thinking: { type: 'enabled', budget_tokens: 2000 },
   };
 
   const run = await Run.create<t.IState>({
@@ -93,7 +112,7 @@ async function testThinking(): Promise<void> {
   console.log('Running first query with thinking enabled...');
   const firstInputs = { messages: [...conversationHistory] };
   await run.processStream(firstInputs, config);
-  
+
   // Extract and display thinking blocks
   const finalMessages = run.getRunMessages();
 
@@ -101,30 +120,32 @@ async function testThinking(): Promise<void> {
   console.log('\n\nTest 2: Multi-turn conversation with thinking enabled');
   const userMessage2 = `Given your previous analysis, what would be the most significant technical challenges in making this transition?`;
   conversationHistory.push(new HumanMessage(userMessage2));
-  
+
   console.log('Running second query with thinking enabled...');
   const secondInputs = { messages: [...conversationHistory] };
   await run.processStream(secondInputs, config);
-  
+
   // Display thinking blocks for second response
   const finalMessages2 = run.getRunMessages();
 
   // Test 3: Redacted thinking mode
   console.log('\n\nTest 3: Redacted thinking mode');
-  const magicString = "ANTHROPIC_MAGIC_STRING_TRIGGER_REDACTED_THINKING_46C9A13E193C177646C7398A98432ECCCE4C1253D5E2D82641AC0E52CC2876CB";
+  const magicString =
+    'ANTHROPIC_MAGIC_STRING_TRIGGER_REDACTED_THINKING_46C9A13E193C177646C7398A98432ECCCE4C1253D5E2D82641AC0E52CC2876CB';
   const userMessage3 = `${magicString}\n\nExplain how quantum computing works in simple terms.`;
-  
+
   // Reset conversation for clean test
   conversationHistory.length = 0;
   conversationHistory.push(new HumanMessage(userMessage3));
-  
+
   console.log('Running query with redacted thinking...');
   const thirdInputs = { messages: [...conversationHistory] };
   await run.processStream(thirdInputs, config);
-  
+
   // Display redacted thinking blocks
   const finalMessages3 = run.getRunMessages();
   console.log('\n\nThinking feature test completed!');
+  console.dir(finalMessages3, { depth: null });
 }
 
 process.on('unhandledRejection', (reason, promise) => {
@@ -147,4 +168,4 @@ testThinking().catch((err) => {
   console.log('Content parts:');
   console.dir(_contentParts, { depth: null });
   process.exit(1);
-});
+});

package/src/scripts/tools.ts

@@ -18,9 +18,13 @@ async function testStandardStreaming(): Promise<void> {
   const { userName, location, provider, currentDate } = await getArgs();
   const { contentParts, aggregateContent } = createContentAggregator();
   const customHandlers = {
-    [GraphEvents.TOOL_END]: new ToolEndHandler(undefined, (name?: string) => {
-      return true;
-    }),
+    [GraphEvents.TOOL_END]: new ToolEndHandler(
+      undefined,
+      undefined,
+      (name?: string) => {
+        return true;
+      }
+    ),
     [GraphEvents.CHAT_MODEL_END]: {
       handle: (
         _event: string,

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

@@ -1,5 +1,4 @@
 // src/specs/agent-handoffs.test.ts
-import { z } from 'zod';
 import { DynamicStructuredTool } from '@langchain/core/tools';
 import { HumanMessage, ToolMessage } from '@langchain/core/messages';
 import type { ToolCall } from '@langchain/core/messages/tool';
@@ -708,7 +707,7 @@ describe('Agent Handoffs Tests', () => {
       const customTool = new DynamicStructuredTool({
         name: 'custom_tool',
         description: 'A custom tool',
-        schema: z.object({}),
+        schema: { type: 'object', properties: {}, required: [] },
         func: async (): Promise<string> => 'Tool result',
       });
 

package/src/specs/tool-error.test.ts

@@ -1,4 +1,3 @@
-import { z } from 'zod';
 import { config } from 'dotenv';
 config();
 import { tool } from '@langchain/core/tools';
@@ -21,7 +20,13 @@ const errorTool = tool(
   {
     name: 'errorTool',
     description: 'A tool that always throws an error',
-    schema: z.object({ input: z.string().optional() }),
+    schema: {
+      type: 'object',
+      properties: {
+        input: { type: 'string' },
+      },
+      required: [],
+    },
   }
 );
 

package/src/stream.ts

@@ -339,7 +339,8 @@ hasToolCallChunks: ${hasToolCallChunks}
         (c) =>
           (c.type?.startsWith(ContentTypes.THINKING) ?? false) ||
           (c.type?.startsWith(ContentTypes.REASONING) ?? false) ||
-          (c.type?.startsWith(ContentTypes.REASONING_CONTENT) ?? false)
+          (c.type?.startsWith(ContentTypes.REASONING_CONTENT) ?? false) ||
+          c.type === 'redacted_thinking'
       )
     ) {
       await graph.dispatchReasoningDelta(stepId, {
@@ -365,7 +366,8 @@ hasToolCallChunks: ${hasToolCallChunks}
       Array.isArray(chunk.content) &&
       (chunk.content[0]?.type === ContentTypes.THINKING ||
         chunk.content[0]?.type === ContentTypes.REASONING ||
-        chunk.content[0]?.type === ContentTypes.REASONING_CONTENT)
+        chunk.content[0]?.type === ContentTypes.REASONING_CONTENT ||
+        chunk.content[0]?.type === 'redacted_thinking')
     ) {
       reasoning_content = 'valid';
     } else if (

package/src/test/mockTools.ts

@@ -3,7 +3,6 @@
  * Shared mock tools for testing across all test scripts.
  * Centralizes tool definitions to follow DRY principles.
  */
-import { z } from 'zod';
 import { tool } from '@langchain/core/tools';
 import type { StructuredToolInterface } from '@langchain/core/tools';
 import type { LCTool, LCToolRegistry } from '@/types';
@@ -29,7 +28,7 @@ export function createGetTeamMembersTool(): StructuredToolInterface {
       name: 'get_team_members',
       description:
         'Get list of team members. Returns array of objects with id, name, and department fields.',
-      schema: z.object({}),
+      schema: { type: 'object', properties: {}, required: [] },
     }
   );
 }
@@ -59,7 +58,8 @@ export function createGetExpensesTool(): StructuredToolInterface {
   };
 
   return tool(
-    async ({ user_id }: { user_id: string }) => {
+    async (input) => {
+      const { user_id } = input as { user_id: string };
       await new Promise((resolve) => setTimeout(resolve, 30));
       return expenseData[user_id] ?? [];
     },
@@ -67,9 +67,16 @@ export function createGetExpensesTool(): StructuredToolInterface {
       name: 'get_expenses',
       description:
         'Get expense records for a user. Returns array of objects with amount and category fields.',
-      schema: z.object({
-        user_id: z.string().describe('The user ID to fetch expenses for'),
-      }),
+      schema: {
+        type: 'object',
+        properties: {
+          user_id: {
+            type: 'string',
+            description: 'The user ID to fetch expenses for',
+          },
+        },
+        required: ['user_id'],
+      },
     }
   );
 }
@@ -91,7 +98,8 @@ export function createGetWeatherTool(): StructuredToolInterface {
   };
 
   return tool(
-    async ({ city }: { city: string }) => {
+    async (input) => {
+      const { city } = input as { city: string };
       await new Promise((resolve) => setTimeout(resolve, 40));
       const weather = weatherData[city];
       if (!weather) {
@@ -103,9 +111,13 @@ export function createGetWeatherTool(): StructuredToolInterface {
       name: 'get_weather',
       description:
         'Get current weather for a city. Returns object with temperature (number) and condition (string) fields.',
-      schema: z.object({
-        city: z.string().describe('City name'),
-      }),
+      schema: {
+        type: 'object',
+        properties: {
+          city: { type: 'string', description: 'City name' },
+        },
+        required: ['city'],
+      },
     }
   );
 }
@@ -115,7 +127,8 @@ export function createGetWeatherTool(): StructuredToolInterface {
  */
 export function createCalculatorTool(): StructuredToolInterface {
   return tool(
-    async ({ expression }: { expression: string }) => {
+    async (input) => {
+      const { expression } = input as { expression: string };
       await new Promise((resolve) => setTimeout(resolve, 10));
       // Simple eval for demo (in production, use a proper math parser)
 
@@ -125,9 +138,16 @@ export function createCalculatorTool(): StructuredToolInterface {
     {
       name: 'calculator',
       description: 'Evaluate a mathematical expression',
-      schema: z.object({
-        expression: z.string().describe('Mathematical expression to evaluate'),
-      }),
+      schema: {
+        type: 'object',
+        properties: {
+          expression: {
+            type: 'string',
+            description: 'Mathematical expression to evaluate',
+          },
+        },
+        required: ['expression'],
+      },
     }
   );
 }

package/src/tools/CodeExecutor.ts

@@ -1,4 +1,3 @@
-import { z } from 'zod';
 import { config } from 'dotenv';
 import fetch, { RequestInit } from 'node-fetch';
 import { HttpsProxyAgent } from 'https-proxy-agent';
@@ -21,25 +20,33 @@ const accessMessage =
 const emptyOutputMessage =
   'stdout: Empty. Ensure you\'re writing output explicitly.\n';
 
-const CodeExecutionToolSchema = z.object({
-  lang: z
-    .enum([
-      'py',
-      'js',
-      'ts',
-      'c',
-      'cpp',
-      'java',
-      'php',
-      'rs',
-      'go',
-      'd',
-      'f90',
-      'r',
-    ])
-    .describe('The programming language or runtime to execute the code in.'),
-  code: z.string()
-    .describe(`The complete, self-contained code to execute, without any truncation or minimization.
+const SUPPORTED_LANGUAGES = [
+  'py',
+  'js',
+  'ts',
+  'c',
+  'cpp',
+  'java',
+  'php',
+  'rs',
+  'go',
+  'd',
+  'f90',
+  'r',
+] as const;
+
+const CodeExecutionToolSchema = {
+  type: 'object',
+  properties: {
+    lang: {
+      type: 'string',
+      enum: SUPPORTED_LANGUAGES,
+      description:
+        'The programming language or runtime to execute the code in.',
+    },
+    code: {
+      type: 'string',
+      description: `The complete, self-contained code to execute, without any truncation or minimization.
 - The environment is stateless; variables and imports don't persist between executions.
 - Generated files from previous executions are automatically available in "/mnt/data/".
 - Files from previous executions are automatically available and can be modified in place.
@@ -50,21 +57,26 @@ const CodeExecutionToolSchema = z.object({
 - py: Matplotlib: Use \`plt.savefig()\` to save plots as files.
 - js: use the \`console\` or \`process\` methods for all outputs.
 - r: IMPORTANT: No X11 display available. ALL graphics MUST use Cairo library (library(Cairo)).
-- Other languages: use appropriate output functions.`),
-  args: z
-    .array(z.string())
-    .optional()
-    .describe(
-      'Additional arguments to execute the code with. This should only be used if the input code requires additional arguments to run.'
-    ),
-});
+- Other languages: use appropriate output functions.`,
+    },
+    args: {
+      type: 'array',
+      items: { type: 'string' },
+      description:
+        'Additional arguments to execute the code with. This should only be used if the input code requires additional arguments to run.',
+    },
+  },
+  required: ['lang', 'code'],
+} as const;
 
 const baseEndpoint = getCodeBaseURL();
 const EXEC_ENDPOINT = `${baseEndpoint}/exec`;
 
+type SupportedLanguage = (typeof SUPPORTED_LANGUAGES)[number];
+
 function createCodeExecutionTool(
   params: t.CodeExecutionToolParams = {}
-): DynamicStructuredTool<typeof CodeExecutionToolSchema> {
+): DynamicStructuredTool {
   const apiKey =
     params[EnvVar.CODE_API_KEY] ??
     params.apiKey ??
@@ -83,8 +95,13 @@ Usage:
 - NEVER use this tool to execute malicious code.
 `.trim();
 
-  return tool<typeof CodeExecutionToolSchema>(
-    async ({ lang, code, ...rest }, config) => {
+  return tool(
+    async (rawInput, config) => {
+      const { lang, code, ...rest } = rawInput as {
+        lang: SupportedLanguage;
+        code: string;
+        args?: string[];
+      };
       /**
        * Extract session context from config.toolCall (injected by ToolNode).
        * - session_id: For API to associate with previous session

package/src/tools/ProgrammaticToolCalling.ts

@@ -1,5 +1,4 @@
 // src/tools/ProgrammaticToolCalling.ts
-import { z } from 'zod';
 import { config } from 'dotenv';
 import fetch, { RequestInit } from 'node-fetch';
 import { HttpsProxyAgent } from 'https-proxy-agent';
@@ -33,12 +32,13 @@ const DEFAULT_TIMEOUT = 60000;
 // Schema
 // ============================================================================
 
-const ProgrammaticToolCallingSchema = z.object({
-  code: z
-    .string()
-    .min(1)
-    .describe(
-      `Python code that calls tools programmatically. Tools are available as async functions.
+const ProgrammaticToolCallingSchema = {
+  type: 'object',
+  properties: {
+    code: {
+      type: 'string',
+      minLength: 1,
+      description: `Python code that calls tools programmatically. Tools are available as async functions.
 
 CRITICAL - STATELESS EXECUTION:
 Each call is a fresh Python interpreter. Variables, imports, and data do NOT persist between calls.
@@ -66,19 +66,19 @@ Rules:
 - Just write code with await—auto-wrapped in async context
 - DO NOT define async def main() or call asyncio.run()
 - Tools are pre-defined—DO NOT write function definitions
-- Only print() output returns to the model`
-    ),
-  timeout: z
-    .number()
-    .int()
-    .min(1000)
-    .max(300000)
-    .optional()
-    .default(DEFAULT_TIMEOUT)
-    .describe(
-      'Maximum execution time in milliseconds. Default: 60 seconds. Max: 5 minutes.'
-    ),
-});
+- Only print() output returns to the model`,
+    },
+    timeout: {
+      type: 'integer',
+      minimum: 1000,
+      maximum: 300000,
+      default: DEFAULT_TIMEOUT,
+      description:
+        'Maximum execution time in milliseconds. Default: 60 seconds. Max: 5 minutes.',
+    },
+  },
+  required: ['code'],
+} as const;
 
 // ============================================================================
 // Helper Functions
@@ -576,7 +576,7 @@ export function formatCompletedResponse(
  */
 export function createProgrammaticToolCallingTool(
   initParams: t.ProgrammaticToolCallingParams = {}
-): DynamicStructuredTool<typeof ProgrammaticToolCallingSchema> {
+): DynamicStructuredTool {
   const apiKey =
     (initParams[EnvVar.CODE_API_KEY] as string | undefined) ??
     initParams.apiKey ??
@@ -616,8 +616,9 @@ Example (complete pipeline):
   data = await query_db(sql="..."); df = process(data); await save_to_sheet(data=df); print("Done")
 `.trim();
 
-  return tool<typeof ProgrammaticToolCallingSchema>(
-    async (params, config) => {
+  return tool(
+    async (rawParams, config) => {
+      const params = rawParams as { code: string; timeout?: number };
       const { code, timeout = DEFAULT_TIMEOUT } = params;
 
       // Extra params injected by ToolNode (follows web_search pattern)