@anuma/sdk 3.1.3 → 3.2.0

package/dist/server/index.mjs

@@ -108,7 +108,7 @@ import {
   updateVaultMemoryOp,
   upsertMessageOp,
   vaultMemoryToStored
-} from "./chunk-A4V7FRZ6.mjs";
+} from "./chunk-Y3ZS4OI3.mjs";
 import {
   createStreamingDeAnonymizer,
   resolvePiiRedactor
@@ -1111,6 +1111,9 @@ __decorateClass([
 __decorateClass([
   (0, import_decorators6.field)("topics_extracted_version")
 ], VaultMemory.prototype, "topicsExtractedVersion", 2);
+__decorateClass([
+  (0, import_decorators6.field)("last_observed_at")
+], VaultMemory.prototype, "lastObservedAt", 2);
 __decorateClass([
   import_decorators6.readonly,
   (0, import_decorators6.date)("created_at")
@@ -1258,7 +1261,7 @@ __decorateClass([
 ], VaultFolder.prototype, "context", 2);
 
 // src/lib/db/schema.ts
-var SDK_SCHEMA_VERSION = 38;
+var SDK_SCHEMA_VERSION = 39;
 var sdkSchema = (0, import_watermelondb12.appSchema)({
   version: SDK_SCHEMA_VERSION,
   tables: [
@@ -1396,7 +1399,14 @@ var sdkSchema = (0, import_watermelondb12.appSchema)({
         // The extraction-logic version this memory was last stamped under. Null
         // (pre-v38) is treated as version 0, so a bump of TOPICS_EXTRACTION_VERSION
         // re-extracts stale rows. See getMemoriesNeedingTopicExtractionOp.
-        { name: "topics_extracted_version", type: "number", isOptional: true }
+        { name: "topics_extracted_version", type: "number", isOptional: true },
+        // Re-observation watermark (C3). Unix ms of the last time retain() merged
+        // a duplicate observation into this fact (proof_count++). Distinct from
+        // updated_at, which merges deliberately preserve (preserveUpdatedAt) so a
+        // re-observation doesn't reorder the vault by edit time. Null = never
+        // re-observed since the column was added. Indexed so recency-weighted
+        // synthesis can filter/sort on it cheaply.
+        { name: "last_observed_at", type: "number", isOptional: true, isIndexed: true }
       ]
     }),
     // Entity table — canonical names extracted from auto-extraction (W5).
@@ -2035,6 +2045,20 @@ var sdkMigrations = (0, import_migrations.schemaMigrations)({
           columns: [{ name: "topics_extracted_version", type: "number", isOptional: true }]
         })
       ]
+    },
+    // v38 -> v39: re-observation watermark on memory_vault (C3). Existing rows
+    // keep NULL (= never re-observed since the column was added); synthesis
+    // treats NULL as "fall back to updated_at" so no backfill is needed.
+    {
+      toVersion: 39,
+      steps: [
+        (0, import_migrations.addColumns)({
+          table: "memory_vault",
+          columns: [
+            { name: "last_observed_at", type: "number", isOptional: true, isIndexed: true }
+          ]
+        })
+      ]
     }
   ]
 });
@@ -4770,6 +4794,8 @@ async function retain(content, ctx, options = {}) {
             proofCountIncrement: 1,
             sourceChunkIds: mergedSourceIds,
             preserveUpdatedAt: true,
+            // C3: record the re-observation without touching updated_at.
+            lastObservedAt: Date.now(),
             ...eventTimeUpdate && { eventTime: eventTimeUpdate }
           });
           if (updated) {
@@ -4920,6 +4946,8 @@ async function tryConsolidate(trimmed, ctx, options) {
       proofCountIncrement: 1,
       sourceChunkIds: mergedSourceIds,
       preserveUpdatedAt: true,
+      // C3: record the re-observation without touching updated_at.
+      lastObservedAt: Date.now(),
       ...eventTimeUpdate && { eventTime: eventTimeUpdate }
     });
     if (!updated) {
@@ -4956,6 +4984,8 @@ async function tryConsolidate(trimmed, ctx, options) {
       // one. Preserving updated_at keeps the recency multiplier honest
       // and matches the merge/noop paths above.
       preserveUpdatedAt: true,
+      // C3: record the re-observation without touching updated_at.
+      lastObservedAt: Date.now(),
       ...eventTimeUpdate && { eventTime: eventTimeUpdate }
     });
     if (!updated) {
@@ -5759,6 +5789,311 @@ function parseAnswer(body, base, parseSchema) {
   };
 }
 
+// src/lib/memory/synthesizeProfile.ts
+var DEFAULT_SYNTHESIS_MODEL = "inclusionai/ling-2.6-flash";
+var DEFAULT_FACET_RECALL_LIMIT = 20;
+var DEFAULT_FACET_MAX_TOKENS = 512;
+var DEFAULT_SCOPES = ["private"];
+var NEW_FACT_ATTRIBUTION_MIN_SCORE = 0.1;
+var PROFILE_DOC_VERSION = 1;
+var DEFAULT_PROFILE_FACETS = [
+  {
+    key: "bio",
+    label: "Bio",
+    query: "Who is this person? Their background, personality, values, and what defines them.",
+    guidance: "Write a 1-2 sentence bio (max ~40 words) that captures what makes this person distinctive \u2014 their character, values, or a defining thread across the memories. Be specific and grounded; ban generic dating clich\xE9s ('loves to laugh', 'foodie', 'work hard play hard', 'living life to the fullest')."
+  },
+  {
+    key: "interests",
+    label: "Interests",
+    query: "What are this person's hobbies, passions, pastimes, and interests?",
+    guidance: "Return 3-6 specific interests as a comma-separated list (e.g. 'trail running, film photography, Thai cooking'). Prefer concrete activities the memories actually show over broad categories ('music', 'travel'). No sentence, just the list."
+  },
+  {
+    key: "work_role",
+    label: "Work & Role",
+    query: "What does this person do for work \u2014 their profession, role, industry, or studies?",
+    guidance: "State the person's current role/profession and field in one short line (e.g. 'Backend engineer at a fintech startup'). Use only what the memories support; if unclear or absent, return hasEvidence=false rather than guessing a title."
+  },
+  {
+    key: "location_context",
+    label: "Location",
+    query: "Where does this person live, spend time, or come from?",
+    guidance: "Summarize where the person is based or spends time at neighborhood-or-city granularity in one short line (e.g. 'Based in the Mission, SF'). PRIVACY: never emit a precise address, building, or workplace location \u2014 coarse-grain to the city/neighborhood."
+  },
+  {
+    key: "communication_style",
+    label: "Communication Style",
+    query: "How does this person communicate, express themselves, and interact with others?",
+    guidance: "Describe the person's communication and social style in one line using 2-4 concrete adjectives grounded in the memories (e.g. 'Direct, dry-humored, and a careful listener'). Avoid empty praise."
+  },
+  {
+    key: "recent_activity",
+    label: "Recently",
+    query: "What has this person been doing, focused on, or working on recently?",
+    guidance: "Summarize what the person has been up to lately in one line, favoring the most recently reinforced facts. Frame it as current/ongoing (e.g. 'Lately: training for a first half-marathon and learning Portuguese'). Omit if nothing recent stands out."
+  }
+];
+var FACET_RESPONSE_SCHEMA = {
+  type: "object",
+  properties: {
+    summary: {
+      type: "string",
+      description: "The synthesized section prose. Empty string if the memories don't cover it."
+    },
+    hasEvidence: {
+      type: "boolean",
+      description: "False when the supplied memories don't support any claim for this facet."
+    }
+  },
+  required: ["summary", "hasEvidence"],
+  additionalProperties: false
+};
+async function synthesizeProfile(ctx, options = {}) {
+  if (!ctx.vaultCtx) {
+    throw new Error("synthesizeProfile requires ctx.vaultCtx (vault-backed facts).");
+  }
+  if (!ctx.vaultCache) {
+    throw new Error("synthesizeProfile requires ctx.vaultCache (semantic fact recall).");
+  }
+  const facets = options.facets ?? DEFAULT_PROFILE_FACETS;
+  const scopes = options.scopes ?? DEFAULT_SCOPES;
+  const config = {
+    facetKeys: facets.map((f) => f.key).sort(),
+    facetsSignature: facetsSignature(facets),
+    scopes: [...scopes].sort(),
+    redacted: options.redactor !== void 0
+  };
+  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, {
+    // Scope the snapshot to the same scopes synthesis recalls from, so the
+    // watermark, delta, and new-fact attribution all track only facts that can
+    // actually appear in the profile — an out-of-scope change/new-fact must not
+    // trigger a regeneration that scoped recall would never reflect.
+    scopes,
+    includeDeleted: true,
+    includeSuperseded: true
+  });
+  const watermark = computeVaultWatermark(memories);
+  const presentIds = new Set(memories.map((m) => m.uniqueId));
+  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) {
+    const sameOrder = previous.sections.length === facets.length && facets.every((f, i) => previous.sections[i]?.key === f.key);
+    if (sameOrder) return previous;
+    return {
+      ...previous,
+      sections: facets.map((f) => previous.sections.find((s) => s.key === f.key))
+    };
+  }
+  const staleKeys = await computeStaleFacetKeys(ctx, memories, facets, previous, watermark);
+  const settled = await Promise.allSettled(
+    facets.map(async (facet) => {
+      const prior = previous?.sections.find((s) => s.key === facet.key);
+      if (prior && !staleKeys.has(facet.key)) {
+        return prior;
+      }
+      return synthesizeFacet(facet, ctx, options, prior);
+    })
+  );
+  const sections = settled.map((r, i) => {
+    if (r.status === "fulfilled") return r.value;
+    const facet = facets[i];
+    getLogger().warn(
+      "[memory/synthesizeProfile] facet synthesis rejected; using fallback section",
+      {
+        facet: facet.key,
+        error: r.reason instanceof Error ? r.reason.message : String(r.reason)
+      }
+    );
+    return fallbackSection(
+      facet,
+      previous?.sections.find((s) => s.key === facet.key)
+    );
+  });
+  return {
+    version: PROFILE_DOC_VERSION,
+    sections,
+    vaultWatermark: watermark,
+    config,
+    generatedAt: Date.now()
+  };
+}
+function configMatches(a, b) {
+  if (!a) return false;
+  return a.redacted === b.redacted && a.facetsSignature === b.facetsSignature && a.scopes.length === b.scopes.length && a.scopes.every((s, i) => s === b.scopes[i]);
+}
+function facetsSignature(facets) {
+  return facets.map((f) => JSON.stringify([f.key, f.label, f.query, f.guidance])).sort().join("\n");
+}
+function changeTime(m) {
+  return Math.max(m.updatedAt.getTime(), m.supersededAt ?? 0, m.lastObservedAt ?? 0);
+}
+function computeVaultWatermark(memories) {
+  let max = 0;
+  for (const m of memories) {
+    const t = changeTime(m);
+    if (t > max) max = t;
+  }
+  return max;
+}
+async function computeStaleFacetKeys(ctx, memories, facets, previous, watermark) {
+  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 changedIds = new Set(changed.map((m) => m.uniqueId));
+  const presentIds = new Set(memories.map((m) => m.uniqueId));
+  const stale = /* @__PURE__ */ new Set();
+  for (const section of previous.sections) {
+    if (section.sourceMemoryIds.some((id) => changedIds.has(id))) {
+      stale.add(section.key);
+    }
+    if (section.sourceMemoryIds.some((id) => !presentIds.has(id))) {
+      stale.add(section.key);
+    }
+    if (section.stale) {
+      stale.add(section.key);
+    }
+  }
+  for (const facet of facets) {
+    if (!previous.sections.some((s) => s.key === facet.key)) stale.add(facet.key);
+  }
+  const citedIds = new Set(previous.sections.flatMap((s) => s.sourceMemoryIds));
+  const toAttribute = changed.filter(
+    (m) => !m.isDeleted && !m.supersededBy && !citedIds.has(m.uniqueId)
+  );
+  if (toAttribute.length > 0) {
+    const attributed = await attributeFacts(ctx, toAttribute, facets);
+    if (attributed === null) return allKeys;
+    for (const k of attributed) stale.add(k);
+  }
+  return stale;
+}
+async function attributeFacts(ctx, candidates, facets) {
+  const model = ctx.embeddingOptions.model ?? DEFAULT_API_EMBEDDING_MODEL;
+  const factVectors = [];
+  for (const f of candidates) {
+    if (!f.embedding || f.embeddingModel && f.embeddingModel !== model) {
+      getLogger().warn(
+        "[memory/synthesizeProfile] fact lacks a usable current-model embedding; regenerating all facets",
+        { memoryId: f.uniqueId, hasEmbedding: !!f.embedding, embeddingModel: f.embeddingModel }
+      );
+      return null;
+    }
+    let vec;
+    try {
+      vec = JSON.parse(f.embedding);
+    } catch {
+      getLogger().warn(
+        "[memory/synthesizeProfile] fact embedding failed to parse; regenerating all facets",
+        { memoryId: f.uniqueId }
+      );
+      return null;
+    }
+    if (!Array.isArray(vec) || vec.length === 0) return null;
+    factVectors.push(vec);
+  }
+  let queryVectors;
+  try {
+    queryVectors = await generateEmbeddings(
+      facets.map((f) => f.query),
+      ctx.embeddingOptions
+    );
+  } catch (err) {
+    getLogger().warn(
+      "[memory/synthesizeProfile] facet-query embedding failed; regenerating all facets",
+      { error: err instanceof Error ? err.message : String(err) }
+    );
+    return null;
+  }
+  const keys = /* @__PURE__ */ new Set();
+  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) {
+        keys.add(facets[i].key);
+        matchedAny = true;
+      }
+    }
+    if (!matchedAny) return null;
+  }
+  return keys;
+}
+async function synthesizeFacet(facet, ctx, options, prior) {
+  const result = await reflect(facet.query, ctx, {
+    apiKey: options.apiKey,
+    getToken: options.getToken,
+    llmModel: options.llmModel ?? DEFAULT_SYNTHESIS_MODEL,
+    baseUrl: options.baseUrl,
+    fetchFn: options.fetchFn,
+    scopes: options.scopes ?? DEFAULT_SCOPES,
+    limit: options.limit ?? DEFAULT_FACET_RECALL_LIMIT,
+    types: ["fact"],
+    maxTokens: DEFAULT_FACET_MAX_TOKENS,
+    systemPrompt: buildFacetSystemPrompt(facet),
+    responseSchema: FACET_RESPONSE_SCHEMA
+  });
+  const noEvidence = result.basedOn.memoryIds.length === 0;
+  const { text: text12, legitimateEmpty } = extractFacetText(result.structuredOutput);
+  if (!text12 && !legitimateEmpty && !noEvidence) {
+    getLogger().warn(
+      "[memory/synthesizeProfile] facet synthesis returned degraded-empty; keeping prior section",
+      { facet: facet.key, recalledCount: result.basedOn.memoryIds.length }
+    );
+    return fallbackSection(facet, prior);
+  }
+  const section = {
+    key: facet.key,
+    label: facet.label,
+    text: text12,
+    sourceMemoryIds: result.basedOn.memoryIds,
+    generatedAt: Date.now()
+  };
+  if (options.redactor && text12) {
+    const redacted = await options.redactor.redactTextAsync(text12);
+    section.text = redacted.text;
+  }
+  return section;
+}
+function fallbackSection(facet, prior) {
+  if (prior && prior.text) {
+    return { ...prior, stale: true };
+  }
+  return {
+    key: facet.key,
+    label: facet.label,
+    text: "",
+    sourceMemoryIds: [],
+    generatedAt: Date.now(),
+    stale: true
+  };
+}
+function buildFacetSystemPrompt(facet) {
+  return `You are writing the "${facet.label}" section of a person's shareable profile, using their private memories (supplied as evidence) as the only source of truth.
+
+Task for this section:
+${facet.guidance}
+
+Rules:
+- Ground every claim in the supplied memories \u2014 never invent, infer beyond, or embellish what they support.
+- If the memories don't cover this section, return an empty summary with hasEvidence=false. Do not pad or guess.
+- Write in third person about the person, in a natural voice suitable for a public profile (no "I"/"you", no name repetition).
+- Be concise and specific; no preamble, hedging, or meta-commentary.
+- Respond as JSON: { "summary": <the section text, or "">, "hasEvidence": <true|false> }.`;
+}
+function extractFacetText(structured) {
+  if (structured && typeof structured === "object") {
+    const obj = structured;
+    if (obj.hasEvidence === false) return { text: "", legitimateEmpty: true };
+    if (typeof obj.summary === "string")
+      return { text: obj.summary.trim(), legitimateEmpty: false };
+  }
+  return { text: "", legitimateEmpty: false };
+}
+
 // src/lib/memory/topicExtract.ts
 var TOPIC_EXTRACTION_BATCH_SIZE = 10;
 var MAX_CHARS_PER_MEMORY = 300;
