@anuma/sdk 3.8.3 → 3.8.5

package/dist/react/index.cjs

@@ -4229,7 +4229,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);
@@ -4243,60 +4243,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(import_watermelondb9.Q.where("canonical_name", import_watermelondb9.Q.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(import_watermelondb9.Q.where("canonical_name", import_watermelondb9.Q.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(import_watermelondb9.Q.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;
 }
@@ -4311,22 +4313,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(import_watermelondb9.Q.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);
@@ -4334,11 +4342,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(import_watermelondb9.Q.where("entity_id", import_watermelondb9.Q.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(import_watermelondb9.Q.where("id", import_watermelondb9.Q.oneOf(orphanIds))).fetch();
+}
 async function unlinkMemoryEntitiesOp(ctx, memoryIds) {
   if (memoryIds.length === 0) return;
   const links = await ctx.memoryEntityCollection.query(import_watermelondb9.Q.where("memory_id", import_watermelondb9.Q.oneOf(Array.from(memoryIds)))).fetch();
@@ -5275,7 +5295,7 @@ var init_operations3 = __esm({
     init_operations2();
     init_encryption2();
     KNOWN_TRUST_TIERS = /* @__PURE__ */ new Set(["quarantined", "trusted"]);
-    TOPICS_EXTRACTION_VERSION = 2;
+    TOPICS_EXTRACTION_VERSION = 3;
   }
 });
 
@@ -15034,6 +15054,162 @@ init_types3();
 init_logger();
 init_redactor();
 
+// 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
 init_logger();
 init_redactor();
@@ -15974,13 +16150,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 });
   }
@@ -16202,9 +16378,11 @@ function createAutoExtractor(options) {
             }
           }
         );
