@librechat/agents 3.2.57 → 3.2.58

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

@@ -0,0 +1,183 @@
+import axios from 'axios';
+import { createSearchAPI } from './search';
+import { createSearchTool } from './tool';
+import { DATE_RANGE } from './schema';
+
+jest.mock('axios');
+const mockedAxios = axios as jest.Mocked<typeof axios>;
+
+const sampleResponse = {
+  data: {
+    results: [
+      {
+        title: 'TypeScript Best Practices 2026',
+        url: 'https://example.com/ts',
+        description: 'A comprehensive guide to TypeScript.',
+        published_at: '2026-01-15T10:30:00Z',
+      },
+      {
+        title: 'Second result',
+        url: 'https://example.com/second',
+        snippet: 'Snippet fallback when description is absent.',
+      },
+    ],
+  },
+};
+
+describe('Keenable search API', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    delete process.env.KEENABLE_API_KEY;
+    delete process.env.KEENABLE_API_URL;
+  });
+
+  it('returns an error for empty queries without calling the API', async () => {
+    const searchAPI = createSearchAPI({ searchProvider: 'keenable' });
+    const result = await searchAPI.getSources({ query: '   ' });
+
+    expect(result).toEqual({ success: false, error: 'Query cannot be empty' });
+    expect(mockedAxios.post).not.toHaveBeenCalled();
+  });
+
+  it('hits the public endpoint and omits the API key header when keyless', async () => {
+    mockedAxios.post.mockResolvedValueOnce(sampleResponse);
+
+    const searchAPI = createSearchAPI({ searchProvider: 'keenable' });
+    const result = await searchAPI.getSources({ query: 'typescript' });
+
+    expect(mockedAxios.post).toHaveBeenCalledWith(
+      'https://api.keenable.ai/v1/search/public',
+      { query: 'typescript' },
+      expect.objectContaining({
+        headers: expect.objectContaining({ 'X-Keenable-Title': 'LibreChat' }),
+      })
+    );
+    const headers = mockedAxios.post.mock.calls[0][2]?.headers as Record<
+      string,
+      string
+    >;
+    expect(headers['X-API-Key']).toBeUndefined();
+    expect(result.success).toBe(true);
+  });
+
+  it('hits the authenticated endpoint and sends the API key when a key is set', async () => {
+    mockedAxios.post.mockResolvedValueOnce(sampleResponse);
+
+    const searchAPI = createSearchAPI({
+      searchProvider: 'keenable',
+      keenableApiKey: 'secret-key',
+    });
+    await searchAPI.getSources({ query: 'typescript' });
+
+    expect(mockedAxios.post).toHaveBeenCalledWith(
+      'https://api.keenable.ai/v1/search',
+      { query: 'typescript' },
+      expect.objectContaining({
+        headers: expect.objectContaining({ 'X-API-Key': 'secret-key' }),
+      })
+    );
+  });
+
+  it('maps results into organic sources (description and snippet fallback)', async () => {
+    mockedAxios.post.mockResolvedValueOnce(sampleResponse);
+
+    const searchAPI = createSearchAPI({ searchProvider: 'keenable' });
+    const result = await searchAPI.getSources({ query: 'typescript' });
+
+    expect(result.data?.organic).toEqual([
+      {
+        title: 'TypeScript Best Practices 2026',
+        link: 'https://example.com/ts',
+        snippet: 'A comprehensive guide to TypeScript.',
+        date: '2026-01-15T10:30:00Z',
+      },
+      {
+        title: 'Second result',
+        link: 'https://example.com/second',
+        snippet: 'Snippet fallback when description is absent.',
+        date: undefined,
+      },
+    ]);
+  });
+
+  it('applies the site filter and limits results client-side', async () => {
+    mockedAxios.post.mockResolvedValueOnce({
+      data: {
+        results: [{ url: '1' }, { url: '2' }, { url: '3' }],
+      },
+    });
+
+    const searchAPI = createSearchAPI({
+      searchProvider: 'keenable',
+      keenableSearchOptions: { site: 'github.com', maxResults: 2 },
+    });
+    const result = await searchAPI.getSources({ query: 'typescript' });
+
+    expect(mockedAxios.post).toHaveBeenCalledWith(
+      expect.any(String),
+      { query: 'typescript', site: 'github.com' },
+      expect.any(Object)
+    );
+    expect(result.data?.organic).toHaveLength(2);
+  });
+
+  it('maps date ranges to Keenable published filters', async () => {
+    mockedAxios.post.mockResolvedValueOnce(sampleResponse);
+
+    const searchAPI = createSearchAPI({ searchProvider: 'keenable' });
+    await searchAPI.getSources({
+      query: 'typescript',
+      date: DATE_RANGE.PAST_WEEK,
+    });
+
+    expect(mockedAxios.post).toHaveBeenCalledWith(
+      expect.any(String),
+      { query: 'typescript', published_after: '7d' },
+      expect.any(Object)
+    );
+  });
+
+  it('surfaces request failures as a structured error', async () => {
+    mockedAxios.post.mockRejectedValueOnce(new Error('Network error'));
+
+    const searchAPI = createSearchAPI({ searchProvider: 'keenable' });
+    const result = await searchAPI.getSources({ query: 'typescript' });
+
+    expect(result.success).toBe(false);
+    expect(result.error).toBe('Keenable API request failed: Network error');
+  });
+});
+
+describe('Keenable capability gating', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    delete process.env.KEENABLE_API_KEY;
+    delete process.env.KEENABLE_API_URL;
+  });
+
+  it('skips image/news/video sub-searches (organic-only provider)', async () => {
+    mockedAxios.post.mockResolvedValueOnce(sampleResponse).mockResolvedValue({
+      data: { success: true, data: { markdown: '# A', html: '<p>a</p>' } },
+    });
+
+    const searchTool = createSearchTool({
+      searchProvider: 'keenable',
+      scraperProvider: 'firecrawl',
+      firecrawlApiKey: 'k',
+      topResults: 1,
+      rerankerType: 'none',
+    });
+
+    await searchTool.invoke({
+      query: 'typescript',
+      images: true,
+      news: true,
+      videos: true,
+    });
+
+    const searchCalls = mockedAxios.post.mock.calls.filter(([url]) =>
+      (url as string).includes('keenable')
+    );
+    expect(searchCalls).toHaveLength(1);
+  });
+});

