@anuma/sdk 3.8.2 → 3.8.4

package/dist/expo/index.mjs

@@ -108,7 +108,7 @@ import {
   upsertMessageOp,
   useEncryption,
   vaultMemoryToStored
-} from "./chunk-IFZZQPRO.mjs";
+} from "./chunk-42Y42CAZ.mjs";
 import {
   PII_PATTERNS,
   PiiRedactor,
@@ -5930,6 +5930,162 @@ var WalletPoller = class {
 // src/lib/memory/autoExtract.ts
 import { Q as Q3 } from "@nozbe/watermelondb";
 
+// src/lib/memory/entitySalience.ts
+var GENERIC_ENTITY_NAMES = /* @__PURE__ */ new Set([
+  // Relative and absolute time
+  "today",
+  "tomorrow",
+  "yesterday",
+  "tonight",
+  "morning",
+  "afternoon",
+  "evening",
+  "night",
+  "day",
+  "date",
+  "time",
+  "week",
+  "weekend",
+  "weekday",
+  "month",
+  "year",
+  "monday",
+  "tuesday",
+  "wednesday",
+  "thursday",
+  "friday",
+  "saturday",
+  "sunday",
+  "january",
+  "february",
+  "march",
+  "april",
+  "may",
+  "june",
+  "july",
+  "august",
+  "september",
+  "october",
+  "november",
+  "december",
+  // Generic containers and venues — the named ones ("Blue Bottle on Valencia",
+  // "Stanford") are unaffected because they are not bare tokens.
+  "home",
+  "house",
+  "apartment",
+  "room",
+  "office",
+  "work",
+  "workplace",
+  "school",
+  "gym",
+  "store",
+  "shop",
+  "hospital",
+  "airport",
+  "hotel",
+  "city",
+  "town",
+  "country",
+  "place",
+  // Generic calendar entries — "Chicago Marathon" survives, "meeting" doesn't.
+  "meeting",
+  "call",
+  "appointment",
+  "reminder",
+  "event",
+  "birthday",
+  "breakfast",
+  "lunch",
+  "dinner",
+  "brunch",
+  "vacation",
+  "holiday",
+  "trip",
+  // Plurals are listed explicitly rather than stemmed: naive `s`-stripping
+  // would fold real titles into generics ("The Times" → "time"). Only plurals
+  // that are junk as topics in their own right belong here — note the absence
+  // of "times", "places", and anything else that reads as a name.
+  "days",
+  "weeks",
+  "weekends",
+  "months",
+  "years",
+  "rooms",
+  "offices",
+  "houses",
+  "apartments",
+  "stores",
+  "shops",
+  "hotels",
+  "meetings",
+  "calls",
+  "appointments",
+  "reminders",
+  "events",
+  "birthdays",
+  "trips",
+  "vacations",
+  "holidays",
+  // Meta / filler the models occasionally echo back as an entity
+  "user",
+  "assistant",
+  "memory",
+  "memories",
+  "note",
+  "notes",
+  "thing",
+  "things",
+  "stuff",
+  "something",
+  "someone",
+  "anything",
+  "everything",
+  "none",
+  "other",
+  "misc",
+  "general",
+  "unknown"
+]);
+function isGenericEntityName(name) {
+  const tokens = name.toLowerCase().split(/[^\p{L}\p{N}]+/u).filter((token) => token.length > 0);
+  if (tokens.length === 0) return true;
+  const distinctive = tokens.filter(
+    (token) => !GENERIC_ENTITY_NAMES.has(token) && !ARTICLES.has(token) && !WEAK_MODIFIERS.has(token)
+  );
+  if (distinctive.length > 0) return false;
+  const generic = tokens.filter((token) => GENERIC_ENTITY_NAMES.has(token));
+  if (generic.length === 0) return true;
+  const titleShaped = generic.length === 1 && tokens.some((token) => ARTICLES.has(token)) && !tokens.some((token) => WEAK_MODIFIERS.has(token));
+  return !titleShaped;
+}
+var ARTICLES = /* @__PURE__ */ new Set(["the", "a", "an"]);
+var WEAK_MODIFIERS = /* @__PURE__ */ new Set([
+  "my",
+  "our",
+  "their",
+  "his",
+  "her",
+  "its",
+  "this",
+  "that",
+  "next",
+  "last",
+  "upcoming",
+  "every",
+  "at",
+  "in",
+  "on",
+  "of",
+  "for",
+  "with",
+  "from",
+  "to",
+  "by",
+  "and",
+  "or"
+]);
+
 // src/lib/memory/injectionClassifier.ts
 var DEFAULT_MODEL = "inclusionai/ling-2.6-flash";
 var DEFAULT_ATTEMPTS = 2;
@@ -6858,13 +7014,13 @@ function parseEntities(raw) {
   for (const e of raw) {
     if (typeof e === "string") {
       const name2 = e.trim();
-      if (name2.length > 0) out.push({ name: name2 });
+      if (name2.length > 0 && !isGenericEntityName(name2)) out.push({ name: name2 });
       continue;
     }
     if (typeof e !== "object" || e === null) continue;
     const obj = e;
     const name = typeof obj.name === "string" ? obj.name.trim() : "";
-    if (name.length === 0) continue;
+    if (name.length === 0 || isGenericEntityName(name)) continue;
     const kind = typeof obj.kind === "string" && ENTITY_KINDS.includes(obj.kind) ? obj.kind : void 0;
     out.push(kind !== void 0 ? { name, kind } : { name });
   }
@@ -8167,7 +8323,11 @@ var SYSTEM_PROMPT4 = `You assign topics to saved memories for a personal memory
 
 Each memory is a short statement about the user. For each memory, list the NAMED entities it mentions \u2014 these become the memory's topics, used to connect related memories in a knowledge graph.
 
-Include only NAMED entities, skip generic/common nouns. ${ENTITY_KIND_GUIDELINES}
+Include only NAMED entities, skip generic/common nouns. A topic must identify a specific thing the user could recognize by name; if it would be equally true of thousands of unrelated memories, leave it out:
+- SKIP bare generic nouns even when the memory capitalizes them or a calendar entry is titled that way \u2014 "Home", "Work", "Meeting", "Lunch", "Birthday", "Appointment", "Trip", "Today", "Friday", "March" are NOT topics.
+- KEEP the specific thing instead, when the memory names one: "Blue Bottle on Valencia" over "cafe", "Chicago Marathon" over "event", "Hollowpoint Labs" over "work".
+- Prefer 0 entities over a weak one. A memory whose only candidate is a generic noun has NO entities.
+${ENTITY_KIND_GUIDELINES}
 
 Each memory below is written as "<id>: <text>". Output strict JSON: {"memories": [{"id": string, "entities": [{"name": string, "kind": string}]}]}
 - exactly one element per input memory; copy its id EXACTLY as written (the token before the first ": "), with no brackets, quotes, or extra characters
@@ -8179,7 +8339,7 @@ async function extractEntitiesForMemories(memories, options) {
   const redactor = resolvePiiRedactor(options.piiRedaction);
   const vocabulary = (options.existingEntityNames ?? []).filter((n) => n.trim().length > 0).slice(0, MAX_VOCABULARY_NAMES).map((n) => redactor ? redactor.redactText(n).text : n);
   const vocabularyNote = vocabulary.length > 0 ? `The user's existing topics: ${vocabulary.join(", ")}.
-When a memory refers to one of these, reuse the EXACT existing name (same spelling and casing) instead of a variant.
+When a memory refers to one of these, reuse the EXACT existing name (same spelling, casing, spacing and punctuation) instead of a variant \u2014 if "Foo.ai" is listed, never emit "Foo ai" or "Foo AI", and if "Jane Roe" is listed, emit that rather than a bare "Jane".
 
 ` : "";
   for (let i = 0; i < memories.length; i += TOPIC_EXTRACTION_BATCH_SIZE) {

package/dist/expo/{recall-MUFOZB6P.mjs → recall-JFZ3Z6EX.mjs}

@@ -1,6 +1,6 @@
 import {
   recall
-} from "./chunk-IFZZQPRO.mjs";
+} from "./chunk-42Y42CAZ.mjs";
 import "./chunk-BOY27A2C.mjs";
 import "./chunk-GYKJOWEO.mjs";
 export {

package/dist/react/{chunk-35BHTCK4.mjs → chunk-NLVSQAYH.mjs}

@@ -1929,7 +1929,7 @@ function entityToStored(e) {
     updatedAt: e.updatedAt
   };
 }
-async function upsertEntitiesOp(ctx, entities) {
+async function upsertEntitiesInWrite(ctx, entities) {
   const kindByName = /* @__PURE__ */ new Map();
   for (const e of entities) {
     const name = normalizeEntityName(e.name);
@@ -1943,60 +1943,62 @@ async function upsertEntitiesOp(ctx, entities) {
   }
   const unique = Array.from(kindByName.keys());
   const out = /* @__PURE__ */ new Map();
-  if (unique.length === 0) return out;
-  return await ctx.database.write(async () => {
-    const existing = await ctx.entityCollection.query(Q2.where("canonical_name", Q2.oneOf(unique))).fetch();
-    const existingNames = new Set(existing.map((e) => e.canonicalName));
-    const updates = existing.filter((e) => {
-      const incoming = kindByName.get(e.canonicalName);
-      return incoming !== void 0 && (e.kind === null || e.kind === void 0 || e.kind === "");
-    });
-    const missing = unique.filter((n) => !existingNames.has(n));
-    const created = missing.map(
-      (name) => ctx.entityCollection.prepareCreate((record) => {
-        record._setRaw("canonical_name", name);
-        const kind = kindByName.get(name);
-        if (kind !== void 0) record._setRaw("kind", kind);
-      })
-    );
-    const updated = updates.map(
-      (e) => e.prepareUpdate((record) => {
-        record._setRaw("kind", kindByName.get(e.canonicalName));
-      })
-    );
-    if (created.length > 0 || updated.length > 0) {
-      await ctx.database.batch(...created, ...updated);
-    }
-    for (const e of existing) out.set(e.canonicalName, entityToStored(e));
-    for (const record of created) out.set(record.canonicalName, entityToStored(record));
-    return out;
+  if (unique.length === 0) return { entities: out, operations: [] };
+  const existing = await ctx.entityCollection.query(Q2.where("canonical_name", Q2.oneOf(unique))).fetch();
+  const existingNames = new Set(existing.map((e) => e.canonicalName));
+  const updates = existing.filter((e) => {
+    const incoming = kindByName.get(e.canonicalName);
+    return incoming !== void 0 && (e.kind === null || e.kind === void 0 || e.kind === "");
   });
+  const missing = unique.filter((n) => !existingNames.has(n));
+  const created = missing.map(
+    (name) => ctx.entityCollection.prepareCreate((record) => {
+      record._setRaw("canonical_name", name);
+      const kind = kindByName.get(name);
+      if (kind !== void 0) record._setRaw("kind", kind);
+    })
+  );
+  const updated = updates.map(
+    (e) => e.prepareUpdate((record) => {
+      record._setRaw("kind", kindByName.get(e.canonicalName));
+    })
+  );
+  for (const e of existing) out.set(e.canonicalName, entityToStored(e));
+  for (const record of created) out.set(record.canonicalName, entityToStored(record));
+  return { entities: out, operations: [...created, ...updated] };
 }
 async function linkMemoryEntitiesOp(ctx, memoryId, entityInputs, options) {
   if (entityInputs.length === 0) return [];
   const normalized = entityInputs.map((e) => typeof e === "string" ? { name: e } : e);
-  const byName = await upsertEntitiesOp(ctx, normalized);
-  const entities = Array.from(byName.values());
-  if (entities.length === 0) return [];
   const userId = ctx.userId;
   let skipped = false;
+  let entities = [];
   await ctx.database.write(async () => {
+    const { entities: byName, operations: entityOps } = await upsertEntitiesInWrite(
+      ctx,
+      normalized
+    );
+    entities = Array.from(byName.values());
     if (options?.unlessTopicsUserManaged && await autoLinkBlocked(ctx, memoryId)) {
+      if (entityOps.length > 0) {
+        await ctx.database.batch(...entityOps);
+      }
       skipped = true;
       return;
     }
+    if (entities.length === 0) return;
     const existingLinks = await ctx.memoryEntityCollection.query(Q2.where("memory_id", memoryId)).fetch();
     const existingEntityIds = new Set(existingLinks.map((l) => String(l.entityId)));
     const toCreate = entities.filter((e) => !existingEntityIds.has(e.uniqueId));
-    if (toCreate.length === 0) return;
-    const prepared = toCreate.map(
+    if (entityOps.length === 0 && toCreate.length === 0) return;
+    const linkOps = toCreate.map(
       (e) => ctx.memoryEntityCollection.prepareCreate((record) => {
         record._setRaw("memory_id", memoryId);
         record._setRaw("entity_id", e.uniqueId);
         if (userId !== void 0) record._setRaw("user_id", userId);
       })
     );
-    await ctx.database.batch(...prepared);
+    await ctx.database.batch(...entityOps, ...linkOps);
   });
   return skipped ? [] : entities;
 }
@@ -2011,22 +2013,28 @@ async function autoLinkBlocked(ctx, memoryId) {
 }
 async function replaceMemoryEntitiesGuardedOp(ctx, memoryId, entityInputs) {
   const normalized = entityInputs.map((e) => typeof e === "string" ? { name: e } : e);
-  const byName = await upsertEntitiesOp(ctx, normalized);
-  const entities = Array.from(byName.values());
   const userId = ctx.userId;
   let skipped = false;
+  let entities = [];
   await ctx.database.write(async () => {
     if (await autoLinkBlocked(ctx, memoryId)) {
       skipped = true;
       return;
     }
+    const { entities: byName, operations: entityOps } = await upsertEntitiesInWrite(
+      ctx,
+      normalized
+    );
+    entities = Array.from(byName.values());
     const existingLinks = await ctx.memoryEntityCollection.query(Q2.where("memory_id", memoryId)).fetch();
     const keep = new Set(entities.map((e) => e.uniqueId));
     const existingEntityIds = new Set(existingLinks.map((l) => String(l.entityId)));
     const toCreate = entities.filter((e) => !existingEntityIds.has(e.uniqueId));
     const toDestroy = existingLinks.filter((l) => !keep.has(String(l.entityId)));
-    if (toCreate.length === 0 && toDestroy.length === 0) return;
+    if (entityOps.length === 0 && toCreate.length === 0 && toDestroy.length === 0) return;
+    const orphans = await findOrphanedEntities(ctx, memoryId, toDestroy);
     await ctx.database.batch(
+      ...entityOps,
       ...toCreate.map(
         (e) => ctx.memoryEntityCollection.prepareCreate((record) => {
           record._setRaw("memory_id", memoryId);
@@ -2034,11 +2042,23 @@ async function replaceMemoryEntitiesGuardedOp(ctx, memoryId, entityInputs) {
           if (userId !== void 0) record._setRaw("user_id", userId);
         })
       ),
-      ...toDestroy.map((l) => l.prepareDestroyPermanently())
+      ...toDestroy.map((l) => l.prepareDestroyPermanently()),
+      ...orphans.map((e) => e.prepareDestroyPermanently())
     );
   });
   return skipped ? null : entities;
 }
+async function findOrphanedEntities(ctx, memoryId, toDestroy) {
+  const candidateIds = [...new Set(toDestroy.map((l) => String(l.entityId)))];
+  if (candidateIds.length === 0) return [];
+  const links = await ctx.memoryEntityCollection.query(Q2.where("entity_id", Q2.oneOf(candidateIds))).fetch();
+  const stillLinked = new Set(
+    links.filter((l) => String(l.memoryId) !== memoryId).map((l) => String(l.entityId))
+  );
+  const orphanIds = candidateIds.filter((id) => !stillLinked.has(id));
+  if (orphanIds.length === 0) return [];
+  return await ctx.entityCollection.query(Q2.where("id", Q2.oneOf(orphanIds))).fetch();
+}
 async function unlinkMemoryEntitiesOp(ctx, memoryIds) {
   if (memoryIds.length === 0) return;
   const links = await ctx.memoryEntityCollection.query(Q2.where("memory_id", Q2.oneOf(Array.from(memoryIds)))).fetch();
@@ -2738,7 +2758,7 @@ async function getUnfiledVaultMemoriesOp(ctx) {
     (record) => vaultMemoryToStored(record, ctx.walletAddress, ctx.signMessage, ctx.embeddedWalletSigner)
   );
 }
-var TOPICS_EXTRACTION_VERSION = 2;
+var TOPICS_EXTRACTION_VERSION = 3;
 async function getMemoriesNeedingTopicExtractionOp(ctx, options) {
   const entityCtx = ctx.entityCtx;
   if (!entityCtx) {
@@ -5641,7 +5661,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-JUERXQA7.mjs");
+        const { recall: recall2 } = await import("./recall-BCEH7U2Z.mjs");
         const result = await recall2(
           query,
           { vaultCtx, embeddingOptions, vaultCache: cache },