-        const advancedTo = window2[window2.length - 1].id;
-        stateFor(conversationId).watermark = advancedTo;
-        persistCursor(conversationId, messages, advancedTo, contiguous);
+        if (outcome !== "empty-after-retry") {
+          const advancedTo = window2[window2.length - 1].id;
+          stateFor(conversationId).watermark = advancedTo;
+          persistCursor(conversationId, messages, advancedTo, contiguous);
+        }
         for (let i = 0; i < results.length; i++) {
           if (results[i].action === "suppressed") continue;
           options.onMemoryExtracted?.({
@@ -17322,7 +17500,11 @@ var SYSTEM_PROMPT6 = `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
@@ -17334,7 +17516,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/react/index.d.mts

@@ -5771,7 +5771,7 @@ interface EntityOperationsContext {
  * Link a memory to one or more entities. Accepts bare names (back-compat)
  * or `{ name, kind }` objects. Names are normalized; missing entities are
  * auto-created (with their kind), and an existing entity's null kind is
- * back-filled — see {@link upsertEntitiesOp}. Idempotent — duplicate
+ * back-filled — see {@link upsertEntitiesInWrite}. Idempotent — duplicate
  * (memory_id, entity_id) pairs are skipped.
  *
  * `options.unlessTopicsUserManaged` re-checks the memory's vault row INSIDE
@@ -5782,8 +5782,9 @@ interface EntityOperationsContext {
  * mid-call (orphaning links the cascade already swept) — so only an in-write
  * check guarantees a user's manual edit or delete can't be grafted over. The
  * row read fails CLOSED (skip links) so a transient fault never attaches
- * topics to a memory we couldn't verify. Entity upserts still happen
- * (vocabulary is global); returns [] when links were skipped.
+ * topics to a memory we couldn't verify. Entity upserts and link creation
+ * run in ONE writer to prevent orphan-prune races; returns [] when links
+ * were skipped.
  */
 declare function linkMemoryEntitiesOp(ctx: EntityOperationsContext, memoryId: string, entityInputs: ReadonlyArray<EntityInput>, options?: {
     unlessTopicsUserManaged?: boolean;
@@ -5798,6 +5799,10 @@ declare function linkMemoryEntitiesOp(ctx: EntityOperationsContext, memoryId: st
  * destroy-stale are batched in ONE writer, after the same in-write guard as
  * the link op (user-managed / deleted / absent / read-fault ⇒ skip).
  *
+ * That batch also prunes `entity` rows left with no links at all (see
+ * {@link findOrphanedEntities}) — otherwise a topic the extractor has disowned
+ * keeps rendering as a chip that matches no memory.
+ *
  * Returns the linked entities ([] for an answered-empty set), or null when
  * the guard skipped — callers must treat null as "not persisted" (e.g. don't
  * stamp `topics_extracted_at`).
@@ -7208,7 +7213,7 @@ declare function getUnfiledVaultMemoriesOp(ctx: VaultMemoryOperationsContext): P
  * by the next sweep, so topic-quality improvements propagate across the existing
  * vault. The worker's `limit` drains that re-extraction across sweeps.
  */
-declare const TOPICS_EXTRACTION_VERSION = 2;
+declare const TOPICS_EXTRACTION_VERSION = 3;
 /**
  * Result of {@link getMemoriesNeedingTopicExtractionOp}: which memories the
  * background topic worker should run LLM entity extraction on, and which it
@@ -7383,6 +7388,12 @@ declare function updateVaultMemoryEmbeddingOp(ctx: VaultMemoryOperationsContext,
  * during a busy window are still examined instead of scrolling out of a last-N
  * window.
  *
+ * The watermark advances only when the extractor genuinely EXAMINED the window.
+ * A pipeline throw and an `empty-after-retry` outcome (the extraction LLM
+ * returned empty/malformed after exhausting its retries) both leave it in place,
+ * so the next turn's window re-covers those messages instead of stranding them.
+ * A quiet turn that legitimately yielded no facts *does* advance it.
+ *
  * Durability: the in-memory watermark alone does NOT survive process death, so
  * a session killed after messages accumulate but before extraction would, on
  * the next launch, fall back to a trailing-window guess and could skip the

package/dist/react/index.d.ts

@@ -5771,7 +5771,7 @@ interface EntityOperationsContext {
  * Link a memory to one or more entities. Accepts bare names (back-compat)
  * or `{ name, kind }` objects. Names are normalized; missing entities are
  * auto-created (with their kind), and an existing entity's null kind is
- * back-filled — see {@link upsertEntitiesOp}. Idempotent — duplicate
+ * back-filled — see {@link upsertEntitiesInWrite}. Idempotent — duplicate
  * (memory_id, entity_id) pairs are skipped.
  *
  * `options.unlessTopicsUserManaged` re-checks the memory's vault row INSIDE
@@ -5782,8 +5782,9 @@ interface EntityOperationsContext {
  * mid-call (orphaning links the cascade already swept) — so only an in-write
  * check guarantees a user's manual edit or delete can't be grafted over. The
  * row read fails CLOSED (skip links) so a transient fault never attaches
- * topics to a memory we couldn't verify. Entity upserts still happen
- * (vocabulary is global); returns [] when links were skipped.
+ * topics to a memory we couldn't verify. Entity upserts and link creation
+ * run in ONE writer to prevent orphan-prune races; returns [] when links
+ * were skipped.
  */
 declare function linkMemoryEntitiesOp(ctx: EntityOperationsContext, memoryId: string, entityInputs: ReadonlyArray<EntityInput>, options?: {
     unlessTopicsUserManaged?: boolean;
@@ -5798,6 +5799,10 @@ declare function linkMemoryEntitiesOp(ctx: EntityOperationsContext, memoryId: st
  * destroy-stale are batched in ONE writer, after the same in-write guard as
  * the link op (user-managed / deleted / absent / read-fault ⇒ skip).
  *
+ * That batch also prunes `entity` rows left with no links at all (see
+ * {@link findOrphanedEntities}) — otherwise a topic the extractor has disowned
+ * keeps rendering as a chip that matches no memory.
+ *
  * Returns the linked entities ([] for an answered-empty set), or null when
  * the guard skipped — callers must treat null as "not persisted" (e.g. don't
  * stamp `topics_extracted_at`).
@@ -7208,7 +7213,7 @@ declare function getUnfiledVaultMemoriesOp(ctx: VaultMemoryOperationsContext): P
  * by the next sweep, so topic-quality improvements propagate across the existing
  * vault. The worker's `limit` drains that re-extraction across sweeps.
  */
-declare const TOPICS_EXTRACTION_VERSION = 2;
+declare const TOPICS_EXTRACTION_VERSION = 3;
 /**
  * Result of {@link getMemoriesNeedingTopicExtractionOp}: which memories the
  * background topic worker should run LLM entity extraction on, and which it
@@ -7383,6 +7388,12 @@ declare function updateVaultMemoryEmbeddingOp(ctx: VaultMemoryOperationsContext,
  * during a busy window are still examined instead of scrolling out of a last-N
  * window.
  *
+ * The watermark advances only when the extractor genuinely EXAMINED the window.
+ * A pipeline throw and an `empty-after-retry` outcome (the extraction LLM
+ * returned empty/malformed after exhausting its retries) both leave it in place,
+ * so the next turn's window re-covers those messages instead of stranding them.
+ * A quiet turn that legitimately yielded no facts *does* advance it.
+ *
  * Durability: the in-memory watermark alone does NOT survive process death, so
  * a session killed after messages accumulate but before extraction would, on
  * the next launch, fall back to a trailing-window guess and could skip the