@anuma/sdk 3.12.2 → 3.13.1

package/dist/expo/index.cjs

@@ -4003,6 +4003,31 @@ var init_endpointOverride = __esm({
 function normalizeEntityName(name) {
   return name.trim().toLowerCase();
 }
+function serializeTopics(topics) {
+  return JSON.stringify(topics);
+}
+function parseTopics(value) {
+  if (typeof value !== "string" || value.length === 0) return null;
+  let parsed;
+  try {
+    parsed = JSON.parse(value);
+  } catch {
+    return null;
+  }
+  if (!Array.isArray(parsed)) return null;
+  const out = [];
+  for (const raw of parsed) {
+    if (typeof raw !== "object" || raw === null) continue;
+    const { name, kind, source } = raw;
+    if (typeof name !== "string" || name.trim().length === 0) continue;
+    out.push({
+      name,
+      ...typeof kind === "string" && kind.length > 0 ? { kind } : {},
+      source: source === "user" ? "user" : "auto"
+    });
+  }
+  return out;
+}
 var ENTITY_KINDS;
 var init_types3 = __esm({
   "src/lib/db/entities/types.ts"() {
@@ -4068,9 +4093,62 @@ async function upsertEntitiesInWrite(ctx, entities) {
   for (const record of created) out.set(record.canonicalName, entityToStored(record));
   return { entities: out, operations: [...created, ...updated] };
 }
+async function findVaultRowInWrite(ctx, memoryId) {
+  try {
+    const rows = await ctx.database.get("memory_vault").query(import_watermelondb8.Q.where("id", memoryId)).fetch();
+    return rows[0] ?? null;
+  } catch {
+    return null;
+  }
+}
+function prepareTopicsUpdate(row, topics, now) {
+  const originalUpdatedAt = row.updatedAt.getTime();
+  return row.prepareUpdate((r) => {
+    r._setRaw("topics", serializeTopics(topics));
+    r._setRaw("topics_updated_at", now);
+    r._setRaw("updated_at", originalUpdatedAt);
+  });
+}
+function displayNamesOf(entities) {
+  const out = /* @__PURE__ */ new Map();
+  for (const e of entities) {
+    const name = e.name.trim();
+    const normalized = normalizeEntityName(name);
+    if (normalized.length === 0 || out.has(normalized)) continue;
+    out.set(normalized, name);
+  }
+  return out;
+}
+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 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) {
+  if (row === null || source === null) return null;
+  const topics = topicsForEntities(linked, displayNames, source);
+  if (topicsEqual(parseTopics(row.topics), topics)) return null;
+  return { row, topics };
+}
+function topicsForEntities(entities, displayNames, source) {
+  return entities.map((e) => {
+    const name = displayNames.get(e.canonicalName) ?? e.canonicalName;
+    return { name, ...e.kind ? { kind: e.kind } : {}, source };
+  });
+}
+function toEntityObjects(entityInputs) {
+  return entityInputs.map((e) => typeof e === "string" ? { name: e } : e);
+}
+async function prepareMemoryTopicsUpdate(ctx, memoryId, linked, inputs, source) {
+  const row = await findVaultRowInWrite(ctx, memoryId);
+  const write = resolveTopicsWrite(row, linked, displayNamesOf(toEntityObjects(inputs)), source);
+  return write === null ? null : prepareTopicsUpdate(write.row, write.topics, Date.now());
+}
 async function linkMemoryEntitiesOp(ctx, memoryId, entityInputs, options) {
   if (entityInputs.length === 0) return [];
-  const normalized = entityInputs.map((e) => typeof e === "string" ? { name: e } : e);
+  const normalized = toEntityObjects(entityInputs);
   const userId = ctx.userId;
   let skipped = false;
   let entities = [];
@@ -4080,7 +4158,8 @@ async function linkMemoryEntitiesOp(ctx, memoryId, entityInputs, options) {
       normalized
     );
     entities = Array.from(byName.values());
-    if (options?.unlessTopicsUserManaged && await autoLinkBlocked(ctx, memoryId)) {
+    const vaultRow = await findVaultRowInWrite(ctx, memoryId);
+    if (options?.unlessTopicsUserManaged && autoLinkBlocked(vaultRow)) {
       if (entityOps.length > 0) {
         await ctx.database.batch(...entityOps);
       }
@@ -4091,7 +4170,18 @@ async function linkMemoryEntitiesOp(ctx, memoryId, entityInputs, options) {
     const existingLinks = await ctx.memoryEntityCollection.query(import_watermelondb8.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 (entityOps.length === 0 && toCreate.length === 0) return;
+    const keptIds = entities.map((e) => e.uniqueId);
+    const carriedOver = await resolveEntitiesByIds(
+      ctx,
+      [...existingEntityIds].filter((id) => !keptIds.includes(id))
+    );
+    const topicsWrite = resolveTopicsWrite(
+      vaultRow,
+      [...carriedOver, ...entities],
+      displayNamesOf(normalized),
+      options?.topicsSource ?? "auto"
+    );
+    if (entityOps.length === 0 && toCreate.length === 0 && topicsWrite === null) return;
     const linkOps = toCreate.map(
       (e) => ctx.memoryEntityCollection.prepareCreate((record) => {
         record._setRaw("memory_id", memoryId);
@@ -4099,26 +4189,42 @@ async function linkMemoryEntitiesOp(ctx, memoryId, entityInputs, options) {
         if (userId !== void 0) record._setRaw("user_id", userId);
       })
     );
-    await ctx.database.batch(...entityOps, ...linkOps);
+    await ctx.database.batch(
+      ...entityOps,
+      ...linkOps,
+      ...topicsWrite ? [prepareTopicsUpdate(topicsWrite.row, topicsWrite.topics, Date.now())] : []
+    );
   });
   return skipped ? [] : entities;
 }
-async function autoLinkBlocked(ctx, memoryId) {
-  try {
-    const rows = await ctx.database.get("memory_vault").query(import_watermelondb8.Q.where("id", memoryId)).fetch();
-    const row = rows[0];
-    return !row || !!row.isDeleted || !!row.topicsUserManaged;
-  } catch {
-    return true;
-  }
+async function resolveEntitiesByIds(ctx, entityIds) {
+  if (entityIds.length === 0) return [];
+  const rows = await ctx.entityCollection.query(import_watermelondb8.Q.where("id", import_watermelondb8.Q.oneOf(Array.from(entityIds)))).fetch();
+  return rows.map(entityToStored);
+}
+function autoLinkBlocked(row) {
+  return !row || !!row.isDeleted || !!row.topicsUserManaged;
 }
 async function replaceMemoryEntitiesGuardedOp(ctx, memoryId, entityInputs) {
-  const normalized = entityInputs.map((e) => typeof e === "string" ? { name: e } : e);
+  return replaceMemoryEntities(ctx, memoryId, entityInputs, {
+    guarded: true,
+    topicsSource: "auto"
+  });
+}
+async function relinkMemoryEntitiesFromTopicsOp(ctx, memoryId, topics) {
+  return replaceMemoryEntities(ctx, memoryId, topics, {
+    guarded: false,
+    topicsSource: null
+  });
+}
+async function replaceMemoryEntities(ctx, memoryId, entityInputs, options) {
+  const normalized = toEntityObjects(entityInputs);
   const userId = ctx.userId;
   let skipped = false;
   let entities = [];
   await ctx.database.write(async () => {
-    if (await autoLinkBlocked(ctx, memoryId)) {
+    const vaultRow = await findVaultRowInWrite(ctx, memoryId);
+    if (options.guarded && autoLinkBlocked(vaultRow)) {
       skipped = true;
       return;
     }
@@ -4132,7 +4238,15 @@ async function replaceMemoryEntitiesGuardedOp(ctx, memoryId, entityInputs) {
     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 (entityOps.length === 0 && toCreate.length === 0 && toDestroy.length === 0) return;
+    const topicsWrite = resolveTopicsWrite(
+      vaultRow,
+      entities,
+      displayNamesOf(normalized),
+      options.topicsSource
+    );
+    if (entityOps.length === 0 && toCreate.length === 0 && toDestroy.length === 0 && topicsWrite === null) {
+      return;
+    }
     const orphans = await findOrphanedEntities(ctx, memoryId, toDestroy);
     await ctx.database.batch(
       ...entityOps,
@@ -4144,7 +4258,8 @@ async function replaceMemoryEntitiesGuardedOp(ctx, memoryId, entityInputs) {
         })
       ),
       ...toDestroy.map((l) => l.prepareDestroyPermanently()),
-      ...orphans.map((e) => e.prepareDestroyPermanently())
+      ...orphans.map((e) => e.prepareDestroyPermanently()),
+      ...topicsWrite ? [prepareTopicsUpdate(topicsWrite.row, topicsWrite.topics, Date.now())] : []
     );
   });
   return skipped ? null : entities;
@@ -4343,6 +4458,8 @@ function vaultMemoryToStoredRaw(memory) {
     eventTimeEnd: memory.eventTimeEnd ?? null,
     eventTimeKind: memory.eventTimeKind ?? null,
     topicsUserManaged: memory.topicsUserManaged ?? false,
+    topics: parseTopics(memory.topics),
+    topicsUpdatedAt: memory.topicsUpdatedAt ?? null,
     topicsExtractedAt: memory.topicsExtractedAt ?? null,
     topicsExtractedVersion: memory.topicsExtractedVersion ?? null,
     supersededBy: memory.supersededBy ?? null,
@@ -4619,6 +4736,8 @@ function vaultMemoryRawToStoredRaw(raw) {
     eventTimeKind: raw.event_time_kind ?? null,
     // SQLite stores booleans as 0/1, LokiJS as true/false — coerce both.
     topicsUserManaged: raw.topics_user_managed === true || raw.topics_user_managed === 1,
+    topics: parseTopics(raw.topics),
+    topicsUpdatedAt: raw.topics_updated_at ?? null,
     topicsExtractedAt: raw.topics_extracted_at ?? null,
     topicsExtractedVersion: raw.topics_extracted_version ?? null,
     supersededBy: raw.superseded_by ?? null,
@@ -4965,56 +5084,111 @@ async function getUnfiledVaultMemoriesOp(ctx) {
     (record) => vaultMemoryToStored(record, ctx.walletAddress, ctx.signMessage, ctx.embeddedWalletSigner)
   );
 }
+async function linkedEntityNamesByMemory(entityCtx, memoryIds) {
+  const CHUNK = 500;
+  const entityIdByMemory = /* @__PURE__ */ new Map();
+  const allEntityIds = /* @__PURE__ */ new Set();
+  for (let i = 0; i < memoryIds.length; i += CHUNK) {
+    const links = await entityCtx.memoryEntityCollection.query(import_watermelondb9.Q.where("memory_id", import_watermelondb9.Q.oneOf(memoryIds.slice(i, i + CHUNK)))).unsafeFetchRaw();
+    for (const link of links) {
+      const memoryId = String(link.memory_id);
+      const entityId = String(link.entity_id);
+      allEntityIds.add(entityId);
+      let bucket = entityIdByMemory.get(memoryId);
+      if (!bucket) {
+        bucket = /* @__PURE__ */ new Set();
+        entityIdByMemory.set(memoryId, bucket);
+      }
+      bucket.add(entityId);
+    }
+  }
+  const entityIds = Array.from(allEntityIds);
+  const nameById = /* @__PURE__ */ new Map();
+  for (let i = 0; i < entityIds.length; i += CHUNK) {
+    const entities = await entityCtx.entityCollection.query(import_watermelondb9.Q.where("id", import_watermelondb9.Q.oneOf(entityIds.slice(i, i + CHUNK)))).unsafeFetchRaw();
+    for (const e of entities) {
+      if (typeof e.canonical_name === "string") nameById.set(String(e.id), e.canonical_name);
+    }
+  }
+  const out = /* @__PURE__ */ new Map();
+  for (const [memoryId, ids] of entityIdByMemory) {
+    const names = /* @__PURE__ */ new Set();
+    for (const id of ids) {
+      const name = nameById.get(id);
+      if (name !== void 0) names.add(name);
+    }
+    if (names.size > 0) out.set(memoryId, names);
+  }
+  return out;
+}
+function linksDivergeFromTopics(topics, linked) {
+  const wanted = new Set(
+    topics.map((t) => normalizeEntityName(t.name)).filter((n) => n.length > 0)
+  );
+  if (wanted.size !== linked.size) return true;
+  for (const name of wanted) if (!linked.has(name)) return true;
+  return false;
+}
 async function getMemoriesNeedingTopicExtractionOp(ctx, options) {
   const entityCtx = ctx.entityCtx;
   if (!entityCtx) {
     throw new Error("getMemoriesNeedingTopicExtractionOp requires ctx.entityCtx");
   }
-  const conditions = [
-    // Boolean optional column: null (legacy) and false both mean auto-managed.
-    // Q.notEq(true) is a NULL trap on SQLite (NULL <> TRUE is NULL) — enumerate.
-    import_watermelondb9.Q.or(import_watermelondb9.Q.where("topics_user_managed", null), import_watermelondb9.Q.where("topics_user_managed", false)),
-    ...baseVaultConditions(ctx),
-    import_watermelondb9.Q.sortBy("created_at", import_watermelondb9.Q.desc)
-  ];
+  const conditions = [...baseVaultConditions(ctx), import_watermelondb9.Q.sortBy("created_at", import_watermelondb9.Q.desc)];
   const rows = await ctx.vaultMemoryCollection.query(...conditions).unsafeFetchRaw();
-  const stampedPending = [];
-  const unstamped = [];
+  const linkedNames = await linkedEntityNamesByMemory(
+    entityCtx,
+    rows.map((r) => r.id)
+  );
+  const pendingRaw = [];
+  const stampedPendingRaw = [];
+  const linkedUnstampedAll = [];
+  const topicsToRelinkAll = [];
+  const topicsBackfillAll = [];
   for (const raw of rows) {
+    const id = raw.id;
+    const topics = parseTopics(raw.topics);
+    const linked = linkedNames.get(id);
+    if (topics !== null && topics.length > 0 && linksDivergeFromTopics(topics, linked ?? /* @__PURE__ */ new Set())) {
+      topicsToRelinkAll.push(id);
+      continue;
+    }
+    if (raw.topics_user_managed) {
+      if (topics === null && linked !== void 0) topicsBackfillAll.push(id);
+      continue;
+    }
     const stamp = raw.topics_extracted_at ?? null;
+    let isPending = false;
     if (stamp !== null) {
       const version = raw.topics_extracted_version ?? 0;
       if (raw.updated_at > stamp || version < TOPICS_EXTRACTION_VERSION) {
-        stampedPending.push(raw);
+        stampedPendingRaw.push(raw);
+        isPending = true;
       }
-    } else {
-      unstamped.push(raw);
-    }
-  }
-  const linkedIds = /* @__PURE__ */ new Set();
-  const CHUNK = 500;
-  for (let i = 0; i < unstamped.length; i += CHUNK) {
-    const ids = unstamped.slice(i, i + CHUNK).map((r) => r.id);
-    const links = await entityCtx.memoryEntityCollection.query(import_watermelondb9.Q.where("memory_id", import_watermelondb9.Q.oneOf(ids))).unsafeFetchRaw();
-    for (const link of links) linkedIds.add(String(link.memory_id));
-  }
-  const linkedUnstampedAll = [];
-  const pendingRaw = [...stampedPending];
-  for (const raw of unstamped) {
-    if (linkedIds.has(raw.id)) {
-      linkedUnstampedAll.push(raw.id);
+    } else if (linked !== void 0) {
+      linkedUnstampedAll.push(id);
     } else {
       pendingRaw.push(raw);
+      isPending = true;
+    }
+    if (!isPending && topics === null && linked !== void 0) {
+      topicsBackfillAll.push(id);
     }
   }
   const cap = options?.limit !== void 0 && options.limit > 0 ? options.limit : void 0;
-  const limitedPendingRaw = cap !== void 0 ? pendingRaw.slice(0, cap) : pendingRaw;
-  const linkedUnstamped = cap !== void 0 ? linkedUnstampedAll.slice(0, cap) : linkedUnstampedAll;
+  const orderedPendingRaw = [...stampedPendingRaw, ...pendingRaw];
+  const limitedPendingRaw = cap !== void 0 ? orderedPendingRaw.slice(0, cap) : orderedPendingRaw;
   const pending = await mapInBatches(
     limitedPendingRaw,
     (raw) => vaultMemoryRawToStored(raw, ctx.walletAddress, ctx.signMessage, ctx.embeddedWalletSigner)
   );
-  return { pending, linkedUnstamped };
+  const applyCap = (ids) => cap !== void 0 ? ids.slice(0, cap) : ids;
+  return {
+    pending,
+    linkedUnstamped: applyCap(linkedUnstampedAll),
+    topicsToRelink: applyCap(topicsToRelinkAll),
+    topicsBackfill: applyCap(topicsBackfillAll)
+  };
 }
 async function stampTopicsExtractedAtOp(ctx, memoryIds, extractedAt, version = TOPICS_EXTRACTION_VERSION) {
   if (memoryIds.length === 0) return [];
@@ -5048,6 +5222,61 @@ async function stampTopicsExtractedAtOp(ctx, memoryIds, extractedAt, version = T
   }
   return stamped;
 }
+async function relinkMemoryTopicsOp(ctx, memoryIds) {
+  const entityCtx = ctx.entityCtx;
+  if (!entityCtx) {
+    throw new Error("relinkMemoryTopicsOp requires ctx.entityCtx");
+  }
+  const relinked = [];
+  for (const id of Array.from(new Set(memoryIds))) {
+    let record;
+    try {
+      record = await ctx.vaultMemoryCollection.find(id);
+    } catch {
+      continue;
+    }
+    if (record.isDeleted || !isOwnedByCtxUser(ctx, record)) continue;
+    const topics = parseTopics(record.topics);
+    if (topics === null || topics.length === 0) continue;
+    try {
+      await relinkMemoryEntitiesFromTopicsOp(entityCtx, id, topics);
+      relinked.push(id);
+    } catch (err) {
+      getLogger().warn("[memory/topics] relink failed", err);
+    }
+  }
+  return relinked;
+}
+async function backfillMemoryTopicsOp(ctx, memoryIds) {
+  const entityCtx = ctx.entityCtx;
+  if (!entityCtx) {
+    throw new Error("backfillMemoryTopicsOp requires ctx.entityCtx");
+  }
+  const filled = [];
+  for (const id of Array.from(new Set(memoryIds))) {
+    let record;
+    try {
+      record = await ctx.vaultMemoryCollection.find(id);
+    } catch {
+      continue;
+    }
+    if (record.isDeleted || !isOwnedByCtxUser(ctx, record)) continue;
+    if (parseTopics(record.topics) !== null) continue;
+    const links = await entityCtx.memoryEntityCollection.query(import_watermelondb9.Q.where("memory_id", id)).unsafeFetchRaw();
+    const entityIds = links.map((l) => String(l.entity_id));
+    if (entityIds.length === 0) continue;
+    const entities = await entityCtx.entityCollection.query(import_watermelondb9.Q.where("id", import_watermelondb9.Q.oneOf(entityIds))).fetch();
+    if (entities.length === 0) continue;
+    const source = record.topicsUserManaged ? "user" : "auto";
+    await ctx.database.write(async () => {
+      const topicsOp = await prepareMemoryTopicsUpdate(entityCtx, id, entities, [], source);
+      if (!topicsOp) return;
+      await ctx.database.batch(topicsOp);
+      filled.push(id);
+    });
+  }
+  return filled;
+}
 async function deleteAllVaultMemoriesForUserOp(ctx, userId) {
   if (ctx.userId !== void 0 && ctx.userId !== userId) return 0;
   const records = await ctx.vaultMemoryCollection.query(import_watermelondb9.Q.where("user_id", userId), import_watermelondb9.Q.where("is_deleted", false)).fetch();
@@ -5189,6 +5418,7 @@ var init_operations3 = __esm({
     import_watermelondb9 = require("@nozbe/watermelondb");
     init_logger();
     init_operations2();
+    init_types3();
     init_encryption2();
     NON_PRIVATE_VISIBILITIES = ["public"];
     KNOWN_TRUST_TIERS = /* @__PURE__ */ new Set(["quarantined", "trusted"]);
@@ -8385,6 +8615,7 @@ __export(index_exports, {
   WalletPoller: () => WalletPoller,
   addConversationMemoriesOp: () => addConversationMemoriesOp,
   archiveVaultMemoryOp: () => archiveVaultMemoryOp,
+  backfillMemoryTopicsOp: () => backfillMemoryTopicsOp,
   buildNotionAuthUrl: () => buildNotionAuthUrl,
   capHopsForDensity: () => capHopsForDensity,
   chatStorageMigrations: () => chatStorageMigrations,
@@ -8482,6 +8713,7 @@ __export(index_exports, {
   reflect: () => reflect,
   refreshNotionAccessToken: () => refreshNotionAccessToken,
   registerNotionClient: () => registerNotionClient,
+  relinkMemoryTopicsOp: () => relinkMemoryTopicsOp,
   requestEncryptionKey: () => requestEncryptionKey,
   resolvePiiRedactor: () => resolvePiiRedactor,
   restoreVaultMemoryOp: () => restoreVaultMemoryOp,
@@ -14027,6 +14259,12 @@ __decorateClass([
 __decorateClass([
   (0, import_decorators3.field)("topics_user_managed")
 ], VaultMemory.prototype, "topicsUserManaged", 2);
+__decorateClass([
+  (0, import_decorators3.field)("topics")
+], VaultMemory.prototype, "topics", 2);
+__decorateClass([
+  (0, import_decorators3.field)("topics_updated_at")
+], VaultMemory.prototype, "topicsUpdatedAt", 2);
 __decorateClass([
   (0, import_decorators3.field)("topics_extracted_at")
 ], VaultMemory.prototype, "topicsExtractedAt", 2);
@@ -19350,6 +19588,31 @@ function useChatStorage(options) {
         };
       }
       const { callRedactor, callPiiRedaction, maskForCall } = resolvePiiForCall(convId);
+      const effectiveApiType = resolveApiType(requestApiType ?? apiType ?? "auto", model);
+      const isServerToolsFunction = typeof serverToolsFilter === "function";
+      const fetchServerToolsSettled = async (token) => {
+        try {
+          return {
+            tools: await getServerTools({
+              baseUrl,
+              cacheExpirationMs: serverToolsConfig?.cacheExpirationMs,
+              getToken: token,
+              cache: serverToolsConfig?.cache
+            })
+          };
+        } catch (error) {
+          return { error };
+        }
+      };
+      const embedForToolsSettled = async (token) => {
+        try {
+          return { embedding: await embedToolText(contentForStorage, maskForCall, token) };
+        } catch (error) {
+          return { error };
+        }
+      };
+      const serverToolsPromise = getTokenRef.current && !(Array.isArray(serverToolsFilter) && serverToolsFilter.length === 0) ? fetchServerToolsSettled(getTokenRef.current) : null;
+      const userMessageEmbeddingPromise = getTokenRef.current && contentForStorage.length >= MIN_CONTENT_LENGTH_FOR_TOOLS && (isServerToolsFunction && !(serverToolsConfig?.deferLoading?.enabled && effectiveApiType === "responses") || !!clientTools?.length) ? embedForToolsSettled(getTokenRef.current) : null;
       let messagesToSend;
       const storedMessages = await getMessages(convId);
       const knownToolCallEventIds = /* @__PURE__ */ new Set();
@@ -19424,29 +19687,26 @@ function useChatStorage(options) {
         };
       }
       const startTime = Date.now();
-      const effectiveApiType = resolveApiType(requestApiType ?? apiType ?? "auto", model);
       let mergedTools = clientTools;
       let userMessageEmbedding;
       let userMessageEmbeddingFailed = false;
+      let serverFilterEmbeddingFailed = false;
       let filteredServerTools = [];
-      const isServerToolsFunction = typeof serverToolsFilter === "function";
       if (getTokenRef.current && !(Array.isArray(serverToolsFilter) && serverToolsFilter.length === 0)) {
         try {
-          const allServerTools = await getServerTools({
-            baseUrl,
-            cacheExpirationMs: serverToolsConfig?.cacheExpirationMs,
-            getToken: getTokenRef.current,
-            cache: serverToolsConfig?.cache
-          });
+          const settledTools = await (serverToolsPromise ?? fetchServerToolsSettled(getTokenRef.current));
+          if ("error" in settledTools) throw settledTools.error;
+          const allServerTools = settledTools.tools;
           if (serverToolsConfig?.deferLoading?.enabled && effectiveApiType === "responses") {
             filteredServerTools = allServerTools;
           } else if (isServerToolsFunction) {
             if (contentForStorage.length >= MIN_CONTENT_LENGTH_FOR_TOOLS) {
-              userMessageEmbedding = await embedToolText(
-                contentForStorage,
-                maskForCall,
-                getTokenRef.current
-              );
+              const settledEmbedding = await (userMessageEmbeddingPromise ?? embedForToolsSettled(getTokenRef.current));
+              if ("error" in settledEmbedding) {
+                serverFilterEmbeddingFailed = true;
+                throw settledEmbedding.error;
+              }
+              userMessageEmbedding = settledEmbedding.embedding;
               const toolNames = serverToolsFilter(userMessageEmbedding, allServerTools);
               filteredServerTools = filterServerTools(allServerTools, toolNames);
             }
@@ -19470,14 +19730,11 @@ function useChatStorage(options) {
       if (clientTools?.length) {
         try {
           if (!userMessageEmbedding && getTokenRef.current && contentForStorage.length >= MIN_CONTENT_LENGTH_FOR_TOOLS) {
-            try {
-              userMessageEmbedding = await embedToolText(
-                contentForStorage,
-                maskForCall,
-                getTokenRef.current
-              );
-            } catch {
+            const settledEmbedding = !userMessageEmbeddingPromise || serverFilterEmbeddingFailed ? await embedForToolsSettled(getTokenRef.current) : await userMessageEmbeddingPromise;
+            if ("error" in settledEmbedding) {
               userMessageEmbeddingFailed = true;
+            } else {
+              userMessageEmbedding = settledEmbedding.embedding;
             }
           }
           if (typeof clientToolsFilter === "function") {
@@ -20294,7 +20551,7 @@ __decorateClass([
 ], VaultFolder.prototype, "context", 2);
 
 // src/lib/db/schema.ts
-var SDK_SCHEMA_VERSION = 41;
+var SDK_SCHEMA_VERSION = 42;
 var sdkSchema = (0, import_watermelondb19.appSchema)({
   version: SDK_SCHEMA_VERSION,
   tables: [
@@ -20416,9 +20673,33 @@ var sdkSchema = (0, import_watermelondb19.appSchema)({
         // links). Auto-extraction then leaves its links alone — the user owns
         // them. Null/false = topics are auto-derived (default).
         { name: "topics_user_managed", type: "boolean", isOptional: true },
+        // The memory's topics as a DURABLE, SYNCED record: a JSON array of
+        // `{name, kind?, source}`, `name` in the caller's display casing (unlike
+        // `entity.canonical_name`, which is lowercased and has no display
+        // column). `entity` / `memory_entity` are a device-local INDEX over this
+        // — their ids are locally generated, so they can never sync — and a
+        // restored device rebuilds them from these names with no LLM call.
+        // Null = predates v42 (backfilled from the row's current links by the
+        // sweep's topicsBackfill bucket). See getMemoriesNeedingTopicExtractionOp.
+        { name: "topics", type: "string", isOptional: true },
+        // Unix ms of the last write to `topics`. A SECOND timestamp is required:
+        // every topic writer deliberately pins `updated_at` so a topic change
+        // doesn't inflate recall's recency multiplier, and both client sync
+        // paths key on `updated_at` — so without this a topic-only change would
+        // neither upload nor merge. Null = `topics` never written.
+        { name: "topics_updated_at", type: "number", isOptional: true },
         // Unix ms of the last LLM topic-extraction pass over this memory's
         // content. Null = never extracted standalone (legacy rows with entity
         // links are grandfathered — see getMemoriesNeedingTopicExtractionOp).
+        //
+        // DEPRECATED (v42) — `topics_updated_at` subsumes this and
+        // `topics_extracted_version` both: null there means never processed, and
+        // non-null with an empty `topics` means processed and found nothing
+        // (today's "answered empty" case), while a release-time
+        // EXTRACTOR_CHANGED_AT constant compared against `topics_updated_at`
+        // replaces the version check. Both columns are kept only to avoid a
+        // column-drop migration in an otherwise additive list; removing them is
+        // a follow-up once `topics` is proven in production.
         { name: "topics_extracted_at", type: "number", isOptional: true },
         // Write-time supersession (A2). When set, this fact was replaced by a
         // newer, incompatible-value fact (e.g. "Lives in Portland" superseded by
@@ -20432,6 +20713,9 @@ var sdkSchema = (0, import_watermelondb19.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.
+        //
+        // DEPRECATED (v42) alongside `topics_extracted_at` — same rationale and
+        // same removal follow-up; see that column's note above.
         { 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
@@ -21165,6 +21449,23 @@ var sdkMigrations = (0, import_migrations2.schemaMigrations)({
           ]
         })
       ]
+    },
+    // v41 -> v42: topics + topics_updated_at on memory_vault — the durable,
+    // synced record of a memory's topics. Existing rows keep both NULL: the
+    // sweep's topicsBackfill bucket fills them from each row's current entity
+    // links (no LLM), capped under the worker's `limit` so the one-time
+    // re-upload it triggers drains across sweeps instead of spiking.
+    {
+      toVersion: 42,
+      steps: [
+        (0, import_migrations2.addColumns)({
+          table: "memory_vault",
+          columns: [
+            { name: "topics", type: "string", isOptional: true },
+            { name: "topics_updated_at", type: "number", isOptional: true }
+          ]
+        })
+      ]
     }
   ]
 });
@@ -22550,6 +22851,7 @@ function createNotionTools(getAccessToken, requestNotionAccess) {
   WalletPoller,
   addConversationMemoriesOp,
   archiveVaultMemoryOp,
+  backfillMemoryTopicsOp,
   buildNotionAuthUrl,
   capHopsForDensity,
   chatStorageMigrations,
@@ -22647,6 +22949,7 @@ function createNotionTools(getAccessToken, requestNotionAccess) {
   reflect,
   refreshNotionAccessToken,
   registerNotionClient,
+  relinkMemoryTopicsOp,
   requestEncryptionKey,
   resolvePiiRedactor,
   restoreVaultMemoryOp,