@anuma/sdk 9.1.4 → 9.1.6

package/dist/react/index.cjs

@@ -875,7 +875,8 @@ async function callPortalJsonCompletion(req) {
   }
   const maxAttempts = Math.max(1, req.maxAttempts ?? 3);
   const startedAt = Date.now();
-  const overBudget = () => req.totalTimeoutMs !== void 0 && Date.now() - startedAt >= req.totalTimeoutMs;
+  const deadlineAt = req.totalTimeoutMs === void 0 ? void 0 : startedAt + req.totalTimeoutMs;
+  const overBudget = () => deadlineAt !== void 0 && Date.now() >= deadlineAt;
   let lastFailure;
   let reinforce = false;
   const giveUp = () => {
@@ -888,17 +889,11 @@ async function callPortalJsonCompletion(req) {
       lastFailure = { reason: "time-budget-exhausted", attempts: attempt - 1 };
       break;
     }
-    const attemptReq = req.totalTimeoutMs !== void 0 ? {
-      ...req,
-      timeoutMs: Math.max(
-        1,
-        Math.min(req.timeoutMs ?? 6e4, req.totalTimeoutMs - (Date.now() - startedAt))
-      ),
-      ...reinforce && { reinforceJsonContract: true }
-    } : reinforce ? { ...req, reinforceJsonContract: true } : req;
+    const attemptReq = reinforce ? { ...req, reinforceJsonContract: true } : req;
     const outcome2 = await attemptPortalJson(
       { ...attemptReq, transport },
-      endpoint
+      endpoint,
+      deadlineAt
     );
     if (outcome2.kind === "ok") {
       req.onAttempt?.({ attempt, ok: true });
@@ -938,13 +933,38 @@ async function callPortalJsonCompletion(req) {
   }
   return giveUp();
 }
-async function attemptPortalJson(req, endpoint) {
+async function attemptPortalJson(req, endpoint, deadlineAt) {
+  const controller = new AbortController();
+  if (deadlineAt === void 0 || deadlineAt - Date.now() > MAX_TIMER_DELAY_MS) {
+    return requestPortalJson(req, endpoint, controller);
+  }
+  const remainingMs = deadlineAt - Date.now();
+  if (remainingMs <= 0) return TIME_BUDGET_EXHAUSTED;
+  let timer;
+  try {
+    const outcome2 = await Promise.race([
+      new Promise((resolve) => {
+        timer = setTimeout(() => {
+          resolve(TIME_BUDGET_EXHAUSTED);
+          controller.abort();
+        }, remainingMs);
+      }),
+      requestPortalJson(req, endpoint, controller, deadlineAt)
+    ]);
+    return Date.now() >= deadlineAt ? TIME_BUDGET_EXHAUSTED : outcome2;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function requestPortalJson(req, endpoint, controller, deadlineAt) {
   const baseUrl = req.baseUrl ?? defaultBaseUrl();
   const fetchImpl = req.fetchFn ?? fetch;
-  const timeoutMs = req.timeoutMs ?? 6e4;
   const authHeaders = await resolvePortalAuthHeaders(req, req.tag);
+  const remainingMs = deadlineAt === void 0 ? Infinity : deadlineAt - Date.now();
+  if (controller.signal.aborted || remainingMs <= 0) return TIME_BUDGET_EXHAUSTED;
   if (authHeaders === null)
     return { kind: "terminal", code: "auth-unavailable", reason: "auth unavailable (no token)" };
+  const timeoutMs = Math.min(req.timeoutMs ?? 6e4, remainingMs);
   const usesPrefill = req.transport !== "responses" && req.model.startsWith("anthropic/");
   const prefill = usesPrefill ? "{" : "";
   const messages = [
@@ -954,7 +974,6 @@ async function attemptPortalJson(req, endpoint) {
   ];
   if (prefill) messages.push({ role: "assistant", content: prefill });
   const supportsJsonObjectFormat = supportsResponseFormat(req.model);
-  const controller = new AbortController();
   const timer = setTimeout(() => controller.abort(), timeoutMs);
   const requestBody = req.transport === "responses" ? {
     model: req.model,
@@ -1139,7 +1158,7 @@ function extractResponsesContent(body) {
   const text14 = root.output.filter((item) => asRecord(item)?.type === "message").flatMap((item) => Array.isArray(item.content) ? item.content : []).map((part) => asRecord(part)?.text).filter((t) => typeof t === "string").join("");
   return text14;
 }
-var RESPONSE_FORMAT_OK, RESPONSE_SCHEMA_OK, JSON_CONTRACT_REMINDER, RESPONSES_ONLY_MODEL_PREFIXES, CHAT_TO_RESPONSES_FIELDS, FOREIGN_ENDPOINT_SUFFIX, RETRYABLE_HTTP;
+var RESPONSE_FORMAT_OK, RESPONSE_SCHEMA_OK, JSON_CONTRACT_REMINDER, RESPONSES_ONLY_MODEL_PREFIXES, CHAT_TO_RESPONSES_FIELDS, FOREIGN_ENDPOINT_SUFFIX, TIME_BUDGET_EXHAUSTED, MAX_TIMER_DELAY_MS, RETRYABLE_HTTP;
 var init_portalLlm = __esm({
   "src/lib/memory/portalLlm.ts"() {
     "use strict";
@@ -1159,6 +1178,12 @@ var init_portalLlm = __esm({
       chat: "/responses",
       responses: "/chat/completions"
     };
+    TIME_BUDGET_EXHAUSTED = {
+      kind: "terminal",
+      code: "time-budget-exhausted",
+      reason: "time budget exhausted"
+    };
+    MAX_TIMER_DELAY_MS = 2147483647;
     RETRYABLE_HTTP = /* @__PURE__ */ new Set([408, 409, 425, 429]);
   }
 });
@@ -2338,15 +2363,16 @@ async function refreshEncryptionKeyIfMatches(walletAddress, probeCiphertext, sig
   if (!parsed) {
     return false;
   }
+  const startEpoch = sessionEpoch;
   const cached = refreshCandidatesByAddress.get(walletAddress);
   if (cached) {
-    return tryCommitCandidatesIfProbeMatches(walletAddress, parsed, cached);
+    return tryCommitCandidatesIfProbeMatches(walletAddress, parsed, cached, startEpoch);
   }
   let derivePromise = pendingCandidateDerives.get(walletAddress);
   if (!derivePromise) {
     derivePromise = (async () => {
       const candidates2 = await deriveRefreshCandidates(signMessage, embeddedWalletSigner);
-      if (candidates2) {
+      if (candidates2 && sessionEpoch === startEpoch) {
         refreshCandidatesByAddress.set(walletAddress, candidates2);
       }
       return candidates2;
@@ -2358,10 +2384,10 @@ async function refreshEncryptionKeyIfMatches(walletAddress, probeCiphertext, sig
     pendingCandidateDerives.set(walletAddress, derivePromise);
   }
   const candidates = await derivePromise;
-  if (!candidates) {
+  if (!candidates || sessionEpoch !== startEpoch) {
     return false;
   }
-  return tryCommitCandidatesIfProbeMatches(walletAddress, parsed, candidates);
+  return tryCommitCandidatesIfProbeMatches(walletAddress, parsed, candidates, startEpoch);
 }
 function parsePrefixedCiphertext(probeCiphertext) {
   const version = probeCiphertext.startsWith("enc:v3:") ? "v3" : probeCiphertext.startsWith("enc:v2:") ? "v2" : null;
@@ -2404,7 +2430,7 @@ async function deriveRefreshCandidates(signMessage, embeddedWalletSigner) {
   }
   return { legacy: legacyKey, current: currentKey };
 }
-async function tryCommitCandidatesIfProbeMatches(walletAddress, parsed, candidates) {
+async function tryCommitCandidatesIfProbeMatches(walletAddress, parsed, candidates, startEpoch) {
   const candidateHex = parsed.version === "v2" ? candidates.legacy : candidates.current;
   const keyBytes = hexToBytes(candidateHex);
   const candidateCryptoKey = await crypto.subtle.importKey(
@@ -2422,6 +2448,9 @@ async function tryCommitCandidatesIfProbeMatches(walletAddress, parsed, candidat
     );
     return false;
   }
+  if (sessionEpoch !== startEpoch) {
+    return false;
+  }
   setStoredKey(walletAddress, { legacy: candidates.legacy, current: candidates.current });
   cryptoKeyCache.delete(`${walletAddress}:v2`);
   cryptoKeyCache.delete(`${walletAddress}:v3`);
@@ -16784,6 +16813,16 @@ async function updateVaultMemoryOp(ctx, id2, opts) {
     const probe = await ctx.vaultMemoryCollection.find(id2);
     if (probe.isDeleted || probe.supersededBy || !isOwnedByCtxUser(ctx, probe)) return null;
     if (opts.freeFormOnly && isKinded(probe)) return null;
+    const readStoredContent = probe._getRaw("content");
+    if (opts.expectedContent !== void 0) {
+      const current = await vaultMemoryToStored(
+        probe,
+        ctx.walletAddress,
+        ctx.signMessage,
+        ctx.embeddedWalletSigner
+      );
+      if (current.content !== opts.expectedContent) return null;
+    }
     const levelAfter = (current) => {
       if (opts.level !== void 0) return opts.level;
       if (opts.scope === void 0) return resolveMemoryLevel(current.level, current.scope);
@@ -16791,7 +16830,7 @@ async function updateVaultMemoryOp(ctx, id2, opts) {
     };
     assertValidKindLevel(opts.kind !== void 0 ? opts.kind : probe.kind, levelAfter(probe));
     const encryptedKindValue = await encryptKindValue(ctx, opts.kindValue);
-    const encryptedContent = ctx.walletAddress && ctx.signMessage ? await encryptVaultMemoryContent(
+    const encryptedContent = opts.content !== void 0 && ctx.walletAddress && ctx.signMessage ? await encryptVaultMemoryContent(
       opts.content,
       ctx.walletAddress,
       ctx.signMessage,
@@ -16799,13 +16838,13 @@ async function updateVaultMemoryOp(ctx, id2, opts) {
     ) : opts.content;
     let stale = false;
     const record2 = probe;
-    const originalUpdatedAt = record2.updatedAt.getTime();
     await ctx.database.write(async () => {
       await assertCanWrite2(ctx);
-      if (record2.isDeleted || record2.supersededBy || !isOwnedByCtxUser(ctx, record2) || opts.freeFormOnly && isKinded(record2)) {
+      if (record2.isDeleted || record2.supersededBy || !isOwnedByCtxUser(ctx, record2) || opts.freeFormOnly && isKinded(record2) || opts.expectedContent !== void 0 && record2._getRaw("content") !== readStoredContent) {
         stale = true;
         return;
       }
+      const originalUpdatedAt = record2.updatedAt.getTime();
       const nextKind = opts.kind !== void 0 ? opts.kind : record2.kind;
       const nextLevel = levelAfter(record2);
       assertValidKindLevel(nextKind, nextLevel);
@@ -16821,7 +16860,7 @@ async function updateVaultMemoryOp(ctx, id2, opts) {
         replayedObservation = opts.observationSourceIds.every((id3) => observedSources.includes(id3));
       }
       await record2.update((r) => {
-        r._setRaw("content", encryptedContent);
+        if (encryptedContent !== void 0) r._setRaw("content", encryptedContent);
         if (opts.level !== void 0) {
           r._setRaw("level", nextLevel);
           r._setRaw("scope", scopeForLevel(nextLevel));
@@ -17589,7 +17628,7 @@ function classifyDecay(m, now, policy) {
   if (m.source === "manual" || m.source === SOURCE_PHOTO) return "keep";
   if (isTimeSensitiveType(m.factType) && m.eventTimeEnd !== null) {
     if (m.eventTimeEnd < now - resolved.pastEventGraceMs) return "archive";
-    if (m.eventTimeEnd >= now) return "keep";
+    return "keep";
   }
   if (now - lastActivityAt(m) > ttlForType(m.factType, resolved)) return "archive";
   return "keep";
@@ -19571,6 +19610,104 @@ function validate(parsed, originalQuery) {
   return { mode, subQueries };
 }
 
+// src/lib/memoryVault/vaultPreparation.ts
+function createVaultPreparation() {
+  return { corpora: /* @__PURE__ */ new WeakMap(), rows: /* @__PURE__ */ new WeakMap() };
+}
+var pendingRows = /* @__PURE__ */ new WeakMap();
+function loadVaultCorpus(ctx, options, preparation) {
+  if (!preparation) return getAllVaultMemoriesOp(ctx, options);
+  const corpusCache = preparation.corpora;
+  let pending = corpusCache.get(ctx);
+  if (!pending) {
+    pending = /* @__PURE__ */ new Map();
+    corpusCache.set(ctx, pending);
+  }
+  const key = JSON.stringify(options ?? {});
+  let request = pending.get(key);
+  if (!request) {
+    const entries = pending;
+    request = getAllVaultMemoriesOp(ctx, options).catch((error) => {
+      entries.delete(key);
+      throw error;
+    });
+    pending.set(key, request);
+  }
+  return request;
+}
+function rowRequestsFor(registry2, ctx, maskInput) {
+  let byMask = registry2.get(ctx);
+  if (!byMask) {
+    byMask = /* @__PURE__ */ new Map();
+    registry2.set(ctx, byMask);
+  }
+  let requests = byMask.get(maskInput);
+  if (!requests) {
+    requests = /* @__PURE__ */ new Map();
+    byMask.set(maskInput, requests);
+  }
+  return requests;
+}
+function embedVaultRows(ctx, options, rows, preparation) {
+  const pending = rowRequestsFor(pendingRows, ctx, options.maskInput);
+  const prepared = preparation && rowRequestsFor(preparation.rows, ctx, options.maskInput);
+  const model = options.model ?? DEFAULT_API_EMBEDDING_MODEL;
+  const keys = rows.map(
+    (row) => JSON.stringify([
+      row.uniqueId,
+      row.updatedAt?.getTime(),
+      row.content,
+      model,
+      options.baseUrl,
+      options.timeoutMs,
+      options.tokenTimeoutMs,
+      options.totalTimeoutMs
+    ])
+  );
+  const missing = /* @__PURE__ */ new Map();
+  rows.forEach((row, index) => {
+    if (!pending.has(keys[index]) && !prepared?.has(keys[index])) missing.set(keys[index], row);
+  });
+  if (missing.size > 0) {
+    const entries = pending;
+    const batch = Promise.resolve().then(
+      () => generateEmbeddings(
+        [...missing.values()].map((row) => row.content),
+        options
+      )
+    );
+    [...missing].forEach(([key, row], index) => {
+      const request = batch.then((vectors) => {
+        const vector = vectors[index];
+        updateVaultMemoryEmbeddingOp(ctx, row.uniqueId, JSON.stringify(vector), model, {
+          content: row.content,
+          updatedAt: row.updatedAt?.getTime()
+        }).catch(() => {
+        });
+        return vector;
+      }).finally(() => {
+        entries.delete(key);
+        if (entries.size === 0) pendingRows.get(ctx)?.delete(options.maskInput);
+      });
+      pending.set(key, request);
+    });
+  }
+  return Promise.all(
+    keys.map((key) => {
+      const cached = prepared?.get(key);
+      if (cached) return cached;
+      const request = pending.get(key);
+      if (!prepared) return request;
+      const retained = request.catch((error) => {
+        prepared.delete(key);
+        throw error;
+      });
+      prepared.set(key, retained);
+      return retained;
+    })
+  );
+}
+
 // src/lib/memoryVault/vectorVersion.ts
 var vectorRowVersion = /* @__PURE__ */ new WeakMap();
 function contentFingerprint(content) {
@@ -20133,11 +20270,11 @@ async function rankComposite(originalQuery, originalQueryEmbedding, subQueries,
   return combined.slice(0, limit);
 }
 async function preEmbedVaultMemories(vaultCtx, embeddingOptions, cache, options) {
-  const memories = await getAllVaultMemoriesOp(vaultCtx, options);
+  const memories = await loadVaultCorpus(vaultCtx, options);
   const currentModel = embeddingOptions.model ?? DEFAULT_API_EMBEDDING_MODEL;
   const uncachedTexts = [];
   const uncachedKeys = [];
-  const uncachedIds = [];
+  const uncachedRows = [];
   const uncachedVersions = [];
   for (const m of memories) {
     const content = m.content;
@@ -20156,12 +20293,12 @@ async function preEmbedVaultMemories(vaultCtx, embeddingOptions, cache, options)
       }
       uncachedTexts.push(m.content);
       uncachedKeys.push(m.uniqueId);
-      uncachedIds.push(m.uniqueId);
+      uncachedRows.push(m);
       uncachedVersions.push(m.updatedAt);
     }
   }
   if (uncachedTexts.length > 0) {
-    const embeddings = await generateEmbeddings(uncachedTexts, embeddingOptions);
+    const embeddings = await embedVaultRows(vaultCtx, embeddingOptions, uncachedRows);
     for (let i = 0; i < uncachedKeys.length; i++) {
       cacheRowVector(
         cache,
@@ -20170,13 +20307,6 @@ async function preEmbedVaultMemories(vaultCtx, embeddingOptions, cache, options)
         uncachedVersions[i],
         uncachedTexts[i]
       );
-      updateVaultMemoryEmbeddingOp(
-        vaultCtx,
-        uncachedIds[i],
-        JSON.stringify(embeddings[i]),
-        currentModel
-      ).catch(() => {
-      });
     }
   }
 }
@@ -20318,10 +20448,7 @@ async function buildProjectedCorpus(query, vaultCtx, embeddingOptions, cache, qu
       let laneVecs;
       if (opts.embedStats) opts.embedStats.rowsEmbedded += laneRows.length;
       try {
-        laneVecs = await generateEmbeddings(
-          laneRows.map((m) => m.content),
-          embeddingOptions
-        );
+        laneVecs = await embedVaultRows(vaultCtx, embeddingOptions, laneRows);
       } catch (err) {
         laneEmbedFailed = true;
         getLogger().warn(
@@ -20335,13 +20462,6 @@ async function buildProjectedCorpus(query, vaultCtx, embeddingOptions, cache, qu
           cacheRowVector(cache, m.uniqueId, vec, m.updatedAt, m.content);
           resolvedThisCall.add(m.uniqueId);
           vectored.push({ uniqueId: m.uniqueId, embedding: vec, updatedAt: m.updatedAt });
-          updateVaultMemoryEmbeddingOp(
-            vaultCtx,
-            m.uniqueId,
-            JSON.stringify(vecs[i]),
-            currentModel
-          ).catch(() => {
-          });
         });
       }
     }
@@ -20533,9 +20653,10 @@ async function prepareVaultCandidates(query, vaultCtx, embeddingOptions, cache,
       };
     }
   } else {
-    const loaded = await getAllVaultMemoriesOp(
+    const loaded = await loadVaultCorpus(
       vaultCtx,
-      Object.keys(queryOpts).length > 0 ? queryOpts : void 0
+      Object.keys(queryOpts).length > 0 ? queryOpts : void 0,
+      searchOptions?.vaultPreparation
     );
     vaultSize = loaded.length;
     rowsDecrypted = loaded.length;
@@ -20608,7 +20729,12 @@ async function prepareVaultCandidates(query, vaultCtx, embeddingOptions, cache,
       let newEmbeddings;
       embedStats.rowsEmbedded += uncachedTexts.length;
       try {
-        newEmbeddings = await generateEmbeddings(uncachedTexts, embeddingOptions);
+        newEmbeddings = await embedVaultRows(
+          vaultCtx,
+          embeddingOptions,
+          uncachedIndices.map((index) => memories[index]),
+          searchOptions?.vaultPreparation
+        );
       } catch (err) {
         embeddingFailure = true;
         getLogger().warn(
@@ -20624,13 +20750,6 @@ async function prepareVaultCandidates(query, vaultCtx, embeddingOptions, cache,
             memories[uncachedIndices[j]].updatedAt,
             memories[uncachedIndices[j]].content
           );
-          updateVaultMemoryEmbeddingOp(
-            vaultCtx,
-            memories[uncachedIndices[j]].uniqueId,
-            JSON.stringify(newEmbeddings[j]),
-            currentModel
-          ).catch(() => {
-          });
         }
       }
     }
@@ -21035,7 +21154,6 @@ async function retainWithPersistence(content, ctx, options = {}) {
           const factTypeUpdate = pickFactTypeUpdate(existing, options.factType);
           const resurrect = resurrectFields(existing);
           const updated = await ctx.persistence.update(targetId, {
-            content: existing.content,
             freeFormOnly: true,
             proofCountIncrement: 1,
             observationSourceIds: options.sourceChunkIds,
@@ -21274,7 +21392,6 @@ async function tryConsolidate(trimmed, ctx, options, prepared) {
     const factTypeUpdate = pickFactTypeUpdate(existing, options.factType);
     const resurrect = resurrectFields(existing);
     const updated = await ctx.persistence.update(decision.targetId, {
-      content: existing.content,
       freeFormOnly: true,
       proofCountIncrement: 1,
       observationSourceIds: options.sourceChunkIds,
@@ -21302,6 +21419,10 @@ async function tryConsolidate(trimmed, ctx, options, prepared) {
     };
   }
   if (decision.action === "update" && decision.targetId && decision.content) {
+    const expectedContent = candidates.find(
+      (candidate) => candidate.id === decision.targetId
+    )?.content;
+    if (expectedContent === void 0) return null;
     const existing = await ctx.persistence.get(decision.targetId);
     if (!existing || existing.supersededBy) {
       return abandonToRace(
@@ -21309,6 +21430,9 @@ async function tryConsolidate(trimmed, ctx, options, prepared) {
         `update: target ${decision.targetId} ${existing ? "superseded" : "deleted"} before the write`
       );
     }
+    if (existing.content !== expectedContent) {
+      return abandonToRace(options, `update: target ${decision.targetId} edited before the write`);
+    }
     const mergedSourceIds = unionStrings(
       existing.sourceChunkIds ?? [],
       options.sourceChunkIds ?? []
@@ -21321,6 +21445,7 @@ async function tryConsolidate(trimmed, ctx, options, prepared) {
     const resurrect = resurrectFields(existing);
     const updated = await ctx.persistence.update(decision.targetId, {
       content: decision.content,
+      expectedContent,
       freeFormOnly: true,
       proofCountIncrement: 1,
       observationSourceIds: options.sourceChunkIds,
@@ -21333,10 +21458,10 @@ async function tryConsolidate(trimmed, ctx, options, prepared) {
       ...factTypeUpdate !== void 0 && { factType: factTypeUpdate }
     });
     if (!updated) {
-      await assertMergeTargetGoneOrThrow(ctx, decision.targetId);
+      await assertMergeTargetGoneOrThrow(ctx, decision.targetId, expectedContent);
       return abandonToRace(
         options,
-        `update: target ${decision.targetId} deleted mid-write (consolidated rewrite lost)`
+        `update: target ${decision.targetId} changed mid-write (consolidated rewrite lost)`
       );
     }
     cacheRowVector(
@@ -21363,9 +21488,9 @@ async function tryConsolidate(trimmed, ctx, options, prepared) {
   );
   return null;
 }
-async function assertMergeTargetGoneOrThrow(ctx, targetId) {
+async function assertMergeTargetGoneOrThrow(ctx, targetId, expectedContent) {
   const stillExists = await (ctx.persistence.getFresh ? ctx.persistence.getFresh(targetId) : ctx.persistence.get(targetId));
-  if (stillExists && (stillExists.kind === null || stillExists.kind === void 0)) {
+  if (stillExists && (stillExists.kind === null || stillExists.kind === void 0) && (expectedContent === void 0 || stillExists.content === expectedContent)) {
     throw new RetainError(
       "merge-not-persisted",
       `retain: merge into memory ${targetId} failed to persist`
@@ -23211,6 +23336,7 @@ async function recall(query, ctx, options = {}) {
         },
         ...options.rrfK !== void 0 && { rrfK: options.rrfK },
         ...options.decryptLast !== void 0 && { decryptLast: options.decryptLast },
+        ...options.vaultPreparation && { vaultPreparation: options.vaultPreparation },
         ...subQueries && { subQueries },
         ...options.scopes && { scopes: options.scopes },
         ...options.folderId !== void 0 && { folderId: options.folderId },
@@ -24802,16 +24928,16 @@ function createRemoteMemoryPipeline(options) {
       create: (input) => write(createRow(input), 0),
       update: async (id2, patch) => {
         const existing = await get(id2);
-        if (!existing || patch.freeFormOnly && existing.kind !== null && existing.kind !== void 0)
+        if (!existing || patch.expectedContent !== void 0 && existing.content !== patch.expectedContent || patch.freeFormOnly && existing.kind !== null && existing.kind !== void 0)
           return null;
         const snapshot = snapshots.get(id2);
         const memory = {
           ...snapshot.memory,
-          content: patch.content,
+          content: patch.content ?? snapshot.memory.content,
           updated_at: patch.preserveUpdatedAt ? snapshot.memory.updated_at : Math.max(Date.now(), (snapshot.memory.topics_extracted_at ?? 0) + 1)
         };
         if (patch.scope !== void 0) memory.scope = patch.scope;
-        if (patch.embedding === void 0 && patch.content !== snapshot.memory.content) {
+        if (patch.embedding === void 0 && patch.content !== void 0 && patch.content !== snapshot.memory.content) {
           delete memory.embedding;
           delete memory.embedding_model;
         }
@@ -26816,13 +26942,20 @@ async function synthesizeProfile(ctx, options = {}) {
       }
     }
   }
+  const vaultPreparation = createVaultPreparation();
   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, recallCtx, options, fallbackPriors.get(facet.key));
+      return synthesizeFacet(
+        facet,
+        recallCtx,
+        options,
+        fallbackPriors.get(facet.key),
+        vaultPreparation
+      );
     })
   );
   const sections = settled.map((r, i) => {
@@ -26976,7 +27109,7 @@ async function attributeFacts(ctx, candidates, facets) {
   }
   return keys;
 }
-async function synthesizeFacet(facet, ctx, options, prior) {
+async function synthesizeFacet(facet, ctx, options, prior, vaultPreparation) {
   const scopes = options.scopes ?? DEFAULT_SCOPES;
   const limit = options.limit ?? DEFAULT_FACET_RECALL_LIMIT;
   const factTypeWeights = { ...DEFAULT_PROFILE_FACT_TYPE_WEIGHTS, ...options.factTypeWeights };
@@ -26993,6 +27126,7 @@ async function synthesizeFacet(facet, ctx, options, prior) {
     };
   }
   const recalled = await recall(facet.query, ctx, {
+    vaultPreparation,
     scopes,
     limit: hasReviewGate ? RECALL_MAX_LIMIT : limit,
     types: ["fact"],
@@ -38557,17 +38691,24 @@ var import_react20 = require("react");
 init_clientConfig();
 function useTools(options) {
   const { getToken, baseUrl = BASE_URL, includeTools, autoFetch = true } = options;
-  const [tools, setTools] = (0, import_react20.useState)([]);
+  const [allTools, setAllTools] = (0, import_react20.useState)([]);
   const [checksum, setChecksum] = (0, import_react20.useState)(getToolsChecksum2);
   const [isLoading, setIsLoading] = (0, import_react20.useState)(false);
   const [error, setError] = (0, import_react20.useState)(null);
+  const includeToolsRef = (0, import_react20.useRef)(includeTools);
+  if (includeTools !== includeToolsRef.current && (includeTools === void 0 || includeToolsRef.current === void 0 || includeTools.length !== includeToolsRef.current.length || includeTools.some((name, i) => name !== includeToolsRef.current?.[i]))) {
+    includeToolsRef.current = includeTools;
+  }
+  const stableIncludeTools = includeToolsRef.current;
+  const tools = (0, import_react20.useMemo)(
+    () => filterServerTools(allTools, stableIncludeTools),
+    [allTools, stableIncludeTools]
+  );
   const getTokenRef = (0, import_react20.useRef)(getToken);
   const baseUrlRef = (0, import_react20.useRef)(baseUrl);
-  const includeToolsRef = (0, import_react20.useRef)(includeTools);
   (0, import_react20.useEffect)(() => {
     getTokenRef.current = getToken;
     baseUrlRef.current = baseUrl;
-    includeToolsRef.current = includeTools;
   });
   const fetchTools = (0, import_react20.useCallback)(async (forceRefresh = false) => {
     setIsLoading(true);
@@ -38578,8 +38719,7 @@ function useTools(options) {
         baseUrl: baseUrlRef.current,
         forceRefresh
       });
-      const filteredTools = filterServerTools(fetchedTools, includeToolsRef.current);
-      setTools(filteredTools);
+      setAllTools(fetchedTools);
       setChecksum(getToolsChecksum2());
     } catch (err) {
       setError(err instanceof Error ? err : new Error(String(err)));
@@ -38603,11 +38743,6 @@ function useTools(options) {
     },
     [refresh]
   );
-  (0, import_react20.useEffect)(() => {
-    if (tools.length > 0 && includeTools !== void 0) {
-      setTools((currentTools) => filterServerTools(currentTools, includeTools));
-    }
-  }, [includeTools, tools.length]);
   const hasFetchedRef = (0, import_react20.useRef)(false);
   (0, import_react20.useEffect)(() => {
     if (autoFetch && !hasFetchedRef.current) {

package/dist/react/index.d.mts

@@ -4402,6 +4402,13 @@ interface RecencyOptions {
     noDateMultiplier?: number;
 }
 
+type VaultCorpusCache = WeakMap<VaultMemoryOperationsContext, Map<string, Promise<StoredVaultMemory[]>>>;
+type RowRequests = Map<EmbeddingOptions["maskInput"], Map<string, Promise<number[]>>>;
+interface VaultPreparation {
+    corpora: VaultCorpusCache;
+    rows: WeakMap<VaultMemoryOperationsContext, RowRequests>;
+}
+
 declare const DEFAULT_VAULT_CACHE_SIZE = 5000;
 /**
  * Create a VaultEmbeddingCache backed by an LRU with a default cap of
@@ -4419,6 +4426,7 @@ type VaultEmbeddingCache = Map<string, Float32Array>;
  * Options for the vault search tool.
  */
 interface MemoryVaultSearchOptions {
+    /** @internal */ vaultPreparation?: VaultPreparation;
     onCandidateCount?: (count: number) => void;
     /** Maximum number of results to return (default: 5) */
     limit?: number;
@@ -4957,6 +4965,7 @@ interface RankedMemory {
     updatedAt: Date;
 }
 interface RecallOptions {
+    /** @internal */ vaultPreparation?: VaultPreparation;
     /** Embedding cache shared with the rest of the turn, so the query is embedded once across lanes and the send. */
     embeddingCache?: Map<string, Float32Array>;
     /** Which kinds to search. Default: ['fact']. */
@@ -6176,7 +6185,8 @@ interface CreateVaultMemoryOptions {
     geohash?: string;
 }
 interface UpdateVaultMemoryOptions {
-    content: string;
+    content?: string;
+    expectedContent?: string;
     /** When true, the write is skipped (returns null) if the row carries a profile kind. */
     freeFormOnly?: boolean;
     /**
@@ -6869,9 +6879,10 @@ declare function ttlForType(factType: string | null, policy?: Partial<DecayPolic
  *     null `eventTimeEnd` is still ongoing, so this rule does not fire for it.
  *  4. Age fallback — `now - updatedAt > TTL(factType)` → archive. Durable types
  *     have Infinity TTL, so this never fires for them; null/unknown use medium.
- *     EXCEPTION: a `plan`/`ongoing_context` with a still-upcoming event
- *     (`eventTimeEnd >= now`) is kept — it must not age-archive before the event
- *     happens; only rule 3 (after it passes) may archive it.
+ *     EXCEPTION: a `plan` / `ongoing_context` with an upcoming event or an event
+ *     within the grace period (`eventTimeEnd >= now - pastEventGraceMs`) stays
+ *     active, even after its activity TTL expires. Rule 3 archives it after the
+ *     grace period ends.
  *  5. Otherwise → keep.
  *
  * @param m     Plaintext decay inputs for one row.
@@ -7202,7 +7213,9 @@ type MemoryCreate = Pick<CreateVaultMemoryOptions, "content" | "scope" | "factTy
  * `embedding` (with `embeddingModel`) only when you already have the new one.
  * @public
  */
-type MemoryUpdate = Pick<UpdateVaultMemoryOptions, "content" | "scope" | "factType" | "eventTime" | "embedding" | "embeddingModel" | "kind" | "kindValue" | "level">;
+type MemoryUpdate = Pick<UpdateVaultMemoryOptions, "scope" | "factType" | "eventTime" | "embedding" | "embeddingModel" | "kind" | "kindValue" | "level"> & {
+    content: string;
+};
 /**
  * Fact-only recall. Conversation chunks are message storage, not memory, so
  * the chunk-lane knobs are not part of this surface; nor is `folderId` (see