@absolutejs/absolute 0.19.0-beta.489 → 0.19.0-beta.490

package/dist/ai/index.js

@@ -2113,18 +2113,256 @@ var aiChat = (config) => {
 init_constants();
 import { Elysia as Elysia2 } from "elysia";
 
-// src/ai/rag/reranking.ts
+// src/ai/rag/lexical.ts
+var DEFAULT_FUSION_CONSTANT = 60;
 var tokenize = (value) => value.toLowerCase().split(/[^a-z0-9]+/i).map((token) => token.trim()).filter((token) => token.length > 1);
+var collectMetadataStrings = (value) => {
+  if (typeof value === "string" || typeof value === "number") {
+    return [String(value)];
+  }
+  if (Array.isArray(value)) {
+    return value.flatMap((entry) => collectMetadataStrings(entry));
+  }
+  if (value && typeof value === "object") {
+    return Object.values(value).flatMap((entry) => collectMetadataStrings(entry));
+  }
+  return [];
+};
+var buildRAGLexicalHaystack = (result) => [
+  result.title,
+  result.source,
+  result.chunkText,
+  ...collectMetadataStrings(result.metadata)
+].filter((value) => Boolean(value)).join(" ");
+var scoreRAGLexicalMatch = (query, result) => {
+  const queryTokens = tokenize(query);
+  if (queryTokens.length === 0) {
+    return 0;
+  }
+  const haystack = buildRAGLexicalHaystack(result).toLowerCase();
+  const haystackTokens = tokenize(haystack);
+  const haystackSet = new Set(haystackTokens);
+  const overlap = queryTokens.filter((token) => haystackSet.has(token)).length;
+  if (overlap === 0) {
+    return 0;
+  }
+  const exactPhraseBoost = haystack.includes(query.toLowerCase()) ? 1 : 0;
+  const sourceBoost = typeof result.source === "string" && queryTokens.some((token) => result.source?.toLowerCase().includes(token)) ? 0.5 : 0;
+  const coverageBoost = overlap / queryTokens.length;
+  return coverageBoost + exactPhraseBoost + sourceBoost;
+};
+var rankResults = (results) => results.map((result, index) => ({
+  rank: index + 1,
+  result
+}));
+var fuseRAGQueryResults = ({
+  fusion = "rrf",
+  fusionConstant = DEFAULT_FUSION_CONSTANT,
+  lexical = [],
+  lexicalWeight = 2,
+  vector = [],
+  vectorWeight = 1
+}) => {
+  const merged = new Map;
+  const vectorContributionWeight = Math.max(0, vectorWeight);
+  const lexicalContributionWeight = Math.max(0, lexicalWeight);
+  const applyRanked = (ranked, source) => {
+    for (const entry of ranked) {
+      const existing = merged.get(entry.result.chunkId);
+      const weight = source === "lexical" ? lexicalContributionWeight : vectorContributionWeight;
+      const contribution = fusion === "max" ? entry.result.score * weight : weight / (fusionConstant + entry.rank);
+      const baseResult = existing?.result ?? entry.result;
+      const existingSignals = existing?.result.metadata && typeof existing.result.metadata.retrievalSignals === "object" && existing.result.metadata.retrievalSignals !== null ? existing.result.metadata.retrievalSignals : {};
+      const nextScore = fusion === "max" ? Math.max(existing?.score ?? 0, contribution) : (existing?.score ?? 0) + contribution;
+      merged.set(entry.result.chunkId, {
+        result: {
+          ...baseResult,
+          score: nextScore,
+          metadata: {
+            ...baseResult.metadata,
+            retrievalSignals: {
+              lexical: source === "lexical" || existingSignals.lexical === true,
+              vector: source === "vector" || existingSignals.vector === true
+            }
+          }
+        },
+        score: nextScore
+      });
+    }
+  };
+  applyRanked(rankResults(vector), "vector");
+  applyRanked(rankResults(lexical), "lexical");
+  return [...merged.values()].map(({ result, score }) => ({ ...result, score })).sort((left, right) => {
+    if (right.score !== left.score) {
+      return right.score - left.score;
+    }
+    return left.chunkId.localeCompare(right.chunkId);
+  });
+};
+var resolveRAGHybridSearchOptions = (retrieval) => {
+  if (!retrieval) {
+    return {
+      fusion: "rrf",
+      fusionConstant: DEFAULT_FUSION_CONSTANT,
+      lexicalTopK: undefined,
+      lexicalWeight: 2,
+      mode: "vector",
+      vectorWeight: 1
+    };
+  }
+  if (typeof retrieval === "string") {
+    return {
+      fusion: "rrf",
+      fusionConstant: DEFAULT_FUSION_CONSTANT,
+      lexicalTopK: undefined,
+      lexicalWeight: 2,
+      mode: retrieval,
+      vectorWeight: 1
+    };
+  }
+  return {
+    fusion: retrieval.fusion ?? "rrf",
+    fusionConstant: Math.max(1, Math.floor(retrieval.fusionConstant ?? DEFAULT_FUSION_CONSTANT)),
+    lexicalTopK: retrieval.lexicalTopK,
+    lexicalWeight: Math.max(0, retrieval.lexicalWeight ?? 2),
+    mode: retrieval.mode ?? "vector",
+    vectorWeight: Math.max(0, retrieval.vectorWeight ?? 1)
+  };
+};
+
+// src/ai/rag/queryTransforms.ts
+var tokenize2 = (value) => value.toLowerCase().split(/[^a-z0-9]+/i).map((token) => token.trim()).map((token) => token.endsWith("ies") && token.length > 3 ? `${token.slice(0, -3)}y` : token.endsWith("s") && token.length > 3 ? token.slice(0, -1) : token).filter((token) => token.length > 1);
+var DOMAIN_EXPANSIONS = {
+  archive: ["archive", "zip", "bundle", "entry", "runbook", "recovery"],
+  audio: ["audio", "media", "recording", "speaker", "transcript"],
+  deck: ["slide", "deck", "presentation", "pptx"],
+  email: ["email", "mail", "thread", "message", "attachment"],
+  image: ["image", "ocr", "scan", "screenshot"],
+  pdf: ["pdf", "document", "page", "ocr", "scan"],
+  spreadsheet: ["sheet", "worksheet", "workbook", "spreadsheet", "xlsx"],
+  video: ["video", "media", "recording", "transcript", "timestamp"]
+};
+var detectDomains = (tokens) => {
+  const tokenSet = new Set(tokens);
+  const domains = new Set;
+  for (const token of tokenSet) {
+    if (token === "sheet" || token === "worksheet" || token === "workbook" || token === "spreadsheet" || token === "xlsx") {
+      domains.add("spreadsheet");
+    }
+    if (token === "archive" || token === "zip" || token === "bundle") {
+      domains.add("archive");
+    }
+    if (token === "audio" || token === "speaker") {
+      domains.add("audio");
+    }
+    if (token === "video" || token === "timestamp") {
+      domains.add("video");
+    }
+    if (token === "pdf" || token === "page" || token === "ocr") {
+      domains.add("pdf");
+    }
+    if (token === "slide" || token === "deck" || token === "presentation") {
+      domains.add("deck");
+    }
+    if (token === "email" || token === "mail" || token === "thread") {
+      domains.add("email");
+    }
+    if (token === "image" || token === "scan" || token === "screenshot") {
+      domains.add("image");
+    }
+  }
+  return [...domains];
+};
+var uniqueQueryStrings = (values) => Array.from(new Set(values.map((value) => value.trim()).filter((value) => value.length > 0)));
+var createHeuristicRAGQueryTransform = (options = {}) => createRAGQueryTransform({
+  defaultModel: options.defaultModel ?? "absolute-heuristic-query-transform",
+  providerName: options.providerName ?? "absolute_heuristic",
+  transform: ({ query }) => {
+    const tokens = tokenize2(query);
+    const domains = detectDomains(tokens);
+    if (domains.length === 0) {
+      return { query };
+    }
+    const expandedTerms = domains.flatMap((domain) => DOMAIN_EXPANSIONS[domain] ?? []);
+    const rewrittenQuery = uniqueQueryStrings([
+      ...tokens,
+      ...expandedTerms
+    ]).join(" ");
+    const variants = domains.map((domain) => uniqueQueryStrings([
+      ...tokens,
+      ...DOMAIN_EXPANSIONS[domain] ?? []
+    ]).join(" "));
+    return {
+      query: rewrittenQuery,
+      variants
+    };
+  }
+});
+var createRAGQueryTransform = (options) => ({
+  defaultModel: options.defaultModel,
+  providerName: options.providerName,
+  transform: options.transform
+});
+var resolveRAGQueryTransform = (queryTransform) => {
+  if (!queryTransform) {
+    return null;
+  }
+  if (typeof queryTransform === "function") {
+    return {
+      defaultModel: undefined,
+      providerName: undefined,
+      transform: queryTransform
+    };
+  }
+  return queryTransform;
+};
+var applyRAGQueryTransform = async ({
+  input,
+  queryTransform
+}) => {
+  const resolved = resolveRAGQueryTransform(queryTransform);
+  if (!resolved) {
+    return {
+      query: input.query,
+      variants: []
+    };
+  }
+  return Promise.resolve(resolved.transform({
+    ...input,
+    model: input.model ?? resolved.defaultModel
+  }));
+};
+
+// src/ai/rag/reranking.ts
+var tokenize3 = (value) => value.toLowerCase().split(/[^a-z0-9]+/i).map((token) => token.trim()).map((token) => token.endsWith("ies") && token.length > 3 ? `${token.slice(0, -3)}y` : token.endsWith("s") && token.length > 3 ? token.slice(0, -1) : token).filter((token) => token.length > 1);
+var collectMetadataStrings2 = (value) => {
+  if (typeof value === "string" || typeof value === "number") {
+    return [String(value)];
+  }
+  if (Array.isArray(value)) {
+    return value.flatMap((entry) => collectMetadataStrings2(entry));
+  }
+  if (value && typeof value === "object") {
+    return Object.values(value).flatMap((entry) => collectMetadataStrings2(entry));
+  }
+  return [];
+};
 var scoreHeuristicMatch = (queryTokens, result) => {
   if (queryTokens.length === 0) {
     return result.score;
   }
-  const haystack = tokenize([result.title, result.source, result.chunkText].filter(Boolean).join(" "));
+  const metadataValues = collectMetadataStrings2(result.metadata);
+  const haystack = tokenize3([result.title, result.source, result.chunkText, ...metadataValues].filter(Boolean).join(" "));
   const haystackSet = new Set(haystack);
   const overlap = queryTokens.filter((token) => haystackSet.has(token)).length;
   const overlapBoost = overlap / queryTokens.length;
-  return result.score + overlapBoost;
+  const normalizedQuery = queryTokens.join(" ");
+  const exactPhraseBoost = normalizeText([result.title, result.source, result.chunkText, ...metadataValues].filter(Boolean).join(" ")).includes(normalizedQuery) ? 1 : 0;
+  const sourcePathBoost = typeof result.source === "string" && queryTokens.some((token) => result.source?.toLowerCase().includes(token)) ? 0.5 : 0;
+  const metadataBoost = metadataValues.length > 0 ? queryTokens.filter((token) => metadataValues.some((value) => value.toLowerCase().includes(token))).length / queryTokens.length : 0;
+  return result.score + overlapBoost + exactPhraseBoost + sourcePathBoost + metadataBoost;
 };
+var normalizeText = (value) => tokenize3(value).join(" ");
 var applyRAGReranking = async ({
   input,
   reranker
@@ -2143,7 +2381,7 @@ var createHeuristicRAGReranker = (options = {}) => createRAGReranker({
   defaultModel: options.defaultModel ?? "absolute-heuristic-reranker",
   providerName: options.providerName ?? "absolute_heuristic",
   rerank: ({ query, results }) => {
-    const queryTokens = tokenize(query);
+    const queryTokens = tokenize3(query);
     return [...results].map((result, index) => ({
       index,
       result,
@@ -3378,8 +3616,26 @@ var prepareRAGDirectoryDocuments = async (input) => prepareRAGDocuments(await lo
 
 // src/ai/rag/collection.ts
 var DEFAULT_TOP_K = 6;
+var mergeQueryResults = (results) => {
+  const merged = new Map;
+  for (const result of results) {
+    const existing = merged.get(result.chunkId);
+    if (!existing || result.score > existing.score) {
+      merged.set(result.chunkId, result);
+    }
+  }
+  return [...merged.values()].sort((left, right) => {
+    if (right.score !== left.score) {
+      return right.score - left.score;
+    }
+    return left.chunkId.localeCompare(right.chunkId);
+  });
+};
+var shouldRunVectorRetrieval = (mode) => mode === "vector" || mode === "hybrid";
+var shouldRunLexicalRetrieval = (mode, store) => mode === "lexical" || mode === "hybrid" && Boolean(store.queryLexical);
 var createRAGCollection = (options) => {
   const defaultTopK = options.defaultTopK ?? DEFAULT_TOP_K;
+  const defaultCandidateMultiplier = Math.max(1, Math.floor(options.defaultCandidateMultiplier ?? 4));
   const { getCapabilities } = options.store;
   const { getStatus } = options.store;
   const embeddingProvider = resolveRAGEmbeddingProvider(options.embedding, options.store.embed, options.defaultModel);
@@ -3391,21 +3647,64 @@ var createRAGCollection = (options) => {
   };
   const search = async (input) => {
     const model = input.model ?? options.defaultModel;
-    const queryVector = await embed({
+    const topK = input.topK ?? defaultTopK;
+    const hasReranker = Boolean(input.rerank ?? options.rerank);
+    const candidateTopK = Math.max(topK, Math.floor(input.candidateTopK ?? (hasReranker ? topK * defaultCandidateMultiplier : topK)));
+    const retrieval = resolveRAGHybridSearchOptions(input.retrieval);
+    const transformed = await applyRAGQueryTransform({
+      input: {
+        candidateTopK,
+        filter: input.filter,
+        model,
+        query: input.query,
+        scoreThreshold: input.scoreThreshold,
+        topK
+      },
+      queryTransform: input.queryTransform ?? options.queryTransform
+    });
+    const searchQueries = Array.from(new Set([transformed.query, ...transformed.variants ?? []])).filter(Boolean);
+    const runVector = shouldRunVectorRetrieval(retrieval.mode);
+    const runLexical = shouldRunLexicalRetrieval(retrieval.mode, options.store);
+    const lexicalTopK = Math.max(topK, Math.floor(retrieval.lexicalTopK ?? candidateTopK));
+    const queryVector = runVector ? await embed({
       model,
       signal: input.signal,
       text: input.query
-    }, "query");
-    const topK = input.topK ?? defaultTopK;
-    const results = await options.store.query({
-      filter: input.filter,
-      queryVector,
-      topK
+    }, "query") : [];
+    const resultGroups = await Promise.all(searchQueries.map(async (query) => {
+      const [vectorResults2, lexicalResults2] = await Promise.all([
+        runVector ? embed({
+          model,
+          signal: input.signal,
+          text: query
+        }, "query").then((nextQueryVector) => options.store.query({
+          filter: input.filter,
+          queryVector: nextQueryVector,
+          topK: candidateTopK
+        })) : Promise.resolve([]),
+        runLexical ? options.store.queryLexical?.({
+          filter: input.filter,
+          query,
+          topK: lexicalTopK
+        }) ?? Promise.resolve([]) : Promise.resolve([])
+      ]);
+      return { lexicalResults: lexicalResults2, vectorResults: vectorResults2 };
+    }));
+    const vectorResults = mergeQueryResults(resultGroups.flatMap((group) => group.vectorResults));
+    const lexicalResults = mergeQueryResults(resultGroups.flatMap((group) => group.lexicalResults));
+    const results = retrieval.mode === "lexical" ? lexicalResults : retrieval.mode === "vector" ? vectorResults : fuseRAGQueryResults({
+      fusion: retrieval.fusion,
+      fusionConstant: retrieval.fusionConstant,
+      lexical: lexicalResults,
+      lexicalWeight: retrieval.lexicalWeight,
+      vector: vectorResults,
+      vectorWeight: retrieval.vectorWeight
     });
     const rerankInput = {
+      candidateTopK,
       filter: input.filter,
       model,
-      query: input.query,
+      query: transformed.query,
       queryVector,
       results,
       scoreThreshold: input.scoreThreshold,
@@ -3666,6 +3965,79 @@ var compareRAGRerankers = async ({
     suiteLabel: suite.label ?? suite.id
   };
 };
+var summarizeEvaluationResponseComparison = (entries, idKey) => {
+  if (entries.length === 0) {
+    return {};
+  }
+  const byPassingRate = [...entries].sort((left, right) => {
+    if (right.response.passingRate !== left.response.passingRate) {
+      return right.response.passingRate - left.response.passingRate;
+    }
+    if (right.response.summary.averageF1 !== left.response.summary.averageF1) {
+      return right.response.summary.averageF1 - left.response.summary.averageF1;
+    }
+    return left.response.summary.averageLatencyMs - right.response.summary.averageLatencyMs;
+  });
+  const byAverageF1 = [...entries].sort((left, right) => right.response.summary.averageF1 - left.response.summary.averageF1);
+  const byLatency = [...entries].sort((left, right) => left.response.summary.averageLatencyMs - right.response.summary.averageLatencyMs);
+  const getId = (entry) => typeof entry[idKey] === "string" ? entry[idKey] : undefined;
+  return {
+    bestByAverageF1: getId(byAverageF1[0]),
+    bestByPassingRate: getId(byPassingRate[0]),
+    fastest: getId(byLatency[0])
+  };
+};
+var resolveRetrievalMode = (candidate) => {
+  if (!candidate.retrieval) {
+    return "vector";
+  }
+  return typeof candidate.retrieval === "string" ? candidate.retrieval : candidate.retrieval.mode ?? "vector";
+};
+var compareRAGRetrievalStrategies = async ({
+  collection,
+  suite,
+  retrievals,
+  defaultTopK = DEFAULT_TOP_K2
+}) => {
+  const entries = await Promise.all(retrievals.map(async (candidate) => {
+    const response = await evaluateRAGCollection({
+      collection: {
+        ...collection,
+        search: (input) => collection.search({
+          ...input,
+          queryTransform: candidate.queryTransform ?? input.queryTransform,
+          rerank: candidate.rerank ?? input.rerank,
+          retrieval: candidate.retrieval ?? input.retrieval
+        })
+      },
+      defaultTopK,
+      input: suite.input,
+      rerank: candidate.rerank
+    });
+    return {
+      label: candidate.label ?? candidate.id,
+      response,
+      retrievalId: candidate.id,
+      retrievalMode: resolveRetrievalMode(candidate)
+    };
+  }));
+  const leaderboard = buildRAGEvaluationLeaderboard(entries.map((entry) => ({
+    elapsedMs: entry.response.elapsedMs,
+    finishedAt: 0,
+    id: entry.retrievalId,
+    label: entry.label,
+    response: entry.response,
+    startedAt: 0,
+    suiteId: suite.id
+  })));
+  return {
+    entries,
+    leaderboard,
+    summary: summarizeRAGRetrievalComparison(entries),
+    suiteId: suite.id,
+    suiteLabel: suite.label ?? suite.id
+  };
+};
 var createRAGEvaluationSuite = (suite) => suite;
 var evaluateRAGCollection = async ({
   collection,
@@ -3794,26 +4166,9 @@ var summarizeRAGEvaluationCase = ({
   };
 };
 var summarizeRAGRerankerComparison = (entries) => {
-  if (entries.length === 0) {
-    return {};
-  }
-  const byPassingRate = [...entries].sort((left, right) => {
-    if (right.response.passingRate !== left.response.passingRate) {
-      return right.response.passingRate - left.response.passingRate;
-    }
-    if (right.response.summary.averageF1 !== left.response.summary.averageF1) {
-      return right.response.summary.averageF1 - left.response.summary.averageF1;
-    }
-    return left.response.summary.averageLatencyMs - right.response.summary.averageLatencyMs;
-  });
-  const byAverageF1 = [...entries].sort((left, right) => right.response.summary.averageF1 - left.response.summary.averageF1);
-  const byLatency = [...entries].sort((left, right) => left.response.summary.averageLatencyMs - right.response.summary.averageLatencyMs);
-  return {
-    bestByAverageF1: byAverageF1[0]?.rerankerId,
-    bestByPassingRate: byPassingRate[0]?.rerankerId,
-    fastest: byLatency[0]?.rerankerId
-  };
+  return summarizeEvaluationResponseComparison(entries, "rerankerId");
 };
+var summarizeRAGRetrievalComparison = (entries) => summarizeEvaluationResponseComparison(entries, "retrievalId");
 
 // src/ai/rag/types.ts
 var buildRAGContext = (hits) => {
@@ -6098,6 +6453,35 @@ var createInMemoryStatus = (dimensions) => ({
   vectorMode: "in_memory"
 });
 var createInMemoryRAGStore = (options = {}) => {
+  const valuesMatch = (expected, actual) => {
+    if (actual === expected) {
+      return true;
+    }
+    if (typeof actual === "object" && actual !== null && typeof expected === "object" && expected !== null) {
+      return JSON.stringify(actual) === JSON.stringify(expected);
+    }
+    return false;
+  };
+  const matchesFilter = (chunk, filter) => {
+    if (!filter) {
+      return true;
+    }
+    return Object.entries(filter).every(([key, value]) => {
+      if (key === "chunkId") {
+        return valuesMatch(value, chunk.chunkId);
+      }
+      if (key === "source") {
+        return valuesMatch(value, chunk.source);
+      }
+      if (key === "title") {
+        return valuesMatch(value, chunk.title);
+      }
+      if (!chunk.metadata) {
+        return false;
+      }
+      return valuesMatch(value, chunk.metadata[key]);
+    });
+  };
   const storeChunk = (chunk) => {
     const existingIndex = chunks.findIndex((item) => item.chunkId === chunk.chunkId);
     if (existingIndex < 0) {
@@ -6142,6 +6526,30 @@ var createInMemoryRAGStore = (options = {}) => {
       title: entry.chunk.title
     }));
   };
+  const queryLexical = async (input) => {
+    const results = chunks.map((chunk) => ({
+      chunk,
+      score: scoreRAGLexicalMatch(input.query, {
+        chunkText: chunk.text,
+        metadata: chunk.metadata,
+        source: chunk.source,
+        title: chunk.title
+      })
+    })).filter(({ chunk }) => matchesFilter(chunk, input.filter)).filter(({ score }) => score > 0).sort((left, right) => {
+      if (right.score !== left.score) {
+        return right.score - left.score;
+      }
+      return left.chunk.chunkId.localeCompare(right.chunk.chunkId);
+    });
+    return results.slice(0, input.topK).map((entry) => ({
+      chunkId: entry.chunk.chunkId,
+      chunkText: entry.chunk.text,
+      metadata: entry.chunk.metadata,
+      score: entry.score,
+      source: entry.chunk.source,
+      title: entry.chunk.title
+    }));
+  };
   const upsert = async (input) => {
     const next = await Promise.all(input.chunks.map(async (chunk) => ({
       ...chunk,
@@ -6158,6 +6566,7 @@ var createInMemoryRAGStore = (options = {}) => {
     clear,
     embed,
     query,
+    queryLexical,
     upsert,
     getCapabilities: () => capabilities,
     getStatus: () => createInMemoryStatus(dimensions)
@@ -6767,6 +7176,31 @@ var createSQLiteRAGStore = (options = {}) => {
       return queryFallback(input);
     }
   };
+  const queryLexical = async (input) => {
+    const rawRows = toStoredRows(jsonStatements.query.all());
+    const chunks = mapFilterToRows(rawRows).filter((chunk) => matchesFilter(chunk, input.filter)).map((chunk) => ({
+      chunk,
+      score: scoreRAGLexicalMatch(input.query, {
+        chunkText: chunk.text,
+        metadata: chunk.metadata,
+        source: chunk.source,
+        title: chunk.title
+      })
+    })).filter(({ score }) => score > 0).sort((left, right) => {
+      if (right.score !== left.score) {
+        return right.score - left.score;
+      }
+      return left.chunk.chunkId.localeCompare(right.chunk.chunkId);
+    });
+    return chunks.slice(0, input.topK).map(({ chunk, score }) => ({
+      chunkId: chunk.chunkId,
+      chunkText: chunk.text,
+      metadata: chunk.metadata,
+      score,
+      source: chunk.source,
+      title: chunk.title
+    }));
+  };
   const upsert = async (input) => {
     const chunks = input.chunks.length > 0 ? await Promise.all(input.chunks.map(async (chunk) => ({
       chunkId: chunk.chunkId,
@@ -6806,6 +7240,7 @@ var createSQLiteRAGStore = (options = {}) => {
     clear,
     embed,
     query,
+    queryLexical,
     upsert,
     getCapabilities: () => createSQLiteCapabilities(useNative),
     getStatus: () => createSQLiteStatus(dimensions, nativeDiagnostics, useNative)
@@ -7823,9 +8258,12 @@ export {
   streamAI,
   serializeAIMessage,
   searchDocuments,
+  scoreRAGLexicalMatch,
   runRAGEvaluationSuite,
   resolveRAGStreamStage,
   resolveRAGReranker,
+  resolveRAGQueryTransform,
+  resolveRAGHybridSearchOptions,
   resolveRAGEmbeddingProvider,
   resolveAbsoluteSQLiteVecExtensionPath,
   resolveAbsoluteSQLiteVec,
@@ -7871,6 +8309,7 @@ export {
   geminiOCR,
   geminiEmbeddings,
   gemini,
+  fuseRAGQueryResults,
   executeDryRunRAGEvaluation,
   evaluateRAGCollection,
   deepseekEmbeddings,
@@ -7880,6 +8319,7 @@ export {
   createRAGVector,
   createAIStream as createRAGTransport,
   createRAGReranker,
+  createRAGQueryTransform,
   createRAGPDFOCRExtractor,
   createRAGOCRProvider,
   createRAGMediaTranscriber,
@@ -7901,10 +8341,12 @@ export {
   createLegacyDocumentExtractor,
   createInMemoryRAGStore,
   createHeuristicRAGReranker,
+  createHeuristicRAGQueryTransform,
   createEmailExtractor,
   createEPUBExtractor,
   createConversationManager,
   createBuiltinArchiveExpander,
+  compareRAGRetrievalStrategies,
   compareRAGRerankers,
   buildRAGUpsertInputFromUploads,
   buildRAGUpsertInputFromURLs,
@@ -7913,6 +8355,7 @@ export {
   buildRAGStreamProgress as buildRAGTransportProgress,
   buildRAGSourceSummaries,
   buildRAGSourceGroups,
+  buildRAGLexicalHaystack,
   buildRAGGroundingReferences,
   buildRAGGroundedAnswer,
   buildRAGEvaluationResponse,
@@ -7920,11 +8363,12 @@ export {
   buildRAGCitations,
   buildRAGCitationReferenceMap,
   applyRAGReranking,
+  applyRAGQueryTransform,
   anthropicOCR,
   alibabaEmbeddings,
   alibaba,
   aiChat
 };
 
-//# debugId=8379FE201AE8A9CF64756E2164756E21
+//# debugId=4FC06DD026EF238A64756E2164756E21
 //# sourceMappingURL=index.js.map