@librechat/agents 3.4.6 → 3.5.0

package/src/tools/search/format.test.ts

@@ -1,242 +0,0 @@
-import type * as t from './types';
-import { formatResultsForLLM, resolveMaxLLMOutputChars } from './format';
-
-const makeOrganic = (
-  link: string,
-  highlights: t.Highlight[]
-): t.ProcessedOrganic => ({
-  link,
-  title: `Title for ${link}`,
-  snippet: `Snippet for ${link}`,
-  highlights,
-});
-
-const highlight = (text: string, score = 0.9): t.Highlight => ({ text, score });
-
-const reference = (url: string, originalIndex = 0): t.UsedReferences[number] => ({
-  type: 'link',
-  originalIndex,
-  reference: { originalUrl: url, title: 'Ref', text: 'ref' },
-});
-
-const countHighlightBlocks = (output: string): number =>
-  (output.match(/### Highlight \d+/g) ?? []).length;
-
-const OMISSION_MARKER = 'omitted to fit the context budget';
-
-describe('resolveMaxLLMOutputChars', () => {
-  const originalEnv = process.env.SEARCH_MAX_LLM_OUTPUT_CHARS;
-
-  afterEach(() => {
-    if (originalEnv == null) {
-      delete process.env.SEARCH_MAX_LLM_OUTPUT_CHARS;
-    } else {
-      process.env.SEARCH_MAX_LLM_OUTPUT_CHARS = originalEnv;
-    }
-  });
-
-  test('falls back to the 50,000 char default when nothing is configured', () => {
-    delete process.env.SEARCH_MAX_LLM_OUTPUT_CHARS;
-    expect(resolveMaxLLMOutputChars()).toBe(50000);
-    expect(resolveMaxLLMOutputChars(0)).toBe(50000);
-    expect(resolveMaxLLMOutputChars(-100)).toBe(50000);
-  });
-
-  test('honors the SEARCH_MAX_LLM_OUTPUT_CHARS env var', () => {
-    process.env.SEARCH_MAX_LLM_OUTPUT_CHARS = '777';
-    expect(resolveMaxLLMOutputChars()).toBe(777);
-    expect(resolveMaxLLMOutputChars(0)).toBe(777);
-  });
-
-  test('an explicit positive config value wins over env and default', () => {
-    process.env.SEARCH_MAX_LLM_OUTPUT_CHARS = '777';
-    expect(resolveMaxLLMOutputChars(1234)).toBe(1234);
-  });
-
-  test('ignores a non-numeric env var', () => {
-    process.env.SEARCH_MAX_LLM_OUTPUT_CHARS = 'not-a-number';
-    expect(resolveMaxLLMOutputChars()).toBe(50000);
-  });
-});
-
-describe('formatResultsForLLM highlight budget', () => {
-  test('keeps whole highlights in relevance order until the budget is hit', () => {
-    const results: t.SearchResultData = {
-      organic: [
-        makeOrganic('https://a.com', [highlight('A'.repeat(100))]),
-        makeOrganic('https://b.com', [highlight('B'.repeat(100))]),
-      ],
-    };
-
-    const { output } = formatResultsForLLM(0, results, 100);
-
-    expect(output).toContain('A'.repeat(100));
-    expect(output).not.toContain('B'.repeat(100));
-    expect(countHighlightBlocks(output)).toBe(1);
-    expect(output).toContain('_[1 additional highlight omitted to fit the context budget');
-  });
-
-  test('truncates the boundary highlight when meaningful room remains', () => {
-    const results: t.SearchResultData = {
-      organic: [makeOrganic('https://a.com', [highlight('A'.repeat(1000))])],
-    };
-
-    const { output } = formatResultsForLLM(0, results, 500);
-
-    expect(output).toContain('…[truncated]');
-    expect(output).toContain('A'.repeat(500));
-    expect(output).not.toContain('A'.repeat(501));
-    expect(output).toContain('_[1 additional highlight omitted to fit the context budget');
-  });
-
-  test('drops the boundary highlight entirely when too little room remains', () => {
-    const results: t.SearchResultData = {
-      organic: [
-        makeOrganic('https://a.com', [highlight('A'.repeat(100))]),
-        makeOrganic('https://b.com', [highlight('B'.repeat(100))]),
-      ],
-    };
-
-    const { output } = formatResultsForLLM(0, results, 150);
-
-    expect(output).toContain('A'.repeat(100));
-    expect(output).not.toContain('…[truncated]');
-    expect(output).not.toContain('B');
-    expect(countHighlightBlocks(output)).toBe(1);
-  });
-
-  test('always keeps snippets, titles, and URLs even when all highlights are dropped', () => {
-    const results: t.SearchResultData = {
-      organic: [makeOrganic('https://a.com', [highlight('A'.repeat(100))])],
-    };
-
-    const { output } = formatResultsForLLM(0, results, 10);
-
-    expect(output).toContain('URL: https://a.com');
-    expect(output).toContain('Summary: Snippet for https://a.com');
-    expect(output).toContain('"Title for https://a.com"');
-    expect(countHighlightBlocks(output)).toBe(0);
-    expect(output).toContain('_[1 additional highlight omitted to fit the context budget');
-  });
-
-  test('emits no omission marker when every highlight fits the budget', () => {
-    const results: t.SearchResultData = {
-      organic: [
-        makeOrganic('https://a.com', [highlight('A'.repeat(100))]),
-        makeOrganic('https://b.com', [highlight('B'.repeat(100))]),
-      ],
-    };
-
-    const { output } = formatResultsForLLM(0, results, 50000);
-
-    expect(output).toContain('A'.repeat(100));
-    expect(output).toContain('B'.repeat(100));
-    expect(countHighlightBlocks(output)).toBe(2);
-    expect(output).not.toContain(OMISSION_MARKER);
-  });
-
-  test('drops references with no surviving marker when truncating', () => {
-    const withRefs = highlight('A'.repeat(1000));
-    withRefs.references = [reference('https://cited.example')];
-    const results: t.SearchResultData = {
-      organic: [makeOrganic('https://a.com', [withRefs])],
-    };
-
-    const { output, references } = formatResultsForLLM(0, results, 500);
-
-    expect(output).toContain('…[truncated]');
-    expect(output).not.toContain('Core References');
-    expect(output).not.toContain('https://cited.example');
-    expect(references).toHaveLength(0);
-  });
-
-  test('keeps references whose marker survives truncation and drops the rest', () => {
-    const withRefs = highlight(`(link#1) ${'A'.repeat(1000)} (link#2)`);
-    withRefs.references = [
-      reference('https://one.example', 0),
-      reference('https://two.example', 1),
-    ];
-    const results: t.SearchResultData = {
-      organic: [makeOrganic('https://a.com', [withRefs])],
-    };
-
-    const { output, references } = formatResultsForLLM(0, results, 500);
-
-    expect(output).toContain('…[truncated]');
-    expect(output).toContain('https://one.example');
-    expect(output).not.toContain('https://two.example');
-    expect(references).toHaveLength(1);
-    expect(references[0].link).toBe('https://one.example');
-  });
-
-  test('stops at the boundary highlight — no lower-ranked highlight slips in', () => {
-    const results: t.SearchResultData = {
-      organic: [
-        makeOrganic('https://a.com', [
-          highlight('A'.repeat(100), 0.9),
-          highlight('B'.repeat(300), 0.8),
-          highlight('C'.repeat(10), 0.7),
-        ]),
-      ],
-    };
-
-    const { output } = formatResultsForLLM(0, results, 150);
-
-    expect(output).toContain('A'.repeat(100));
-    expect(output).not.toContain('B'.repeat(300));
-    expect(output).not.toContain('C'.repeat(10));
-    expect(output).not.toContain('…[truncated]');
-    expect(countHighlightBlocks(output)).toBe(1);
-  });
-
-  test('keeps references on a whole highlight that fits the budget', () => {
-    const withRefs = highlight('A'.repeat(100));
-    withRefs.references = [reference('https://cited.example')];
-    const results: t.SearchResultData = {
-      organic: [makeOrganic('https://a.com', [withRefs])],
-    };
-
-    const { output, references } = formatResultsForLLM(0, results, 50000);
-
-    expect(output).toContain('Core References');
-    expect(references).toHaveLength(1);
-    expect(references[0].link).toBe('https://cited.example');
-  });
-
-  test('skips blank highlights instead of charging them against the budget', () => {
-    const results: t.SearchResultData = {
-      organic: [
-        makeOrganic('https://a.com', [
-          highlight('   \n\t  '),
-          highlight('A'.repeat(100)),
-        ]),
-      ],
-    };
-
-    const { output } = formatResultsForLLM(0, results, 100);
-
-    expect(output).toContain('A'.repeat(100));
-    expect(output).not.toContain('…[truncated]');
-    expect(countHighlightBlocks(output)).toBe(1);
-    expect(output).not.toContain(OMISSION_MARKER);
-  });
-
-  test('spends the budget across organic results before news results', () => {
-    const results: t.SearchResultData = {
-      organic: [makeOrganic('https://a.com', [highlight('A'.repeat(100))])],
-      topStories: [
-        {
-          link: 'https://news.com',
-          title: 'Story',
-          highlights: [highlight('N'.repeat(100))],
-        },
-      ],
-    };
-
-    const { output } = formatResultsForLLM(0, results, 100);
-
-    expect(output).toContain('A'.repeat(100));
-    expect(output).not.toContain('N'.repeat(100));
-    expect(output).toContain('_[1 additional highlight omitted to fit the context budget');
-  });
-});

package/src/tools/search/http-agent.test.ts

@@ -1,133 +0,0 @@
-import axios from 'axios';
-import { Agent as HttpAgent } from 'http';
-import { Agent as HttpsAgent } from 'https';
-import { createFirecrawlScraper } from './firecrawl';
-import { createReranker } from './rerankers';
-import { createCrwAPI } from './crw-search';
-import { createSearchAPI } from './search';
-
-jest.mock('axios');
-const mockedAxios = axios as jest.Mocked<typeof axios>;
-
-const httpAgent = new HttpAgent();
-const httpsAgent = new HttpsAgent();
-
-describe('injected http(s) agent', () => {
-  beforeEach(() => {
-    jest.clearAllMocks();
-  });
-
-  it('passes both agents to the firecrawl scraper request config', async () => {
-    mockedAxios.post.mockResolvedValueOnce({
-      data: { success: true, data: { markdown: 'x' } },
-    });
-
-    const scraper = createFirecrawlScraper({
-      apiKey: 'test-key',
-      httpAgent,
-      httpsAgent,
-    });
-    await scraper.scrapeUrl('https://example.com');
-
-    expect(mockedAxios.post).toHaveBeenCalledWith(
-      expect.any(String),
-      expect.anything(),
-      expect.objectContaining({ httpAgent, httpsAgent })
-    );
-  });
-
-  it('omits agents from the firecrawl request config when none are provided', async () => {
-    mockedAxios.post.mockResolvedValueOnce({
-      data: { success: true, data: { markdown: 'x' } },
-    });
-
-    const scraper = createFirecrawlScraper({ apiKey: 'test-key' });
-    await scraper.scrapeUrl('https://example.com');
-
-    const requestConfig = mockedAxios.post.mock.calls[0][2];
-    expect(requestConfig?.httpAgent).toBeUndefined();
-    expect(requestConfig?.httpsAgent).toBeUndefined();
-  });
-
-  it('passes both agents to the Jina reranker request config', async () => {
-    mockedAxios.post.mockResolvedValueOnce({ data: { results: [] } });
-
-    const reranker = createReranker({
-      rerankerType: 'jina',
-      jinaApiKey: 'test-key',
-      httpAgent,
-      httpsAgent,
-    });
-    await reranker?.rerank('query', ['a', 'b'], 2);
-
-    expect(mockedAxios.post).toHaveBeenCalledWith(
-      expect.any(String),
-      expect.anything(),
-      expect.objectContaining({ httpAgent, httpsAgent })
-    );
-  });
-
-  it('passes agents supplied through the crw search options bag', async () => {
-    mockedAxios.post.mockResolvedValueOnce({
-      data: { success: true, data: { web: [] } },
-    });
-
-    const api = createCrwAPI('test-key', undefined, { httpAgent, httpsAgent });
-    await api.getSources({ query: 'query' });
-
-    expect(mockedAxios.post).toHaveBeenCalledWith(
-      expect.any(String),
-      expect.anything(),
-      expect.objectContaining({ httpAgent, httpsAgent })
-    );
-  });
-
-  it('threads agents from the tool config into the serper search request', async () => {
-    mockedAxios.post.mockResolvedValueOnce({ data: { organic: [] } });
-
-    const api = createSearchAPI({
-      searchProvider: 'serper',
-      serperApiKey: 'test-key',
-      httpAgent,
-      httpsAgent,
-    });
-    await api.getSources({ query: 'query' });
-
-    expect(mockedAxios.post).toHaveBeenCalledWith(
-      expect.any(String),
-      expect.anything(),
-      expect.objectContaining({ httpAgent, httpsAgent })
-    );
-  });
-
-  it('threads agents from the tool config into the searxng search request', async () => {
-    mockedAxios.get.mockResolvedValueOnce({ data: { results: [] } });
-
-    const api = createSearchAPI({
-      searchProvider: 'searxng',
-      searxngInstanceUrl: 'https://searxng.example.com',
-      httpAgent,
-      httpsAgent,
-    });
-    await api.getSources({ query: 'query' });
-
-    expect(mockedAxios.get).toHaveBeenCalledWith(
-      expect.any(String),
-      expect.objectContaining({ httpAgent, httpsAgent })
-    );
-  });
-
-  it('omits agents from the serper search request when none are provided', async () => {
-    mockedAxios.post.mockResolvedValueOnce({ data: { organic: [] } });
-
-    const api = createSearchAPI({
-      searchProvider: 'serper',
-      serperApiKey: 'test-key',
-    });
-    await api.getSources({ query: 'query' });
-
-    const requestConfig = mockedAxios.post.mock.calls[0][2];
-    expect(requestConfig?.httpAgent).toBeUndefined();
-    expect(requestConfig?.httpsAgent).toBeUndefined();
-  });
-});

package/src/tools/search/jina-reranker.test.ts

@@ -1,306 +0,0 @@
-import axios from 'axios';
-
-import { createReranker, JinaReranker } from './rerankers';
-import { createDefaultLogger } from './utils';
-
-type AxiosErrorFixture = Error & {
-  isAxiosError: true;
-  code: string;
-  config: {
-    data: string;
-    headers: {
-      Authorization: string;
-    };
-    method: string;
-    url: string;
-  };
-  response: {
-    data: {
-      details?: string;
-      message: string;
-    };
-    status: number;
-  };
-};
-
-const getApiUrl = (reranker: JinaReranker): string => {
-  const descriptor = Object.getOwnPropertyDescriptor(reranker, 'apiUrl');
-  if (typeof descriptor?.value === 'string') {
-    return descriptor.value;
-  }
-  throw new Error('Expected JinaReranker apiUrl to be initialized.');
-};
-
-const createAxiosErrorFixture = (
-  url: string,
-  responseData: AxiosErrorFixture['response']['data']
-): AxiosErrorFixture =>
-  Object.assign(new Error('Request failed with status code 500'), {
-    isAxiosError: true as const,
-    code: 'ERR_BAD_RESPONSE',
-    config: {
-      data: JSON.stringify({ documents: ['document1', 'document2'] }),
-      headers: {
-        Authorization: 'Bearer test-key',
-      },
-      method: 'post',
-      url,
-    },
-    response: {
-      data: responseData,
-      status: 500,
-    },
-  });
-
-describe('JinaReranker', () => {
-  const mockLogger = createDefaultLogger();
-
-  afterEach(() => {
-    jest.restoreAllMocks();
-  });
-
-  describe('constructor', () => {
-    it('should use default API URL when no apiUrl is provided', () => {
-      const reranker = new JinaReranker({
-        apiKey: 'test-key',
-        logger: mockLogger,
-      });
-
-      const apiUrl = getApiUrl(reranker);
-      expect(apiUrl).toBe('https://api.jina.ai/v1/rerank');
-    });
-
-    it('should use custom API URL when provided', () => {
-      const customUrl = 'https://custom-jina-endpoint.com/v1/rerank';
-      const reranker = new JinaReranker({
-        apiKey: 'test-key',
-        apiUrl: customUrl,
-        logger: mockLogger,
-      });
-
-      const apiUrl = getApiUrl(reranker);
-      expect(apiUrl).toBe(customUrl);
-    });
-
-    it('should use environment variable JINA_API_URL when available', () => {
-      const originalEnv = process.env.JINA_API_URL;
-      process.env.JINA_API_URL = 'https://env-jina-endpoint.com/v1/rerank';
-
-      const reranker = new JinaReranker({
-        apiKey: 'test-key',
-        logger: mockLogger,
-      });
-
-      const apiUrl = getApiUrl(reranker);
-      expect(apiUrl).toBe('https://env-jina-endpoint.com/v1/rerank');
-
-      if (typeof originalEnv === 'string') {
-        process.env.JINA_API_URL = originalEnv;
-      } else {
-        delete process.env.JINA_API_URL;
-      }
-    });
-
-    it('should prioritize explicit apiUrl over environment variable', () => {
-      const originalEnv = process.env.JINA_API_URL;
-      process.env.JINA_API_URL = 'https://env-jina-endpoint.com/v1/rerank';
-
-      const customUrl = 'https://explicit-jina-endpoint.com/v1/rerank';
-      const reranker = new JinaReranker({
-        apiKey: 'test-key',
-        apiUrl: customUrl,
-        logger: mockLogger,
-      });
-
-      const apiUrl = getApiUrl(reranker);
-      expect(apiUrl).toBe(customUrl);
-
-      if (typeof originalEnv === 'string') {
-        process.env.JINA_API_URL = originalEnv;
-      } else {
-        delete process.env.JINA_API_URL;
-      }
-    });
-  });
-
-  describe('rerank method', () => {
-    it('should log the API URL being used', async () => {
-      const customUrl = 'https://test-jina-endpoint.com/v1/rerank';
-      const reranker = new JinaReranker({
-        apiKey: 'test-key',
-        apiUrl: customUrl,
-        logger: mockLogger,
-      });
-
-      const logSpy = jest
-        .spyOn(mockLogger, 'debug')
-        .mockImplementation(() => mockLogger);
-      jest.spyOn(mockLogger, 'error').mockImplementation(() => mockLogger);
-      jest
-        .spyOn(axios, 'post')
-        .mockRejectedValueOnce(new Error('Network error'));
-
-      await reranker.rerank('test query', ['document1', 'document2'], 2);
-
-      expect(logSpy).toHaveBeenCalledWith(
-        expect.stringContaining(
-          `Reranking 2 chunks with Jina using API URL: ${customUrl}`
-        )
-      );
-    });
-
-    it('should log compact Axios errors without request internals', async () => {
-      const customUrl =
-        'https://test-jina-endpoint.com/v1/rerank?api_key=hidden';
-      const reranker = new JinaReranker({
-        apiKey: 'test-key',
-        apiUrl: customUrl,
-        logger: mockLogger,
-      });
-      const errorSpy = jest
-        .spyOn(mockLogger, 'error')
-        .mockImplementation(() => mockLogger);
-      jest.spyOn(mockLogger, 'debug').mockImplementation(() => mockLogger);
-      jest.spyOn(axios, 'isAxiosError').mockReturnValue(true);
-      jest.spyOn(axios, 'post').mockRejectedValueOnce(
-        createAxiosErrorFixture(customUrl, {
-          message: 'upstream failed',
-          details: 'x'.repeat(5000),
-        })
-      );
-
-      const result = await reranker.rerank(
-        'test query',
-        ['document1', 'document2'],
-        2
-      );
-
-      expect(result).toEqual([
-        { text: 'document1', score: 0 },
-        { text: 'document2', score: 0 },
-      ]);
-      expect(errorSpy).toHaveBeenCalledWith(
-        'Error using Jina reranker',
-        expect.objectContaining({
-          code: 'ERR_BAD_RESPONSE',
-          message: 'Request failed with status code 500',
-          method: 'POST',
-          name: 'Error',
-          responseDataSummary: 'object(2)',
-          status: 500,
-          url: 'https://test-jina-endpoint.com/v1/rerank',
-        })
-      );
-
-      const metadata = errorSpy.mock.calls.flat()[1];
-      const serializedMetadata = JSON.stringify(metadata);
-
-      expect(serializedMetadata).not.toContain('upstream failed');
-      expect(serializedMetadata).not.toContain('Authorization');
-      expect(serializedMetadata).not.toContain('api_key');
-      expect(serializedMetadata).not.toContain('document1');
-      expect(serializedMetadata).not.toContain('test-key');
-      expect(serializedMetadata.length).toBeLessThan(500);
-    });
-
-    it('should bound the rerank request with the default timeout', async () => {
-      const customUrl = 'https://test-jina-endpoint.com/v1/rerank';
-      const reranker = new JinaReranker({
-        apiKey: 'test-key',
-        apiUrl: customUrl,
-        logger: mockLogger,
-      });
-      jest.spyOn(mockLogger, 'debug').mockImplementation(() => mockLogger);
-      const postSpy = jest.spyOn(axios, 'post').mockResolvedValueOnce({
-        data: { results: [{ index: 0, relevance_score: 0.9 }] },
-      });
-
-      await reranker.rerank('test query', ['document1'], 1);
-
-      expect(postSpy).toHaveBeenCalledWith(
-        customUrl,
-        expect.any(Object),
-        expect.objectContaining({ timeout: 10000 })
-      );
-    });
-
-    it('should bound the rerank request with a custom timeout', async () => {
-      const customUrl = 'https://test-jina-endpoint.com/v1/rerank';
-      const reranker = new JinaReranker({
-        apiKey: 'test-key',
-        apiUrl: customUrl,
-        timeout: 2500,
-        logger: mockLogger,
-      });
-      jest.spyOn(mockLogger, 'debug').mockImplementation(() => mockLogger);
-      const postSpy = jest.spyOn(axios, 'post').mockResolvedValueOnce({
-        data: { results: [{ index: 0, relevance_score: 0.9 }] },
-      });
-
-      await reranker.rerank('test query', ['document1'], 1);
-
-      expect(postSpy).toHaveBeenCalledWith(
-        customUrl,
-        expect.any(Object),
-        expect.objectContaining({ timeout: 2500 })
-      );
-    });
-  });
-});
-
-describe('createReranker', () => {
-  it('should create JinaReranker with jinaApiUrl when provided', () => {
-    const customUrl = 'https://custom-jina-endpoint.com/v1/rerank';
-    const reranker = createReranker({
-      rerankerType: 'jina',
-      jinaApiKey: 'test-key',
-      jinaApiUrl: customUrl,
-    });
-
-    expect(reranker).toBeInstanceOf(JinaReranker);
-    if (!(reranker instanceof JinaReranker)) {
-      throw new Error('Expected createReranker to return a JinaReranker.');
-    }
-    const apiUrl = getApiUrl(reranker);
-    expect(apiUrl).toBe(customUrl);
-  });
-
-  it('should create JinaReranker with default URL when jinaApiUrl is not provided', () => {
-    const reranker = createReranker({
-      rerankerType: 'jina',
-      jinaApiKey: 'test-key',
-    });
-
-    expect(reranker).toBeInstanceOf(JinaReranker);
-    if (!(reranker instanceof JinaReranker)) {
-      throw new Error('Expected createReranker to return a JinaReranker.');
-    }
-    const apiUrl = getApiUrl(reranker);
-    expect(apiUrl).toBe('https://api.jina.ai/v1/rerank');
-  });
-
-  it('should pass rerankerTimeout through to the rerank request', async () => {
-    const customUrl = 'https://custom-jina-endpoint.com/v1/rerank';
-    const reranker = createReranker({
-      rerankerType: 'jina',
-      jinaApiKey: 'test-key',
-      jinaApiUrl: customUrl,
-      rerankerTimeout: 4000,
-      logger: createDefaultLogger(),
-    });
-    if (!(reranker instanceof JinaReranker)) {
-      throw new Error('Expected createReranker to return a JinaReranker.');
-    }
-    const postSpy = jest.spyOn(axios, 'post').mockResolvedValueOnce({
-      data: { results: [{ index: 0, relevance_score: 0.9 }] },
-    });
-
-    await reranker.rerank('test query', ['document1'], 1);
-
-    expect(postSpy).toHaveBeenCalledWith(
-      customUrl,
-      expect.any(Object),
-      expect.objectContaining({ timeout: 4000 })
-    );
-  });
-});