@librechat/agents 2.4.316 → 2.4.318

package/dist/types/tools/search/types.d.ts

@@ -2,64 +2,40 @@ import type { RunnableConfig } from '@langchain/core/runnables';
 import type { BaseReranker } from './rerankers';
 export type SearchProvider = 'serper' | 'searxng';
 export type RerankerType = 'infinity' | 'jina' | 'cohere' | 'none';
-export interface OrganicResult {
-    position?: number;
-    title?: string;
-    link: string;
-    snippet?: string;
-    date?: string;
-}
-export interface TopStoryResult {
-    title?: string;
-    link: string;
-    source?: string;
-    date?: string;
-    imageUrl?: string;
-}
-export interface ImageResult {
-    title?: string;
-    imageUrl?: string;
-}
-export interface KnowledgeGraphResult {
-    title?: string;
-    type?: string;
-    description?: string;
-    attributes?: Record<string, string>;
-    imageUrl?: string;
-}
-export interface AnswerBoxResult {
-    title?: string;
-    answer?: string;
-    snippet?: string;
-    date?: string;
-}
-export interface PeopleAlsoAskResult {
-    question?: string;
-    answer?: string;
-}
 export interface Highlight {
     score: number;
     text: string;
+    references?: UsedReferences;
 }
-export interface ValidSource {
-    link: string;
-    position?: number;
-    title?: string;
-    snippet?: string;
-    date?: string;
+export type ProcessedSource = {
     content?: string;
     attribution?: string;
+    references?: References;
     highlights?: Highlight[];
-}
+};
+export type ProcessedOrganic = OrganicResult & ProcessedSource;
+export type ProcessedTopStory = TopStoryResult & ProcessedSource;
+export type ValidSource = ProcessedOrganic | ProcessedTopStory;
+export type ResultReference = {
+    link: string;
+    title?: string;
+    attribution?: string;
+};
 export interface SearchResultData {
-    organic?: ValidSource[];
-    topStories?: ValidSource[];
+    organic?: ProcessedOrganic[];
+    topStories?: ProcessedTopStory[];
     images?: ImageResult[];
+    videos?: VideoResult[];
+    places?: PlaceResult[];
+    news?: NewsResult[];
+    shopping?: ShoppingResult[];
     knowledgeGraph?: KnowledgeGraphResult;
     answerBox?: AnswerBoxResult;
     peopleAlsoAsk?: PeopleAlsoAskResult[];
-    relatedSearches?: string[];
-    suggestions?: string[];
+    relatedSearches?: Array<{
+        query: string;
+    }>;
+    references?: ResultReference[];
     error?: string;
 }
 export interface SearchResult {
@@ -80,11 +56,17 @@ export interface SearchConfig {
     searxngInstanceUrl?: string;
     searxngApiKey?: string;
 }
+export type References = {
+    links: MediaReference[];
+    images: MediaReference[];
+    videos: MediaReference[];
+};
 export interface ScrapeResult {
     url: string;
     error?: boolean;
     content: string;
     attribution?: string;
+    references?: References;
     highlights?: Highlight[];
 }
 export interface ProcessSourcesConfig {
@@ -148,3 +130,355 @@ export interface SearchToolConfig extends SearchConfig, ProcessSourcesConfig, Fi
     rerankerType?: RerankerType;
     onSearchResults?: (results: SearchResult, runnableConfig?: RunnableConfig) => void;
 }
+export interface MediaReference {
+    originalUrl: string;
+    title?: string;
+    text?: string;
+}
+export type UsedReferences = {
+    type: 'link' | 'image' | 'video';
+    originalIndex: number;
+    reference: MediaReference;
+}[];
+/** Firecrawl */
+export interface FirecrawlScrapeOptions {
+    formats?: string[];
+    includeTags?: string[];
+    excludeTags?: string[];
+    headers?: Record<string, string>;
+    waitFor?: number;
+    timeout?: number;
+}
+export interface ScrapeMetadata {
+    sourceURL?: string;
+    url?: string;
+    scrapeId?: string;
+    statusCode?: number;
+    title?: string;
+    description?: string;
+    language?: string;
+    favicon?: string;
+    viewport?: string;
+    robots?: string;
+    'theme-color'?: string;
+    'og:url'?: string;
+    'og:title'?: string;
+    'og:description'?: string;
+    'og:type'?: string;
+    'og:image'?: string;
+    'og:image:width'?: string;
+    'og:image:height'?: string;
+    'og:site_name'?: string;
+    ogUrl?: string;
+    ogTitle?: string;
+    ogDescription?: string;
+    ogImage?: string;
+    ogSiteName?: string;
+    'article:author'?: string;
+    'article:published_time'?: string;
+    'article:modified_time'?: string;
+    'article:section'?: string;
+    'article:tag'?: string;
+    'article:publisher'?: string;
+    publishedTime?: string;
+    modifiedTime?: string;
+    'twitter:site'?: string;
+    'twitter:creator'?: string;
+    'twitter:card'?: string;
+    'twitter:image'?: string;
+    'twitter:dnt'?: string;
+    'twitter:app:name:iphone'?: string;
+    'twitter:app:id:iphone'?: string;
+    'twitter:app:url:iphone'?: string;
+    'twitter:app:name:ipad'?: string;
+    'twitter:app:id:ipad'?: string;
+    'twitter:app:url:ipad'?: string;
+    'twitter:app:name:googleplay'?: string;
+    'twitter:app:id:googleplay'?: string;
+    'twitter:app:url:googleplay'?: string;
+    'fb:app_id'?: string;
+    'al:ios:url'?: string;
+    'al:ios:app_name'?: string;
+    'al:ios:app_store_id'?: string;
+    [key: string]: string | number | boolean | null | undefined;
+}
+export interface FirecrawlScrapeResponse {
+    success: boolean;
+    data?: {
+        markdown?: string;
+        html?: string;
+        rawHtml?: string;
+        screenshot?: string;
+        links?: string[];
+        metadata?: ScrapeMetadata;
+    };
+    error?: string;
+}
+export interface FirecrawlScraperConfig {
+    apiKey?: string;
+    apiUrl?: string;
+    formats?: string[];
+    timeout?: number;
+}
+export type GetSourcesParams = {
+    query: string;
+    country?: string;
+    numResults?: number;
+};
+/** Serper API */
+export interface VideoResult {
+    title?: string;
+    link?: string;
+    snippet?: string;
+    imageUrl?: string;
+    duration?: string;
+    source?: string;
+    channel?: string;
+    date?: string;
+    position?: number;
+}
+export interface PlaceResult {
+    position?: number;
+    name?: string;
+    address?: string;
+    latitude?: number;
+    longitude?: number;
+    rating?: number;
+    ratingCount?: number;
+    category?: string;
+    identifier?: string;
+}
+export interface NewsResult {
+    title?: string;
+    link?: string;
+    snippet?: string;
+    date?: string;
+    source?: string;
+    imageUrl?: string;
+    position?: number;
+}
+export interface ShoppingResult {
+    title?: string;
+    source?: string;
+    link?: string;
+    price?: string;
+    delivery?: string;
+    imageUrl?: string;
+    rating?: number;
+    ratingCount?: number;
+    offers?: string;
+    productId?: string;
+    position?: number;
+}
+export interface ScholarResult {
+    title?: string;
+    link?: string;
+    publicationInfo?: string;
+    snippet?: string;
+    year?: number;
+    citedBy?: number;
+}
+export interface ImageResult {
+    title?: string;
+    imageUrl?: string;
+    imageWidth?: number;
+    imageHeight?: number;
+    thumbnailUrl?: string;
+    thumbnailWidth?: number;
+    thumbnailHeight?: number;
+    source?: string;
+    domain?: string;
+    link?: string;
+    googleUrl?: string;
+    position?: number;
+}
+export interface SerperSearchPayload extends SerperSearchInput {
+    /**
+     * Search type/vertical
+     * Options: "search" (web), "images", "news", "places", "videos"
+     */
+    type?: 'search' | 'images' | 'news' | 'places' | 'videos';
+    /**
+     * Starting index for search results pagination (used instead of page)
+     */
+    start?: number;
+    /**
+     * Filtering for safe search
+     * Options: "off", "moderate", "active"
+     */
+    safe?: 'off' | 'moderate' | 'active';
+}
+export type SerperSearchParameters = Pick<SerperSearchPayload, 'q' | 'type'> & {
+    engine: 'google';
+};
+export interface OrganicResult {
+    position?: number;
+    title?: string;
+    link: string;
+    snippet?: string;
+    date?: string;
+    sitelinks?: Array<{
+        title: string;
+        link: string;
+    }>;
+}
+export interface TopStoryResult {
+    title?: string;
+    link: string;
+    source?: string;
+    date?: string;
+    imageUrl?: string;
+}
+export interface KnowledgeGraphResult {
+    title?: string;
+    type?: string;
+    imageUrl?: string;
+    description?: string;
+    descriptionSource?: string;
+    descriptionLink?: string;
+    attributes?: Record<string, string>;
+    website?: string;
+}
+export interface AnswerBoxResult {
+    title?: string;
+    snippet?: string;
+    snippetHighlighted?: string[];
+    link?: string;
+    date?: string;
+}
+export interface PeopleAlsoAskResult {
+    question?: string;
+    snippet?: string;
+    title?: string;
+    link?: string;
+}
+export type RelatedSearches = Array<{
+    query: string;
+}>;
+export interface SerperSearchInput {
+    /**
+     * The search query string
+     */
+    q: string;
+    /**
+     * Country code for localized results
+     * Examples: "us", "uk", "ca", "de", etc.
+     */
+    gl?: string;
+    /**
+     * Interface language
+     * Examples: "en", "fr", "de", etc.
+     */
+    hl?: string;
+    /**
+     * Number of results to return (up to 100)
+     */
+    num?: number;
+    /**
+     * Specific location for contextual results
+     * Example: "New York, NY"
+     */
+    location?: string;
+    /**
+     * Search autocorrection setting
+     */
+    autocorrect?: boolean;
+    page?: number;
+}
+export type SerperResultData = {
+    searchParameters: SerperSearchPayload;
+    organic?: OrganicResult[];
+    topStories?: TopStoryResult[];
+    images?: ImageResult[];
+    videos?: VideoResult[];
+    places?: PlaceResult[];
+    news?: NewsResult[];
+    shopping?: ShoppingResult[];
+    peopleAlsoAsk?: PeopleAlsoAskResult[];
+    relatedSearches?: RelatedSearches;
+    knowledgeGraph?: KnowledgeGraphResult;
+    answerBox?: AnswerBoxResult;
+    credits?: number;
+};
+/** SearXNG */
+export interface SearxNGSearchPayload {
+    /**
+     * The search query string
+     * Supports syntax specific to different search engines
+     * Example: "site:github.com SearXNG"
+     */
+    q: string;
+    /**
+     * Comma-separated list of search categories
+     * Example: "general,images,news"
+     */
+    categories?: string;
+    /**
+     * Comma-separated list of search engines to use
+     * Example: "google,bing,duckduckgo"
+     */
+    engines?: string;
+    /**
+     * Code of the language for search results
+     * Example: "en", "fr", "de", "es"
+     */
+    language?: string;
+    /**
+     * Search page number
+     * Default: 1
+     */
+    pageno?: number;
+    /**
+     * Time range filter for search results
+     * Options: "day", "month", "year"
+     */
+    time_range?: 'day' | 'month' | 'year';
+    /**
+     * Output format of results
+     * Options: "json", "csv", "rss"
+     */
+    format?: 'json' | 'csv' | 'rss';
+    /**
+     * Open search results on new tab
+     * Options: `0` (off), `1` (on)
+     */
+    results_on_new_tab?: 0 | 1;
+    /**
+     * Proxy image results through SearxNG
+     * Options: true, false
+     */
+    image_proxy?: boolean;
+    /**
+     * Service for autocomplete suggestions
+     * Options: "google", "dbpedia", "duckduckgo", "mwmbl",
+     *          "startpage", "wikipedia", "stract", "swisscows", "qwant"
+     */
+    autocomplete?: string;
+    /**
+     * Safe search filtering level
+     * Options: "0" (off), "1" (moderate), "2" (strict)
+     */
+    safesearch?: 0 | 1 | 2;
+    /**
+     * Theme to use for results page
+     * Default: "simple" (other themes may be available per instance)
+     */
+    theme?: string;
+    /**
+     * List of enabled plugins
+     * Default: "Hash_plugin,Self_Information,Tracker_URL_remover,Ahmia_blacklist"
+     */
+    enabled_plugins?: string;
+    /**
+     * List of disabled plugins
+     */
+    disabled_plugins?: string;
+    /**
+     * List of enabled engines
+     */
+    enabled_engines?: string;
+    /**
+     * List of disabled engines
+     */
+    disabled_engines?: string;
+}

package/dist/types/tools/search/utils.d.ts

@@ -0,0 +1,3 @@
+import type * as t from './types';
+export declare const getDomainName: (link: string, metadata?: t.ScrapeMetadata) => string | undefined;
+export declare function getAttribution(link: string, metadata?: t.ScrapeMetadata): string | undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@librechat/agents",
-  "version": "2.4.316",
+  "version": "2.4.318",
   "main": "./dist/cjs/main.cjs",
   "module": "./dist/esm/main.mjs",
   "types": "./dist/types/index.d.ts",
@@ -73,7 +73,7 @@
   },
   "dependencies": {
     "@langchain/anthropic": "^0.3.20",
-    "@langchain/aws": "^0.1.8",
+    "@langchain/aws": "0.1.8",
     "@langchain/community": "^0.3.42",
     "@langchain/core": "^0.3.55",
     "@langchain/deepseek": "^0.0.1",
@@ -84,6 +84,7 @@
     "@langchain/ollama": "^0.2.0",
     "@langchain/openai": "^0.5.10",
     "@langchain/xai": "^0.0.2",
+    "cheerio": "^1.0.0",
     "dotenv": "^16.4.7",
     "https-proxy-agent": "^7.0.6",
     "nanoid": "^3.3.7"

package/src/scripts/search.ts

@@ -86,7 +86,7 @@ async function testStandardStreaming(): Promise<void> {
       tools: [createSearchTool()],
       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}.`,
+      // additional_instructions: `The user's name is ${userName} and they are located in ${location}.`,
     },
     returnContent: true,
     customHandlers,
