@librechat/agents 3.1.1 → 3.1.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@librechat/agents",
-  "version": "3.1.01",
+  "version": "3.1.2",
   "main": "./dist/cjs/main.cjs",
   "module": "./dist/esm/main.mjs",
   "types": "./dist/types/index.d.ts",

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/tools/__tests__/ProgrammaticToolCalling.integration.test.ts

@@ -4,6 +4,9 @@
  * These tests hit the LIVE Code API and verify end-to-end functionality.
  *
  * Run with: npm test -- ProgrammaticToolCalling.integration.test.ts
+ *
+ * Requires LIBRECHAT_CODE_API_KEY environment variable.
+ * Tests are skipped when the API key is not available.
  */
 import { config as dotenvConfig } from 'dotenv';
 dotenvConfig();
@@ -19,19 +22,17 @@ import {
   createProgrammaticToolRegistry,
 } from '@/test/mockTools';
 
-describe('ProgrammaticToolCalling - Live API Integration', () => {
+const apiKey = process.env.LIBRECHAT_CODE_API_KEY;
+const shouldSkip = apiKey == null || apiKey === '';
+
+const describeIfApiKey = shouldSkip ? describe.skip : describe;
+
+describeIfApiKey('ProgrammaticToolCalling - Live API Integration', () => {
   let ptcTool: ReturnType<typeof createProgrammaticToolCallingTool>;
   let toolMap: t.ToolMap;
   let toolDefinitions: t.LCTool[];
 
   beforeAll(() => {
-    const apiKey = process.env.LIBRECHAT_CODE_API_KEY;
-    if (apiKey == null || apiKey === '') {
-      throw new Error(
-        'LIBRECHAT_CODE_API_KEY not set. Required for integration tests.'
-      );
-    }
-
     const tools = [
       createGetTeamMembersTool(),
       createGetExpensesTool(),
@@ -42,7 +43,7 @@ describe('ProgrammaticToolCalling - Live API Integration', () => {
     toolMap = new Map(tools.map((t) => [t.name, t]));
     toolDefinitions = Array.from(createProgrammaticToolRegistry().values());
 
-    ptcTool = createProgrammaticToolCallingTool({ apiKey });
+    ptcTool = createProgrammaticToolCallingTool({ apiKey: apiKey! });
   });
 
   it('executes simple single tool call', async () => {

package/src/tools/__tests__/ToolSearch.integration.test.ts

@@ -4,6 +4,9 @@
  * These tests hit the LIVE Code API and verify end-to-end search functionality.
  *
  * Run with: npm test -- ToolSearch.integration.test.ts
+ *
+ * Requires LIBRECHAT_CODE_API_KEY environment variable.
+ * Tests are skipped when the API key is not available.
  */
 import { config as dotenvConfig } from 'dotenv';
 dotenvConfig();
@@ -12,19 +15,17 @@ import { describe, it, expect, beforeAll } from '@jest/globals';
 import { createToolSearch } from '../ToolSearch';
 import { createToolSearchToolRegistry } from '@/test/mockTools';
 
-describe('ToolSearch - Live API Integration', () => {
+const apiKey = process.env.LIBRECHAT_CODE_API_KEY;
+const shouldSkip = apiKey == null || apiKey === '';
+
+const describeIfApiKey = shouldSkip ? describe.skip : describe;
+
+describeIfApiKey('ToolSearch - Live API Integration', () => {
   let searchTool: ReturnType<typeof createToolSearch>;
   const toolRegistry = createToolSearchToolRegistry();
 
   beforeAll(() => {
-    const apiKey = process.env.LIBRECHAT_CODE_API_KEY;
-    if (apiKey == null || apiKey === '') {
-      throw new Error(
-        'LIBRECHAT_CODE_API_KEY not set. Required for integration tests.'
-      );
-    }
-
-    searchTool = createToolSearch({ apiKey, toolRegistry });
+    searchTool = createToolSearch({ apiKey: apiKey!, toolRegistry });
   });
 
   it('searches for expense-related tools', async () => {