@anuma/sdk 3.8.5 → 3.9.1

package/dist/server/{chunk-FS56IDOW.mjs → chunk-QC4WHNIJ.mjs}

@@ -16583,6 +16583,85 @@ async function getAllVaultMemoriesOp(ctx, options) {
     (raw) => vaultMemoryRawToStored(raw, ctx.walletAddress, ctx.signMessage, ctx.embeddedWalletSigner)
   );
 }
+function baseVaultSql(ctx) {
+  const clauses = [
+    '"is_deleted" = 0',
+    '"archived_at" is null',
+    `"trust_tier" is not 'quarantined'`,
+    '"superseded_by" is null'
+  ];
+  const args = [];
+  if (ctx.userId !== void 0) {
+    clauses.push('"user_id" = ?');
+    args.push(ctx.userId);
+  }
+  return { sql: clauses.join(" and "), args };
+}
+async function getVaultCandidateKeysOp(ctx, options) {
+  const mapRaw = (raw) => ({
+    uniqueId: raw.id,
+    folderId: raw.folder_id ?? null,
+    scope: raw.scope ?? "",
+    embeddingModel: raw.embedding_model ?? null,
+    updatedAt: new Date(raw.updated_at)
+  });
+  try {
+    const base = baseVaultSql(ctx);
+    const clauses = [base.sql];
+    const args = [...base.args];
+    if (options?.scopes?.length) {
+      clauses.push(`"scope" in (${options.scopes.map(() => "?").join(",")})`);
+      args.push(...options.scopes);
+    }
+    if (options?.folderId !== void 0) {
+      clauses.push(options.folderId === null ? '"folder_id" is null' : '"folder_id" = ?');
+      if (options.folderId !== null) args.push(options.folderId);
+    }
+    const sql = `select "id", "scope", "folder_id", "embedding_model", "updated_at" from "memory_vault" where ${clauses.join(" and ")}`;
+    const rows = await ctx.vaultMemoryCollection.query(import_watermelondb3.Q.unsafeSqlQuery(sql, args)).unsafeFetchRaw();
+    return rows.map(mapRaw);
+  } catch (err) {
+    getLogger().debug(
+      "memoryVault: getVaultCandidateKeysOp projected SQL unavailable, using full-load fallback: " + (err instanceof Error ? err.message : String(err))
+    );
+    const conditions = [
+      ...baseVaultConditions(ctx),
+      ...options?.scopes?.length ? [import_watermelondb3.Q.where("scope", import_watermelondb3.Q.oneOf(options.scopes))] : [],
+      ...options?.folderId !== void 0 ? [import_watermelondb3.Q.where("folder_id", options.folderId)] : []
+    ];
+    const rows = await ctx.vaultMemoryCollection.query(...conditions).unsafeFetchRaw();
+    return rows.map(mapRaw);
+  }
+}
+async function getVaultEmbeddingsByIdsOp(ctx, ids) {
+  if (ids.length === 0) return [];
+  const mapRaw = (raw) => ({
+    uniqueId: raw.id,
+    embedding: raw.embedding ?? null,
+    embeddingModel: raw.embedding_model ?? null
+  });
+  try {
+    const base = baseVaultSql(ctx);
+    const sql = `select "id", "embedding", "embedding_model" from "memory_vault" where ${base.sql} and "id" in (${ids.map(() => "?").join(",")})`;
+    const rows = await ctx.vaultMemoryCollection.query(import_watermelondb3.Q.unsafeSqlQuery(sql, [...base.args, ...ids])).unsafeFetchRaw();
+    return rows.map(mapRaw);
+  } catch (err) {
+    getLogger().debug(
+      "memoryVault: getVaultEmbeddingsByIdsOp projected SQL unavailable, using full-load fallback: " + (err instanceof Error ? err.message : String(err))
+    );
+    const rows = await ctx.vaultMemoryCollection.query(...baseVaultConditions(ctx), import_watermelondb3.Q.where("id", import_watermelondb3.Q.oneOf(ids))).unsafeFetchRaw();
+    return rows.map(mapRaw);
+  }
+}
+async function getVaultMemoriesByIdsOp(ctx, ids) {
+  if (ids.length === 0) return [];
+  const conditions = [...baseVaultConditions(ctx), import_watermelondb3.Q.where("id", import_watermelondb3.Q.oneOf(ids))];
+  const results = await ctx.vaultMemoryCollection.query(...conditions).unsafeFetchRaw();
+  return mapInBatches(
+    results,
+    (raw) => vaultMemoryRawToStored(raw, ctx.walletAddress, ctx.signMessage, ctx.embeddedWalletSigner)
+  );
+}
 async function getAllVaultMemoryContentsOp(ctx, options) {
   const results = await ctx.vaultMemoryCollection.query(...baseVaultConditions(ctx, options)).unsafeFetchRaw();
   return mapInBatches(results, async (raw) => {
@@ -19262,80 +19341,97 @@ async function eagerEmbedContent(content, embeddingOptions, cache, vaultCtx, mem
     );
   }
 }
-async function searchVaultMemoriesWithSize(query, vaultCtx, embeddingOptions, cache, searchOptions) {
-  const limit = searchOptions?.limit ?? 5;
-  const minSimilarity = searchOptions?.minSimilarity ?? 0.1;
-  const scopes = searchOptions?.scopes;
-  if (!query || typeof query !== "string") {
-    return { results: [], vaultSize: 0, reranked: false, hadV2Head: false };
-  }
-  const folderId = searchOptions?.folderId;
-  const queryOpts = {};
-  if (scopes?.length) queryOpts.scopes = scopes;
-  if (folderId !== void 0) queryOpts.folderId = folderId;
-  if (searchOptions?.factTypes?.length) queryOpts.factTypes = searchOptions.factTypes;
-  if (searchOptions?.includeArchived) queryOpts.includeArchived = true;
-  const loaded = await getAllVaultMemoriesOp(
+function admitVaultProjections(queryEmbedding, vectored, k) {
+  return vectored.map((it) => ({ it, score: cosineSimilarity(queryEmbedding, it.embedding) })).sort((a, b) => b.score - a.score || b.it.updatedAt.getTime() - a.it.updatedAt.getTime()).slice(0, k).map((s) => s.it.uniqueId);
+}
+async function buildProjectedCorpus(query, vaultCtx, embeddingOptions, cache, queryOpts, opts) {
+  const keys = await getVaultCandidateKeysOp(
     vaultCtx,
     Object.keys(queryOpts).length > 0 ? queryOpts : void 0
   );
-  const memories = loaded.filter((m) => !isEncrypted(m.content));
-  if (memories.length < loaded.length) {
-    getLogger().warn(
-      `memoryVault: ${loaded.length - memories.length}/${loaded.length} memories still encrypted (key unavailable?) \u2014 excluded from search`
-    );
-  }
-  if (memories.length === 0) {
-    return { results: [], vaultSize: loaded.length, reranked: false, hadV2Head: false };
+  const vaultSize = keys.length;
+  if (keys.length === 0) {
+    return { memories: [], embeddedItems: [], queryEmbedding: [], vaultSize: 0 };
   }
   const queryEmbedding = await generateEmbedding(query, embeddingOptions);
   const currentModel = embeddingOptions.model ?? DEFAULT_API_EMBEDDING_MODEL;
-  const uncachedTexts = [];
-  const uncachedIndices = [];
-  let staleReembedCount = 0;
-  for (let i = 0; i < memories.length; i++) {
-    const content = memories[i].content;
-    const memoryId = memories[i].uniqueId;
-    const cached = cache.get(memoryId);
-    if (cached && cached.length === queryEmbedding.length) continue;
-    if (cached) cache.delete(memoryId);
-    const storedModel = memories[i].embeddingModel;
-    const modelCompatible = (storedModel ?? currentModel) === currentModel;
-    if (memories[i].embedding && modelCompatible) {
+  const vectored = [];
+  const missIds = [];
+  const noVectorIds = [];
+  const keyById = new Map(keys.map((k2) => [k2.uniqueId, k2]));
+  for (const k2 of keys) {
+    const cached = cache.get(k2.uniqueId);
+    if (cached && cached.length === queryEmbedding.length) {
+      vectored.push({ uniqueId: k2.uniqueId, embedding: cached, updatedAt: k2.updatedAt });
+      continue;
+    }
+    const modelCompatible = (k2.embeddingModel ?? currentModel) === currentModel;
+    if (modelCompatible) missIds.push(k2.uniqueId);
+    else noVectorIds.push(k2.uniqueId);
+  }
+  if (missIds.length > 0) {
+    const rows = await getVaultEmbeddingsByIdsOp(vaultCtx, missIds);
+    const gotVector = /* @__PURE__ */ new Set();
+    for (const r of rows) {
+      if (!r.embedding) continue;
       try {
-        const parsed = JSON.parse(memories[i].embedding);
+        const parsed = JSON.parse(r.embedding);
         if (Array.isArray(parsed) && parsed.length === queryEmbedding.length) {
-          cache.set(memoryId, Float32Array.from(parsed));
-          continue;
+          const vec = Float32Array.from(parsed);
+          cache.set(r.uniqueId, vec);
+          const k2 = keyById.get(r.uniqueId);
+          vectored.push({ uniqueId: r.uniqueId, embedding: vec, updatedAt: k2.updatedAt });
+          gotVector.add(r.uniqueId);
         }
       } catch {
       }
     }
-    if (memories[i].embedding && !modelCompatible) staleReembedCount++;
-    uncachedTexts.push(content);
-    uncachedIndices.push(i);
+    for (const id of missIds) if (!gotVector.has(id)) noVectorIds.push(id);
   }
-  if (staleReembedCount > 0) {
-    getLogger().warn(
-      `memoryVault: re-embedding ${staleReembedCount} memories whose stored embedding model differs from the current model (${currentModel}) \u2014 embedding-model change detected`
+  if (noVectorIds.length > 0) {
+    const laneIds = noVectorIds.slice(0, opts.unembeddedCap);
+    if (noVectorIds.length > laneIds.length) {
+      getLogger().warn(
+        `memoryVault: projected search un-embedded lane capped at ${laneIds.length}/${noVectorIds.length}`
+      );
+    }
+    const laneRows = (await getVaultMemoriesByIdsOp(vaultCtx, laneIds)).filter(
+      (m) => !isEncrypted(m.content)
     );
-  }
-  if (uncachedTexts.length > 0) {
-    const newEmbeddings = await generateEmbeddings(uncachedTexts, embeddingOptions);
-    for (let j = 0; j < uncachedTexts.length; j++) {
-      cache.set(memories[uncachedIndices[j]].uniqueId, Float32Array.from(newEmbeddings[j]));
-      updateVaultMemoryEmbeddingOp(
-        vaultCtx,
-        memories[uncachedIndices[j]].uniqueId,
-        JSON.stringify(newEmbeddings[j]),
-        currentModel
-      ).catch(
-        // Silently swallow – SDK must not use console.*; embedding will be retried on next search
-        () => {
-        }
+    if (laneRows.length > 0) {
+      const laneVecs = await generateEmbeddings(
+        laneRows.map((m) => m.content),
+        embeddingOptions
       );
+      laneRows.forEach((m, i) => {
+        const vec = Float32Array.from(laneVecs[i]);
+        cache.set(m.uniqueId, vec);
+        vectored.push({ uniqueId: m.uniqueId, embedding: vec, updatedAt: m.updatedAt });
+        updateVaultMemoryEmbeddingOp(
+          vaultCtx,
+          m.uniqueId,
+          JSON.stringify(laneVecs[i]),
+          currentModel
+        ).catch(() => {
+        });
+      });
+    }
+  }
+  const k = Math.max(opts.limit * opts.admitFactor, opts.admitFloor);
+  const admittedIds = admitVaultProjections(queryEmbedding, vectored, k);
+  const admissionSet = new Set(admittedIds);
+  if (opts.forceIncludeIds) {
+    for (const id of opts.forceIncludeIds) {
+      if (keyById.has(id)) admissionSet.add(id);
     }
   }
+  const admittedRows = await getVaultMemoriesByIdsOp(vaultCtx, [...admissionSet]);
+  const memories = admittedRows.filter((m) => !isEncrypted(m.content));
+  if (memories.length < admittedRows.length) {
+    getLogger().warn(
+      `memoryVault: ${admittedRows.length - memories.length}/${admittedRows.length} admitted memories still encrypted (key unavailable?) \u2014 excluded from projected search`
+    );
+  }
   const embeddedItems = memories.map((m) => ({
     id: m.uniqueId,
     content: m.content,
@@ -19350,6 +19446,125 @@ async function searchVaultMemoriesWithSize(query, vaultCtx, embeddingOptions, ca
     eventTimeKind: normalizeEventTimeKind(m.eventTimeKind),
     factType: m.factType
   }));
+  return { memories, embeddedItems, queryEmbedding, vaultSize };
+}
+async function searchVaultMemoriesWithSize(query, vaultCtx, embeddingOptions, cache, searchOptions) {
+  const limit = searchOptions?.limit ?? 5;
+  const minSimilarity = searchOptions?.minSimilarity ?? 0.1;
+  const scopes = searchOptions?.scopes;
+  if (!query || typeof query !== "string") {
+    return { results: [], vaultSize: 0, reranked: false, hadV2Head: false };
+  }
+  const folderId = searchOptions?.folderId;
+  const queryOpts = {};
+  if (scopes?.length) queryOpts.scopes = scopes;
+  if (folderId !== void 0) queryOpts.folderId = folderId;
+  if (searchOptions?.factTypes?.length) queryOpts.factTypes = searchOptions.factTypes;
+  if (searchOptions?.includeArchived) queryOpts.includeArchived = true;
+  const ADMIT_FACTOR = searchOptions?.admitFactor ?? 3;
+  const ADMIT_FLOOR = searchOptions?.admitFloor ?? 30;
+  const UNEMBEDDED_CAP = 200;
+  let memories;
+  let embeddedItems;
+  let queryEmbedding;
+  let vaultSize;
+  if (searchOptions?.decryptLast) {
+    const forceIncludeIds = [
+      ...searchOptions.entityRanking ?? [],
+      ...searchOptions.temporalRanking ?? []
+    ];
+    const corpus = await buildProjectedCorpus(query, vaultCtx, embeddingOptions, cache, queryOpts, {
+      limit,
+      admitFactor: ADMIT_FACTOR,
+      admitFloor: ADMIT_FLOOR,
+      unembeddedCap: UNEMBEDDED_CAP,
+      ...forceIncludeIds.length > 0 && { forceIncludeIds }
+    });
+    if (corpus.vaultSize === 0) {
+      return { results: [], vaultSize: 0, reranked: false, hadV2Head: false };
+    }
+    ({ memories, embeddedItems, queryEmbedding, vaultSize } = corpus);
+    if (memories.length === 0) {
+      return { results: [], vaultSize, reranked: false, hadV2Head: false };
+    }
+  } else {
+    const loaded = await getAllVaultMemoriesOp(
+      vaultCtx,
+      Object.keys(queryOpts).length > 0 ? queryOpts : void 0
+    );
+    vaultSize = loaded.length;
+    memories = loaded.filter((m) => !isEncrypted(m.content));
+    if (memories.length < loaded.length) {
+      getLogger().warn(
+        `memoryVault: ${loaded.length - memories.length}/${loaded.length} memories still encrypted (key unavailable?) \u2014 excluded from search`
+      );
+    }
+    if (memories.length === 0) {
+      return { results: [], vaultSize: loaded.length, reranked: false, hadV2Head: false };
+    }
+    queryEmbedding = await generateEmbedding(query, embeddingOptions);
+    const currentModel = embeddingOptions.model ?? DEFAULT_API_EMBEDDING_MODEL;
+    const uncachedTexts = [];
+    const uncachedIndices = [];
+    let staleReembedCount = 0;
+    for (let i = 0; i < memories.length; i++) {
+      const content = memories[i].content;
+      const memoryId = memories[i].uniqueId;
+      const cached = cache.get(memoryId);
+      if (cached && cached.length === queryEmbedding.length) continue;
+      if (cached) cache.delete(memoryId);
+      const storedModel = memories[i].embeddingModel;
+      const modelCompatible = (storedModel ?? currentModel) === currentModel;
+      if (memories[i].embedding && modelCompatible) {
+        try {
+          const parsed = JSON.parse(memories[i].embedding);
+          if (Array.isArray(parsed) && parsed.length === queryEmbedding.length) {
+            cache.set(memoryId, Float32Array.from(parsed));
+            continue;
+          }
+        } catch {
+        }
+      }
+      if (memories[i].embedding && !modelCompatible) staleReembedCount++;
+      uncachedTexts.push(content);
+      uncachedIndices.push(i);
+    }
+    if (staleReembedCount > 0) {
+      getLogger().warn(
+        `memoryVault: re-embedding ${staleReembedCount} memories whose stored embedding model differs from the current model (${currentModel}) \u2014 embedding-model change detected`
+      );
+    }
+    if (uncachedTexts.length > 0) {
+      const newEmbeddings = await generateEmbeddings(uncachedTexts, embeddingOptions);
+      for (let j = 0; j < uncachedTexts.length; j++) {
+        cache.set(memories[uncachedIndices[j]].uniqueId, Float32Array.from(newEmbeddings[j]));
+        updateVaultMemoryEmbeddingOp(
+          vaultCtx,
+          memories[uncachedIndices[j]].uniqueId,
+          JSON.stringify(newEmbeddings[j]),
+          currentModel
+        ).catch(
+          // Silently swallow – SDK must not use console.*; embedding will be retried on next search
+          () => {
+          }
+        );
+      }
+    }
+    embeddedItems = memories.map((m) => ({
+      id: m.uniqueId,
+      content: m.content,
+      embedding: cache.get(m.uniqueId) ?? [],
+      createdAt: m.createdAt,
+      updatedAt: m.updatedAt,
+      proofCount: m.proofCount,
+      lastObservedAt: m.lastObservedAt,
+      eventTimeStart: m.eventTimeStart,
+      sourceChunkIds: m.sourceChunkIds,
+      eventTimeEnd: m.eventTimeEnd,
+      eventTimeKind: normalizeEventTimeKind(m.eventTimeKind),
+      factType: m.factType
+    }));
+  }
   if (queryEmbedding.length > 0) {
     const mismatched = embeddedItems.filter(
       (it) => it.embedding.length > 0 && it.embedding.length !== queryEmbedding.length
@@ -19435,7 +19650,7 @@ async function searchVaultMemoriesWithSize(query, vaultCtx, embeddingOptions, ca
       });
       return stampTimestamps({
         results: composite,
-        vaultSize: loaded.length,
+        vaultSize,
         reranked: rerankStats.applied,
         hadV2Head: v2HeadStats.hadResults
       });
@@ -19460,7 +19675,7 @@ async function searchVaultMemoriesWithSize(query, vaultCtx, embeddingOptions, ca
     });
     return stampTimestamps({
       results: results2,
-      vaultSize: loaded.length,
+      vaultSize,
       reranked: rerankStats.applied,
       hadV2Head: v2HeadStats.hadResults
     });
@@ -19473,7 +19688,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, hadV2Head: results2.length > 0 });
+    return stampTimestamps({ results: results2, vaultSize, hadV2Head: results2.length > 0 });
   }
   const results = rankVaultMemories(query, queryEmbedding, embeddedItems, {
     limit,
@@ -19485,7 +19700,7 @@ async function searchVaultMemoriesWithSize(query, vaultCtx, embeddingOptions, ca
       supersessionWindow: searchOptions.supersessionWindow
     }
   });
-  return stampTimestamps({ results, vaultSize: loaded.length, hadV2Head: results.length > 0 });
+  return stampTimestamps({ results, vaultSize, hadV2Head: results.length > 0 });
 }
 async function searchVaultMemories(query, vaultCtx, embeddingOptions, cache, searchOptions) {
   const { results } = await searchVaultMemoriesWithSize(
@@ -19574,7 +19789,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-VDMDNQNB.mjs");
+        const { recall: recall2 } = await import("./recall-NLJNELJY.mjs");
         const result = await recall2(
           query,
           { vaultCtx, embeddingOptions, vaultCache: cache },
@@ -20221,6 +20436,7 @@ async function recall(query, ctx, options = {}) {
           bm25AdmissionDivisor: options.bm25AdmissionDivisor
         },
         ...options.rrfK !== void 0 && { rrfK: options.rrfK },
+        ...options.decryptLast !== void 0 && { decryptLast: options.decryptLast },
         ...decomposeAvailable && {
           decompose: "llm",
           decomposeOptions: options.decomposeOptions