@librechat/agents 3.1.0 → 3.1.2

package/src/specs/azure.simple.test.ts

@@ -19,7 +19,6 @@ import { ContentTypes, GraphEvents, Providers, TitleMethod } from '@/common';
 import { ChatModelStreamHandler, createContentAggregator } from '@/stream';
 import { capitalizeFirstLetter } from './spec.utils';
 import { getLLMConfig } from '@/utils/llmConfig';
-import { getArgs } from '@/scripts/args';
 import { Run } from '@/run';
 
 // Auto-skip this suite if Azure env vars are not present
@@ -34,15 +33,24 @@ const hasAzure = requiredAzureEnv.every(
 );
 const describeIfAzure = hasAzure ? describe : describe.skip;
 
+const isContentFilterError = (error: unknown): boolean => {
+  const message = error instanceof Error ? error.message : String(error);
+  return (
+    message.includes('content management policy') ||
+    message.includes('content filtering')
+  );
+};
+
 const provider = Providers.AZURE;
+let contentFilterTriggered = false;
 describeIfAzure(`${capitalizeFirstLetter(provider)} Streaming Tests`, () => {
   jest.setTimeout(30000);
   let run: Run<t.IState>;
-  let runningHistory: BaseMessage[];
   let collectedUsage: UsageMetadata[];
   let conversationHistory: BaseMessage[];
   let aggregateContent: t.ContentAggregator;
   let contentParts: t.MessageContentComplex[];
+  let runningHistory: BaseMessage[] | null = null;
 
   const config = {
     configurable: {
@@ -129,186 +137,217 @@ describeIfAzure(`${capitalizeFirstLetter(provider)} Streaming Tests`, () => {
   });
 
   test(`${capitalizeFirstLetter(provider)}: should process a simple message, generate title`, async () => {
-    const { userName, location } = await getArgs();
-    const llmConfig = getLLMConfig(provider);
-    const customHandlers = setupCustomHandlers();
-
-    run = await Run.create<t.IState>({
-      runId: 'test-run-id',
-      graphConfig: {
-        type: 'standard',
-        llmConfig,
-        tools: [new Calculator()],
-        instructions:
-          'You are a friendly AI assistant. Always address the user by their name.',
-        additional_instructions: `The user's name is ${userName} and they are located in ${location}.`,
-      },
-      returnContent: true,
-      customHandlers,
-    });
-
-    const userMessage = 'hi';
-    conversationHistory.push(new HumanMessage(userMessage));
-
-    const inputs = {
-      messages: conversationHistory,
-    };
-
-    const finalContentParts = await run.processStream(inputs, config);
-    expect(finalContentParts).toBeDefined();
-    const allTextParts = finalContentParts?.every(
-      (part) => part.type === ContentTypes.TEXT
-    );
-    expect(allTextParts).toBe(true);
-    expect(collectedUsage.length).toBeGreaterThan(0);
-    expect(collectedUsage[0].input_tokens).toBeGreaterThan(0);
-    expect(collectedUsage[0].output_tokens).toBeGreaterThan(0);
-
-    const finalMessages = run.getRunMessages();
-    expect(finalMessages).toBeDefined();
-    conversationHistory.push(...(finalMessages ?? []));
-    expect(conversationHistory.length).toBeGreaterThan(1);
-    runningHistory = conversationHistory.slice();
-
-    expect(onMessageDeltaSpy).toHaveBeenCalled();
-    expect(onMessageDeltaSpy.mock.calls.length).toBeGreaterThan(1);
-    expect(onMessageDeltaSpy.mock.calls[0][3]).toBeDefined(); // Graph exists
-
-    expect(onRunStepSpy).toHaveBeenCalled();
-    expect(onRunStepSpy.mock.calls.length).toBeGreaterThan(0);
-    expect(onRunStepSpy.mock.calls[0][3]).toBeDefined(); // Graph exists
-
-    const { handleLLMEnd, collected } = createMetadataAggregator();
-    const titleResult = await run.generateTitle({
-      provider,
-      inputText: userMessage,
-      titleMethod: TitleMethod.STRUCTURED,
-      contentParts,
-      clientOptions: llmConfig,
-      chainOptions: {
-        callbacks: [
-          {
-            handleLLMEnd,
-          },
-        ],
-      },
-    });
+    try {
+      const llmConfig = getLLMConfig(provider);
+      const customHandlers = setupCustomHandlers();
+
+      run = await Run.create<t.IState>({
+        runId: 'test-run-id',
+        graphConfig: {
+          type: 'standard',
+          llmConfig,
+          tools: [new Calculator()],
+          instructions:
+            'You are a helpful AI assistant. Keep responses concise and friendly.',
+        },
+        returnContent: true,
+        customHandlers,
+      });
 
-    expect(titleResult).toBeDefined();
-    expect(titleResult.title).toBeDefined();
-    expect(titleResult.language).toBeDefined();
-    expect(collected).toBeDefined();
+      const userMessage = 'Hello, how are you today?';
+      conversationHistory.push(new HumanMessage(userMessage));
+
+      const inputs = {
+        messages: conversationHistory,
+      };
+
+      const finalContentParts = await run.processStream(inputs, config);
+      expect(finalContentParts).toBeDefined();
+      const allTextParts = finalContentParts?.every(
+        (part) => part.type === ContentTypes.TEXT
+      );
+      expect(allTextParts).toBe(true);
+      expect(collectedUsage.length).toBeGreaterThan(0);
+      expect(collectedUsage[0].input_tokens).toBeGreaterThan(0);
+      expect(collectedUsage[0].output_tokens).toBeGreaterThan(0);
+
+      const finalMessages = run.getRunMessages();
+      expect(finalMessages).toBeDefined();
+      conversationHistory.push(...(finalMessages ?? []));
+      expect(conversationHistory.length).toBeGreaterThan(1);
+      runningHistory = conversationHistory.slice();
+
+      expect(onMessageDeltaSpy).toHaveBeenCalled();
+      expect(onMessageDeltaSpy.mock.calls.length).toBeGreaterThan(1);
+      expect(onMessageDeltaSpy.mock.calls[0][3]).toBeDefined(); // Graph exists
+
+      expect(onRunStepSpy).toHaveBeenCalled();
+      expect(onRunStepSpy.mock.calls.length).toBeGreaterThan(0);
+      expect(onRunStepSpy.mock.calls[0][3]).toBeDefined(); // Graph exists
+
+      const { handleLLMEnd, collected } = createMetadataAggregator();
+      const titleResult = await run.generateTitle({
+        provider,
+        inputText: userMessage,
+        titleMethod: TitleMethod.STRUCTURED,
+        contentParts,
+        clientOptions: llmConfig,
+        chainOptions: {
+          callbacks: [
+            {
+              handleLLMEnd,
+            },
+          ],
+        },
+      });
+
+      expect(titleResult).toBeDefined();
+      expect(titleResult.title).toBeDefined();
+      expect(titleResult.language).toBeDefined();
+      expect(collected).toBeDefined();
+    } catch (error) {
+      if (isContentFilterError(error)) {
+        contentFilterTriggered = true;
+        console.warn('Skipping test: Azure content filter triggered');
+        return;
+      }
+      throw error;
+    }
   });
 
   test(`${capitalizeFirstLetter(provider)}: should generate title using completion method`, async () => {
-    const { userName, location } = await getArgs();
-    const llmConfig = getLLMConfig(provider);
-    const customHandlers = setupCustomHandlers();
-
-    run = await Run.create<t.IState>({
-      runId: 'test-run-id-completion',
-      graphConfig: {
-        type: 'standard',
-        llmConfig,
-        tools: [new Calculator()],
-        instructions:
-          'You are a friendly AI assistant. Always address the user by their name.',
-        additional_instructions: `The user's name is ${userName} and they are located in ${location}.`,
-      },
-      returnContent: true,
-      customHandlers,
-    });
-
-    const userMessage = 'What is the weather like today?';
-    conversationHistory = [];
-    conversationHistory.push(new HumanMessage(userMessage));
-
-    const inputs = {
-      messages: conversationHistory,
-    };
-
-    const finalContentParts = await run.processStream(inputs, config);
-    expect(finalContentParts).toBeDefined();
-
-    const { handleLLMEnd, collected } = createMetadataAggregator();
-    const titleResult = await run.generateTitle({
-      provider,
-      inputText: userMessage,
-      titleMethod: TitleMethod.COMPLETION, // Using completion method
-      contentParts,
-      clientOptions: llmConfig,
-      chainOptions: {
-        callbacks: [
-          {
-            handleLLMEnd,
-          },
-        ],
-      },
-    });
-
-    expect(titleResult).toBeDefined();
-    expect(titleResult.title).toBeDefined();
-    expect(titleResult.title).not.toBe('');
-    // Completion method doesn't return language
-    expect(titleResult.language).toBeUndefined();
-    expect(collected).toBeDefined();
-    console.log(`Completion method generated title: "${titleResult.title}"`);
+    if (contentFilterTriggered) {
+      console.warn(
+        'Skipping test: Azure content filter was triggered in previous test'
+      );
+      return;
+    }
+    try {
+      const llmConfig = getLLMConfig(provider);
+      const customHandlers = setupCustomHandlers();
+
+      run = await Run.create<t.IState>({
+        runId: 'test-run-id-completion',
+        graphConfig: {
+          type: 'standard',
+          llmConfig,
+          tools: [new Calculator()],
+          instructions:
+            'You are a helpful AI assistant. Keep responses concise and friendly.',
+        },
+        returnContent: true,
+        customHandlers,
+      });
+
+      const userMessage = 'What can you help me with today?';
+      conversationHistory = [];
+      conversationHistory.push(new HumanMessage(userMessage));
+
+      const inputs = {
+        messages: conversationHistory,
+      };
+
+      const finalContentParts = await run.processStream(inputs, config);
+      expect(finalContentParts).toBeDefined();
+
+      const { handleLLMEnd, collected } = createMetadataAggregator();
+      const titleResult = await run.generateTitle({
+        provider,
+        inputText: userMessage,
+        titleMethod: TitleMethod.COMPLETION,
+        contentParts,
+        clientOptions: llmConfig,
+        chainOptions: {
+          callbacks: [
+            {
+              handleLLMEnd,
+            },
+          ],
+        },
+      });
+
+      expect(titleResult).toBeDefined();
+      expect(titleResult.title).toBeDefined();
+      expect(titleResult.title).not.toBe('');
+      expect(titleResult.language).toBeUndefined();
+      expect(collected).toBeDefined();
+      console.log(`Completion method generated title: "${titleResult.title}"`);
+    } catch (error) {
+      if (isContentFilterError(error)) {
+        contentFilterTriggered = true;
+        console.warn('Skipping test: Azure content filter triggered');
+        return;
+      }
+      throw error;
+    }
   });
 
   test(`${capitalizeFirstLetter(provider)}: should follow-up`, async () => {
-    console.log('Previous conversation length:', runningHistory.length);
-    console.log(
-      'Last message:',
-      runningHistory[runningHistory.length - 1].content
-    );
-    const { userName, location } = await getArgs();
-    const llmConfig = getLLMConfig(provider);
-    const customHandlers = setupCustomHandlers();
-
-    run = await Run.create<t.IState>({
-      runId: 'test-run-id',
-      graphConfig: {
-        type: 'standard',
-        llmConfig,
-        tools: [new Calculator()],
-        instructions:
-          'You are a friendly AI assistant. Always address the user by their name.',
-        additional_instructions: `The user's name is ${userName} and they are located in ${location}.`,
-      },
-      returnContent: true,
-      customHandlers,
-    });
-
-    conversationHistory = runningHistory.slice();
-    conversationHistory.push(new HumanMessage('how are you?'));
-
-    const inputs = {
-      messages: conversationHistory,
-    };
-
-    const finalContentParts = await run.processStream(inputs, config);
-    expect(finalContentParts).toBeDefined();
-    const allTextParts = finalContentParts?.every(
-      (part) => part.type === ContentTypes.TEXT
-    );
-    expect(allTextParts).toBe(true);
-    expect(collectedUsage.length).toBeGreaterThan(0);
-    expect(collectedUsage[0].input_tokens).toBeGreaterThan(0);
-    expect(collectedUsage[0].output_tokens).toBeGreaterThan(0);
-
-    const finalMessages = run.getRunMessages();
-    expect(finalMessages).toBeDefined();
-    expect(finalMessages?.length).toBeGreaterThan(0);
-    console.log(
-      `${capitalizeFirstLetter(provider)} follow-up message:`,
-      finalMessages?.[finalMessages.length - 1]?.content
-    );
-
-    expect(onMessageDeltaSpy).toHaveBeenCalled();
-    expect(onMessageDeltaSpy.mock.calls.length).toBeGreaterThan(1);
-
-    expect(onRunStepSpy).toHaveBeenCalled();
-    expect(onRunStepSpy.mock.calls.length).toBeGreaterThan(0);
+    if (contentFilterTriggered || runningHistory == null) {
+      console.warn(
+        'Skipping test: Azure content filter was triggered or no conversation history'
+      );
+      return;
+    }
+    try {
+      console.log('Previous conversation length:', runningHistory.length);
+      console.log(
+        'Last message:',
+        runningHistory[runningHistory.length - 1].content
+      );
+      const llmConfig = getLLMConfig(provider);
+      const customHandlers = setupCustomHandlers();
+
+      run = await Run.create<t.IState>({
+        runId: 'test-run-id',
+        graphConfig: {
+          type: 'standard',
+          llmConfig,
+          tools: [new Calculator()],
+          instructions:
+            'You are a helpful AI assistant. Keep responses concise and friendly.',
+        },
+        returnContent: true,
+        customHandlers,
+      });
+
+      conversationHistory = runningHistory.slice();
+      conversationHistory.push(new HumanMessage('What else can you tell me?'));
+
+      const inputs = {
+        messages: conversationHistory,
+      };
+
+      const finalContentParts = await run.processStream(inputs, config);
+      expect(finalContentParts).toBeDefined();
+      const allTextParts = finalContentParts?.every(
+        (part) => part.type === ContentTypes.TEXT
+      );
+      expect(allTextParts).toBe(true);
+      expect(collectedUsage.length).toBeGreaterThan(0);
+      expect(collectedUsage[0].input_tokens).toBeGreaterThan(0);
+      expect(collectedUsage[0].output_tokens).toBeGreaterThan(0);
+
+      const finalMessages = run.getRunMessages();
+      expect(finalMessages).toBeDefined();
+      expect(finalMessages?.length).toBeGreaterThan(0);
+      console.log(
+        `${capitalizeFirstLetter(provider)} follow-up message:`,
+        finalMessages?.[finalMessages.length - 1]?.content
+      );
+
+      expect(onMessageDeltaSpy).toHaveBeenCalled();
+      expect(onMessageDeltaSpy.mock.calls.length).toBeGreaterThan(1);
+
+      expect(onRunStepSpy).toHaveBeenCalled();
+      expect(onRunStepSpy.mock.calls.length).toBeGreaterThan(0);
+    } catch (error) {
+      if (isContentFilterError(error)) {
+        console.warn('Skipping test: Azure content filter triggered');
+        return;
+      }
+      throw error;
+    }
   });
 
   test('should handle errors appropriately', async () => {

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/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