@anuma/sdk 6.40.0 → 6.42.0

package/dist/server/index.mjs

@@ -25703,6 +25703,10 @@ var ENTITY_KINDS = [
 function normalizeEntityName(name) {
   return name.trim().toLowerCase();
 }
+var TOPIC_SALIENCE_WEIGHTS = { primary: 1, secondary: 0.6, mention: 0.3 };
+function parseTopicWeight(value) {
+  return typeof value === "number" && value > 0 && value <= 1 ? value : void 0;
+}
 function serializeTopics(topics) {
   return JSON.stringify(topics);
 }
@@ -25718,12 +25722,14 @@ function parseTopics(value) {
   const out = [];
   for (const raw of parsed) {
     if (typeof raw !== "object" || raw === null) continue;
-    const { name, kind, source } = raw;
+    const { name, kind, source, weight } = raw;
     if (typeof name !== "string" || name.trim().length === 0) continue;
+    const parsedWeight = parseTopicWeight(weight);
     out.push({
       name,
       ...typeof kind === "string" && kind.length > 0 ? { kind } : {},
-      source: source === "user" ? "user" : "auto"
+      source: source === "user" ? "user" : "auto",
+      ...parsedWeight !== void 0 ? { weight: parsedWeight } : {}
     });
   }
   return out;
@@ -25810,21 +25816,47 @@ function displayNamesOf(entities) {
 }
 function topicsEqual(stored, computed) {
   if (stored === null || stored.length !== computed.length) return false;
-  const key = (t) => JSON.stringify([t.name, t.kind ?? null, t.source]);
+  const key = (t) => JSON.stringify([t.name, t.kind ?? null, t.source, t.weight ?? null]);
   const storedKeys = stored.map(key).sort();
   const computedKeys = computed.map(key).sort();
   return storedKeys.every((k, i) => k === computedKeys[i]);
 }
-function resolveTopicsWrite(row, linked, displayNames, source) {
+function resolveTopicsWrite(row, linked, inputs, source, mode) {
   if (row === null || source === null) return null;
-  const topics = topicsForEntities(linked, displayNames, source);
-  if (topicsEqual(parseTopics(row.topics), topics)) return null;
+  const stored = parseTopics(row.topics);
+  const carried = mode === "merge" ? stored : null;
+  const weights = source === "auto" ? weightsOf(carried, inputs) : null;
+  const displayNames = displayNamesOf([...inputs, ...carried ?? []]);
+  const topics = topicsForEntities(linked, displayNames, source, weights);
+  if (topicsEqual(stored, topics)) return null;
   return { row, topics };
 }
-function topicsForEntities(entities, displayNames, source) {
+function weightsOf(stored, inputs) {
+  const out = /* @__PURE__ */ new Map();
+  for (const topic of stored ?? []) out.set(normalizeEntityName(topic.name), topic.weight);
+  for (const input of inputs) {
+    const weight = parseTopicWeight(input.weight);
+    if (weight === void 0) continue;
+    const name = normalizeEntityName(input.name);
+    if (!out.has(name)) {
+      out.set(name, weight);
+      continue;
+    }
+    const current = out.get(name);
+    if (current !== void 0 && weight > current) out.set(name, weight);
+  }
+  return out;
+}
+function topicsForEntities(entities, displayNames, source, weights) {
   return entities.map((e) => {
     const name = displayNames.get(e.canonicalName) ?? e.canonicalName;
-    return { name, ...e.kind ? { kind: e.kind } : {}, source };
+    const weight = weights?.get(e.canonicalName);
+    return {
+      name,
+      ...e.kind ? { kind: e.kind } : {},
+      source,
+      ...weight !== void 0 ? { weight } : {}
+    };
   });
 }
 function toEntityObjects(entityInputs) {
@@ -25832,7 +25864,7 @@ function toEntityObjects(entityInputs) {
 }
 async function resolveMemoryTopicsWrite(ctx, memoryId, linked, inputs, source) {
   const row = await findVaultRowInWrite(ctx, memoryId);
-  return resolveTopicsWrite(row, linked, displayNamesOf(toEntityObjects(inputs)), source);
+  return resolveTopicsWrite(row, linked, toEntityObjects(inputs), source, "replace");
 }
 function prepareMemoryTopicsUpdate(write) {
   return prepareTopicsUpdate(write.row, write.topics, Date.now());
@@ -25870,8 +25902,9 @@ async function linkMemoryEntitiesOp(ctx, memoryId, entityInputs, options) {
     const topicsWrite = resolveTopicsWrite(
       vaultRow,
       [...carriedOver, ...entities],
-      displayNamesOf(normalized),
-      options?.topicsSource ?? "auto"
+      normalized,
+      options?.topicsSource ?? "auto",
+      "merge"
     );
     if (entityOps.length === 0 && kindBackfills.length === 0 && toCreate.length === 0 && topicsWrite === null) {
       return;
@@ -25937,8 +25970,9 @@ async function replaceMemoryEntities(ctx, memoryId, entityInputs, options) {
     const topicsWrite = resolveTopicsWrite(
       vaultRow,
       entities,
-      displayNamesOf(normalized),
-      options.topicsSource
+      normalized,
+      options.topicsSource,
+      "replace"
     );
     if (entityOps.length === 0 && kindBackfills.length === 0 && toCreate.length === 0 && toDestroy.length === 0 && topicsWrite === null) {
       return;
@@ -30897,9 +30931,9 @@ For each durable fact, output:
 - type: one of identity | preference | relationship | plan | ongoing_context | constraint | other
 - confidence: 0.0-1.0; how sure you are this is durable AND true. Only include facts >= 0.7.
 - sourceMessageIds: which message IDs from the conversation contained the evidence
-- entities: named entities mentioned, each as an object { "name": string, "kind": one of "person" | "organization" | "place" | "event" | "product" | "thing" | "concept" | "other" }. Optional \u2014 include only NAMED entities, skip generic/common nouns. ${ENTITY_KIND_GUIDELINES} Examples:
-    - "started a new job at Hollowpoint Labs and I'm learning Haskell for it" \u2192 entities: [{ "name": "Hollowpoint Labs", "kind": "organization" }, { "name": "Haskell", "kind": "concept" }]
-    - "running the Berlin Half in May and I track workouts in Whoop" \u2192 entities: [{ "name": "Berlin Half", "kind": "event" }, { "name": "Whoop", "kind": "product" }]
+- entities: named entities mentioned, each as an object { "name": string, "kind": one of "person" | "organization" | "place" | "event" | "product" | "thing" | "concept" | "other", "salience": one of "primary" | "secondary" | "mention" }. Optional \u2014 include only NAMED entities, skip generic/common nouns. ${ENTITY_KIND_GUIDELINES} Salience is how central the entity is to the fact: "primary" = the fact is ABOUT it (usually exactly one per fact), "secondary" = a meaningful part of it, "mention" = named in passing. Examples:
+    - "started a new job at Hollowpoint Labs and I'm learning Haskell for it" \u2192 entities: [{ "name": "Hollowpoint Labs", "kind": "organization", "salience": "primary" }, { "name": "Haskell", "kind": "concept", "salience": "secondary" }]
+    - "running the Berlin Half in May and I track workouts in Whoop" \u2192 entities: [{ "name": "Berlin Half", "kind": "event", "salience": "primary" }, { "name": "Whoop", "kind": "product", "salience": "mention" }]
 - eventTime: when the event in this fact occurs/occurred. Resolve relative phrases ("yesterday", "next week") against the current date given in the user message. Output one of:
     - { "kind": "point", "start": "YYYY-MM-DD" }     for a single date ("met Sara on March 14, 2026")
     - { "kind": "range", "start": "YYYY-MM-DD", "end": "YYYY-MM-DD" }  for a span ("Japan trip May 4\u201315, 2026")
@@ -30980,9 +31014,10 @@ function restoreCandidates(candidates, redactor, ownNames) {
       candidate: {
         ...c,
         content: content.text,
-        entities: c.entities.map((e) => ({ kind: e.kind, restored: redactor.restoreForStorage(e.name) })).filter((e) => !e.restored.unresolved).map(
-          (e) => e.kind !== void 0 ? { name: e.restored.text, kind: e.kind } : { name: e.restored.text }
-        )
+        entities: c.entities.flatMap((e) => {
+          const restored = redactor.restoreForStorage(e.name);
+          return restored.unresolved ? [] : [{ ...e, name: restored.text }];
+        })
       },
       unresolved: content.unresolved
     };
@@ -31211,7 +31246,12 @@ function parseEntities(raw) {
     const name = typeof obj.name === "string" ? obj.name.trim() : "";
     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 });
+    const weight = typeof obj.salience === "string" && Object.keys(TOPIC_SALIENCE_WEIGHTS).includes(obj.salience) ? TOPIC_SALIENCE_WEIGHTS[obj.salience] : void 0;
+    out.push({
+      name,
+      ...kind !== void 0 ? { kind } : {},
+      ...weight !== void 0 ? { weight } : {}
+    });
   }
   return out;
 }
@@ -33170,7 +33210,13 @@ Include only NAMED entities, skip generic/common nouns. A topic must identify a
 - 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}]}]}
+Give each entity a "salience" \u2014 how central it is to the memory:
+- "primary": the memory is ABOUT it. A memory with entities usually has exactly one primary; never more than two.
+- "secondary": a meaningful part of the memory, but not its subject.
+- "mention": named in passing; the memory would say much the same without it.
+Example: "Ran the Chicago Marathon with my sister Ana in 3:41" \u2192 Chicago Marathon primary, Ana secondary.
+
+Each memory below is written as "<id>: <text>". Output strict JSON: {"memories": [{"id": string, "entities": [{"name": string, "kind": string, "salience": "primary" | "secondary" | "mention"}]}]}
 - exactly one element per input memory; copy its id EXACTLY as written (the token before the first ": "), with no brackets, quotes, or extra characters
 - "entities" may be empty when a memory mentions no named entities \u2014 most short memories have 0-3
 No prose.`;
@@ -33241,9 +33287,10 @@ List each memory's named entities.`,
   return out;
 }
 function restoreEntities(entities, redactor) {
-  return entities.map((e) => ({ kind: e.kind, restored: redactor.restoreForStorage(e.name) })).filter((e) => !e.restored.unresolved).map(
-    (e) => e.kind !== void 0 ? { name: e.restored.text, kind: e.kind } : { name: e.restored.text }
-  );
+  return entities.flatMap((e) => {
+    const restored = redactor.restoreForStorage(e.name);
+    return restored.unresolved ? [] : [{ ...e, name: restored.text }];
+  });
 }
 function parseTopicResponse(parsed, validIds) {
   if (typeof parsed !== "object" || parsed === null) return null;
@@ -33639,12 +33686,19 @@ var FACET_STRUCTURED_RESPONSE_HINT = {
   interests: `, "interests": <the same interests as an array of at most ${NEARBY_MAX_INTERESTS} strings of at most ${NEARBY_MAX_INTEREST_CODEPOINTS} characters each, e.g. ["trail running", "film photography"], or []>`
 };
 async function synthesizeProfile(ctx, options = {}) {
-  if (!ctx.vaultCtx) {
-    throw new Error("synthesizeProfile requires ctx.vaultCtx (vault-backed facts).");
+  const { store } = options;
+  const vaultCtx = ctx.vaultCtx;
+  if (!store && !vaultCtx) {
+    throw new Error(
+      "synthesizeProfile requires options.store or ctx.vaultCtx (vault-backed facts)."
+    );
   }
-  if (!ctx.vaultCache) {
-    throw new Error("synthesizeProfile requires ctx.vaultCache (semantic fact recall).");
+  if (!store && !ctx.vaultCache) {
+    throw new Error(
+      "synthesizeProfile requires options.store or ctx.vaultCache (semantic fact recall)."
+    );
   }
+  const recallCtx = store ? { embeddingOptions: ctx.embeddingOptions, factSource: store.factSource } : ctx;
   const facets = options.facets ?? DEFAULT_PROFILE_FACETS;
   const scopes = options.scopes ?? DEFAULT_SCOPES;
   const config = {
@@ -33655,11 +33709,8 @@ async function synthesizeProfile(ctx, options = {}) {
     reviewedMemoryIdsSignature: reviewedMemoryIdsSignature(options.reviewedMemoryIds)
   };
   const previous = options.previous && options.previous.version === PROFILE_DOC_VERSION && configMatches(options.previous.config, config) ? options.previous : void 0;
-  const memories = await getAllVaultMemoriesOp(ctx.vaultCtx, {
-    scopes,
-    includeDeleted: true,
-    includeSuperseded: true
-  });
+  const listOptions = { scopes, includeDeleted: true, includeSuperseded: true };
+  const [memories, projections] = store ? await Promise.all([store.list(listOptions), store.listProjections(listOptions)]) : [await getAllVaultMemoriesOp(vaultCtx, listOptions), []];
   const watermark = computeVaultWatermark(memories);
   const observationTrends = summarizeObservationTrends(
     memories.filter((m) => !m.isDeleted && m.supersededBy === null).map((m) => ({
@@ -33669,11 +33720,14 @@ async function synthesizeProfile(ctx, options = {}) {
     }))
   );
   const presentIds = new Set(memories.map((m) => m.uniqueId));
+  const unreadableMemoryIds = projections.map((p) => p.uniqueId).filter((id) => !presentIds.has(id)).sort();
+  const previousUnreadable = new Set(previous?.unreadableMemoryIds ?? []);
+  const sameUnreadable = unreadableMemoryIds.length === previousUnreadable.size && unreadableMemoryIds.every((id) => previousUnreadable.has(id));
   const hasStaleSections = previous?.sections.some((s) => s.stale);
   const citesMissingFact = previous?.sections.some(
     (s) => s.sourceMemoryIds.some((id) => !presentIds.has(id))
   );
-  if (previous && previous.vaultWatermark === watermark && !hasStaleSections && !citesMissingFact) {
+  if (previous && previous.vaultWatermark === watermark && !hasStaleSections && !citesMissingFact && sameUnreadable) {
     const sameOrder = previous.sections.length === facets.length && facets.every((f, i) => previous.sections[i]?.key === f.key);
     if (sameOrder) {
       if (trendsEqual(previous.observationTrends, observationTrends)) return previous;
@@ -33686,12 +33740,13 @@ async function synthesizeProfile(ctx, options = {}) {
     };
   }
   const staleKeys = await computeStaleFacetKeys(
-    ctx,
+    recallCtx,
     memories,
     facets,
     previous,
     watermark,
-    options.reviewedMemoryIds
+    options.reviewedMemoryIds,
+    previousUnreadable
   );
   const memoriesById = new Map(memories.map((memory) => [memory.uniqueId, memory]));
   const fallbackPriors = /* @__PURE__ */ new Map();
@@ -33711,7 +33766,7 @@ async function synthesizeProfile(ctx, options = {}) {
       if (prior && !staleKeys.has(facet.key)) {
         return prior;
       }
-      return synthesizeFacet(facet, ctx, options, fallbackPriors.get(facet.key));
+      return synthesizeFacet(facet, recallCtx, options, fallbackPriors.get(facet.key));
     })
   );
   const sections = settled.map((r, i) => {
@@ -33726,12 +33781,18 @@ async function synthesizeProfile(ctx, options = {}) {
     );
     return fallbackSection(facet, fallbackPriors.get(facet.key));
   });
+  if (!sameUnreadable && unreadableMemoryIds.length > 0) {
+    getLogger().warn("[memory/synthesizeProfile] some memories could not be read", {
+      unreadable: unreadableMemoryIds.length
+    });
+  }
   return {
     version: PROFILE_DOC_VERSION,
     sections,
     vaultWatermark: watermark,
     config,
     observationTrends,
+    ...unreadableMemoryIds.length > 0 && { unreadableMemoryIds },
     generatedAt: Date.now()
   };
 }
@@ -33765,11 +33826,13 @@ function computeVaultWatermark(memories) {
   }
   return max;
 }
-async function computeStaleFacetKeys(ctx, memories, facets, previous, watermark, reviewedMemoryIds) {
+async function computeStaleFacetKeys(ctx, memories, facets, previous, watermark, reviewedMemoryIds, previouslyUnreadable) {
   const allKeys = new Set(facets.map((f) => f.key));
   if (previous && watermark < previous.vaultWatermark) return allKeys;
   if (!previous) return allKeys;
-  const changed = memories.filter((m) => changeTime(m) > previous.vaultWatermark);
+  const changed = memories.filter(
+    (m) => changeTime(m) > previous.vaultWatermark || previouslyUnreadable.has(m.uniqueId)
+  );
   const changedIds = new Set(changed.map((m) => m.uniqueId));
   const presentIds = new Set(memories.map((m) => m.uniqueId));
   const stale = /* @__PURE__ */ new Set();
@@ -33843,7 +33906,12 @@ async function attributeFacts(ctx, candidates, facets) {
   for (const fv of factVectors) {
     let matchedAny = false;
     for (let i = 0; i < facets.length; i++) {
-      if (cosineSimilarity(fv, queryVectors[i]) >= NEW_FACT_ATTRIBUTION_MIN_SCORE) {
+      const query = queryVectors[i];
+      const similarity = cosineSimilarity(
+        fv,
+        fv.length < query.length ? query.slice(0, fv.length) : query
+      );
+      if (similarity >= NEW_FACT_ATTRIBUTION_MIN_SCORE) {
         keys.add(facets[i].key);
         matchedAny = true;
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@anuma/sdk",
-  "version": "6.40.0",
+  "version": "6.42.0",
   "description": "",
   "main": "./dist/index.cjs",
   "module": "./dist/index.mjs",