@librechat/agents 3.0.0-rc8 → 3.0.0

package/src/stream.ts

@@ -398,9 +398,13 @@ export function createContentAggregator(): t.ContentAggregatorResult {
 
   const updateContent = (
     index: number,
-    contentPart: t.MessageContentComplex,
+    contentPart?: t.MessageContentComplex,
     finalUpdate = false
   ): void => {
+    if (!contentPart) {
+      console.warn('No content part found in \'updateContent\'');
+      return;
+    }
     const partType = contentPart.type ?? '';
     if (!partType) {
       console.warn('No content type found in content part');
@@ -578,7 +582,10 @@ export function createContentAggregator(): t.ContentAggregatorResult {
       event === GraphEvents.ON_AGENT_UPDATE &&
       (data as t.AgentUpdate | undefined)?.agent_update
     ) {
-      const contentPart = data as t.AgentUpdate;
+      const contentPart = data as t.AgentUpdate | undefined;
+      if (!contentPart) {
+        return;
+      }
       updateContent(contentPart.agent_update.index, contentPart);
     } else if (event === GraphEvents.ON_REASONING_DELTA) {
       const reasoningDelta = data as t.ReasoningDeltaEvent;

package/src/tools/search/firecrawl.ts

@@ -7,9 +7,10 @@ import { createDefaultLogger } from './utils';
  * Firecrawl scraper implementation
  * Uses the Firecrawl API to scrape web pages
  */
-export class FirecrawlScraper {
+export class FirecrawlScraper implements t.BaseScraper {
   private apiKey: string;
   private apiUrl: string;
+  private version: string;
   private defaultFormats: string[];
   private timeout: number;
   private logger: t.Logger;
@@ -32,11 +33,13 @@ export class FirecrawlScraper {
   constructor(config: t.FirecrawlScraperConfig = {}) {
     this.apiKey = config.apiKey ?? process.env.FIRECRAWL_API_KEY ?? '';
 
+    this.version = config.version ?? 'v2';
+
     const baseUrl =
       config.apiUrl ??
       process.env.FIRECRAWL_BASE_URL ??
       'https://api.firecrawl.dev';
-    this.apiUrl = `${baseUrl.replace(/\/+$/, '')}/v1/scrape`;
+    this.apiUrl = `${baseUrl.replace(/\/+$/, '')}/${this.version}/scrape`;
 
     this.defaultFormats = config.formats ?? ['markdown', 'rawHtml'];
     this.timeout = config.timeout ?? 7500;

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

@@ -0,0 +1,126 @@
+import { JinaReranker } from './rerankers';
+import { createDefaultLogger } from './utils';
+
+describe('JinaReranker', () => {
+  const mockLogger = createDefaultLogger();
+  
+  describe('constructor', () => {
+    it('should use default API URL when no apiUrl is provided', () => {
+      const reranker = new JinaReranker({
+        apiKey: 'test-key',
+        logger: mockLogger,
+      });
+      
+      // Access private property for testing
+      const apiUrl = (reranker as any).apiUrl;
+      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 = (reranker as any).apiUrl;
+      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 = (reranker as any).apiUrl;
+      expect(apiUrl).toBe('https://env-jina-endpoint.com/v1/rerank');
+      
+      // Restore original environment
+      if (originalEnv) {
+        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 = (reranker as any).apiUrl;
+      expect(apiUrl).toBe(customUrl);
+      
+      // Restore original environment
+      if (originalEnv) {
+        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');
+      
+      try {
+        await reranker.rerank('test query', ['document1', 'document2'], 2);
+      } catch (error) {
+        // Expected to fail due to missing API key, but we can check the log
+      }
+      
+      expect(logSpy).toHaveBeenCalledWith(
+        expect.stringContaining(`Reranking 2 chunks with Jina using API URL: ${customUrl}`)
+      );
+      
+      logSpy.mockRestore();
+    });
+  });
+});
+
+describe('createReranker', () => {
+  const { createReranker } = require('./rerankers');
+  
+  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);
+    const apiUrl = (reranker as any).apiUrl;
+    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);
+    const apiUrl = (reranker as any).apiUrl;
+    expect(apiUrl).toBe('https://api.jina.ai/v1/rerank');
+  });
+});

package/src/tools/search/rerankers.ts

@@ -28,15 +28,20 @@ export abstract class BaseReranker {
 }
 
 export class JinaReranker extends BaseReranker {
+  private apiUrl: string;
+
   constructor({
     apiKey = process.env.JINA_API_KEY,
+    apiUrl = process.env.JINA_API_URL || 'https://api.jina.ai/v1/rerank',
     logger,
   }: {
     apiKey?: string;
+    apiUrl?: string;
     logger?: t.Logger;
   }) {
     super(logger);
     this.apiKey = apiKey;
+    this.apiUrl = apiUrl;
   }
 
   async rerank(
@@ -44,7 +49,7 @@ export class JinaReranker extends BaseReranker {
     documents: string[],
     topK: number = 5
   ): Promise<t.Highlight[]> {
-    this.logger.debug(`Reranking ${documents.length} chunks with Jina`);
+    this.logger.debug(`Reranking ${documents.length} chunks with Jina using API URL: ${this.apiUrl}`);
 
     try {
       if (this.apiKey == null || this.apiKey === '') {
@@ -61,7 +66,7 @@ export class JinaReranker extends BaseReranker {
       };
 
       const response = await axios.post<t.JinaRerankerResponse | undefined>(
-        'https://api.jina.ai/v1/rerank',
+        this.apiUrl,
         requestData,
         {
           headers: {
@@ -201,17 +206,18 @@ export class InfinityReranker extends BaseReranker {
 export const createReranker = (config: {
   rerankerType: t.RerankerType;
   jinaApiKey?: string;
+  jinaApiUrl?: string;
   cohereApiKey?: string;
   logger?: t.Logger;
 }): BaseReranker | undefined => {
-  const { rerankerType, jinaApiKey, cohereApiKey, logger } = config;
+  const { rerankerType, jinaApiKey, jinaApiUrl, cohereApiKey, logger } = config;
 
   // Create a default logger if none is provided
   const defaultLogger = logger || createDefaultLogger();
 
   switch (rerankerType.toLowerCase()) {
   case 'jina':
-    return new JinaReranker({ apiKey: jinaApiKey, logger: defaultLogger });
+    return new JinaReranker({ apiKey: jinaApiKey, apiUrl: jinaApiUrl, logger: defaultLogger });
   case 'cohere':
     return new CohereReranker({
       apiKey: cohereApiKey,
@@ -226,7 +232,7 @@ export const createReranker = (config: {
     defaultLogger.warn(
       `Unknown reranker type: ${rerankerType}. Defaulting to InfinityReranker.`
     );
-    return new JinaReranker({ apiKey: jinaApiKey, logger: defaultLogger });
+    return new JinaReranker({ apiKey: jinaApiKey, apiUrl: jinaApiUrl, logger: defaultLogger });
   }
 };
 

package/src/tools/search/search.ts

@@ -2,7 +2,6 @@ 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';
 
 const chunker = {
@@ -434,7 +433,7 @@ export const createSearchAPI = (
 
 export const createSourceProcessor = (
   config: t.ProcessSourcesConfig = {},
-  scraperInstance?: FirecrawlScraper
+  scraperInstance?: t.BaseScraper
 ): {
   processSources: (
     fields: t.ProcessSourcesFields
@@ -442,7 +441,7 @@ export const createSourceProcessor = (
   topResults: number;
 } => {
   if (!scraperInstance) {
-    throw new Error('Firecrawl scraper instance is required');
+    throw new Error('Scraper instance is required');
   }
   const {
     topResults = 5,
@@ -453,7 +452,7 @@ export const createSourceProcessor = (
   } = config;
 
   const logger_ = logger || createDefaultLogger();
-  const firecrawlScraper = scraperInstance;
+  const scraper = scraperInstance;
 
   const webScraper = {
     scrapeMany: async ({
@@ -465,12 +464,12 @@ export const createSourceProcessor = (
       links: string[];
       onGetHighlights: t.SearchToolConfig['onGetHighlights'];
     }): Promise<Array<t.ScrapeResult>> => {
-      logger_.debug(`Scraping ${links.length} links with Firecrawl`);
+      logger_.debug(`Scraping ${links.length} links`);
       const promises: Array<Promise<t.ScrapeResult>> = [];
       try {
         for (let i = 0; i < links.length; i++) {
           const currentLink = links[i];
-          const promise: Promise<t.ScrapeResult> = firecrawlScraper
+          const promise: Promise<t.ScrapeResult> = scraper
             .scrapeUrl(currentLink, {})
             .then(([url, response]) => {
               const attribution = getAttribution(
@@ -479,8 +478,7 @@ export const createSourceProcessor = (
                 logger_
               );
               if (response.success && response.data) {
-                const [content, references] =
-                  firecrawlScraper.extractContent(response);
+                const [content, references] = scraper.extractContent(response);
                 return {
                   url,
                   references,

package/src/tools/search/serper-scraper.ts

@@ -0,0 +1,155 @@
+import axios from 'axios';
+import type * as t from './types';
+import { createDefaultLogger } from './utils';
+
+/**
+ * Serper scraper implementation
+ * Uses the Serper Scrape API (https://scrape.serper.dev) to scrape web pages
+ *
+ * Features:
+ * - Simple API with single endpoint
+ * - Returns both text and markdown content
+ * - Includes metadata from scraped pages
+ * - Credits-based pricing model
+ *
+ * @example
+ * ```typescript
+ * const scraper = createSerperScraper({
+ *   apiKey: 'your-serper-api-key',
+ *   includeMarkdown: true,
+ *   timeout: 10000
+ * });
+ *
+ * const [url, response] = await scraper.scrapeUrl('https://example.com');
+ * if (response.success) {
+ *   const [content] = scraper.extractContent(response);
+ *   console.log(content);
+ * }
+ * ```
+ */
+export class SerperScraper implements t.BaseScraper {
+  private apiKey: string;
+  private apiUrl: string;
+  private timeout: number;
+  private logger: t.Logger;
+  private includeMarkdown: boolean;
+
+  constructor(config: t.SerperScraperConfig = {}) {
+    this.apiKey = config.apiKey ?? process.env.SERPER_API_KEY ?? '';
+
+    this.apiUrl =
+      config.apiUrl ??
+      process.env.SERPER_SCRAPE_URL ??
+      'https://scrape.serper.dev';
+
+    this.timeout = config.timeout ?? 7500;
+    this.includeMarkdown = config.includeMarkdown ?? true;
+
+    this.logger = config.logger || createDefaultLogger();
+
+    if (!this.apiKey) {
+      this.logger.warn('SERPER_API_KEY is not set. Scraping will not work.');
+    }
+
+    this.logger.debug(
+      `Serper scraper initialized with API URL: ${this.apiUrl}`
+    );
+  }
+
+  /**
+   * Scrape a single URL
+   * @param url URL to scrape
+   * @param options Scrape options
+   * @returns Scrape response
+   */
+  async scrapeUrl(
+    url: string,
+    options: t.SerperScrapeOptions = {}
+  ): Promise<[string, t.SerperScrapeResponse]> {
+    if (!this.apiKey) {
+      return [
+        url,
+        {
+          success: false,
+          error: 'SERPER_API_KEY is not set',
+        },
+      ];
+    }
+
+    try {
+      const payload = {
+        url,
+        includeMarkdown: options.includeMarkdown ?? this.includeMarkdown,
+      };
+
+      const response = await axios.post(this.apiUrl, payload, {
+        headers: {
+          'X-API-KEY': this.apiKey,
+          'Content-Type': 'application/json',
+        },
+        timeout: options.timeout ?? this.timeout,
+      });
+
+      return [url, { success: true, data: response.data }];
+    } catch (error) {
+      const errorMessage =
+        error instanceof Error ? error.message : String(error);
+      return [
+        url,
+        {
+          success: false,
+          error: `Serper Scrape API request failed: ${errorMessage}`,
+        },
+      ];
+    }
+  }
+
+  /**
+   * Extract content from scrape response
+   * @param response Scrape response
+   * @returns Extracted content or empty string if not available
+   */
+  extractContent(
+    response: t.SerperScrapeResponse
+  ): [string, undefined | t.References] {
+    if (!response.success || !response.data) {
+      return ['', undefined];
+    }
+
+    if (response.data.markdown != null) {
+      return [response.data.markdown, undefined];
+    }
+
+    if (response.data.text != null) {
+      return [response.data.text, undefined];
+    }
+
+    return ['', undefined];
+  }
+
+  /**
+   * Extract metadata from scrape response
+   * @param response Scrape response
+   * @returns Metadata object
+   */
+  extractMetadata(
+    response: t.SerperScrapeResponse
+  ): Record<string, string | number | boolean | null | undefined> {
+    if (!response.success || !response.data || !response.data.metadata) {
+      return {};
+    }
+
+    return response.data.metadata;
+  }
+}
+
+/**
+ * Create a Serper scraper instance
+ * @param config Scraper configuration
+ * @returns Serper scraper instance
+ */
+export const createSerperScraper = (
+  config: t.SerperScraperConfig = {}
+): SerperScraper => {
+  return new SerperScraper(config);
+};

package/src/tools/search/tool.ts

@@ -12,6 +12,7 @@ import {
   newsSchema,
 } from './schema';
 import { createSearchAPI, createSourceProcessor } from './search';
+import { createSerperScraper } from './serper-scraper';
 import { createFirecrawlScraper } from './firecrawl';
 import { expandHighlights } from './highlights';
 import { formatResultsForLLM } from './format';
@@ -328,6 +329,27 @@ Use anchor marker(s) immediately after the statement:
  * Creates a search tool with a schema that dynamically includes the country field
  * only when the searchProvider is 'serper'.
  *
+ * Supports multiple scraper providers:
+ * - Firecrawl (default): Full-featured web scraping with multiple formats
+ * - Serper: Lightweight scraping using Serper's scrape API
+ *
+ * @example
+ * ```typescript
+ * // Using Firecrawl scraper (default)
+ * const searchTool = createSearchTool({
+ *   searchProvider: 'serper',
+ *   scraperProvider: 'firecrawl',
+ *   firecrawlApiKey: 'your-firecrawl-key'
+ * });
+ *
+ * // Using Serper scraper
+ * const searchTool = createSearchTool({
+ *   searchProvider: 'serper',
+ *   scraperProvider: 'serper',
+ *   serperApiKey: 'your-serper-key'
+ * });
+ * ```
+ *
  * @param config - The search tool configuration
  * @returns A DynamicStructuredTool with a schema that depends on the searchProvider
  */
@@ -344,11 +366,15 @@ export const createSearchTool = (
     strategies = ['no_extraction'],
     filterContent = true,
     safeSearch = 1,
+    scraperProvider = 'firecrawl',
     firecrawlApiKey,
     firecrawlApiUrl,
+    firecrawlVersion,
     firecrawlOptions,
+    serperScraperOptions,
     scraperTimeout,
     jinaApiKey,
+    jinaApiUrl,
     cohereApiKey,
     onSearchResults: _onSearchResults,
     onGetHighlights,
@@ -384,17 +410,32 @@ export const createSearchTool = (
     searxngApiKey,
   });
 
-  const firecrawlScraper = createFirecrawlScraper({
-    ...firecrawlOptions,
-    apiKey: firecrawlApiKey ?? process.env.FIRECRAWL_API_KEY,
-    apiUrl: firecrawlApiUrl,
-    timeout: scraperTimeout ?? firecrawlOptions?.timeout,
-    formats: firecrawlOptions?.formats ?? ['markdown', 'rawHtml'],
-  });
+  /** Create scraper based on scraperProvider */
+  let scraperInstance: t.BaseScraper;
+
+  if (scraperProvider === 'serper') {
+    scraperInstance = createSerperScraper({
+      ...serperScraperOptions,
+      apiKey: serperApiKey,
+      timeout: scraperTimeout ?? serperScraperOptions?.timeout,
+      logger,
+    });
+  } else {
+    scraperInstance = createFirecrawlScraper({
+      ...firecrawlOptions,
+      apiKey: firecrawlApiKey ?? process.env.FIRECRAWL_API_KEY,
+      apiUrl: firecrawlApiUrl,
+      version: firecrawlVersion,
+      timeout: scraperTimeout ?? firecrawlOptions?.timeout,
+      formats: firecrawlOptions?.formats ?? ['markdown', 'rawHtml'],
+      logger,
+    });
+  }
 
   const selectedReranker = createReranker({
     rerankerType,
     jinaApiKey,
+    jinaApiUrl,
     cohereApiKey,
     logger,
   });
@@ -411,7 +452,7 @@ export const createSearchTool = (
       filterContent,
       logger,
     },
-    firecrawlScraper
+    scraperInstance
   );
 
   const search = createSearchProcessor({

package/src/tools/search/types.ts

@@ -5,6 +5,7 @@ import type { BaseReranker } from './rerankers';
 import { DATE_RANGE } from './schema';
 
 export type SearchProvider = 'serper' | 'searxng';
+export type ScraperProvider = 'firecrawl' | 'serper';
 export type RerankerType = 'infinity' | 'jina' | 'cohere' | 'none';
 
 export interface Highlight {
@@ -94,9 +95,18 @@ export interface ProcessSourcesConfig {
 export interface FirecrawlConfig {
   firecrawlApiKey?: string;
   firecrawlApiUrl?: string;
+  firecrawlVersion?: string;
   firecrawlOptions?: FirecrawlScraperConfig;
 }
 
+export interface SerperScraperConfig {
+  apiKey?: string;
+  apiUrl?: string;
+  timeout?: number;
+  logger?: Logger;
+  includeMarkdown?: boolean;
+}
+
 export interface ScraperContentResult {
   content: string;
 }
@@ -148,9 +158,12 @@ export interface SearchToolConfig
   logger?: Logger;
   safeSearch?: SafeSearchLevel;
   jinaApiKey?: string;
+  jinaApiUrl?: string;
   cohereApiKey?: string;
   rerankerType?: RerankerType;
+  scraperProvider?: ScraperProvider;
   scraperTimeout?: number;
+  serperScraperOptions?: SerperScraperConfig;
   onSearchResults?: (
     results: SearchResult,
     runnableConfig?: RunnableConfig
@@ -169,9 +182,30 @@ export type UsedReferences = {
   reference: MediaReference;
 }[];
 
+/** Base Scraper Interface */
+export interface BaseScraper {
+  scrapeUrl(
+    url: string,
+    options?: unknown
+  ): Promise<[string, FirecrawlScrapeResponse | SerperScrapeResponse]>;
+  extractContent(
+    response: FirecrawlScrapeResponse | SerperScrapeResponse
+  ): [string, undefined | References];
+  extractMetadata(
+    response: FirecrawlScrapeResponse | SerperScrapeResponse
+  ):
+    | ScrapeMetadata
+    | Record<string, string | number | boolean | null | undefined>;
+}
+
 /** Firecrawl */
 export type FirecrawlScrapeOptions = Omit<
   FirecrawlScraperConfig,
+  'apiKey' | 'apiUrl' | 'version' | 'logger'
+>;
+
+export type SerperScrapeOptions = Omit<
+  SerperScraperConfig,
   'apiKey' | 'apiUrl' | 'logger'
 >;
 
@@ -250,9 +284,21 @@ export interface FirecrawlScrapeResponse {
   error?: string;
 }
 
+export interface SerperScrapeResponse {
+  success: boolean;
+  data?: {
+    text?: string;
+    markdown?: string;
+    metadata?: Record<string, string | number | boolean | null | undefined>;
+    credits?: number;
+  };
+  error?: string;
+}
+
 export interface FirecrawlScraperConfig {
   apiKey?: string;
   apiUrl?: string;
+  version?: string;
   formats?: string[];
   timeout?: number;
   logger?: Logger;

package/src/types/graph.ts

@@ -334,7 +334,10 @@ export type GraphEdge = {
    */
   prompt?:
     | string
-    | ((messages: BaseMessage[], runStartIndex: number) => string | undefined);
+    | ((
+        messages: BaseMessage[],
+        runStartIndex: number
+      ) => string | Promise<string> | undefined);
   /**
    * When true, excludes messages from startIndex when adding prompt.
    * Automatically set to true when {results} variable is used in prompt.
@@ -364,4 +367,6 @@ export interface AgentInputs {
   clientOptions?: ClientOptions;
   additional_instructions?: string;
   reasoningKey?: 'reasoning_content' | 'reasoning';
+  /** Format content blocks as strings (for legacy compatibility i.e. Ollama/Azure Serverless) */
+  useLegacyContent?: boolean;
 }

package/src/types/messages.ts

@@ -0,0 +1,4 @@
+import type Anthropic from '@anthropic-ai/sdk';
+import type { BaseMessage } from '@langchain/core/messages';
+export type AnthropicMessages = Array<AnthropicMessage | BaseMessage>;
+export type AnthropicMessage = Anthropic.MessageParam;