@librechat/agents 2.4.22 → 2.4.31

package/src/tools/search/highlights.ts

@@ -0,0 +1,237 @@
+import type * as t from './types';
+
+// 2. Pre-compile all regular expressions (only do this once)
+// Group patterns by priority for early returns
+const priorityPatterns = [
+  // High priority patterns (structural)
+  [
+    { regex: /\n\n/g }, // Double newline (paragraph break)
+    { regex: /\n/g }, // Single newline
+    { regex: /={3,}\s*\n|-{3,}\s*\n/g }, // Section separators
+  ],
+  // Medium priority (semantic)
+  [
+    { regex: /[.!?][")\]]?\s/g }, // End of sentence
+    { regex: /;\s/g }, // Semicolon
+    { regex: /:\s/g }, // Colon
+  ],
+  // Low priority (any breaks)
+  [
+    { regex: /,\s/g }, // Comma
+    { regex: /\s-\s/g }, // Dash surrounded by spaces
+    { regex: /\s/g }, // Any space
+  ],
+];
+
+function findFirstMatch(text: string, regex: RegExp): number {
+  // Reset regex
+  regex.lastIndex = 0;
+
+  // For very long texts, try chunking
+  if (text.length > 10000) {
+    const chunkSize = 2000;
+    let position = 0;
+
+    while (position < text.length) {
+      const chunk = text.substring(position, position + chunkSize);
+      regex.lastIndex = 0;
+
+      const match = regex.exec(chunk);
+      if (match) {
+        return position + match.index;
+      }
+
+      // Move to next chunk with some overlap
+      position += chunkSize - 100;
+      if (position >= text.length) break;
+    }
+    return -1;
+  }
+
+  // For shorter texts, normal regex search
+  const match = regex.exec(text);
+  return match ? match.index : -1;
+}
+
+// 3. Optimized boundary finding functions
+function findLastMatch(text: string, regex: RegExp): number {
+  // Reset regex state
+  regex.lastIndex = 0;
+
+  let lastIndex = -1;
+  let lastLength = 0;
+  let match;
+
+  // For very long texts, use a different approach to avoid regex engine slowdowns
+  if (text.length > 10000) {
+    // Try dividing the text into chunks for faster processing
+    const chunkSize = 2000;
+    let startPosition = Math.max(0, text.length - chunkSize);
+
+    while (startPosition >= 0) {
+      const chunk = text.substring(startPosition, startPosition + chunkSize);
+      regex.lastIndex = 0;
+
+      let chunkLastIndex = -1;
+      let chunkLastLength = 0;
+
+      while ((match = regex.exec(chunk)) !== null) {
+        chunkLastIndex = match.index;
+        chunkLastLength = match[0].length;
+      }
+
+      if (chunkLastIndex !== -1) {
+        return startPosition + chunkLastIndex + chunkLastLength;
+      }
+
+      // Move to previous chunk with some overlap
+      startPosition = Math.max(0, startPosition - chunkSize + 100) - 1;
+      if (startPosition <= 0) break;
+    }
+    return -1;
+  }
+
+  // For shorter texts, normal regex search
+  while ((match = regex.exec(text)) !== null) {
+    lastIndex = match.index;
+    lastLength = match[0].length;
+  }
+
+  return lastIndex === -1 ? -1 : lastIndex + lastLength;
+}
+
+// 4. Find the best boundary with priority groups
+function findBestBoundary(text: string, direction = 'backward'): number {
+  if (!text || text.length === 0) return 0;
+
+  // Try each priority group
+  for (const patternGroup of priorityPatterns) {
+    for (const pattern of patternGroup) {
+      const position =
+        direction === 'backward'
+          ? findLastMatch(text, pattern.regex)
+          : findFirstMatch(text, pattern.regex);
+
+      if (position !== -1) {
+        return position;
+      }
+    }
+  }
+
+  // No match found, use character boundary
+  return direction === 'backward' ? text.length : 0;
+}
+
+/**
+ * Expand highlights in search results using smart boundary detection.
+ *
+ * This implementation finds natural text boundaries like paragraphs, sentences,
+ * and phrases to provide context while maintaining readability.
+ *
+ * @param searchResults - Search results object
+ * @param mainExpandBy - Primary expansion size on each side (default: 300)
+ * @param separatorExpandBy - Additional range to look for separators (default: 150)
+ * @returns Copy of search results with expanded highlights
+ */
+export function expandHighlights(
+  searchResults: t.SearchResultData,
+  mainExpandBy = 300,
+  separatorExpandBy = 150
+): t.SearchResultData {
+  // 1. Avoid full deep copy - only copy what we modify
+  const resultCopy = { ...searchResults };
+
+  // Only deep copy the relevant arrays
+  if (resultCopy.organic) {
+    resultCopy.organic = [...resultCopy.organic];
+  }
+  if (resultCopy.topStories) {
+    resultCopy.topStories = [...resultCopy.topStories];
+  }
+
+  // 5. Process the results efficiently
+  const processResultTypes = ['organic', 'topStories'] as const;
+
+  for (const resultType of processResultTypes) {
+    if (!resultCopy[resultType as 'organic' | 'topStories']) continue;
+
+    // Map results to new array with modified highlights
+    resultCopy[resultType] = resultCopy[resultType]?.map((result) => {
+      if (
+        result.content == null ||
+        result.content === '' ||
+        !result.highlights ||
+        result.highlights.length === 0
+      ) {
+        return result; // No modification needed
+      }
+
+      // Create a shallow copy with expanded highlights
+      const resultCopy = { ...result };
+      const content = result.content;
+      const highlights = [];
+
+      // Process each highlight
+      for (const highlight of result.highlights) {
+        const highlightText = highlight.text;
+
+        let startPos = content.indexOf(highlightText);
+        let highlightLen = highlightText.length;
+
+        if (startPos === -1) {
+          // Try with stripped whitespace
+          const strippedHighlight = highlightText.trim();
+          startPos = content.indexOf(strippedHighlight);
+
+          if (startPos === -1) {
+            highlights.push({
+              text: highlight.text,
+              score: highlight.score,
+            });
+            continue;
+          }
+          highlightLen = strippedHighlight.length;
+        }
+
+        // Calculate boundaries
+        const mainStart = Math.max(0, startPos - mainExpandBy);
+        const mainEnd = Math.min(
+          content.length,
+          startPos + highlightLen + mainExpandBy
+        );
+
+        const separatorStart = Math.max(0, mainStart - separatorExpandBy);
+        const separatorEnd = Math.min(
+          content.length,
+          mainEnd + separatorExpandBy
+        );
+
+        // Extract text segments
+        const headText = content.substring(separatorStart, mainStart);
+        const tailText = content.substring(mainEnd, separatorEnd);
+
+        // Find natural boundaries
+        const bestHeadBoundary = findBestBoundary(headText, 'backward');
+        const bestTailBoundary = findBestBoundary(tailText, 'forward');
+
+        // Calculate final positions
+        const finalStart = separatorStart + bestHeadBoundary;
+        const finalEnd = mainEnd + bestTailBoundary;
+
+        // Extract the expanded highlight
+        const expandedHighlightText = content
+          .substring(finalStart, finalEnd)
+          .trim();
+        highlights.push({
+          text: expandedHighlightText,
+          score: highlight.score,
+        });
+      }
+
+      resultCopy.highlights = highlights;
+      return resultCopy;
+    });
+  }
+
+  return resultCopy;
+}

package/src/tools/search/index.ts

@@ -0,0 +1,2 @@
+export * from './tool';
+export type * from './types';

package/src/tools/search/rerankers.ts

@@ -0,0 +1,248 @@
+/* eslint-disable no-console */
+import axios from 'axios';
+import type * as t from './types';
+
+export abstract class BaseReranker {
+  protected apiKey: string | undefined;
+
+  constructor() {
+    // Each specific reranker will set its API key
+  }
+
+  abstract rerank(
+    query: string,
+    documents: string[],
+    topK?: number
+  ): Promise<t.Highlight[]>;
+
+  protected getDefaultRanking(
+    documents: string[],
+    topK: number
+  ): t.Highlight[] {
+    return documents
+      .slice(0, Math.min(topK, documents.length))
+      .map((doc) => ({ text: doc, score: 0 }));
+  }
+
+  protected logDocumentSamples(documents: string[]): void {
+    console.log('Sample documents being sent to API:');
+    for (let i = 0; i < Math.min(3, documents.length); i++) {
+      console.log(`Document ${i}: ${documents[i].substring(0, 100)}...`);
+    }
+  }
+}
+
+export class JinaReranker extends BaseReranker {
+  constructor({ apiKey = process.env.JINA_API_KEY }: { apiKey?: string }) {
+    super();
+    this.apiKey = apiKey;
+  }
+
+  async rerank(
+    query: string,
+    documents: string[],
+    topK: number = 5
+  ): Promise<t.Highlight[]> {
+    console.log(`Reranking ${documents.length} documents with Jina`);
+
+    try {
+      if (this.apiKey == null || this.apiKey === '') {
+        console.warn('JINA_API_KEY is not set. Using default ranking.');
+        return this.getDefaultRanking(documents, topK);
+      }
+
+      this.logDocumentSamples(documents);
+
+      const requestData = {
+        model: 'jina-reranker-v2-base-multilingual',
+        query: query,
+        top_n: topK,
+        documents: documents,
+        return_documents: true,
+      };
+
+      const response = await axios.post<t.JinaRerankerResponse | undefined>(
+        'https://api.jina.ai/v1/rerank',
+        requestData,
+        {
+          headers: {
+            'Content-Type': 'application/json',
+            Authorization: `Bearer ${this.apiKey}`,
+          },
+        }
+      );
+
+      // Log the response data structure
+      console.log('Jina API response structure:');
+      console.log('Model:', response.data?.model);
+      console.log('Usage:', response.data?.usage);
+      console.log('Results count:', response.data?.results.length);
+
+      // Log a sample of the results
+      if ((response.data?.results.length ?? 0) > 0) {
+        console.log(
+          'Sample result:',
+          JSON.stringify(response.data?.results[0], null, 2)
+        );
+      }
+
+      if (response.data && response.data.results.length) {
+        return response.data.results.map((result) => {
+          const docIndex = result.index;
+          const score = result.relevance_score;
+          let text = '';
+
+          // If return_documents is true, the document field will be present
+          if (result.document != null) {
+            const doc = result.document;
+            if (typeof doc === 'object' && 'text' in doc) {
+              text = doc.text;
+            } else if (typeof doc === 'string') {
+              text = doc;
+            }
+          } else {
+            // Otherwise, use the index to get the document
+            text = documents[docIndex];
+          }
+
+          return { text, score };
+        });
+      } else {
+        console.warn(
+          'Unexpected response format from Jina API. Using default ranking.'
+        );
+        return this.getDefaultRanking(documents, topK);
+      }
+    } catch (error) {
+      console.error('Error using Jina reranker:', error);
+      // Fallback to default ranking on error
+      return this.getDefaultRanking(documents, topK);
+    }
+  }
+}
+
+export class CohereReranker extends BaseReranker {
+  constructor({ apiKey = process.env.COHERE_API_KEY }: { apiKey?: string }) {
+    super();
+    this.apiKey = apiKey;
+  }
+
+  async rerank(
+    query: string,
+    documents: string[],
+    topK: number = 5
+  ): Promise<t.Highlight[]> {
+    console.log(`Reranking ${documents.length} documents with Cohere`);
+
+    try {
+      if (this.apiKey == null || this.apiKey === '') {
+        console.warn('COHERE_API_KEY is not set. Using default ranking.');
+        return this.getDefaultRanking(documents, topK);
+      }
+
+      this.logDocumentSamples(documents);
+
+      const requestData = {
+        model: 'rerank-v3.5',
+        query: query,
+        top_n: topK,
+        documents: documents,
+      };
+
+      const response = await axios.post<t.CohereRerankerResponse | undefined>(
+        'https://api.cohere.com/v2/rerank',
+        requestData,
+        {
+          headers: {
+            'Content-Type': 'application/json',
+            Authorization: `Bearer ${this.apiKey}`,
+          },
+        }
+      );
+
+      // Log the response data structure
+      console.log('Cohere API response structure:');
+      console.log('ID:', response.data?.id);
+      console.log('Meta:', response.data?.meta);
+      console.log('Results count:', response.data?.results.length);
+
+      // Log a sample of the results
+      if ((response.data?.results.length ?? 0) > 0) {
+        console.log(
+          'Sample result:',
+          JSON.stringify(response.data?.results[0], null, 2)
+        );
+      }
+
+      if (response.data && response.data.results.length) {
+        return response.data.results.map((result) => {
+          const docIndex = result.index;
+          const score = result.relevance_score;
+          const text = documents[docIndex];
+          return { text, score };
+        });
+      } else {
+        console.warn(
+          'Unexpected response format from Cohere API. Using default ranking.'
+        );
+        return this.getDefaultRanking(documents, topK);
+      }
+    } catch (error) {
+      console.error('Error using Cohere reranker:', error);
+      // Fallback to default ranking on error
+      return this.getDefaultRanking(documents, topK);
+    }
+  }
+}
+
+export class InfinityReranker extends BaseReranker {
+  constructor() {
+    super();
+    // No API key needed for the placeholder implementation
+  }
+
+  async rerank(
+    query: string,
+    documents: string[],
+    topK: number = 5
+  ): Promise<t.Highlight[]> {
+    console.log(
+      `Reranking ${documents.length} documents with Infinity (placeholder)`
+    );
+    // This would be replaced with actual Infinity reranker implementation
+    return this.getDefaultRanking(documents, topK);
+  }
+}
+
+/**
+ * Creates the appropriate reranker based on type and configuration
+ */
+export const createReranker = (config: {
+  rerankerType: t.RerankerType;
+  jinaApiKey?: string;
+  cohereApiKey?: string;
+}): BaseReranker | undefined => {
+  const { rerankerType, jinaApiKey, cohereApiKey } = config;
+
+  switch (rerankerType.toLowerCase()) {
+  case 'jina':
+    return new JinaReranker({ apiKey: jinaApiKey });
+  case 'cohere':
+    return new CohereReranker({ apiKey: cohereApiKey });
+  case 'infinity':
+    return new InfinityReranker();
+  case 'none':
+    console.log('Skipping reranking as reranker is set to "none"');
+    return undefined;
+  default:
+    console.warn(
+      `Unknown reranker type: ${rerankerType}. Defaulting to InfinityReranker.`
+    );
+    return new JinaReranker({ apiKey: jinaApiKey });
+  }
+};
+
+// Example usage:
+// const jinaReranker = new JinaReranker();
+// const cohereReranker = new CohereReranker();
+// const infinityReranker = new InfinityReranker();