@anuma/sdk 2.3.1 → 2.4.1

package/dist/expo/{chunk-SF5AYTXH.mjs → chunk-UOUJUZM4.mjs}

@@ -1483,7 +1483,13 @@ async function readJsonField(model, column, walletAddress) {
   }
 }
 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(Q.where("is_deleted", false)).fetch();
   const activeConversationIds = new Set(
     // Use _getRaw for reliable raw column access
@@ -1503,23 +1509,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" } });
       }
@@ -1546,9 +1583,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 };
   });
 }
@@ -3685,9 +3744,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);
@@ -3696,15 +3755,51 @@ function recencyMultiplier(updatedAt, opts = {}) {
 
 // src/lib/memory/reranker.ts
 var MODEL_ID = "Xenova/ms-marco-MiniLM-L-6-v2";
+var RerankerUnavailableError = class extends Error {
+  constructor(reason) {
+    super("cross-encoder reranker unavailable (@huggingface/transformers not installed)");
+    this.name = "RerankerUnavailableError";
+    this.reason = reason;
+  }
+};
+var available = void 0;
 var modelPromise = null;
+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;
@@ -4265,6 +4360,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) {
@@ -4285,8 +4383,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 {
@@ -4420,6 +4523,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) {
@@ -4455,11 +4561,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) {
@@ -4551,7 +4662,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 = {};
@@ -4568,7 +4679,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;
@@ -4644,12 +4755,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 },
@@ -4676,6 +4793,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,
@@ -4687,12 +4805,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,
@@ -4704,9 +4830,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, {
@@ -4716,7 +4849,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,
@@ -4728,7 +4861,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(
@@ -4817,7 +4950,7 @@ function createMemoryVaultSearchTool(vaultCtx, embeddingOptions, cache, searchOp
             legacy.map((r) => ({ id: r.uniqueId, content: r.content, score: r.similarity }))
           );
         }
-        const { recall: recall2 } = await import("./recall-PCKDVF3U.mjs");
+        const { recall: recall2 } = await import("./recall-HI7VO3VM.mjs");
         const result = await recall2(
           query,
           { vaultCtx, embeddingOptions, vaultCache: cache },
@@ -5135,6 +5268,7 @@ function scoreEventTimeOverlap(memoryStart, memoryEnd, memoryKind, window2) {
 var DEFAULT_LIMIT = 8;
 var DEFAULT_BUDGET = "low";
 var DEFAULT_FACT_MIN_SCORE = 0.1;
+var nowMs = () => typeof performance !== "undefined" && typeof performance.now === "function" ? performance.now() : Date.now();
 var DEFAULT_CHUNK_MIN_SCORE = 0.5;
 function flagsForBudget(budget) {
   switch (budget) {
@@ -5167,22 +5301,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,
@@ -5233,14 +5412,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(
@@ -5250,18 +5434,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 }
     };
   }
@@ -5310,10 +5499,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 }
   };
@@ -5456,7 +5647,10 @@ export {
   stampTopicsExtractedAtOp,
   deleteAllVaultMemoriesForUserOp,
   updateVaultMemoryEmbeddingOp,
+  RerankerUnavailableError,
+  isRerankerAvailable,
   DEFAULT_VAULT_CACHE_SIZE,
+  LRUCache,
   createVaultEmbeddingCache,
   recall,
   preEmbedVaultMemories,