@anuma/sdk 2.4.0 → 2.4.1

package/dist/server/index.cjs

@@ -16385,7 +16385,13 @@ async function searchMessagesOp(ctx, queryVector, options) {
   );
 }
 async function searchChunksOp(ctx, queryVector, options) {
-  const { limit = 10, minSimilarity = 0.5, conversationId, embeddingModel } = options || {};
+  const {
+    limit = 10,
+    minSimilarity = 0.5,
+    conversationId,
+    embeddingModel,
+    chunkCache
+  } = options || {};
   const activeConversations = await ctx.conversationsCollection.query(import_watermelondb14.Q.where("is_deleted", false)).fetch();
   const activeConversationIds = new Set(
     // Use _getRaw for reliable raw column access
@@ -16405,23 +16411,54 @@ async function searchChunksOp(ctx, queryVector, options) {
         continue;
       }
     }
+    const version = Number(message._getRaw("updated_at")) || 0;
+    const cached = chunkCache?.get(message.id);
+    if (cached && cached.version === version) {
+      if (cached.chunks.length > 0) {
+        for (let ci = 0; ci < cached.chunks.length; ci++) {
+          const vec = cached.chunks[ci];
+          if (vec.length === 0) continue;
+          const similarity = cosineSimilarity(queryVector, vec);
+          if (similarity >= minSimilarity) {
+            candidates.push({
+              message,
+              similarity,
+              chunkTextSource: { kind: "chunk-cached", chunkIndex: ci, version }
+            });
+          }
+        }
+      } else if (cached.fallback) {
+        const similarity = cosineSimilarity(queryVector, cached.fallback);
+        if (similarity >= minSimilarity) {
+          candidates.push({ message, similarity, chunkTextSource: { kind: "message" } });
+        }
+      }
+      continue;
+    }
     const chunks = await readJsonField(message, "chunks", ctx.walletAddress);
     if (chunks && chunks.length > 0) {
-      for (const chunk of chunks) {
-        if (!chunk.vector || chunk.vector.length === 0) continue;
-        const similarity = cosineSimilarity(queryVector, chunk.vector);
+      const vectors = chunks.map(
+        (chunk) => chunk.vector && chunk.vector.length > 0 ? Float32Array.from(chunk.vector) : new Float32Array(0)
+      );
+      chunkCache?.set(message.id, { version, chunks: vectors });
+      for (let ci = 0; ci < chunks.length; ci++) {
+        const vec = vectors[ci];
+        if (vec.length === 0) continue;
+        const similarity = cosineSimilarity(queryVector, vec);
         if (similarity >= minSimilarity) {
           candidates.push({
             message,
             similarity,
-            chunkTextSource: { kind: "chunk", text: chunk.text }
+            chunkTextSource: { kind: "chunk", text: chunks[ci].text }
           });
         }
       }
     } else {
       const messageVector = await readJsonField(message, "vector", ctx.walletAddress);
       if (!messageVector || messageVector.length === 0) continue;
-      const similarity = cosineSimilarity(queryVector, messageVector);
+      const fallback = Float32Array.from(messageVector);
+      chunkCache?.set(message.id, { version, chunks: [], fallback });
+      const similarity = cosineSimilarity(queryVector, fallback);
       if (similarity >= minSimilarity) {
         candidates.push({ message, similarity, chunkTextSource: { kind: "message" } });
       }
@@ -16448,9 +16485,31 @@ async function searchChunksOp(ctx, queryVector, options) {
       })
     )
   );
