@librechat/agents 2.4.321 → 2.4.322

package/src/tools/search/search.ts

@@ -1,10 +1,9 @@
-/* eslint-disable no-console */
 import axios from 'axios';
 import { RecursiveCharacterTextSplitter } from '@langchain/textsplitters';
 import type * as t from './types';
+import { getAttribution, createDefaultLogger } from './utils';
 import { FirecrawlScraper } from './firecrawl';
 import { BaseReranker } from './rerankers';
-import { getAttribution } from './utils';
 
 const chunker = {
   cleanText: (text: string): string => {
@@ -52,12 +51,14 @@ const chunker = {
       chunkSize?: number;
       chunkOverlap?: number;
       separators?: string[];
-    }
+    },
+    logger?: t.Logger
   ): Promise<string[][]> => {
     // Split multiple texts
+    const logger_ = logger || createDefaultLogger();
     const promises = texts.map((text) =>
       chunker.splitText(text, options).catch((error) => {
-        console.error('Error splitting text:', error);
+        logger_.error('Error splitting text:', error);
         return [text];
       })
     );
@@ -82,18 +83,22 @@ const getHighlights = async ({
   content,
   reranker,
   topResults = 5,
+  logger,
 }: {
   content: string;
   query: string;
   reranker?: BaseReranker;
   topResults?: number;
+  logger?: t.Logger;
 }): Promise<t.Highlight[] | undefined> => {
+  const logger_ = logger || createDefaultLogger();
+
   if (!content) {
-    console.warn('No content provided for highlights');
+    logger_.warn('No content provided for highlights');
     return;
   }
   if (!reranker) {
-    console.warn('No reranker provided for highlights');
+    logger_.warn('No reranker provided for highlights');
     return;
   }
 
@@ -102,14 +107,14 @@ const getHighlights = async ({
     if (Array.isArray(documents)) {
       return await reranker.rerank(query, documents, topResults);
     } else {
-      console.error(
+      logger_.error(
         'Expected documents to be an array, got:',
         typeof documents
       );
       return;
     }
   } catch (error) {
-    console.error('Error in content processing:', error);
+    logger_.error('Error in content processing:', error);
     return;
   }
 };
@@ -131,25 +136,49 @@ const createSerperAPI = (
 
   const getSources = async ({
     query,
+    date,
     country,
+    safeSearch,
     numResults = 8,
+    type,
   }: t.GetSourcesParams): Promise<t.SearchResult> => {
     if (!query.trim()) {
       return { success: false, error: 'Query cannot be empty' };
     }
 
     try {
+      const safe = ['off', 'moderate', 'active'] as const;
       const payload: t.SerperSearchPayload = {
         q: query,
+        safe: safe[safeSearch ?? 1],
         num: Math.min(Math.max(1, numResults), 10),
       };
 
+      // Set the search type if provided
+      if (type) {
+        payload.type = type;
+      }
+
+      if (date != null) {
+        payload.tbs = `qdr:${date}`;
+      }
+
       if (country != null && country !== '') {
         payload['gl'] = country.toLowerCase();
       }
 
+      // Determine the API endpoint based on the search type
+      let apiEndpoint = config.apiUrl;
+      if (type === 'images') {
+        apiEndpoint = 'https://google.serper.dev/images';
+      } else if (type === 'videos') {
+        apiEndpoint = 'https://google.serper.dev/videos';
+      } else if (type === 'news') {
+        apiEndpoint = 'https://google.serper.dev/news';
+      }
+
       const response = await axios.post<t.SerperResultData>(
-        config.apiUrl,
+        apiEndpoint,
         payload,
         {
           headers: {
@@ -169,6 +198,8 @@ const createSerperAPI = (
         peopleAlsoAsk: data.peopleAlsoAsk,
         knowledgeGraph: data.knowledgeGraph,
         relatedSearches: data.relatedSearches,
+        videos: data.videos ?? [],
+        news: data.news ?? [],
       };
 
       return { success: true, data: results };
@@ -202,6 +233,7 @@ const createSearXNGAPI = (
   const getSources = async ({
     query,
     numResults = 8,
+    type,
   }: t.GetSourcesParams): Promise<t.SearchResult> => {
     if (!query.trim()) {
       return { success: false, error: 'Query cannot be empty' };
@@ -218,12 +250,22 @@ const createSearXNGAPI = (
         searchUrl = searchUrl.replace(/\/$/, '') + '/search';
       }
 
+      // Determine the search category based on the type
+      let category = 'general';
+      if (type === 'images') {
+        category = 'images';
+      } else if (type === 'videos') {
+        category = 'videos';
+      } else if (type === 'news') {
+        category = 'news';
+      }
+
       // Prepare parameters for SearXNG
       const params: t.SearxNGSearchPayload = {
         q: query,
         format: 'json',
         pageno: 1,
-        categories: 'general',
+        categories: category,
         language: 'all',
         safesearch: 0,
         engines: 'google,bing,duckduckgo',
@@ -271,6 +313,8 @@ const createSearXNGAPI = (
         topStories: [],
         // Use undefined instead of null for optional properties
         relatedSearches: data.suggestions ?? [],
+        videos: [],
+        news: [],
       };
 
       return { success: true, data: results };
@@ -327,8 +371,10 @@ export const createSourceProcessor = (
     // strategies = ['no_extraction'],
     // filterContent = true,
     reranker,
+    logger,
   } = config;
 
+  const logger_ = logger || createDefaultLogger();
   const firecrawlScraper = scraperInstance;
 
   const webScraper = {
@@ -341,7 +387,7 @@ export const createSourceProcessor = (
       links: string[];
       onGetHighlights: t.SearchToolConfig['onGetHighlights'];
     }): Promise<Array<t.ScrapeResult>> => {
-      console.log(`Scraping ${links.length} links with Firecrawl`);
+      logger_.debug(`Scraping ${links.length} links with Firecrawl`);
       const promises: Array<Promise<t.ScrapeResult>> = [];
       try {
         for (let i = 0; i < links.length; i++) {
@@ -349,7 +395,11 @@ export const createSourceProcessor = (
           const promise: Promise<t.ScrapeResult> = firecrawlScraper
             .scrapeUrl(currentLink, {})
             .then(([url, response]) => {
-              const attribution = getAttribution(url, response.data?.metadata);
+              const attribution = getAttribution(
+                url,
+                response.data?.metadata,
+                logger_
+              );
               if (response.success && response.data) {
                 const [content, references] =
                   firecrawlScraper.extractContent(response);
@@ -371,8 +421,9 @@ export const createSourceProcessor = (
             .then(async (result) => {
               try {
                 if (result.error != null) {
-                  console.error(
-                    `Error scraping ${result.url}: ${result.content}`
+                  logger_.error(
+                    `Error scraping ${result.url}: ${result.content}`,
+                    result.error
                   );
                   return {
                     ...result,
@@ -382,6 +433,7 @@ export const createSourceProcessor = (
                   query,
                   reranker,
                   content: result.content,
+                  logger: logger_,
                 });
                 if (onGetHighlights) {
                   onGetHighlights(result.url);
@@ -391,14 +443,14 @@ export const createSourceProcessor = (
                   highlights,
                 };
               } catch (error) {
-                console.error('Error processing scraped content:', error);
+                logger_.error('Error processing scraped content:', error);
                 return {
                   ...result,
                 };
               }
             })
             .catch((error) => {
-              console.error(`Error scraping ${currentLink}:`, error);
+              logger_.error(`Error scraping ${currentLink}:`, error);
               return {
                 url: currentLink,
                 error: true,
@@ -409,7 +461,7 @@ export const createSourceProcessor = (
         }
         return await Promise.all(promises);
       } catch (error) {
-        console.error('Error in scrapeMany:', error);
+        logger_.error('Error in scrapeMany:', error);
         return [];
       }
     },
@@ -453,6 +505,7 @@ export const createSourceProcessor = (
     result,
     numElements,
     query,
+    news,
     proMode = true,
     onGetHighlights,
   }: t.ProcessSourcesFields): Promise<t.SearchResultData> => {
@@ -520,7 +573,7 @@ export const createSourceProcessor = (
         organicLinksSet
       );
 
-      if (organicLinks.length === 0 && topStoryLinks.length === 0) {
+      if (organicLinks.length === 0 && (topStoryLinks.length === 0 || !news)) {
         return result.data;
       }
 
@@ -541,7 +594,7 @@ export const createSourceProcessor = (
       }
 
       // Process top story links
-      if (topStoryLinks.length > 0) {
+      if (news && topStoryLinks.length > 0) {
         promises.push(
           fetchContents({
             query,
@@ -555,18 +608,17 @@ export const createSourceProcessor = (
 
       await Promise.all(promises);
 
-      // Update sources with scraped content
       if (result.data.organic.length > 0) {
         updateSourcesWithContent(result.data.organic, sourceMap);
       }
 
-      if (topStories.length > 0) {
+      if (news && topStories.length > 0) {
         updateSourcesWithContent(topStories, sourceMap);
       }
 
       return result.data;
     } catch (error) {
-      console.error('Error in processSources:', error);
+      logger_.error('Error in processSources:', error);
       return {
         organic: [],
         topStories: [],

package/src/tools/search/tool.ts

@@ -1,88 +1,246 @@
-/* eslint-disable no-console */
 import { z } from 'zod';
 import { tool, DynamicStructuredTool } from '@langchain/core/tools';
 import type { RunnableConfig } from '@langchain/core/runnables';
 import type * as t from './types';
+import {
+  DATE_RANGE,
+  querySchema,
+  dateSchema,
+  countrySchema,
+  imagesSchema,
+  videosSchema,
+  newsSchema,
+} from './schema';
 import { createSearchAPI, createSourceProcessor } from './search';
 import { createFirecrawlScraper } from './firecrawl';
 import { expandHighlights } from './highlights';
 import { formatResultsForLLM } from './format';
+import { createDefaultLogger } from './utils';
 import { createReranker } from './rerankers';
 import { Constants } from '@/common';
 
-const DEFAULT_QUERY_DESCRIPTION = `
-GUIDELINES:
-- Start broad, then narrow: Begin with key concepts, then refine with specifics
-- Think like sources: Use terminology experts would use in the field
-- Consider perspective: Frame queries from different viewpoints for better results
-- Quality over quantity: A precise 3-4 word query often beats lengthy sentences
-
-TECHNIQUES (combine for power searches):
-- EXACT PHRASES: Use quotes ("climate change report")
-- EXCLUDE TERMS: Use minus to remove unwanted results (-wikipedia)
-- SITE-SPECIFIC: Restrict to websites (site:edu research)
-- FILETYPE: Find specific documents (filetype:pdf study)
-- OR OPERATOR: Find alternatives (electric OR hybrid cars)
-- DATE RANGE: Recent information (data after:2020)
-- WILDCARDS: Use * for unknown terms (how to * bread)
-- SPECIFIC QUESTIONS: Use who/what/when/where/why/how
-- DOMAIN TERMS: Include technical terminology for specialized topics
-- CONCISE TERMS: Prioritize keywords over sentences
-`.trim();
-
-const DEFAULT_COUNTRY_DESCRIPTION = `Country code to localize search results.
-Use standard 2-letter country codes: "us", "uk", "ca", "de", "fr", "jp", "br", etc.
-Provide this when the search should return results specific to a particular country.
-Examples:
-- "us" for United States (default)
-- "de" for Germany
-- "in" for India
-`.trim();
+/**
+ * Executes parallel searches and merges the results
+ */
+async function executeParallelSearches({
+  searchAPI,
+  query,
+  date,
+  country,
+  safeSearch,
+  images,
+  videos,
+  news,
+  logger,
+}: {
+  searchAPI: ReturnType<typeof createSearchAPI>;
+  query: string;
+  date?: DATE_RANGE;
+  country?: string;
+  safeSearch: t.SearchToolConfig['safeSearch'];
+  images: boolean;
+  videos: boolean;
+  news: boolean;
+  logger: t.Logger;
+}): Promise<t.SearchResult> {
+  // Prepare all search tasks to run in parallel
+  const searchTasks: Promise<t.SearchResult>[] = [
+    // Main search
+    searchAPI.getSources({
+      query,
+      date,
+      country,
+      safeSearch,
+    }),
+  ];
+
+  if (images) {
+    searchTasks.push(
+      searchAPI
+        .getSources({
+          query,
+          date,
+          country,
+          safeSearch,
+          type: 'images',
+        })
+        .catch((error) => {
+          logger.error('Error fetching images:', error);
+          return {
+            success: false,
+            error: `Images search failed: ${error instanceof Error ? error.message : String(error)}`,
+          };
+        })
+    );
+  }
+  if (videos) {
+    searchTasks.push(
+      searchAPI
+        .getSources({
+          query,
+          date,
+          country,
+          safeSearch,
+          type: 'videos',
+        })
+        .catch((error) => {
+          logger.error('Error fetching videos:', error);
+          return {
+            success: false,
+            error: `Videos search failed: ${error instanceof Error ? error.message : String(error)}`,
+          };
+        })
+    );
+  }
+  if (news) {
+    searchTasks.push(
+      searchAPI
+        .getSources({
+          query,
+          date,
+          country,
+          safeSearch,
+          type: 'news',
+        })
+        .catch((error) => {
+          logger.error('Error fetching news:', error);
+          return {
+            success: false,
+            error: `News search failed: ${error instanceof Error ? error.message : String(error)}`,
+          };
+        })
+    );
+  }
+
+  // Run all searches in parallel
+  const results = await Promise.all(searchTasks);
+
+  // Get the main search result (first result)
+  const mainResult = results[0];
+  if (!mainResult.success) {
+    throw new Error(mainResult.error ?? 'Search failed');
+  }
+
+  // Merge additional results with the main results
+  const mergedResults = { ...mainResult.data };
+
+  // Convert existing news to topStories if present
+  if (mergedResults.news !== undefined && mergedResults.news.length > 0) {
+    const existingNewsAsTopStories = mergedResults.news
+      .filter((newsItem) => newsItem.link !== undefined && newsItem.link !== '')
+      .map((newsItem) => ({
+        title: newsItem.title ?? '',
+        link: newsItem.link ?? '',
+        source: newsItem.source ?? '',
+        date: newsItem.date ?? '',
+        imageUrl: newsItem.imageUrl ?? '',
+        processed: false,
+      }));
+    mergedResults.topStories = [
+      ...(mergedResults.topStories ?? []),
+      ...existingNewsAsTopStories,
+    ];
+    delete mergedResults.news;
+  }
+
+  results.slice(1).forEach((result) => {
+    if (result.success && result.data !== undefined) {
+      if (result.data.images !== undefined && result.data.images.length > 0) {
+        mergedResults.images = [
+          ...(mergedResults.images ?? []),
+          ...result.data.images,
+        ];
+      }
+      if (result.data.videos !== undefined && result.data.videos.length > 0) {
+        mergedResults.videos = [
+          ...(mergedResults.videos ?? []),
+          ...result.data.videos,
+        ];
+      }
+      if (result.data.news !== undefined && result.data.news.length > 0) {
+        const newsAsTopStories = result.data.news.map((newsItem) => ({
+          ...newsItem,
+          link: newsItem.link ?? '',
+        }));
+        mergedResults.topStories = [
+          ...(mergedResults.topStories ?? []),
+          ...newsAsTopStories,
+        ];
+      }
+    }
+  });
+
+  return { success: true, data: mergedResults };
+}
 
 function createSearchProcessor({
   searchAPI,
+  safeSearch,
   sourceProcessor,
   onGetHighlights,
+  logger,
 }: {
+  safeSearch: t.SearchToolConfig['safeSearch'];
   searchAPI: ReturnType<typeof createSearchAPI>;
   sourceProcessor: ReturnType<typeof createSourceProcessor>;
   onGetHighlights: t.SearchToolConfig['onGetHighlights'];
+  logger: t.Logger;
 }) {
   return async function ({
     query,
+    date,
     country,
     proMode = true,
     maxSources = 5,
     onSearchResults,
+    images = false,
+    videos = false,
+    news = false,
   }: {
     query: string;
     country?: string;
-    maxSources?: number;
+    date?: DATE_RANGE;
     proMode?: boolean;
+    maxSources?: number;
     onSearchResults: t.SearchToolConfig['onSearchResults'];
+    images?: boolean;
+    videos?: boolean;
+    news?: boolean;
   }): Promise<t.SearchResultData> {
     try {
-      const result = await searchAPI.getSources({ query, country });
-      onSearchResults?.(result);
+      // Execute parallel searches and merge results
+      const searchResult = await executeParallelSearches({
+        searchAPI,
+        query,
+        date,
+        country,
+        safeSearch,
+        images,
+        videos,
+        news,
+        logger,
+      });
 
-      if (!result.success) {
-        throw new Error(result.error ?? 'Search failed');
-      }
+      onSearchResults?.(searchResult);
 
       const processedSources = await sourceProcessor.processSources({
         query,
-        result,
+        news,
+        result: searchResult,
         proMode,
         onGetHighlights,
         numElements: maxSources,
       });
+
       return expandHighlights(processedSources);
     } catch (error) {
-      console.error('Error in search:', error);
+      logger.error('Error in search:', error);
       return {
         organic: [],
         topStories: [],
         images: [],
+        videos: [],
+        news: [],
         relatedSearches: [],
         error: error instanceof Error ? error.message : String(error),
       };
@@ -116,11 +274,15 @@ function createTool({
 }): DynamicStructuredTool<typeof schema> {
   return tool<typeof schema>(
     async (params, runnableConfig) => {
-      const { query, country: _c } = params;
+      const { query, date, country: _c, images, videos, news } = params;
       const country = typeof _c === 'string' && _c ? _c : undefined;
       const searchResult = await search({
         query,
+        date,
         country,
+        images,
+        videos,
+        news,
         onSearchResults: createOnSearchResults({
           runnableConfig,
           onSearchResults: _onSearchResults,
@@ -181,6 +343,7 @@ export const createSearchTool = (
     topResults = 5,
     strategies = ['no_extraction'],
     filterContent = true,
+    safeSearch = 1,
     firecrawlApiKey,
     firecrawlApiUrl,
     firecrawlFormats = ['markdown', 'html'],
@@ -190,19 +353,25 @@ export const createSearchTool = (
     onGetHighlights,
   } = config;
 
-  const querySchema = z.string().describe(DEFAULT_QUERY_DESCRIPTION);
+  const logger = config.logger || createDefaultLogger();
+
   const schemaObject: {
     query: z.ZodString;
+    date: z.ZodOptional<z.ZodNativeEnum<typeof DATE_RANGE>>;
     country?: z.ZodOptional<z.ZodString>;
+    images: z.ZodOptional<z.ZodBoolean>;
+    videos: z.ZodOptional<z.ZodBoolean>;
+    news: z.ZodOptional<z.ZodBoolean>;
   } = {
     query: querySchema,
+    date: dateSchema,
+    images: imagesSchema,
+    videos: videosSchema,
+    news: newsSchema,
   };
 
   if (searchProvider === 'serper') {
-    schemaObject.country = z
-      .string()
-      .optional()
-      .describe(DEFAULT_COUNTRY_DESCRIPTION);
+    schemaObject.country = countrySchema;
   }
 
   const toolSchema = z.object(schemaObject);
@@ -224,10 +393,11 @@ export const createSearchTool = (
     rerankerType,
     jinaApiKey,
     cohereApiKey,
+    logger,
   });
 
   if (!selectedReranker) {
-    console.warn('No reranker selected. Using default ranking.');
+    logger.warn('No reranker selected. Using default ranking.');
   }
 
   const sourceProcessor = createSourceProcessor(
@@ -236,14 +406,17 @@ export const createSearchTool = (
       topResults,
       strategies,
       filterContent,
+      logger,
     },
     firecrawlScraper
   );
 
   const search = createSearchProcessor({
     searchAPI,
+    safeSearch,
     sourceProcessor,
     onGetHighlights,
+    logger,
   });
 
   return createTool({