package/src/tools/search/rerankers.ts

@@ -4,6 +4,11 @@ import { createDefaultLogger, formatErrorForLog } from './utils';
 
 const DEFAULT_JINA_API_URL = 'https://api.jina.ai/v1/rerank';
 
+/** Every other network call in the search pipeline is bounded (scrapers,
+ * search providers); rerank requests must be too, or a hung rerank API
+ * stalls the whole tool. */
+const DEFAULT_RERANKER_TIMEOUT = 10000;
+
 const getDefaultJinaApiUrl = (): string =>
   process.env.JINA_API_URL != null && process.env.JINA_API_URL !== ''
     ? process.env.JINA_API_URL
@@ -36,19 +41,23 @@ export abstract class BaseReranker {
 
 export class JinaReranker extends BaseReranker {
   private apiUrl: string;
+  private timeout: number;
 
   constructor({
     apiKey = process.env.JINA_API_KEY,
     apiUrl = getDefaultJinaApiUrl(),
+    timeout = DEFAULT_RERANKER_TIMEOUT,
     logger,
   }: {
     apiKey?: string;
     apiUrl?: string;
+    timeout?: number;
     logger?: t.Logger;
   }) {
     super(logger);
     this.apiKey = apiKey;
     this.apiUrl = apiUrl;
+    this.timeout = timeout;
   }
 
   async rerank(
@@ -56,7 +65,9 @@ export class JinaReranker extends BaseReranker {
     documents: string[],
     topK: number = 5
   ): Promise<t.Highlight[]> {
-    this.logger.debug(`Reranking ${documents.length} chunks with Jina using API URL: ${this.apiUrl}`);
+    this.logger.debug(
+      `Reranking ${documents.length} chunks with Jina using API URL: ${this.apiUrl}`
+    );
 
     try {
       if (this.apiKey == null || this.apiKey === '') {
@@ -80,6 +91,7 @@ export class JinaReranker extends BaseReranker {
             'Content-Type': 'application/json',
             Authorization: `Bearer ${this.apiKey}`,
           },
+          timeout: this.timeout,
         }
       );
 
@@ -122,15 +134,20 @@ export class JinaReranker extends BaseReranker {
 }
 
 export class CohereReranker extends BaseReranker {
+  private timeout: number;
+
   constructor({
     apiKey = process.env.COHERE_API_KEY,
+    timeout = DEFAULT_RERANKER_TIMEOUT,
     logger,
   }: {
     apiKey?: string;
+    timeout?: number;
     logger?: t.Logger;
   }) {
     super(logger);
     this.apiKey = apiKey;
+    this.timeout = timeout;
   }
 
   async rerank(
@@ -161,6 +178,7 @@ export class CohereReranker extends BaseReranker {
             'Content-Type': 'application/json',
             Authorization: `Bearer ${this.apiKey}`,
           },
+          timeout: this.timeout,
         }
       );
 
@@ -218,19 +236,33 @@ export const createReranker = (config: {
   jinaApiKey?: string;
   jinaApiUrl?: string;
   cohereApiKey?: string;
+  rerankerTimeout?: number;
   logger?: t.Logger;
 }): BaseReranker | undefined => {
-  const { rerankerType, jinaApiKey, jinaApiUrl, cohereApiKey, logger } = config;
+  const {
+    rerankerType,
+    jinaApiKey,
+    jinaApiUrl,
+    cohereApiKey,
+    rerankerTimeout,
+    logger,
+  } = config;
 
   // Create a default logger if none is provided
   const defaultLogger = logger || createDefaultLogger();
 
   switch (rerankerType.toLowerCase()) {
   case 'jina':
-    return new JinaReranker({ apiKey: jinaApiKey, apiUrl: jinaApiUrl, logger: defaultLogger });
+    return new JinaReranker({
+      apiKey: jinaApiKey,
+      apiUrl: jinaApiUrl,
+      timeout: rerankerTimeout,
+      logger: defaultLogger,
+    });
   case 'cohere':
     return new CohereReranker({
       apiKey: cohereApiKey,
+      timeout: rerankerTimeout,
       logger: defaultLogger,
     });
   case 'infinity':
@@ -242,7 +274,12 @@ export const createReranker = (config: {
     defaultLogger.warn(
       `Unknown reranker type: ${rerankerType}. Defaulting to InfinityReranker.`
     );
-    return new JinaReranker({ apiKey: jinaApiKey, apiUrl: jinaApiUrl, logger: defaultLogger });
+    return new JinaReranker({
+      apiKey: jinaApiKey,
+      apiUrl: jinaApiUrl,
+      timeout: rerankerTimeout,
+      logger: defaultLogger,
+    });
   }
 };
 

package/src/tools/search/search.ts

@@ -2,6 +2,7 @@ import axios from 'axios';
 import { RecursiveCharacterTextSplitter } from '@langchain/textsplitters';
 import type * as t from './types';
 import { getAttribution, createDefaultLogger } from './utils';
+import { createKeenableAPI } from './keenable-search';
 import { createTavilyAPI } from './tavily-search';
 import { BaseReranker } from './rerankers';
 
@@ -67,6 +68,43 @@ const chunker = {
 };
 
 const DEFAULT_MAX_CONTENT_LENGTH = 50000;
+const DEFAULT_CHUNK_SIZE = 150;
+const DEFAULT_CHUNK_OVERLAP = 50;
+
+/** Resolves reranker chunking from config, the `SEARCH_CHUNK_SIZE` /
+ * `SEARCH_CHUNK_OVERLAP` env vars, or the defaults (150 / 50 chars). The
+ * overlap is clamped below the chunk size — `RecursiveCharacterTextSplitter`
+ * throws when overlap >= size. */
+function resolveChunkOptions(
+  chunkSize?: number,
+  chunkOverlap?: number
+): { chunkSize: number; chunkOverlap: number } {
+  const resolve = (
+    configValue: number | undefined,
+    envVar: string,
+    fallback: number
+  ): number => {
+    if (configValue != null && configValue > 0) {
+      return configValue;
+    }
+    const envValue = Number(process.env[envVar]);
+    if (Number.isFinite(envValue) && envValue > 0) {
+      return envValue;
+    }
+    return fallback;
+  };
+
+  const size = resolve(chunkSize, 'SEARCH_CHUNK_SIZE', DEFAULT_CHUNK_SIZE);
+  let overlap = resolve(
+    chunkOverlap,
+    'SEARCH_CHUNK_OVERLAP',
+    DEFAULT_CHUNK_OVERLAP
+  );
+  if (overlap >= size) {
+    overlap = Math.floor(size / 3);
+  }
+  return { chunkSize: size, chunkOverlap: overlap };
+}
 
 /** Resolves the per-source scraped content cap from config, the
  * `SEARCH_MAX_CONTENT_LENGTH` env var, or the default (50,000 chars) */
@@ -103,6 +141,7 @@ const getHighlights = async ({
   reranker,
   topResults = 5,
   maxContentLength = DEFAULT_MAX_CONTENT_LENGTH,
+  chunkOptions,
   logger,
 }: {
   content: string;
@@ -110,6 +149,7 @@ const getHighlights = async ({
   reranker?: BaseReranker;
   topResults?: number;
   maxContentLength?: number;
+  chunkOptions?: { chunkSize: number; chunkOverlap: number };
   logger?: t.Logger;
 }): Promise<t.Highlight[] | undefined> => {
   const logger_ = logger || createDefaultLogger();
@@ -125,7 +165,8 @@ const getHighlights = async ({
 
   try {
     const documents = await chunker.splitText(
-      truncateContent(content, maxContentLength)
+      truncateContent(content, maxContentLength),
+      chunkOptions
     );
     if (Array.isArray(documents)) {
       return await reranker.rerank(query, documents, topResults);
@@ -445,6 +486,9 @@ export const createSearchAPI = (
     tavilyApiKey,
     tavilySearchUrl,
     tavilySearchOptions,
+    keenableApiKey,
+    keenableApiUrl,
+    keenableSearchOptions,
   } = config;
 
   if (searchProvider.toLowerCase() === 'serper') {
@@ -453,9 +497,15 @@ export const createSearchAPI = (
     return createSearXNGAPI(searxngInstanceUrl, searxngApiKey);
   } else if (searchProvider.toLowerCase() === 'tavily') {
     return createTavilyAPI(tavilyApiKey, tavilySearchUrl, tavilySearchOptions);
+  } else if (searchProvider.toLowerCase() === 'keenable') {
+    return createKeenableAPI(
+      keenableApiKey,
+      keenableApiUrl,
+      keenableSearchOptions
+    );
   } else {
     throw new Error(
-      `Invalid search provider: ${searchProvider}. Must be 'serper', 'searxng', or 'tavily'`
+      `Invalid search provider: ${searchProvider}. Must be 'serper', 'searxng', 'tavily', or 'keenable'`
     );
   }
 };
@@ -481,6 +531,10 @@ export const createSourceProcessor = (
   } = config;
 
   const maxContentLength = resolveMaxContentLength(config.maxContentLength);
+  const chunkOptions = resolveChunkOptions(
+    config.chunkSize,
+    config.chunkOverlap
+  );
   const logger_ = logger || createDefaultLogger();
   const scraper = scraperInstance;
 
@@ -521,8 +575,10 @@ export const createSourceProcessor = (
       const highlights = await getHighlights({
         query,
         reranker,
+        topResults,
         content: result.content,
         maxContentLength,
+        chunkOptions,
         logger: logger_,
       });
       if (onGetHighlights) {

package/src/tools/search/source-processing.test.ts

@@ -14,6 +14,7 @@ const silentLogger = {
 
 class RecordingReranker extends BaseReranker {
   public rerankCalls: string[][] = [];
+  public topKCalls: number[] = [];
 
   constructor() {
     super(silentLogger);
@@ -25,6 +26,7 @@ class RecordingReranker extends BaseReranker {
     topK: number = 5
   ): Promise<t.Highlight[]> {
     this.rerankCalls.push(documents);
+    this.topKCalls.push(topK);
     return this.getDefaultRanking(documents, topK);
   }
 }
@@ -212,6 +214,90 @@ describe('createSourceProcessor content capping', () => {
 
     expect(data.organic?.[0].content?.length).toBe(50000);
   });
+
+  test('passes configured topResults through to the reranker', async () => {
+    const reranker = new RecordingReranker();
+    const scraper = createFakeScraper({ [link]: makeLongContent(3000) });
+    const processor = createSourceProcessor(
+      { reranker, topResults: 2, logger: silentLogger },
+      scraper
+    );
+
+    await processor.processSources({
+      ...baseFields,
+      news: false,
+      numElements: 5,
+      result: { success: true, data: { organic: [makeOrganic(link)] } },
+    });
+
+    expect(reranker.topKCalls).toEqual([2]);
+  });
+});
+
+describe('createSourceProcessor reranker chunking', () => {
+  const link = 'https://a.com';
+  const baseFields = {
+    query: 'test query',
+    proMode: true,
+    onGetHighlights: undefined,
+  };
+
+  const runWithConfig = async (
+    config: Partial<t.ProcessSourcesConfig>
+  ): Promise<string[]> => {
+    const reranker = new RecordingReranker();
+    const scraper = createFakeScraper({ [link]: makeLongContent(10000) });
+    const processor = createSourceProcessor(
+      { reranker, logger: silentLogger, ...config },
+      scraper
+    );
+
+    await processor.processSources({
+      ...baseFields,
+      news: false,
+      numElements: 5,
+      result: { success: true, data: { organic: [makeOrganic(link)] } },
+    });
+
+    return reranker.rerankCalls[0] ?? [];
+  };
+
+  test('configured chunkSize produces fewer, larger chunks', async () => {
+    const defaultDocs = await runWithConfig({});
+    const largeDocs = await runWithConfig({
+      chunkSize: 500,
+      chunkOverlap: 100,
+    });
+
+    expect(defaultDocs.length).toBeGreaterThan(0);
+    expect(largeDocs.length).toBeGreaterThan(0);
+    expect(largeDocs.length).toBeLessThan(defaultDocs.length);
+    expect(Math.max(...defaultDocs.map((d) => d.length))).toBeLessThanOrEqual(
+      150
+    );
+    expect(Math.max(...largeDocs.map((d) => d.length))).toBeLessThanOrEqual(
+      500
+    );
+  });
+
+  test('respects SEARCH_CHUNK_SIZE env vars when config is not set', async () => {
+    process.env.SEARCH_CHUNK_SIZE = '500';
+    process.env.SEARCH_CHUNK_OVERLAP = '100';
+    try {
+      const docs = await runWithConfig({});
+      expect(docs.length).toBeGreaterThan(0);
+      expect(Math.max(...docs.map((d) => d.length))).toBeLessThanOrEqual(500);
+    } finally {
+      delete process.env.SEARCH_CHUNK_SIZE;
+      delete process.env.SEARCH_CHUNK_OVERLAP;
+    }
+  });
+
+  test('clamps overlap below chunk size instead of throwing', async () => {
+    const docs = await runWithConfig({ chunkSize: 200, chunkOverlap: 300 });
+    expect(docs.length).toBeGreaterThan(0);
+    expect(Math.max(...docs.map((d) => d.length))).toBeLessThanOrEqual(200);
+  });
 });
 
 describe('createSourceProcessor topStories capping', () => {

package/src/tools/search/tool.ts

@@ -197,13 +197,17 @@ export async function executeParallelSearches({
 function createSearchProcessor({
   searchAPI,
   safeSearch,
+  supportsImages,
   supportsVideos,
+  supportsNews,
   sourceProcessor,
   onGetHighlights,
   logger,
 }: {
   safeSearch: t.SearchToolConfig['safeSearch'];
+  supportsImages: boolean;
   supportsVideos: boolean;
+  supportsNews: boolean;
   searchAPI: ReturnType<typeof createSearchAPI>;
   sourceProcessor: ReturnType<typeof createSourceProcessor>;
   onGetHighlights: t.SearchToolConfig['onGetHighlights'];
@@ -238,9 +242,9 @@ function createSearchProcessor({
         date,
         country,
         safeSearch,
-        images,
+        images: supportsImages && images,
         videos: supportsVideos && videos,
-        news,
+        news: supportsNews && news,
         logger,
       });
 
@@ -315,7 +319,11 @@ function createTool({
         }),
       });
       const turn = runnableConfig.toolCall?.turn ?? 0;
-      const { output, references } = formatResultsForLLM(turn, searchResult, maxOutputChars);
+      const { output, references } = formatResultsForLLM(
+        turn,
+        searchResult,
+        maxOutputChars
+      );
       const data: t.SearchResultData = { turn, ...searchResult, references };
       return [output, { [Constants.WEB_SEARCH]: data }];
     },
@@ -358,9 +366,15 @@ export const createSearchTool = (
     tavilySearchUrl,
     tavilyExtractUrl,
     tavilySearchOptions,
+    keenableApiKey,
+    keenableApiUrl,
+    keenableSearchOptions,
     rerankerType = 'cohere',
+    rerankerTimeout,
     topResults = 5,
     maxContentLength,
+    chunkSize,
+    chunkOverlap,
     maxOutputChars,
     strategies = ['no_extraction'],
     filterContent = true,
@@ -415,6 +429,9 @@ export const createSearchTool = (
     tavilyApiKey,
     tavilySearchUrl,
     tavilySearchOptions: effectiveTavilySearchOptions,
+    keenableApiKey,
+    keenableApiUrl,
+    keenableSearchOptions,
   });
 
   /** Create scraper based on scraperProvider */
@@ -455,6 +472,7 @@ export const createSearchTool = (
     jinaApiKey,
     jinaApiUrl,
     cohereApiKey,
+    rerankerTimeout,
     logger,
   });
 
@@ -467,6 +485,8 @@ export const createSearchTool = (
       reranker: selectedReranker,
       topResults,
       maxContentLength,
+      chunkSize,
+      chunkOverlap,
       strategies,
       filterContent,
       logger,
@@ -477,7 +497,12 @@ export const createSearchTool = (
   const search = createSearchProcessor({
     searchAPI,
     safeSearch,
-    supportsVideos: searchProvider !== 'tavily',
+    // Keenable is organic-only: its API ignores `type`, so image/news
+    // sub-searches would spend rate limit and merge nothing.
+    supportsImages: searchProvider !== 'keenable',
+    supportsVideos:
+      searchProvider !== 'tavily' && searchProvider !== 'keenable',
+    supportsNews: searchProvider !== 'keenable',
     sourceProcessor,
     onGetHighlights,
     logger,