+  const chunkStateByMsgId = /* @__PURE__ */ new Map();
+  const needsChunkText = /* @__PURE__ */ new Set();
+  for (const c of topK) {
+    if (c.chunkTextSource.kind === "chunk-cached") needsChunkText.add(c.message.id);
+  }
+  await Promise.all(
+    Array.from(needsChunkText, async (id) => {
+      const m = uniqueMessages.get(id);
+      const parsed = await readJsonField(m, "chunks", ctx.walletAddress);
+      const version = Number(m._getRaw("updated_at")) || 0;
+      if (parsed) chunkStateByMsgId.set(id, { version, chunks: parsed });
+    })
+  );
   return topK.map(({ message, similarity, chunkTextSource }) => {
     const stored = { ...storedById.get(message.id) };
-    const chunkText2 = chunkTextSource.kind === "chunk" ? chunkTextSource.text : stored.content;
+    let chunkText2;
+    if (chunkTextSource.kind === "chunk") {
+      chunkText2 = chunkTextSource.text;
+    } else if (chunkTextSource.kind === "chunk-cached") {
+      const state = chunkStateByMsgId.get(message.id);
+      const chunk = state && state.version === chunkTextSource.version ? state.chunks[chunkTextSource.chunkIndex] : void 0;
+      chunkText2 = chunk?.text ?? stored.content;
+    } else {
+      chunkText2 = stored.content;
+    }
     return { chunkText: chunkText2, message: stored, similarity };
   });
 }