@@ -101,7 +101,7 @@ async function testStandardStreaming(): Promise<void> {
     version: 'v2' as const,
   };
 
-  console.log('Test 1: Weather query (content parts test)');
+  console.log('Test 1: Search query (search tool test)');
 
   // const userMessage = `
   // Make a search for the weather in ${location} today, which is ${currentDate}.
@@ -109,7 +109,9 @@ async function testStandardStreaming(): Promise<void> {
   // Make sure to always refer to me by name, which is ${userName}.
   // After giving me a thorough summary, tell me a joke about the weather forecast we went over.
   // `;
-  const userMessage = 'Are massage guns good?';
+  // const userMessage = 'Are massage guns good?';
+  // const userMessage = 'What is functional programming?';
+  const userMessage = "Get me today's trending news.";
 
   conversationHistory.push(new HumanMessage(userMessage));
 

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

@@ -0,0 +1,173 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable no-console */
+// content.test.ts
+import * as fs from 'fs';
+import { processContent } from './content';
+
+describe('Link Processor', () => {
+  afterAll(() => {
+    if (fs.existsSync('./temp.html')) {
+      fs.unlinkSync('./temp.html');
+    }
+    if (fs.existsSync('./temp.md')) {
+      fs.unlinkSync('./temp.md');
+    }
+  });
+  // Basic functionality tests
+  test('should replace basic links with references', () => {
+    const html = `
+      <p>Test with <a href="https://example.com/link" title="Example">a link</a></p>
+      <p>And an <img src="https://example.com/img.jpg" alt="image"></p>
+      <p>Plus a <video src="https://example.com/video.mp4"></video></p>
+    `;
+
+    const markdown = `
+      Test with [a link](https://example.com/link "Example")
+      And an ![image](https://example.com/img.jpg)
+      Plus a [video](https://example.com/video.mp4)
+    `;
+
+    const result = processContent(html, markdown);
+
+    expect(result.links.length).toBe(1);
+    expect(result.images.length).toBe(1);
+    expect(result.videos.length).toBe(1);
+    expect(result.markdown).toContain('link#1');
+    expect(result.markdown).toContain('image#1');
+    expect(result.markdown).toContain('video#1');
+  });
+
+  // Edge case tests
+  test('should handle links with parentheses and special characters', () => {
+    const html = `
+      <a href="https://example.com/page(1).html" title="Parens">Link with parens</a>
+      <a href="https://example.com/path?query=test&param=value">Link with query</a>
+    `;
+
+    const markdown = `
+      [Link with parens](https://example.com/page(1).html "Parens")
+      [Link with query](https://example.com/path?query=test&param=value)
+    `;
+
+    const result = processContent(html, markdown);
+
+    expect(result.links.length).toBe(2);
+    expect(result.markdown).toContain('link#1');
+    expect(result.markdown).toContain('link#2');
+  });
+
+  // Performance test with large files
+  test('should process large files efficiently', () => {
+    const html = fs.readFileSync('src/tools/search/test.html', 'utf-8');
+    const markdown = fs.readFileSync('src/tools/search/test.md', 'utf-8');
+
+    // const largeHtml = generateLargeHtml(1000); // 1000 links
+    // fs.writeFileSync('./temp.html', largeHtml);
+
+    // const largeMd = generateLargeMarkdown(1000); // 1000 links
+    // fs.writeFileSync('./temp.md', largeMd);
+
+    // const html = fs.readFileSync('./temp.html', 'utf-8');
+    // const markdown = fs.readFileSync('./temp.md', 'utf-8');
+
+    // Measure time taken to process
+    const startTime = process.hrtime();
+    const result = processContent(html, markdown);
+    const elapsed = process.hrtime(startTime);
+    const timeInMs = elapsed[0] * 1000 + elapsed[1] / 1000000;
+
+    console.log(
+      `Processed ${result.links.length} links, ${result.images.length} images, and ${result.videos.length} videos in ${timeInMs.toFixed(2)}ms`
+    );
+
+    // Basic validations for large file processing
+    expect(result.links.length).toBeGreaterThan(0);
+    expect(result.markdown).toContain('link#');
+
+    // Check if all links were replaced (sample check)
+    expect(result.markdown).not.toContain('https://example.com/link');
+  });
+
+  // Memory usage test
+  test('should have reasonable memory usage', () => {
+    const html = fs.readFileSync('src/tools/search/test.html', 'utf-8');
+    const markdown = fs.readFileSync('src/tools/search/test.md', 'utf-8');
+
+    const beforeMem = process.memoryUsage();
+    processContent(html, markdown);
+    const afterMem = process.memoryUsage();
+
+    const heapUsed = (afterMem.heapUsed - beforeMem.heapUsed) / 1024 / 1024; // MB
+
+    console.log(`Memory used: ${heapUsed.toFixed(2)} MB`);
+
+    // This is a loose check - actual thresholds depend on your environment
+    expect(heapUsed).toBeLessThan(100); // Should use less than 100MB additional heap
+  });
+
+  // Real-world file test (if available)
+  test('should process real-world Wikipedia content', () => {
+    // Try to find real-world test files if they exist
+    const wikiHtml = 'src/tools/search/test.html';
+    const wikiMd = 'src/tools/search/test.md';
+
+    if (fs.existsSync(wikiHtml) && fs.existsSync(wikiMd)) {
+      const html = fs.readFileSync(wikiHtml, 'utf-8');
+      const markdown = fs.readFileSync(wikiMd, 'utf-8');
+
+      const result = processContent(html, markdown);
+
+      console.log(
+        `Processed ${result.links.length} Wikipedia links, ${result.images.length} images, and ${result.videos.length} videos`
+      );
+
+      expect(result.links.length).toBeGreaterThan(10); // Wikipedia articles typically have many links
+      expect(result.markdown).not.toMatch(/\]\(https?:\/\/[^\s")]+\)/); // No regular URLs should remain
+    } else {
+      console.log('Wikipedia test files not found, skipping this test');
+    }
+  });
+});
+
+// Helper function to generate large HTML test data
+function generateLargeHtml(linkCount: number): string {
+  let html = '<html><body>';
+
+  for (let i = 1; i <= linkCount; i++) {
+    html += `<p>Paragraph ${i} with <a href="https://example.com/link${i}" title="Link ${i}">link ${i}</a>`;
+
+    if (i % 10 === 0) {
+      html += ` and <img src="https://example.com/image${i / 10}.jpg" alt="Image ${i / 10}">`;
+    }
+
+    if (i % 50 === 0) {
+      html += ` and <video src="https://example.com/video${i / 50}.mp4" title="Video ${i / 50}"></video>`;
+    }
+
+    html += '</p>';
+  }
+
+  html += '</body></html>';
+  return html;
+}
+
+/** Helper function to generate large Markdown test data  */
+function generateLargeMarkdown(linkCount: number): string {
+  let markdown = '# Test Document\n\n';
+
+  for (let i = 1; i <= linkCount; i++) {
+    markdown += `Paragraph ${i} with [link ${i}](https://example.com/link${i} "Link ${i}")`;
+
+    if (i % 10 === 0) {
+      markdown += ` and ![Image ${i / 10}](https://example.com/image${i / 10}.jpg)`;
+    }
+
+    if (i % 50 === 0) {
+      markdown += ` and [Video ${i / 50}](https://example.com/video${i / 50}.mp4 "Video ${i / 50}")`;
+    }
+
+    markdown += '\n\n';
+  }
+
+  return markdown;
+}