opensentinel 2.1.1 → 3.1.1

package/dist/enhanced-retrieval-DNLLEM4Z.js

@@ -0,0 +1,753 @@
+import {
+  generateEmbedding
+} from "./chunk-IZJMVV7O.js";
+import {
+  providerRegistry
+} from "./chunk-BXZ6EA52.js";
+import {
+  db
+} from "./chunk-XKYRH4FM.js";
+import {
+  env
+} from "./chunk-ZLZKF2PM.js";
+import "./chunk-35WYTA3C.js";
+import "./chunk-PLDDJCW6.js";
+
+// src/core/memory/hybrid-search.ts
+import { sql } from "drizzle-orm";
+var RRF_K = 60;
+async function vectorSearch(query, userId, limit = 10) {
+  const queryEmbedding = await generateEmbedding(query);
+  const results = await db.execute(sql`
+    SELECT
+      id, user_id, type, content, importance, source, provenance,
+      created_at,
+      1 - (embedding <=> ${JSON.stringify(queryEmbedding)}::vector) as similarity
+    FROM memories
+    ${userId ? sql`WHERE user_id = ${userId}` : sql``}
+    ORDER BY embedding <=> ${JSON.stringify(queryEmbedding)}::vector
+    LIMIT ${limit}
+  `);
+  return results;
+}
+async function keywordSearch(query, userId, limit = 10) {
+  const results = await db.execute(sql`
+    SELECT
+      id, user_id, type, content, importance, source, provenance,
+      created_at,
+      ts_rank(search_vector, plainto_tsquery('english', ${query})) as keyword_rank
+    FROM memories
+    WHERE search_vector IS NOT NULL
+      AND search_vector @@ plainto_tsquery('english', ${query})
+      ${userId ? sql`AND user_id = ${userId}` : sql``}
+    ORDER BY keyword_rank DESC
+    LIMIT ${limit}
+  `);
+  return results.map((r) => ({
+    ...r,
+    keywordRank: r.keyword_rank
+  }));
+}
+async function graphAugmentedSearch(query, userId, limit = 10) {
+  const entities = await db.execute(sql`
+    SELECT id, name, type
+    FROM graph_entities
+    WHERE name ILIKE ${"%" + query + "%"}
+      ${userId ? sql`AND user_id = ${userId}` : sql``}
+    LIMIT 5
+  `);
+  if (entities.length === 0) {
+    return [];
+  }
+  const entityIds = entities.map((e) => e.id);
+  const entityNames = entities.map((e) => e.name);
+  const namePattern = entityNames.join("|");
+  const results = await db.execute(sql`
+    SELECT
+      id, user_id, type, content, importance, source, provenance,
+      created_at,
+      1.0 as graph_score
+    FROM memories
+    WHERE content ~* ${namePattern}
+      ${userId ? sql`AND user_id = ${userId}` : sql``}
+    ORDER BY importance DESC, created_at DESC
+    LIMIT ${limit}
+  `);
+  return results.map((r) => ({
+    ...r,
+    graphScore: r.graph_score
+  }));
+}
+function reciprocalRankFusion(rankedLists, k = RRF_K) {
+  const scores = /* @__PURE__ */ new Map();
+  for (const list of rankedLists) {
+    for (let rank = 0; rank < list.length; rank++) {
+      const id = list[rank].id;
+      const rrfScore = 1 / (k + rank + 1);
+      scores.set(id, (scores.get(id) || 0) + rrfScore);
+    }
+  }
+  return scores;
+}
+async function hybridSearch(query, options = {}) {
+  const {
+    userId,
+    limit = 10,
+    since,
+    until,
+    includeKeyword = true,
+    includeGraph = true
+  } = options;
+  const searchPromises = [
+    vectorSearch(query, userId, limit * 2)
+    // Fetch more for better fusion
+  ];
+  if (includeKeyword) {
+    searchPromises.push(keywordSearch(query, userId, limit * 2));
+  }
+  if (includeGraph) {
+    searchPromises.push(graphAugmentedSearch(query, userId, limit));
+  }
+  const results = await Promise.all(searchPromises);
+  const [vectorResults, keywordResults, graphResults] = results;
+  const allResults = /* @__PURE__ */ new Map();
+  for (const r of vectorResults || []) {
+    allResults.set(r.id, r);
+  }
+  for (const r of keywordResults || []) {
+    if (!allResults.has(r.id)) allResults.set(r.id, r);
+  }
+  for (const r of graphResults || []) {
+    if (!allResults.has(r.id)) allResults.set(r.id, r);
+  }
+  const rankedLists = [vectorResults || []];
+  if (keywordResults) rankedLists.push(keywordResults);
+  if (graphResults) rankedLists.push(graphResults);
+  const rrfScores = reciprocalRankFusion(rankedLists);
+  let finalResults = [];
+  for (const [id, rrfScore] of rrfScores) {
+    const data = allResults.get(id);
+    if (!data) continue;
+    finalResults.push({
+      id: data.id,
+      userId: data.user_id,
+      type: data.type,
+      content: data.content,
+      importance: data.importance || 5,
+      source: data.source,
+      provenance: data.provenance,
+      similarity: data.similarity || 0,
+      keywordRank: data.keywordRank || data.keyword_rank || 0,
+      rrfScore,
+      createdAt: data.created_at
+    });
+  }
+  if (since) {
+    finalResults = finalResults.filter((r) => new Date(r.createdAt) >= since);
+  }
+  if (until) {
+    finalResults = finalResults.filter((r) => new Date(r.createdAt) <= until);
+  }
+  return finalResults.sort((a, b) => b.rrfScore - a.rrfScore).slice(0, limit);
+}
+
+// src/core/memory/contextual-query.ts
+var DEFAULT_MAX_HISTORY_MESSAGES = 4;
+var MAX_TOKENS = 200;
+var SYSTEM_PROMPT = "Rewrite this query to be self-contained by resolving pronouns, references, and implicit context from the conversation. Return ONLY the rewritten query, nothing else.";
+async function buildContextualQuery(query, conversationHistory, opts) {
+  try {
+    if (!env.CONTEXTUAL_QUERY_ENABLED) {
+      return query;
+    }
+    if (!conversationHistory || conversationHistory.length < 2) {
+      return query;
+    }
+    const maxHistory = opts?.maxHistoryMessages ?? DEFAULT_MAX_HISTORY_MESSAGES;
+    const recentHistory = conversationHistory.slice(-maxHistory);
+    const conversationText = recentHistory.map((msg) => `${msg.role === "user" ? "User" : "Assistant"}: ${msg.content}`).join("\n");
+    const userPrompt = `Conversation so far:
+${conversationText}
+
+Current query to rewrite:
+${query}`;
+    const provider = providerRegistry.getDefault();
+    const model = opts?.model ?? "claude-sonnet-4-5-20250929";
+    const response = await provider.createMessage({
+      model,
+      max_tokens: MAX_TOKENS,
+      system: SYSTEM_PROMPT,
+      messages: [
+        {
+          role: "user",
+          content: userPrompt
+        }
+      ]
+    });
+    const rewrittenQuery = response.content.filter((block) => block.type === "text" && block.text).map((block) => block.text).join("").trim();
+    if (!rewrittenQuery) {
+      return query;
+    }
+    return rewrittenQuery;
+  } catch {
+    return query;
+  }
+}
+
+// src/core/memory/hyde.ts
+import { sql as sql2 } from "drizzle-orm";
+var RRF_K2 = 60;
+var DEFAULT_SYSTEM_PROMPT = "You are a helpful assistant. Generate a detailed document that would perfectly answer the following question. Write as if this document already exists in a knowledge base. Be specific and factual.";
+var DEFAULT_MAX_TOKENS = 300;
+async function generateHypotheticalDocument(query, opts) {
+  const systemPrompt = opts?.systemPrompt ?? DEFAULT_SYSTEM_PROMPT;
+  const maxTokens = opts?.maxTokens ?? DEFAULT_MAX_TOKENS;
+  const provider = providerRegistry.getDefault();
+  const response = await provider.createMessage({
+    model: "claude-sonnet-4-20250514",
+    max_tokens: maxTokens,
+    system: systemPrompt,
+    messages: [
+      {
+        role: "user",
+        content: query
+      }
+    ]
+  });
+  const text = response.content.filter((block) => block.type === "text").map((block) => block.text ?? "").join("");
+  return text;
+}
+async function vectorSearchWithEmbedding(embedding, userId, limit = 10) {
+  const embeddingStr = JSON.stringify(embedding);
+  const results = await db.execute(sql2`
+    SELECT
+      id, user_id, type, content, importance, source, provenance,
+      created_at,
+      1 - (embedding <=> ${embeddingStr}::vector) as similarity
+    FROM memories
+    ${userId ? sql2`WHERE user_id = ${userId}` : sql2``}
+    ORDER BY embedding <=> ${embeddingStr}::vector
+    LIMIT ${limit}
+  `);
+  return results;
+}
+function reciprocalRankFusion2(rankedLists, k = RRF_K2) {
+  const scores = /* @__PURE__ */ new Map();
+  for (const list of rankedLists) {
+    for (let rank = 0; rank < list.length; rank++) {
+      const id = list[rank].id;
+      const rrfScore = 1 / (k + rank + 1);
+      scores.set(id, (scores.get(id) || 0) + rrfScore);
+    }
+  }
+  return scores;
+}
+async function hydeSearch(query, userId, limit = 10) {
+  if (!env.HYDE_ENABLED) {
+    const results = await hybridSearch(query, { userId, limit });
+    return results.map((r) => ({ ...r, hydeDocument: "" }));
+  }
+  let hydeDocument;
+  try {
+    hydeDocument = await generateHypotheticalDocument(query);
+  } catch (error) {
+    console.warn("[HyDE] LLM generation failed, falling back to hybrid search:", error);
+    const results = await hybridSearch(query, { userId, limit });
+    return results.map((r) => ({ ...r, hydeDocument: "" }));
+  }
+  if (!hydeDocument || hydeDocument.trim().length === 0) {
+    console.warn("[HyDE] Empty hypothetical document, falling back to hybrid search");
+    const results = await hybridSearch(query, { userId, limit });
+    return results.map((r) => ({ ...r, hydeDocument: "" }));
+  }
+  let hydeEmbedding;
+  try {
+    hydeEmbedding = await generateEmbedding(hydeDocument);
+  } catch (error) {
+    console.warn("[HyDE] Embedding generation failed, falling back to hybrid search:", error);
+    const results = await hybridSearch(query, { userId, limit });
+    return results.map((r) => ({ ...r, hydeDocument: "" }));
+  }
+  const fetchLimit = limit * 2;
+  const [vectorResults, kwResults] = await Promise.all([
+    vectorSearchWithEmbedding(hydeEmbedding, userId, fetchLimit),
+    keywordSearch(query, userId, fetchLimit)
+  ]);
+  const allResults = /* @__PURE__ */ new Map();
+  for (const r of vectorResults) {
+    allResults.set(r.id, r);
+  }
+  for (const r of kwResults) {
+    if (!allResults.has(r.id)) {
+      allResults.set(r.id, r);
+    }
+  }
+  const rrfScores = reciprocalRankFusion2([vectorResults, kwResults]);
+  const finalResults = [];
+  for (const [id, rrfScore] of rrfScores) {
+    const data = allResults.get(id);
+    if (!data) continue;
+    finalResults.push({
+      id: data.id,
+      userId: data.user_id,
+      type: data.type,
+      content: data.content,
+      importance: data.importance || 5,
+      source: data.source,
+      provenance: data.provenance,
+      similarity: data.similarity || 0,
+      keywordRank: data.keywordRank || data.keyword_rank || 0,
+      rrfScore,
+      createdAt: data.created_at,
+      hydeDocument
+    });
+  }
+  return finalResults.sort((a, b) => b.rrfScore - a.rrfScore).slice(0, limit);
+}
+
+// src/core/memory/retrieval-cache.ts
+import Redis from "ioredis";
+import { createHash } from "crypto";
+var KEY_PREFIX = "rag:cache:";
+var DEFAULT_TTL_SECONDS = 3600;
+var RetrievalCache = class {
+  redis = null;
+  connecting = false;
+  /**
+   * Lazily create / return a Redis client.
+   * Returns null if Redis is unavailable.
+   */
+  async getClient() {
+    if (this.redis) return this.redis;
+    if (this.connecting) return null;
+    try {
+      this.connecting = true;
+      const client = new Redis(env.REDIS_URL, {
+        maxRetriesPerRequest: null,
+        lazyConnect: true
+      });
+      await client.connect();
+      this.redis = client;
+      return this.redis;
+    } catch {
+      this.redis = null;
+      return null;
+    } finally {
+      this.connecting = false;
+    }
+  }
+  /**
+   * Hash an embedding vector for use as a cache key.
+   *
+   * Rounds each component to 4 decimal places to tolerate minor
+   * floating-point differences, then produces a SHA-256 hex digest.
+   */
+  hashEmbedding(embedding) {
+    const rounded = embedding.map((v) => v.toFixed(4)).join(",");
+    return createHash("sha256").update(rounded).digest("hex");
+  }
+  /**
+   * Look up cached search results for the given embedding.
+   * Returns null on cache miss or if the cache is disabled / unavailable.
+   */
+  async getCachedResults(queryEmbedding) {
+    if (!env.RETRIEVAL_CACHE_ENABLED) return null;
+    try {
+      const client = await this.getClient();
+      if (!client) return null;
+      const hash = this.hashEmbedding(queryEmbedding);
+      const key = `${KEY_PREFIX}${hash}`;
+      const raw = await client.get(key);
+      if (!raw) return null;
+      const cached = JSON.parse(raw);
+      cached.results = cached.results.map((r) => ({
+        ...r,
+        createdAt: new Date(r.createdAt)
+      }));
+      return cached;
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Store search results in Redis, keyed by embedding hash.
+   *
+   * @param queryEmbedding - The embedding vector used for the search.
+   * @param results        - The hybrid search results to cache.
+   * @param ttl            - Time-to-live in seconds (default 3600).
+   */
+  async cacheResults(queryEmbedding, results, ttl = DEFAULT_TTL_SECONDS) {
+    if (!env.RETRIEVAL_CACHE_ENABLED) return;
+    try {
+      const client = await this.getClient();
+      if (!client) return;
+      const hash = this.hashEmbedding(queryEmbedding);
+      const key = `${KEY_PREFIX}${hash}`;
+      const entry = {
+        results,
+        cachedAt: Date.now(),
+        queryHash: hash
+      };
+      await client.set(key, JSON.stringify(entry), "EX", ttl);
+    } catch {
+    }
+  }
+  /**
+   * Remove cache entries matching a key pattern.
+   *
+   * @param pattern - Glob pattern appended to the key prefix.
+   *                  Defaults to `*` (all retrieval cache keys).
+   * @returns The number of keys deleted.
+   */
+  async invalidateCache(pattern) {
+    try {
+      const client = await this.getClient();
+      if (!client) return 0;
+      const scanPattern = `${KEY_PREFIX}${pattern ?? "*"}`;
+      let deleted = 0;
+      let cursor = "0";
+      do {
+        const [nextCursor, keys] = await client.scan(
+          cursor,
+          "MATCH",
+          scanPattern,
+          "COUNT",
+          100
+        );
+        cursor = nextCursor;
+        if (keys.length > 0) {
+          deleted += await client.del(...keys);
+        }
+      } while (cursor !== "0");
+      return deleted;
+    } catch {
+      return 0;
+    }
+  }
+};
+var instance = null;
+function getRetrievalCache() {
+  if (!instance) {
+    instance = new RetrievalCache();
+  }
+  return instance;
+}
+
+// src/core/memory/reranker.ts
+var DEFAULT_BATCH_SIZE = 5;
+var DEFAULT_MAX_TOKENS2 = 100;
+var DEFAULT_SCORE = 5;
+var DEFAULT_MODEL = "claude-sonnet-4-20250514";
+function buildScoringPrompt(query, documents) {
+  const docList = documents.map((doc, i) => `${i + 1}. ${doc}`).join("\n");
+  return `You are a relevance judge. Given a search query and a list of retrieved documents, rate each document's relevance to the query on a scale of 0-10.
+
+Query: ${query}
+
+Documents:
+${docList}
+
+Return a JSON array of scores: [score1, score2, ...]
+Only return the JSON array, nothing else.`;
+}
+function parseScores(text, expectedCount) {
+  try {
+    const parsed = JSON.parse(text.trim());
+    if (Array.isArray(parsed)) {
+      return parsed.map((s) => {
+        const n = Number(s);
+        return Number.isFinite(n) ? Math.min(10, Math.max(0, n)) : DEFAULT_SCORE;
+      });
+    }
+  } catch {
+  }
+  const matches = text.match(/\d+(?:\.\d+)?/g);
+  if (matches && matches.length > 0) {
+    return matches.slice(0, expectedCount).map((m) => {
+      const n = Number(m);
+      return Number.isFinite(n) ? Math.min(10, Math.max(0, n)) : DEFAULT_SCORE;
+    });
+  }
+  return new Array(expectedCount).fill(DEFAULT_SCORE);
+}
+async function batchRerank(query, results, batchSize = DEFAULT_BATCH_SIZE, model) {
+  const provider = providerRegistry.getDefault();
+  const resolvedModel = model || DEFAULT_MODEL;
+  const rankedResults = [];
+  const batches = [];
+  for (let i = 0; i < results.length; i += batchSize) {
+    batches.push(results.slice(i, i + batchSize));
+  }
+  const batchPromises = batches.map(async (batch) => {
+    const documents = batch.map((r) => r.content);
+    const prompt = buildScoringPrompt(query, documents);
+    try {
+      const response = await provider.createMessage({
+        model: resolvedModel,
+        max_tokens: DEFAULT_MAX_TOKENS2,
+        system: "You are a relevance scoring assistant. Only output valid JSON.",
+        messages: [{ role: "user", content: prompt }]
+      });
+      const responseText = response.content.filter((block) => block.type === "text").map((block) => block.text || "").join("");
+      const scores = parseScores(responseText, batch.length);
+      return batch.map((result, idx) => ({
+        ...result,
+        rerankScore: idx < scores.length ? scores[idx] : DEFAULT_SCORE
+      }));
+    } catch (error) {
+      console.warn(
+        `[Reranker] LLM scoring failed for batch, assigning default score of ${DEFAULT_SCORE}:`,
+        error instanceof Error ? error.message : error
+      );
+      return batch.map((result) => ({
+        ...result,
+        rerankScore: DEFAULT_SCORE
+      }));
+    }
+  });
+  const batchResults = await Promise.all(batchPromises);
+  for (const batch of batchResults) {
+    rankedResults.push(...batch);
+  }
+  return rankedResults;
+}
+async function rerank(query, results, opts) {
+  try {
+    const minScore = opts?.minScore ?? env.RERANK_MIN_SCORE;
+    if (!env.RERANK_ENABLED) {
+      return results.map((r) => ({ ...r, rerankScore: DEFAULT_SCORE }));
+    }
+    if (results.length <= 1) {
+      return results.map((r) => ({ ...r, rerankScore: 10 }));
+    }
+    let ranked = await batchRerank(query, results, DEFAULT_BATCH_SIZE, opts?.model);
+    ranked = ranked.filter((r) => r.rerankScore >= minScore);
+    ranked.sort((a, b) => b.rerankScore - a.rerankScore);
+    if (opts?.topK && opts.topK > 0) {
+      ranked = ranked.slice(0, opts.topK);
+    }
+    return ranked;
+  } catch (error) {
+    console.error(
+      "[Reranker] Re-ranking failed, returning original results:",
+      error instanceof Error ? error.message : error
+    );
+    return results.map((r) => ({ ...r, rerankScore: DEFAULT_SCORE }));
+  }
+}
+
+// src/core/memory/multi-step.ts
+var COMPLETENESS_MAX_TOKENS = 300;
+var COMPLETENESS_MODEL = "claude-sonnet-4-5-20250929";
+async function evaluateCompleteness(query, context) {
+  try {
+    const provider = providerRegistry.getDefault();
+    const response = await provider.createMessage({
+      model: COMPLETENESS_MODEL,
+      max_tokens: COMPLETENESS_MAX_TOKENS,
+      system: "You are a retrieval evaluation assistant. Only output valid JSON.",
+      messages: [
+        {
+          role: "user",
+          content: `Analyze whether the following context sufficiently answers the query. Return a JSON object with:
+- "complete": boolean (true if context fully answers the query)
+- "gaps": string[] (list of missing information)
+- "followUpQueries": string[] (search queries to fill the gaps, max 2)
+
+Query: ${query}
+
+Context:
+${context}
+
+Return only the JSON object.`
+        }
+      ]
+    });
+    const responseText = response.content.filter((block) => block.type === "text").map((block) => block.text || "").join("");
+    const parsed = JSON.parse(responseText.trim());
+    return {
+      complete: Boolean(parsed.complete),
+      gaps: Array.isArray(parsed.gaps) ? parsed.gaps : [],
+      followUpQueries: Array.isArray(parsed.followUpQueries) ? parsed.followUpQueries.slice(0, 2) : []
+    };
+  } catch (error) {
+    console.warn(
+      "[MultiStepRAG] Completeness evaluation failed, assuming complete:",
+      error instanceof Error ? error.message : error
+    );
+    return { complete: true, gaps: [], followUpQueries: [] };
+  }
+}
+async function multiStepRetrieve(query, initialResults, opts) {
+  if (!env.MULTISTEP_RAG_ENABLED) {
+    return {
+      results: initialResults,
+      steps: 0,
+      followUpQueries: []
+    };
+  }
+  const maxSteps = opts?.maxSteps ?? env.MULTISTEP_MAX_STEPS;
+  const userId = opts?.userId;
+  const limit = opts?.limit ?? 10;
+  const resultsById = /* @__PURE__ */ new Map();
+  for (const r of initialResults) {
+    resultsById.set(r.id, r);
+  }
+  const allFollowUpQueries = [];
+  let stepsPerformed = 0;
+  for (let step = 0; step < maxSteps; step++) {
+    const currentResults = Array.from(resultsById.values());
+    const contextText = currentResults.map((r) => r.content).join("\n\n");
+    const evaluation = await evaluateCompleteness(query, contextText);
+    if (evaluation.complete || evaluation.followUpQueries.length === 0) {
+      break;
+    }
+    stepsPerformed++;
+    const followUps = evaluation.followUpQueries.slice(0, 2);
+    allFollowUpQueries.push(...followUps);
+    const retrievalPromises = followUps.map(async (followUpQuery) => {
+      const searchResults = await hybridSearch(followUpQuery, {
+        userId,
+        limit
+      });
+      const rankedResults = await rerank(followUpQuery, searchResults);
+      return rankedResults;
+    });
+    const additionalResultSets = await Promise.all(retrievalPromises);
+    for (const resultSet of additionalResultSets) {
+      for (const r of resultSet) {
+        if (!resultsById.has(r.id)) {
+          resultsById.set(r.id, r);
+        }
+      }
+    }
+  }
+  const mergedResults = Array.from(resultsById.values()).sort(
+    (a, b) => b.rerankScore - a.rerankScore
+  );
+  return {
+    results: mergedResults,
+    steps: stepsPerformed,
+    followUpQueries: allFollowUpQueries
+  };
+}
+
+// src/core/memory/enhanced-retrieval.ts
+function toRankedResults(results, defaultScore) {
+  return results.map((r) => ({
+    ...r,
+    rerankScore: defaultScore ?? r.rrfScore * 10
+  }));
+}
+async function enhancedRetrieve(query, opts) {
+  const userId = opts?.userId;
+  const limit = opts?.limit ?? 10;
+  const conversationHistory = opts?.conversationHistory;
+  let steps = 0;
+  try {
+    let effectiveQuery = query;
+    if (env.CONTEXTUAL_QUERY_ENABLED && conversationHistory && conversationHistory.length >= 2) {
+      console.log("[EnhancedRetrieval] Contextual query rewrite enabled, rewriting query...");
+      effectiveQuery = await buildContextualQuery(query, conversationHistory);
+      steps++;
+      console.log(`[EnhancedRetrieval] Rewritten query: "${effectiveQuery}"`);
+    }
+    let cached = false;
+    let queryEmbedding = null;
+    if (env.RETRIEVAL_CACHE_ENABLED) {
+      console.log("[EnhancedRetrieval] Cache enabled, checking for cached results...");
+      queryEmbedding = await generateEmbedding(effectiveQuery);
+      const cache = getRetrievalCache();
+      const cachedResult = await cache.getCachedResults(queryEmbedding);
+      if (cachedResult) {
+        console.log("[EnhancedRetrieval] Cache hit, using cached results");
+        cached = true;
+        steps++;
+        let rankedResults2 = toRankedResults(cachedResult.results, 5);
+        if (env.RERANK_ENABLED) {
+          console.log("[EnhancedRetrieval] Re-ranking cached results...");
+          rankedResults2 = await rerank(effectiveQuery, cachedResult.results);
+          steps++;
+        }
+        if (env.MULTISTEP_RAG_ENABLED) {
+          console.log("[EnhancedRetrieval] Multi-step retrieval on cached results...");
+          rankedResults2 = await multiStepRetrieve(effectiveQuery, rankedResults2, { userId });
+          steps++;
+        }
+        return {
+          results: rankedResults2,
+          cached: true,
+          steps,
+          queryUsed: effectiveQuery
+        };
+      }
+      console.log("[EnhancedRetrieval] Cache miss, proceeding to search");
+    }
+    let searchResults;
+    if (env.HYDE_ENABLED) {
+      console.log("[EnhancedRetrieval] HyDE enabled, generating hypothetical doc...");
+      searchResults = await hydeSearch(effectiveQuery, userId, limit);
+      steps++;
+    } else {
+      console.log("[EnhancedRetrieval] Running hybrid search...");
+      searchResults = await hybridSearch(effectiveQuery, { userId, limit });
+      steps++;
+    }
+    let rankedResults;
+    if (env.RERANK_ENABLED) {
+      console.log("[EnhancedRetrieval] Re-ranking results...");
+      rankedResults = await rerank(effectiveQuery, searchResults);
+      steps++;
+    } else {
+      rankedResults = toRankedResults(searchResults);
+    }
+    if (env.RETRIEVAL_CACHE_ENABLED && !cached) {
+      console.log("[EnhancedRetrieval] Storing results in cache...");
+      if (!queryEmbedding) {
+        queryEmbedding = await generateEmbedding(effectiveQuery);
+      }
+      const cache = getRetrievalCache();
+      await cache.cacheResults(queryEmbedding, searchResults);
+    }
+    if (env.MULTISTEP_RAG_ENABLED) {
+      console.log("[EnhancedRetrieval] Multi-step retrieval enabled, filling gaps...");
+      rankedResults = await multiStepRetrieve(effectiveQuery, rankedResults, { userId });
+      steps++;
+    }
+    return {
+      results: rankedResults,
+      cached,
+      steps,
+      queryUsed: effectiveQuery
+    };
+  } catch (error) {
+    console.error(
+      "[EnhancedRetrieval] Pipeline failed, falling back to plain hybrid search:",
+      error instanceof Error ? error.message : error
+    );
+    try {
+      const fallbackResults = await hybridSearch(query, { userId, limit });
+      return {
+        results: toRankedResults(fallbackResults, 5),
+        cached: false,
+        steps: 0,
+        queryUsed: query
+      };
+    } catch (fallbackError) {
+      console.error(
+        "[EnhancedRetrieval] Fallback hybrid search also failed:",
+        fallbackError instanceof Error ? fallbackError.message : fallbackError
+      );
+      return {
+        results: [],
+        cached: false,
+        steps: 0,
+        queryUsed: query
+      };
+    }
+  }
+}
+export {
+  enhancedRetrieve
+};
+//# sourceMappingURL=enhanced-retrieval-DNLLEM4Z.js.map