@@ -18765,9 +18824,9 @@ function recencyMultiplier(updatedAt, opts = {}) {
   const updatedMs = updatedAt.getTime();
   if (!Number.isFinite(updatedMs)) return noDate;
   const now = opts.now ?? /* @__PURE__ */ new Date();
-  const nowMs = now.getTime();
-  if (!Number.isFinite(nowMs)) return noDate;
-  const ageDays = Math.max(0, (nowMs - updatedMs) / DAY_MS);
+  const nowMs2 = now.getTime();
+  if (!Number.isFinite(nowMs2)) return noDate;
+  const ageDays = Math.max(0, (nowMs2 - updatedMs) / DAY_MS);
   const perYearDecay = opts.perYearDecay ?? DEFAULT_PER_YEAR_DECAY;
   const floor = opts.floor ?? DEFAULT_FLOOR;
   const decay = perYearDecay * (ageDays / 365);
@@ -18785,14 +18844,42 @@ var init_recency = __esm({
 });
 
 // src/lib/memory/reranker.ts
+function isRerankerAvailable() {
+  return available;
+}
+function isModuleMissing(err) {
+  let e = err;
+  for (let depth = 0; depth < 5 && e !== null && e !== void 0; depth++) {
+    const code = e.code;
+    if (code === "ERR_MODULE_NOT_FOUND" || code === "MODULE_NOT_FOUND") return true;
+    if (e instanceof Error && /cannot find (module|package)|failed to resolve|unable to resolve module|requiring unknown module/i.test(
+      e.message
+    )) {
+      return true;
+    }
+    e = e.cause;
+  }
+  return false;
+}
 async function getModel() {
+  if (available === false) throw new RerankerUnavailableError(void 0);
   if (!modelPromise) {
     const load = (async () => {
-      const transformers = await import("@huggingface/transformers");
+      let transformers;
+      try {
+        transformers = await import("@huggingface/transformers");
+      } catch (err) {
+        if (isModuleMissing(err)) {
+          available = false;
+          throw new RerankerUnavailableError(err);
+        }
+        throw err;
+      }
       const [tokenizer, model] = await Promise.all([
         transformers.AutoTokenizer.from_pretrained(MODEL_ID),
         transformers.AutoModelForSequenceClassification.from_pretrained(MODEL_ID)
       ]);
+      available = true;
       return { tokenizer, model };
     })();
     modelPromise = load;
@@ -18834,11 +18921,19 @@ async function rerankPairs(query, items) {
   }
   return items.map((item, i) => ({ id: item.id, content: item.content, score: scores[i] })).sort((a, b) => b.score - a.score);
 }
-var MODEL_ID, modelPromise;
+var MODEL_ID, RerankerUnavailableError, available, modelPromise;
 var init_reranker = __esm({
   "src/lib/memory/reranker.ts"() {
     "use strict";
     MODEL_ID = "Xenova/ms-marco-MiniLM-L-6-v2";
+    RerankerUnavailableError = class extends Error {
+      constructor(reason) {
+        super("cross-encoder reranker unavailable (@huggingface/transformers not installed)");
+        this.name = "RerankerUnavailableError";
+        this.reason = reason;
+      }
+    };
+    available = void 0;
     modelPromise = null;
   }
 });
@@ -19722,22 +19817,67 @@ async function recall(query, ctx, options = {}) {
   const flags = flagsForBudget(requestedBudget);
   const decomposeAvailable = flags.decompose && !!options.decomposeOptions;
   const usedBudget = requestedBudget === "high" && !decomposeAvailable ? "mid" : requestedBudget;
+  const t0 = nowMs();
+  let prepMs = 0;
+  let factLaneMs = 0;
+  let chunkLaneMs = 0;
+  let fuseMs = 0;
+  const factResults = [];
+  const chunkResults = [];
+  let vaultSize;
+  let didRerank = false;
+  let hadV2Head = false;
+  const emitDiagnostics = (candidateCount) => {
+    const cb = options.onDiagnostics;
+    if (!cb) return;
+    const degraded = [];
+    if (flags.rerank && factResults.length > 0 && hadV2Head && !didRerank) {
+      degraded.push("rerank-unavailable");
+    }
+    if (flags.decompose && !decomposeAvailable) degraded.push("decompose-unavailable");
+    const diagnostics = {
+      usedBudget,
+      reranked: didRerank,
+      candidateCount,
+      ...vaultSize !== void 0 && { vaultSize },
+      factCount: factResults.length,
+      chunkCount: chunkResults.length,
+      timings: {
+        total: nowMs() - t0,
+        prep: prepMs,
+        factLane: factLaneMs,
+        chunkLane: chunkLaneMs,
+        fuse: fuseMs
+      },
+      degraded
+    };
+    try {
+      cb(diagnostics);
+    } catch {
+    }
+  };
   if (!query || typeof query !== "string" || query.trim().length === 0) {
+    emitDiagnostics(0);
     return { memories: [], usedBudget, reranked: false, candidateCount: 0 };
   }
   const needsChunkEmbedding = types.includes("chunk") && ctx.storageCtx;
   const wantsTemporal = types.includes("fact") && ctx.vaultCtx;
+  const prepStart = nowMs();
   const [queryEmbedding, entityRanking, temporalRanking] = await Promise.all([
     needsChunkEmbedding ? generateEmbedding(query, ctx.embeddingOptions) : Promise.resolve(void 0),
     buildGraphLaneRanking(query, ctx),
     wantsTemporal ? buildTemporalLaneRanking(query, ctx.vaultCtx, options.now) : Promise.resolve([])
   ]);
-  const factResults = [];
-  const chunkResults = [];
-  let vaultSize;
+  prepMs = nowMs() - prepStart;
   if (types.includes("fact") && ctx.vaultCtx && ctx.vaultCache) {
+    const factStart = nowMs();
     const vaultMinScore = options.minScore ?? DEFAULT_FACT_MIN_SCORE;
-    const { results, vaultSize: size } = await searchVaultMemoriesWithSize(
+    const {
+      results,
+      vaultSize: size,
+      reranked,
+      hadV2Head: v2Head
+    } = await searchVaultMemoriesWithSize(
       query,
       ctx.vaultCtx,
       ctx.embeddingOptions,
@@ -19788,14 +19928,19 @@ async function recall(query, ctx, options = {}) {
       )
     );
     vaultSize = size;
+    didRerank = reranked;
+    hadV2Head = v2Head;
+    factLaneMs = nowMs() - factStart;
   }
   if (types.includes("chunk") && ctx.storageCtx && queryEmbedding) {
+    const chunkStart = nowMs();
     const chunkMinScore = options.minScore ?? DEFAULT_CHUNK_MIN_SCORE;
     const results = await searchChunksOp(ctx.storageCtx, queryEmbedding, {
       limit: types.includes("fact") ? Math.max(limit * 2, 16) : limit,
       minSimilarity: chunkMinScore,
       embeddingModel: ctx.embeddingOptions.model ?? DEFAULT_API_EMBEDDING_MODEL,
-      ...options.conversationId && { conversationId: options.conversationId }
+      ...options.conversationId && { conversationId: options.conversationId },
+      ...ctx.chunkCache && { chunkCache: ctx.chunkCache }
     });
     chunkResults.push(
       ...dedupeBy(
@@ -19805,18 +19950,23 @@ async function recall(query, ctx, options = {}) {
         (r) => r.chunkText.trim()
       )
     );
+    chunkLaneMs = nowMs() - chunkStart;
   }
+  const fuseStart = nowMs();
   if (types.length === 1 || factResults.length === 0 || chunkResults.length === 0) {
     const memories2 = [
       ...factResults.map(toFactMemory),
       ...chunkResults.map(toChunkMemory)
     ];
     memories2.sort((a, b) => b.score - a.score);
+    const candidateCount = factResults.length + chunkResults.length;
+    fuseMs = nowMs() - fuseStart;
+    emitDiagnostics(candidateCount);
     return {
       memories: memories2.slice(0, limit),
       usedBudget,
-      reranked: flags.rerank,
-      candidateCount: factResults.length + chunkResults.length,
+      reranked: didRerank,
+      candidateCount,
       ...vaultSize !== void 0 && { vaultSize }
     };
   }
@@ -19865,10 +20015,12 @@ async function recall(query, ctx, options = {}) {
     suppressed = next;
     memories = selectWith(suppressed);
   }
+  fuseMs = nowMs() - fuseStart;
+  emitDiagnostics(byId.size);
   return {
     memories,
     usedBudget,
-    reranked: flags.rerank,
+    reranked: didRerank,
     candidateCount: byId.size,
     ...vaultSize !== void 0 && { vaultSize }
   };
@@ -19932,7 +20084,7 @@ function toChunkMemory(r) {
     updatedAt: r.message.createdAt
   };
 }
-var DEFAULT_LIMIT, DEFAULT_BUDGET, DEFAULT_FACT_MIN_SCORE, DEFAULT_CHUNK_MIN_SCORE;
+var DEFAULT_LIMIT, DEFAULT_BUDGET, DEFAULT_FACT_MIN_SCORE, nowMs, DEFAULT_CHUNK_MIN_SCORE;
 var init_recall = __esm({
   "src/lib/memory/recall.ts"() {
     "use strict";
@@ -19948,6 +20100,7 @@ var init_recall = __esm({
     DEFAULT_LIMIT = 8;
     DEFAULT_BUDGET = "low";
     DEFAULT_FACT_MIN_SCORE = 0.1;
+    nowMs = () => typeof performance !== "undefined" && typeof performance.now === "function" ? performance.now() : Date.now();
     DEFAULT_CHUNK_MIN_SCORE = 0.5;
   }
 });
@@ -20147,6 +20300,9 @@ async function rankFusedVaultMemoriesAsync(query, queryEmbedding, items, options
     bm25AdmissionDivisor: options?.bm25AdmissionDivisor,
     rrfK: options?.rrfK
   });
+  if (options?.v2HeadStats) {
+    options.v2HeadStats.hadResults = v2Ranked.length > 0;
+  }
   let combined;
   let tailSlice = [];
   if (options?.rerank) {
@@ -20167,8 +20323,13 @@ async function rankFusedVaultMemoriesAsync(query, queryEmbedding, items, options
         return { ...r, similarity: v2 * (1 + ceWeight * ce) };
       });
       combined.sort((a, b) => b.similarity - a.similarity);
+      if (headSlice.length > 0 && options.rerankStats) options.rerankStats.applied = true;
     } catch (err) {
-      getLogger().warn("[memory/search] cross-encoder rerank failed; using V2 ranking", err);
+      if (err instanceof RerankerUnavailableError) {
+        getLogger().debug("[memory/search] cross-encoder unavailable; using V2 ranking");
+      } else {
+        getLogger().warn("[memory/search] cross-encoder rerank failed; using V2 ranking", err);
+      }
       combined = v2Ranked;
     }
   } else {
@@ -20302,6 +20463,9 @@ async function rankComposite(originalQuery, originalQueryEmbedding, subQueries,
     (r) => r !== null
   );
   combined.sort((a, b) => b.similarity - a.similarity);
+  if (options?.v2HeadStats) {
+    options.v2HeadStats.hadResults = combined.length > 0;
+  }
   if (options?.includeUnrankedTail) {
     const fusedIds = new Set(combined.map((r) => r.uniqueId));
     for (const item of items) {
@@ -20337,11 +20501,16 @@ async function rankComposite(originalQuery, originalQueryEmbedding, subQueries,
       }));
       head.sort((a, b) => b.similarity - a.similarity);
       combined = [...head, ...tailSlice];
+      if (headSlice.length > 0 && options.rerankStats) options.rerankStats.applied = true;
     } catch (err) {
-      getLogger().warn(
-        "[memory/search] composite cross-encoder rerank failed; using fused ranking",
-        err
-      );
+      if (err instanceof RerankerUnavailableError) {
+        getLogger().debug("[memory/search] cross-encoder unavailable; using fused ranking");
+      } else {
+        getLogger().warn(
+          "[memory/search] composite cross-encoder rerank failed; using fused ranking",
+          err
+        );
+      }
     }
   }
   if (options?.mmr) {
@@ -20433,7 +20602,7 @@ async function searchVaultMemoriesWithSize(query, vaultCtx, embeddingOptions, ca
   const minSimilarity = searchOptions?.minSimilarity ?? 0.1;
   const scopes = searchOptions?.scopes;
   if (!query || typeof query !== "string") {
-    return { results: [], vaultSize: 0 };
+    return { results: [], vaultSize: 0, reranked: false, hadV2Head: false };
   }
   const folderId = searchOptions?.folderId;
   const queryOpts = {};
@@ -20450,7 +20619,7 @@ async function searchVaultMemoriesWithSize(query, vaultCtx, embeddingOptions, ca
     );
   }
   if (memories.length === 0) {
-    return { results: [], vaultSize: loaded.length };
+    return { results: [], vaultSize: loaded.length, reranked: false, hadV2Head: false };
   }
   const queryEmbedding = await generateEmbedding(query, embeddingOptions);
   const currentModel = embeddingOptions.model ?? DEFAULT_API_EMBEDDING_MODEL;
@@ -20526,12 +20695,18 @@ async function searchVaultMemoriesWithSize(query, vaultCtx, embeddingOptions, ca
     memories.map((m) => [m.uniqueId, { createdAt: m.createdAt, updatedAt: m.updatedAt }])
   );
   const stampTimestamps = (out) => {
-    out.results = out.results.map((r) => {
+    const results2 = out.results.map((r) => {
       const ts = timestampById.get(r.uniqueId);
       return ts ? { ...r, createdAt: ts.createdAt, updatedAt: ts.updatedAt } : r;
     });
-    return out;
+    return {
+      results: results2,
+      vaultSize: out.vaultSize,
+      reranked: out.reranked ?? false,
+      hadV2Head: out.hadV2Head ?? false
+    };
   };
+  const rerankStats = { applied: false };
   const useFusion = searchOptions?.useFusion ?? true;
   const tuning = {
     ...searchOptions?.recencyAlpha !== void 0 && { recencyAlpha: searchOptions.recencyAlpha },
@@ -20558,6 +20733,7 @@ async function searchVaultMemoriesWithSize(query, vaultCtx, embeddingOptions, ca
         query: sq,
         embedding: subEmbeddings[i]
       }));
+      const v2HeadStats = { hadResults: false };
       const composite = await rankComposite(query, queryEmbedding, subQueries, embeddedItems, {
         limit,
         minSimilarity,
@@ -20569,12 +20745,20 @@ async function searchVaultMemoriesWithSize(query, vaultCtx, embeddingOptions, ca
         ...searchOptions.mmr !== void 0 && { mmr: searchOptions.mmr },
         ...tuning,
         ...searchOptions.entityRanking && { entityRanking: searchOptions.entityRanking },
-        ...searchOptions.temporalRanking && { temporalRanking: searchOptions.temporalRanking }
+        ...searchOptions.temporalRanking && { temporalRanking: searchOptions.temporalRanking },
+        rerankStats,
+        v2HeadStats
+      });
+      return stampTimestamps({
+        results: composite,
+        vaultSize: loaded.length,
+        reranked: rerankStats.applied,
+        hadV2Head: v2HeadStats.hadResults
       });
-      return stampTimestamps({ results: composite, vaultSize: loaded.length });
     }
   }
   if (useFusion && searchOptions?.rerank) {
+    const v2HeadStats = { hadResults: false };
     const results2 = await rankFusedVaultMemoriesAsync(query, queryEmbedding, embeddedItems, {
       limit,
       minSimilarity,
@@ -20586,9 +20770,16 @@ async function searchVaultMemoriesWithSize(query, vaultCtx, embeddingOptions, ca
       ...searchOptions.mmr !== void 0 && { mmr: searchOptions.mmr },
       ...tuning,
       ...searchOptions.entityRanking && { entityRanking: searchOptions.entityRanking },
-      ...searchOptions.temporalRanking && { temporalRanking: searchOptions.temporalRanking }
+      ...searchOptions.temporalRanking && { temporalRanking: searchOptions.temporalRanking },
+      rerankStats,
+      v2HeadStats
+    });
+    return stampTimestamps({
+      results: results2,
+      vaultSize: loaded.length,
+      reranked: rerankStats.applied,
+      hadV2Head: v2HeadStats.hadResults
     });
-    return stampTimestamps({ results: results2, vaultSize: loaded.length });
   }
   if (useFusion) {
     const results2 = rankFusedVaultMemories(query, queryEmbedding, embeddedItems, {
@@ -20598,7 +20789,7 @@ async function searchVaultMemoriesWithSize(query, vaultCtx, embeddingOptions, ca
       ...searchOptions?.entityRanking && { entityRanking: searchOptions.entityRanking },
       ...searchOptions?.temporalRanking && { temporalRanking: searchOptions.temporalRanking }
     });
-    return stampTimestamps({ results: results2, vaultSize: loaded.length });
+    return stampTimestamps({ results: results2, vaultSize: loaded.length, hadV2Head: results2.length > 0 });
   }
   const results = rankVaultMemories(query, queryEmbedding, embeddedItems, {
     limit,
@@ -20610,7 +20801,7 @@ async function searchVaultMemoriesWithSize(query, vaultCtx, embeddingOptions, ca
       supersessionWindow: searchOptions.supersessionWindow
     }
   });
-  return stampTimestamps({ results, vaultSize: loaded.length });
+  return stampTimestamps({ results, vaultSize: loaded.length, hadV2Head: results.length > 0 });
 }
 async function searchVaultMemories(query, vaultCtx, embeddingOptions, cache, searchOptions) {
   const { results } = await searchVaultMemoriesWithSize(
@@ -21560,6 +21751,7 @@ __export(index_exports, {
   DEFAULT_ANALYSIS_PROMPT: () => DEFAULT_ANALYSIS_PROMPT,
   DEFAULT_ANALYZE_AFTER_MESSAGES: () => DEFAULT_ANALYZE_AFTER_MESSAGES,
   DEFAULT_CACHE_EXPIRATION_MS: () => DEFAULT_CACHE_EXPIRATION_MS,
+  DEFAULT_CHUNK_CACHE_SIZE: () => DEFAULT_CHUNK_CACHE_SIZE,
   DEFAULT_CHUNK_OVERLAP: () => DEFAULT_CHUNK_OVERLAP,
   DEFAULT_CHUNK_SIZE: () => DEFAULT_CHUNK_SIZE,
   DEFAULT_DOCUMENT_PATTERN: () => DEFAULT_DOCUMENT_PATTERN,
@@ -21590,6 +21782,7 @@ __export(index_exports, {
   QueueManager: () => QueueManager,
   RECALL_MAX_LIMIT: () => RECALL_MAX_LIMIT,
   RECALL_TOOL_NAME: () => RECALL_TOOL_NAME,
+  RerankerUnavailableError: () => RerankerUnavailableError,
   SDK_SCHEMA_VERSION: () => SDK_SCHEMA_VERSION,
   SERVER_TOOL_DEPENDENCY_SETS: () => SERVER_TOOL_DEPENDENCY_SETS,
   SLIDER_CONFIG: () => SLIDER_CONFIG,
@@ -21631,6 +21824,7 @@ __export(index_exports, {
   clearServerToolsCache: () => clearServerToolsCache,
   composeHooks: () => composeHooks,
   createAutoExtractor: () => createAutoExtractor,
+  createChunkVectorCache: () => createChunkVectorCache,
   createConversationOp: () => createConversationOp,
   createCryptoPricePreProcessor: () => createCryptoPricePreProcessor,
   createMediaBatchOp: () => createMediaBatchOp,
@@ -21736,6 +21930,7 @@ __export(index_exports, {
   hardDeleteMediaOp: () => hardDeleteMediaOp,
   hasEncryptionKey: () => hasEncryptionKey,
   hasKeyPair: () => hasKeyPair,
+  isRerankerAvailable: () => isRerankerAvailable,
   isSupportedFile: () => isSupportedFile,
   isSupportedMediaType: () => isSupportedMediaType,
   makeSyntheticStoredConversation: () => makeSyntheticStoredConversation,
@@ -26484,6 +26679,13 @@ function createAutoExtractor(options) {
   };
 }
 
+// src/lib/memory/chunkVectorCache.ts
+init_lruCache();
+var DEFAULT_CHUNK_CACHE_SIZE = 5e3;
+function createChunkVectorCache(maxSize = DEFAULT_CHUNK_CACHE_SIZE) {
+  return new LRUCache(maxSize);
+}
+
 // src/lib/memory/index.ts
 init_recall();
 
@@ -26748,6 +26950,9 @@ function parseAnswer(body, base, parseSchema) {
   };
 }
 
+// src/lib/memory/index.ts
+init_reranker();
+
 // src/lib/memory/topicExtract.ts
 init_operations2();
 init_operations3();
@@ -32459,6 +32664,7 @@ function buildSystemPrompt(ctx, options) {
   DEFAULT_ANALYSIS_PROMPT,
   DEFAULT_ANALYZE_AFTER_MESSAGES,
   DEFAULT_CACHE_EXPIRATION_MS,
+  DEFAULT_CHUNK_CACHE_SIZE,
   DEFAULT_CHUNK_OVERLAP,
   DEFAULT_CHUNK_SIZE,
   DEFAULT_DOCUMENT_PATTERN,
@@ -32489,6 +32695,7 @@ function buildSystemPrompt(ctx, options) {
   QueueManager,
   RECALL_MAX_LIMIT,
   RECALL_TOOL_NAME,
+  RerankerUnavailableError,
   SDK_SCHEMA_VERSION,
   SERVER_TOOL_DEPENDENCY_SETS,
   SLIDER_CONFIG,
@@ -32530,6 +32737,7 @@ function buildSystemPrompt(ctx, options) {
   clearServerToolsCache,
   composeHooks,
   createAutoExtractor,
+  createChunkVectorCache,
   createConversationOp,
   createCryptoPricePreProcessor,
   createMediaBatchOp,
@@ -32635,6 +32843,7 @@ function buildSystemPrompt(ctx, options) {
   hardDeleteMediaOp,
   hasEncryptionKey,
   hasKeyPair,
+  isRerankerAvailable,
   isSupportedFile,
   isSupportedMediaType,
   makeSyntheticStoredConversation,