@@ -11626,6 +11961,7 @@ export {
   DEFAULT_MIN_CHUNK_SIZE,
   DEFAULT_MIN_MESSAGES,
   DEFAULT_PERSONALITY_SETTINGS,
+  DEFAULT_PROFILE_FACETS,
   DEFAULT_PROMPT_TEMPLATES,
   DEFAULT_REFRESH_EVERY_MESSAGES,
   DEFAULT_SERVER_TOOLS_MATCH_OPTIONS,
@@ -11640,6 +11976,7 @@ export {
   Media,
   Message,
   ModelPreference,
+  PROFILE_DOC_VERSION,
   PdfProcessor,
   PostgreSQLAdapter,
   ProcessorRegistry,
@@ -11846,6 +12183,7 @@ export {
   streamReplayPath,
   summaryToSystemMessage,
   supersedeVaultMemoryOp,
+  synthesizeProfile,
   toolSetSystemPrompts,
   updateConversationProjectOp,
   updateConversationTitleOp,

package/dist/server/{recall-2K7IOKY3.mjs → recall-Z72DM2JK.mjs}

@@ -1,6 +1,6 @@
 import {
   recall
-} from "./chunk-A4V7FRZ6.mjs";
+} from "./chunk-Y3ZS4OI3.mjs";
 import "./chunk-AHJT66EO.mjs";
 import "./chunk-3RPGXXPZ.mjs";
 export {

package/package.json

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