@anuma/sdk 7.0.6 → 7.1.0

package/dist/expo/index.mjs

@@ -11131,6 +11131,11 @@ import { Q as Q5 } from "@nozbe/watermelondb";
 
 // src/lib/db/entities/operations.ts
 import { Q as Q4 } from "@nozbe/watermelondb";
+async function assertCanWrite(ctx) {
+  if (ctx.canWrite && !await ctx.canWrite()) {
+    throw new Error("Memory source is no longer eligible");
+  }
+}
 function entityToStored(e) {
   return {
     uniqueId: e.id,
@@ -11271,6 +11276,7 @@ async function linkMemoryEntitiesOp(ctx, memoryId, entityInputs, options) {
   let skipped = false;
   let entities = [];
   await ctx.database.write(async () => {
+    await assertCanWrite(ctx);
     const {
       entities: byName,
       operations: entityOps,
@@ -11346,6 +11352,7 @@ async function replaceMemoryEntities(ctx, memoryId, entityInputs, options) {
   let skipped = false;
   let entities = [];
   await ctx.database.write(async () => {
+    await assertCanWrite(ctx);
     const vaultRow = await findVaultRowInWrite(ctx, memoryId);
     if (options.guarded && autoLinkBlocked(vaultRow)) {
       skipped = true;
@@ -11406,6 +11413,7 @@ async function unlinkMemoryEntitiesOp(ctx, memoryIds) {
   const links = await ctx.memoryEntityCollection.query(Q4.where("memory_id", Q4.oneOf(Array.from(memoryIds)))).fetch();
   if (links.length === 0) return;
   await ctx.database.write(async () => {
+    await assertCanWrite(ctx);
     await ctx.database.batch(...links.map((l) => l.prepareDestroyPermanently()));
   });
 }
@@ -11414,6 +11422,7 @@ async function unlinkAllMemoryEntitiesForUserOp(ctx, userId) {
   const links = await ctx.memoryEntityCollection.query(Q4.where("user_id", userId)).fetch();
   if (links.length === 0) return;
   await ctx.database.write(async () => {
+    await assertCanWrite(ctx);
     await ctx.database.batch(...links.map((l) => l.prepareDestroyPermanently()));
   });
 }
@@ -11505,6 +11514,17 @@ async function decryptVaultMemoryFields(memory, address, signMessage, embeddedWa
   };
 }
 
+// src/lib/db/memoryVault/sourceChunkIds.ts
+var MAX_SOURCE_CHUNK_IDS_BYTES = 16 << 10;
+var utf8 = new TextEncoder();
+function serializeSourceChunkIds(ids) {
+  const sizes = ids.map((id) => utf8.encode(JSON.stringify(id)).length + 1);
+  let total = sizes.reduce((sum, size) => sum + size, 1);
+  let start = 0;
+  while (total > MAX_SOURCE_CHUNK_IDS_BYTES && start < ids.length) total -= sizes[start++];
+  return JSON.stringify(ids.slice(start));
+}
+
 // src/lib/db/memoryVault/types.ts
 var MEMORY_KINDS = [
   "display_name",
@@ -11577,6 +11597,11 @@ function visibilityConditions(requested) {
 function isKinded(record2) {
   return record2.kind !== null && record2.kind !== void 0;
 }
+async function assertCanWrite2(ctx) {
+  if (ctx.canWrite && !await ctx.canWrite()) {
+    throw new Error("Memory source is no longer eligible");
+  }
+}
 function assertValidKindLevel(kind, level) {
   const hasKind = kind !== null && kind !== void 0;
   if (hasKind && !MEMORY_KINDS.includes(kind)) {
@@ -11652,15 +11677,15 @@ async function mapInBatches(items, fn) {
   return results;
 }
 function vaultMemoryToStoredRaw(memory) {
-  let sourceChunkIds = null;
+  let sourceChunkIds2 = null;
   if (memory.sourceChunkIds) {
     try {
       const parsed = JSON.parse(memory.sourceChunkIds);
       if (Array.isArray(parsed)) {
-        sourceChunkIds = parsed.filter((s) => typeof s === "string");
+        sourceChunkIds2 = parsed.filter((s) => typeof s === "string");
       }
     } catch {
-      sourceChunkIds = null;
+      sourceChunkIds2 = null;
     }
   }
   return {
@@ -11674,7 +11699,7 @@ function vaultMemoryToStoredRaw(memory) {
     userId: memory.userId ?? null,
     embedding: memory.embedding ?? null,
     embeddingModel: memory.embeddingModel ?? null,
-    sourceChunkIds,
+    sourceChunkIds: sourceChunkIds2,
     proofCount: memory.proofCount ?? null,
     source: memory.source ?? null,
     media: parseMedia(memory.media),
@@ -11723,7 +11748,7 @@ function populateNewVaultMemory(record2, ctx, opts, encryptedContent, encryptedK
     record2._setRaw("embedding_model", opts.embeddingModel ?? null);
   }
   if (opts.sourceChunkIds !== void 0) {
-    record2._setRaw("source_chunk_ids", JSON.stringify(opts.sourceChunkIds));
+    record2._setRaw("source_chunk_ids", serializeSourceChunkIds(opts.sourceChunkIds));
   }
   record2._setRaw("proof_count", opts.proofCount ?? 1);
   record2._setRaw("source", opts.source ?? "manual");
@@ -11757,8 +11782,7 @@ async function createVaultMemoryOp(ctx, opts) {
     ctx.embeddedWalletSigner
   ) : opts.content;
   const created = await ctx.database.write(async () => {
-    if (ctx.canWrite && !await ctx.canWrite())
-      throw new Error("Memory source is no longer eligible");
+    await assertCanWrite2(ctx);
     return ctx.vaultMemoryCollection.create(
       (record2) => populateNewVaultMemory(record2, ctx, opts, encryptedContent, encryptedKindValue)
     );
@@ -11777,8 +11801,7 @@ async function createSupersedingMemoryOp(ctx, opts, targetId) {
   ) : opts.content;
   let createdRecord = null;
   await ctx.database.write(async () => {
-    if (ctx.canWrite && !await ctx.canWrite())
-      throw new Error("Memory source is no longer eligible");
+    await assertCanWrite2(ctx);
     let target;
     try {
       target = await ctx.vaultMemoryCollection.find(targetId);
@@ -11870,8 +11893,7 @@ async function createVaultMemoriesBatchOp(ctx, optionsArray) {
     })
   );
   const created = await ctx.database.write(async () => {
-    if (ctx.canWrite && !await ctx.canWrite())
-      throw new Error("Memory source is no longer eligible");
+    await assertCanWrite2(ctx);
     const prepared = optionsArray.map(
       (opts, i) => ctx.vaultMemoryCollection.prepareCreate(
         (record2) => populateNewVaultMemory(record2, ctx, opts, encryptedContents[i], encryptedKindValues[i])
@@ -11901,16 +11923,16 @@ async function getVaultMemoryOp(ctx, id) {
   }
 }
 function vaultMemoryRawToStoredRaw(raw) {
-  let sourceChunkIds = null;
+  let sourceChunkIds2 = null;
   const rawChunks = raw.source_chunk_ids;
   if (typeof rawChunks === "string" && rawChunks) {
     try {
       const parsed = JSON.parse(rawChunks);
       if (Array.isArray(parsed)) {
-        sourceChunkIds = parsed.filter((s) => typeof s === "string");
+        sourceChunkIds2 = parsed.filter((s) => typeof s === "string");
       }
     } catch {
-      sourceChunkIds = null;
+      sourceChunkIds2 = null;
     }
   }
   return {
@@ -11924,7 +11946,7 @@ function vaultMemoryRawToStoredRaw(raw) {
     userId: raw.user_id ?? null,
     embedding: raw.embedding ?? null,
     embeddingModel: raw.embedding_model ?? null,
-    sourceChunkIds,
+    sourceChunkIds: sourceChunkIds2,
     proofCount: raw.proof_count ?? null,
     source: raw.source ?? null,
     eventTimeStart: raw.event_time_start ?? null,
@@ -12176,8 +12198,7 @@ async function updateVaultMemoryOp(ctx, id, opts) {
     const record2 = probe;
     const originalUpdatedAt = record2.updatedAt.getTime();
     await ctx.database.write(async () => {
-      if (ctx.canWrite && !await ctx.canWrite())
-        throw new Error("Memory source is no longer eligible");
+      await assertCanWrite2(ctx);
       if (record2.isDeleted || record2.supersededBy || !isOwnedByCtxUser(ctx, record2) || opts.freeFormOnly && isKinded(record2)) {
         stale = true;
         return;
@@ -12221,7 +12242,7 @@ async function updateVaultMemoryOp(ctx, id, opts) {
         if (opts.sourceChunkIds !== void 0) {
           r._setRaw(
             "source_chunk_ids",
-            JSON.stringify(
+            serializeSourceChunkIds(
               opts.observationSourceIds?.length ? [.../* @__PURE__ */ new Set([...observedSources, ...opts.sourceChunkIds])] : opts.sourceChunkIds
             )
           );
@@ -12288,6 +12309,7 @@ async function setMemoryEntitiesOp(ctx, memoryId, entities) {
   let stale = false;
   const originalUpdatedAt = record2.updatedAt.getTime();
   await ctx.database.write(async (writer) => {
+    await assertCanWrite2(ctx);
     if (record2.isDeleted || !isOwnedByCtxUser(ctx, record2)) {
       stale = true;
       return;
@@ -12329,6 +12351,7 @@ async function clearMemoryTopicsOverrideOp(ctx, memoryId, options) {
   const originalUpdatedAt = record2.updatedAt.getTime();
   let cleared = false;
   await ctx.database.write(async () => {
+    await assertCanWrite2(ctx);
     if (options?.unlessTopicsRecorded && parseTopics(record2.topics) !== null) return;
     cleared = true;
     await record2.update((r) => {
@@ -12352,6 +12375,7 @@ async function setMemoryVisibilityOp(ctx, id, opts) {
   if (record2.isDeleted || !isOwnedByCtxUser(ctx, record2)) return null;
   let stale = false;
   await ctx.database.write(async () => {
+    await assertCanWrite2(ctx);
     if (record2.isDeleted || !isOwnedByCtxUser(ctx, record2)) {
       stale = true;
       return;
@@ -12380,6 +12404,7 @@ async function deleteVaultMemoryOp(ctx, id) {
     if (record2.isDeleted || !isOwnedByCtxUser(ctx, record2)) return false;
     let stale = false;
     await ctx.database.write(async () => {
+      await assertCanWrite2(ctx);
       if (record2.isDeleted || !isOwnedByCtxUser(ctx, record2)) {
         stale = true;
         return;
@@ -12417,8 +12442,7 @@ async function supersedeVaultMemoryOp(ctx, id, supersededById) {
     }
     let stale = false;
     await ctx.database.write(async () => {
-      if (ctx.canWrite && !await ctx.canWrite())
-        throw new Error("Memory source is no longer eligible");
+      await assertCanWrite2(ctx);
       if (record2.isDeleted || record2.supersededBy || !isOwnedByCtxUser(ctx, record2)) {
         stale = true;
         return;
@@ -12580,6 +12604,7 @@ async function stampTopicsExtractedAtOp(ctx, memoryIds, extractedAt, version = T
   for (let i = 0; i < uniqueIds.length; i += CHUNK) {
     const chunkIds = uniqueIds.slice(i, i + CHUNK);
     await ctx.database.write(async () => {
+      await assertCanWrite2(ctx);
       const records = [];
       for (const id of chunkIds) {
         try {
@@ -12613,6 +12638,7 @@ async function relinkMemoryTopicsOp(ctx, memoryIds) {
   for (const id of Array.from(new Set(memoryIds))) {
     try {
       await ctx.database.write(async (writer) => {
+        await assertCanWrite2(ctx);
         let record2;
         try {
           record2 = await ctx.vaultMemoryCollection.find(id);
@@ -12643,6 +12669,7 @@ async function backfillMemoryTopicsOp(ctx, memoryIds) {
   for (let i = 0; i < uniqueIds.length; i += CHUNK) {
     const chunkIds = uniqueIds.slice(i, i + CHUNK);
     await ctx.database.write(async () => {
+      await assertCanWrite2(ctx);
       const writes = [];
       for (const id of chunkIds) {
         let record2;
@@ -12675,6 +12702,7 @@ async function deleteAllVaultMemoriesForUserOp(ctx, userId) {
   const records = await ctx.vaultMemoryCollection.query(Q5.where("user_id", userId), Q5.where("is_deleted", false)).fetch();
   if (records.length === 0) return 0;
   await ctx.database.write(async () => {
+    await assertCanWrite2(ctx);
     const prepared = records.map(
       (record2) => record2.prepareUpdate((r) => {
         r._setRaw("is_deleted", true);
@@ -12729,6 +12757,7 @@ async function archiveVaultMemoryOp(ctx, id, opts) {
     let stale = false;
     const archivedAtValue = opts?.now ?? Date.now();
     await ctx.database.write(async () => {
+      await assertCanWrite2(ctx);
       if (record2.isDeleted || !isOwnedByCtxUser(ctx, record2) || record2.archivedAt !== null) {
         stale = true;
         return;
@@ -12752,6 +12781,7 @@ async function restoreVaultMemoryOp(ctx, id) {
     if (record2.isDeleted || !isOwnedByCtxUser(ctx, record2)) return false;
     let stale = false;
     await ctx.database.write(async () => {
+      await assertCanWrite2(ctx);
       if (record2.isDeleted || !isOwnedByCtxUser(ctx, record2)) {
         stale = true;
         return;
@@ -12772,6 +12802,7 @@ async function hardDeleteDecayedOp(ctx, id, opts) {
     const now = opts.now ?? Date.now();
     let stale = false;
     await ctx.database.write(async () => {
+      await assertCanWrite2(ctx);
       const archivedAt = record2.archivedAt;
       if (record2.isDeleted || !isOwnedByCtxUser(ctx, record2) || archivedAt === null || now - archivedAt <= opts.hardDeleteWindowMs) {
         stale = true;
@@ -12811,6 +12842,7 @@ async function updateVaultMemoryEmbeddingOp(ctx, id, embedding2, embeddingModel,
     }
     let written = false;
     await ctx.database.write(async () => {
+      await assertCanWrite2(ctx);
       if (record2.isDeleted || !isOwnedByCtxUser(ctx, record2)) return;
       const originalUpdatedAt = record2.updatedAt.getTime();
       if (originalUpdatedAt !== readUpdatedAt || record2._getRaw("content") !== readStoredContent)
@@ -16323,6 +16355,13 @@ function restoreCandidates(candidates, redactor, ownNames) {
   ).map((c) => c.candidate);
 }
 async function extractAndRetain(messages, retainCtx, options) {
+  const { memoryStore, signal } = options;
+  if (memoryStore === null) throw new Error("Memory store is not ready");
+  if (memoryStore && options.folderId !== void 0 && options.folderId !== null)
+    throw new Error("Remote memory extraction does not support folders");
+  if (memoryStore && options.extract.piiRedaction && !memoryStore.masksEmbeddingInput)
+    throw new Error("PII-redacted extraction requires a memory store that masks embedding inputs");
+  signal?.throwIfAborted();
   const minConfidence = options.minConfidence ?? DEFAULT_MIN_CONFIDENCE;
   const resolvedConsolidatePii = options.consolidateOptions?.piiRedaction ?? options.extract.piiRedaction;
   const consolidateOptions = options.consolidateOptions !== void 0 ? {
@@ -16356,6 +16395,7 @@ async function extractAndRetain(messages, retainCtx, options) {
     }
   });
   const extractMs = Date.now() - tExtract;
+  signal?.throwIfAborted();
   const filtered = candidates.filter((c) => c.confidence >= minConfidence);
   const log = getLogger();
   const screened = screenCandidatesForInjection(filtered);
@@ -16403,16 +16443,33 @@ async function extractAndRetain(messages, retainCtx, options) {
   const results = [];
   const quarantinedInfo = [];
   let failedWrites = 0;
+  let auditRows;
   const tRetain = Date.now();
   for (const { candidate, isQuarantined, reason, signature } of toRetain) {
     try {
+      signal?.throwIfAborted();
       if (isQuarantined) {
-        const existingId = await findQuarantinedDuplicateOp(
-          retainCtx.vaultCtx,
-          candidate.content,
-          candidate.sourceMessageIds,
-          { scope: options.scope ?? "private", folderId: options.folderId ?? null }
-        ).catch(() => null);
+        let existingId;
+        if (memoryStore) {
+          auditRows ?? (auditRows = memoryStore.list({
+            scopes: [options.scope ?? "private"],
+            includeArchived: true,
+            includeQuarantined: true,
+            includeSuperseded: true
+          }));
+          const sourceKey = [...new Set(candidate.sourceMessageIds)].sort().join("\0");
+          const normalize = (value) => value.normalize("NFKC").trim().replace(/\s+/g, " ").toLowerCase();
+          existingId = (await auditRows).find(
+            (row) => row.trustTier === "quarantined" && row.scope === (options.scope ?? "private") && [...new Set(row.sourceChunkIds ?? [])].sort().join("\0") === sourceKey && normalize(row.content) === normalize(candidate.content)
+          )?.uniqueId ?? null;
+        } else {
+          existingId = await findQuarantinedDuplicateOp(
+            retainCtx.vaultCtx,
+            candidate.content,
+            candidate.sourceMessageIds,
+            { scope: options.scope ?? "private", folderId: options.folderId ?? null }
+          ).catch(() => null);
+        }
         if (existingId) {
           quarantinedInfo.push({
             candidate,
@@ -16423,18 +16480,26 @@ async function extractAndRetain(messages, retainCtx, options) {
           continue;
         }
       }
-      const result = await retain(candidate.content, retainCtx, {
+      const retainOptions = {
         source: "auto-extracted",
         sourceChunkIds: candidate.sourceMessageIds,
         respectTombstones: true,
         ...options.scope !== void 0 && { scope: options.scope },
-        ...options.folderId !== void 0 && { folderId: options.folderId },
         ...consolidateOptions !== void 0 && { consolidateOptions },
         ...candidate.eventTime !== null && { eventTime: candidate.eventTime },
         factType: candidate.type,
         ...isQuarantined && { trustTier: "quarantined", enableAutoMerge: false }
+      };
+      const result = memoryStore ? await memoryStore.retain(candidate.content, {
+        ...retainOptions,
+        canWrite: retainCtx.vaultCtx.canWrite,
+        signal
+      }) : await retain(candidate.content, retainCtx, {
+        ...retainOptions,
+        ...options.folderId !== void 0 && { folderId: options.folderId }
       });
       if (isQuarantined) {
+        auditRows = void 0;
         const info = {
           candidate,
           memoryId: result.memoryId,
@@ -16453,9 +16518,16 @@ async function extractAndRetain(messages, retainCtx, options) {
       }
       succeededCandidates.push(candidate);
       results.push(result);
-      if (result.action !== "suppressed" && options.entityCtx && candidate.entities.length > 0) {
+      if (result.action !== "suppressed" && candidate.entities.length > 0) {
         try {
-          if (!await isMemoryTopicsUserManaged(options.entityCtx, result.memoryId)) {
+          signal?.throwIfAborted();
+          if (memoryStore) {
+            await memoryStore.addTopics(result.memoryId, candidate.entities, {
+              unlessUserManaged: true,
+              canWrite: retainCtx.vaultCtx.canWrite,
+              signal
+            });
+          } else if (options.entityCtx && !await isMemoryTopicsUserManaged(options.entityCtx, result.memoryId)) {
             await linkMemoryEntitiesOp(options.entityCtx, result.memoryId, candidate.entities, {
               unlessTopicsUserManaged: true
             });
@@ -16703,7 +16775,7 @@ function createAutoExtractor(options) {
   };
   const consolidateOptions = options.consolidate ? { ...options.consolidate, ...subPassAuth(options.consolidate.baseUrl) } : void 0;
   const injectionClassifierOptions = options.injectionClassifier ? { ...options.injectionClassifier, ...subPassAuth(options.injectionClassifier.baseUrl) } : void 0;
-  if (options.retainCtx.vaultCtx.entityCtx && !options.entityCtx) {
+  if (!options.memoryStore && options.retainCtx.vaultCtx.entityCtx && !options.entityCtx) {
     getLogger().warn(
       "[memory/extract] retainCtx.vaultCtx.entityCtx is set but extractor was created without `entityCtx` \u2014 W5 graph lane will receive no writes"
     );
@@ -16748,6 +16820,8 @@ function createAutoExtractor(options) {
       try {
         const { candidates, results, failedCount, outcome: outcome2, failure, funnel, timings, model } = await extractAndRetain(window2, retainCtx, {
           extract,
+          memoryStore: options.memoryStore,
+          signal: options.signal,
           ...options.minConfidence !== void 0 && { minConfidence: options.minConfidence },
           ...options.entityCtx !== void 0 && { entityCtx: options.entityCtx },
           ...options.scope !== void 0 && { scope: options.scope },
@@ -18834,6 +18908,7 @@ function createLocalMemoryStore(options) {
     database,
     entityCollection: database.get("entity"),
     memoryEntityCollection: database.get("memory_entity"),
+    canWrite: options.canWrite,
     ...userId !== void 0 && { userId },
     ...options.allowUnscopedRows !== void 0 && {
       allowUnscopedRows: options.allowUnscopedRows
@@ -18845,10 +18920,21 @@ function createLocalMemoryStore(options) {
     walletAddress: options.walletAddress,
     signMessage: options.signMessage,
     embeddedWalletSigner: options.embeddedWalletSigner,
+    canWrite: options.canWrite,
     ...userId !== void 0 && { userId },
     ...options.singleTenant !== void 0 && { singleTenant: options.singleTenant },
     entityCtx
   };
+  const assertWrite = async (writeOptions) => {
+    writeOptions?.signal?.throwIfAborted();
+    if (writeOptions?.canWrite && !await writeOptions.canWrite()) {
+      throw new Error("Memory source is no longer eligible");
+    }
+    if (options.canWrite && !await options.canWrite()) {
+      throw new Error("Memory source is no longer eligible");
+    }
+    writeOptions?.signal?.throwIfAborted();
+  };
   const vaultCache = options.vaultCache ?? createVaultEmbeddingCache();
   const ownedBy = userId !== void 0 ? [Q8.where("user_id", userId)] : [];
   const linksOwnedBy = userId === void 0 ? [] : options.allowUnscopedRows ? [Q8.or(Q8.where("user_id", userId), Q8.where("user_id", null))] : [Q8.where("user_id", userId)];
@@ -18960,9 +19046,25 @@ function createLocalMemoryStore(options) {
     archive: (id) => archiveVaultMemoryOp(vaultCtx, id),
     restore: (id) => restoreVaultMemoryOp(vaultCtx, id),
     setTopics: (memoryId, topics) => setMemoryEntitiesOp(vaultCtx, memoryId, topics),
-    addTopics: (memoryId, topics) => database.write(async (writer) => {
+    addTopics: (memoryId, topics, writeOptions) => database.write(async (writer) => {
+      await assertWrite(writeOptions);
       const owned = await vaultCtx.vaultMemoryCollection.query(Q8.where("id", memoryId), Q8.where("is_deleted", false), ...ownedBy).fetchCount();
-      return owned > 0 ? writer.callWriter(() => linkMemoryEntitiesOp(entityCtx, memoryId, topics)) : [];
+      return owned > 0 ? writer.callWriter(
+        () => linkMemoryEntitiesOp(
+          {
+            ...entityCtx,
+            canWrite: async () => {
+              await assertWrite(writeOptions);
+              return true;
+            }
+          },
+          memoryId,
+          topics,
+          {
+            unlessTopicsUserManaged: writeOptions?.unlessUserManaged
+          }
+        )
+      ) : [];
     }),
     setVisibility: (id, visibility, visibilityOptions) => setMemoryVisibilityOp(vaultCtx, id, { visibility, ...visibilityOptions }),
     recall: (query, recallOptions) => recall(
@@ -18972,7 +19074,17 @@ function createLocalMemoryStore(options) {
     ),
     retain: (content, retainOptions) => retain(
       content,
-      { vaultCtx, embeddingOptions: options.embeddingOptions, vaultCache },
+      {
+        vaultCtx: {
+          ...vaultCtx,
+          canWrite: async () => {
+            await assertWrite(retainOptions);
+            return true;
+          }
+        },
+        embeddingOptions: options.embeddingOptions,
+        vaultCache
+      },
       retainOptions
     ),
     factSource: {
@@ -19076,11 +19188,15 @@ function memoryCipher(canonical) {
   };
 }
 async function reencryptMemoryField(value, canonical, fallbacks = []) {
-  const { encrypt } = memoryCipher(canonical);
-  if (!value.startsWith("enc:")) return encrypt(value);
+  return memoryCipher(canonical).encrypt(
+    await decryptMemoryField(value, [canonical, ...fallbacks])
+  );
+}
+async function decryptMemoryField(value, rings) {
+  if (!value.startsWith("enc:")) return value;
   if (!isEncrypted(value))
     throw new MemoryKeyError("Field has an encryption prefix but an invalid payload");
-  return encrypt(await decryptWith(value, [canonical, ...fallbacks]));
+  return decryptWith(value, rings);
 }
 
 // src/lib/memory/store/remotePersistence.ts
@@ -19618,7 +19734,14 @@ function stored(row) {
 function createRemoteMemoryPipeline(options) {
   const { persistence, embeddingOptions } = options;
   const model = embeddingOptions.model ?? DEFAULT_API_EMBEDDING_MODEL;
-  const operation = (mode, queryOptions = embeddingOptions) => {
+  const operation = (mode, queryOptions = embeddingOptions, writeOptions) => {
+    const signal = writeOptions?.signal;
+    const assertWrite = async () => {
+      signal?.throwIfAborted();
+      if (writeOptions?.canWrite && !await writeOptions.canWrite())
+        throw new Error("Memory source is no longer eligible");
+      signal?.throwIfAborted();
+    };
     const rejectUndecryptable = (failed) => {
       if (!failed.length) return;
       if (mode === "retain")
@@ -19636,7 +19759,7 @@ function createRemoteMemoryPipeline(options) {
       return items.map((item) => stored(item.memory));
     };
     const get = async (id) => {
-      const snapshot = snapshots.get(id) ?? await persistence.get(id);
+      const snapshot = snapshots.get(id) ?? await (signal ? persistence.get(id, signal) : persistence.get(id));
       if (!snapshot || snapshot.memory.is_deleted || snapshot.memory.superseded_by) return null;
       snapshots.set(id, snapshot);
       return stored(snapshot.memory);
@@ -19686,7 +19809,7 @@ function createRemoteMemoryPipeline(options) {
         if (forced.size < 100 && temporal[i] !== void 0) forced.add(temporal[i]);
       }
       const forceIds = [...forced];
-      const windowOptions = (i, signal) => ({
+      const windowOptions = (i, signal2) => ({
         limit: Math.min(100, Math.max((search.limit ?? 8) * 3, 30)),
         force_ids: i === 0 ? forceIds : [],
         ...search.scopes && { scopes: search.scopes },
@@ -19694,13 +19817,15 @@ function createRemoteMemoryPipeline(options) {
         ...search.memoryIds !== void 0 && { memory_ids: search.memoryIds },
         include_archived: search.includeArchived,
         embedding_model: model,
-        ...signal && { signal }
+        ...signal2 && { signal: signal2 }
       });
       const vectors = [queryEmbedding, ...facetEmbeddings];
       let windows;
       if (mode === "retain") {
         windows = await Promise.all(
-          vectors.map((embedding2, i) => persistence.candidateSet(embedding2, windowOptions(i)))
+          vectors.map(
+            (embedding2, i) => persistence.candidateSet(embedding2, windowOptions(i, signal))
+          )
         );
       } else {
         const deadline = new AbortController();
@@ -19773,7 +19898,7 @@ function createRemoteMemoryPipeline(options) {
           embedding: storedVector(JSON.parse(input.embedding)),
           embedding_model: input.embeddingModel
         },
-        source_chunk_ids: JSON.stringify(input.sourceChunkIds ?? []),
+        source_chunk_ids: serializeSourceChunkIds(input.sourceChunkIds ?? []),
         proof_count: input.proofCount ?? 1,
         source: input.source ?? "manual",
         ...input.eventTime && {
@@ -19788,12 +19913,15 @@ function createRemoteMemoryPipeline(options) {
         twin_opt_in: false
       };
     };
-    const write = async (memory, snapshot) => remember([await persistence.put(memory, snapshot)])[0];
+    const write = async (memory, snapshot) => {
+      await assertWrite();
+      return remember([await persistence.put(memory, snapshot, signal)])[0];
+    };
     const port = {
       prepare,
       get,
       getFresh: async (id) => {
-        const current = await persistence.get(id);
+        const current = await (signal ? persistence.get(id, signal) : persistence.get(id));
         return current && !current.memory.is_deleted && !current.memory.superseded_by ? stored(current.memory) : null;
       },
       tombstones: async (embedding2, embeddingModel, scope, folderId) => {
@@ -19804,7 +19932,8 @@ function createRemoteMemoryPipeline(options) {
           embedding_model: embeddingModel,
           strict_model: true,
           include_deleted: true,
-          deleted_only: true
+          deleted_only: true,
+          signal
         });
         rejectUndecryptable(window2.failed);
         return remember(window2.items);
@@ -19832,7 +19961,7 @@ function createRemoteMemoryPipeline(options) {
         const observed = sourceIds(memory.source_chunk_ids);
         const replay = !!patch.observationSourceIds?.length && patch.observationSourceIds.every((id2) => observed.includes(id2));
         if (patch.sourceChunkIds !== void 0)
-          memory.source_chunk_ids = JSON.stringify(
+          memory.source_chunk_ids = serializeSourceChunkIds(
             patch.observationSourceIds?.length ? [.../* @__PURE__ */ new Set([...observed, ...patch.sourceChunkIds])] : patch.sourceChunkIds
           );
         if (!replay) {
@@ -19860,14 +19989,18 @@ function createRemoteMemoryPipeline(options) {
         if (!target || !newer || id === successor) return false;
         const old = snapshots.get(id);
         const next = snapshots.get(successor);
+        await assertWrite();
         remember(
-          await persistence.putMany([
-            {
-              memory: { ...old.memory, superseded_by: successor, superseded_at: Date.now() },
-              expectedVersion: old
-            },
-            { memory: next.memory, expectedVersion: next }
-          ])
+          await persistence.putMany(
+            [
+              {
+                memory: { ...old.memory, superseded_by: successor, superseded_at: Date.now() },
+                expectedVersion: old
+              },
+              { memory: next.memory, expectedVersion: next }
+            ],
+            signal
+          )
         );
         return true;
       },
@@ -19876,18 +20009,22 @@ function createRemoteMemoryPipeline(options) {
         if (!target) return { created: null, retired: false };
         const snapshot = snapshots.get(targetId);
         const successor = createRow(input);
+        await assertWrite();
         const rows = remember(
-          await persistence.putMany([
-            { memory: successor, expectedVersion: 0 },
-            {
-              memory: {
-                ...snapshot.memory,
-                superseded_by: successor.memory_id,
-                superseded_at: Date.now()
-              },
-              expectedVersion: snapshot
-            }
-          ])
+          await persistence.putMany(
+            [
+              { memory: successor, expectedVersion: 0 },
+              {
+                memory: {
+                  ...snapshot.memory,
+                  superseded_by: successor.memory_id,
+                  superseded_at: Date.now()
+                },
+                expectedVersion: snapshot
+              }
+            ],
+            signal
+          )
         );
         return { created: rows[0], retired: true };
       }
@@ -19922,7 +20059,7 @@ function createRemoteMemoryPipeline(options) {
     factSource,
     recall: async (query, recallOptions = {}) => recall(query, { embeddingOptions, factSource }, { ...recallOptions, types: ["fact"] }),
     retain: async (content, retainOptions) => {
-      const { port } = operation("retain");
+      const { port } = operation("retain", embeddingOptions, retainOptions);
       return retainWithPersistence(
         content,
         {
@@ -19939,6 +20076,8 @@ function createRemoteMemoryPipeline(options) {
 
 // src/lib/memory/store/remoteMigration.ts
 var IMPORT_BATCH = 50;
+var EMBED_BATCH = 100;
+var LOCAL_VECTOR_DIMS = 4096;
 var VERIFY_BATCH = 1e3;
 var QUERY_IDS = 1e3;
 var QUERY_PAGE = 200;
@@ -19964,7 +20103,7 @@ var SHORT_FIELDS = [
   "visibility",
   "geohash"
 ];
-var utf8 = new TextEncoder();
+var utf82 = new TextEncoder();
 var METADATA_FIELDS = [
   "scope",
   "kind",
@@ -20015,17 +20154,34 @@ function revision(raw) {
     last_observed_at: num(raw.last_observed_at) ?? null
   };
 }
-function embedding(raw) {
+function embedding(raw, model) {
   const value = text13(raw.embedding);
   if (!value) return void 0;
   try {
-    return storedVector(JSON.parse(value));
+    const vector = JSON.parse(value);
+    const stored2 = text13(raw.embedding_model);
+    if (stored2 === void 0 ? vector.length !== LOCAL_VECTOR_DIMS : stored2 !== model)
+      return void 0;
+    return storedVector(vector);
   } catch {
     return void 0;
   }
 }
+function stringArray(value) {
+  try {
+    const parsed = JSON.parse(value);
+    return Array.isArray(parsed) && parsed.every((id) => typeof id === "string") ? parsed : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function sourceChunkIds(raw) {
+  const value = text13(raw.source_chunk_ids);
+  const ids = value && stringArray(value);
+  return ids ? serializeSourceChunkIds(ids) : value;
+}
 function bytes(value) {
-  return value === void 0 ? 0 : utf8.encode(value).length;
+  return value === void 0 ? 0 : utf82.encode(value).length;
 }
 function fitsNearby(row) {
   return bytes(row.memory_id) <= MAX_ID_BYTES && bytes(row.content) <= MAX_CONTENT_BYTES && bytes(row.kind_value) <= MAX_CONTENT_BYTES && TEXT_FIELDS.every((field10) => bytes(row[field10]) <= MAX_TEXT_BYTES) && SHORT_FIELDS.every((field10) => bytes(row[field10]) <= MAX_SHORT_BYTES);
@@ -20034,16 +20190,16 @@ function invalid(raw) {
   const id = raw.id;
   return typeof id !== "string" || id === "" || bytes(id) > MAX_ID_BYTES || !text13(raw.scope) || (num(raw.created_at) ?? 0) <= 0 || (num(raw.updated_at) ?? 0) <= 0;
 }
-function metadata(raw) {
-  const vector = embedding(raw);
+function metadata(raw, model) {
+  const vector = embedding(raw, model);
   return {
     scope: raw.scope,
     kind: text13(raw.kind),
     level: text13(raw.level),
     folder_id: text13(raw.folder_id),
     is_deleted: bool(raw.is_deleted) ?? false,
-    ...vector && { embedding: vector, embedding_model: text13(raw.embedding_model) },
-    source_chunk_ids: text13(raw.source_chunk_ids),
+    ...vector && { embedding: vector, embedding_model: model },
+    source_chunk_ids: sourceChunkIds(raw),
     proof_count: num(raw.proof_count),
     source: text13(raw.source),
     event_time_start: num(raw.event_time_start),
@@ -20072,30 +20228,63 @@ function defined(value) {
     Object.entries(value).filter(([, field10]) => field10 !== void 0)
   );
 }
-async function remoteRow(raw, canonical, fallbacks, updatedAt) {
-  const content = await reencryptMemoryField(
-    typeof raw.content === "string" ? raw.content : "",
-    canonical,
-    fallbacks
-  );
-  const kindValue = text13(raw.kind_value);
-  const encryptedKindValue = kindValue ? await reencryptMemoryField(kindValue, canonical, fallbacks) : void 0;
+async function prepareRow(raw, canonical, rings, model, updatedAt) {
+  const deleted = bool(raw.is_deleted) ?? false;
+  const { encrypt } = memoryCipher(canonical);
+  const localKindValue = text13(raw.kind_value);
+  let plaintext;
+  let kindValue;
+  try {
+    plaintext = await decryptMemoryField(typeof raw.content === "string" ? raw.content : "", rings);
+    kindValue = localKindValue && await decryptMemoryField(localKindValue, rings);
+  } catch (error) {
+    if (!deleted || !(error instanceof MemoryKeyError)) throw error;
+    plaintext = void 0;
+    kindValue = void 0;
+  }
   const row = {
-    ...defined({ ...metadata(raw), kind_value: encryptedKindValue }),
+    ...defined({
+      ...metadata(raw, model),
+      kind_value: kindValue === void 0 ? void 0 : await encrypt(kindValue)
+    }),
     memory_id: raw.id,
-    content,
+    content: await encrypt(plaintext ?? ""),
     scope: raw.scope,
     created_at: raw.created_at,
     updated_at: updatedAt,
-    is_deleted: bool(raw.is_deleted) ?? false
+    is_deleted: deleted
   };
-  return fitsNearby(row) ? row : null;
+  return { row, plaintext };
 }
-function sameMetadata(local, remote) {
-  const mine = metadata(local);
+async function embedMissing(prepared, options, model, signal) {
+  const needed = prepared.filter((p) => !p.row.embedding && p.plaintext);
+  for (const batch of chunks(needed, EMBED_BATCH)) {
+    if (signal?.aborted) throw aborted(signal);
+    try {
+      const vectors = await generateEmbeddings(
+        batch.map((p) => p.plaintext),
+        { ...options, taskType: "memory_retain_embed" }
+      );
+      if (vectors.length !== batch.length) throw new Error("Incomplete migration embeddings");
+      const stored2 = vectors.map(storedVector);
+      batch.forEach((p, i) => {
+        p.row.embedding = stored2[i];
+        p.row.embedding_model = model;
+      });
+    } catch (error) {
+      getLogger().warn(
+        `[memory/migration] Uploading ${batch.length} row(s) without a vector: embedding failed`,
+        error
+      );
+    }
+  }
+}
+function sameMetadata(local, remote, model) {
+  const mine = metadata(local, model);
   return METADATA_FIELDS.every((field10) => {
     const a = mine[field10] ?? null;
     const b = remote[field10] ?? null;
+    if (field10 === "embedding_model" && a === null) return true;
     if (field10 === "visibility") return (a ?? "private") === (b ?? "private");
     if (field10 === "is_deleted" || field10 === "topics_user_managed" || field10 === "twin_opt_in")
       return (a ?? false) === (b ?? false);
@@ -20191,7 +20380,8 @@ async function backfillTopics(ctx) {
 }
 async function migrateMemoriesToRemote(options) {
   const { canonical, signal } = options;
-  const fallbacks = options.fallbacks ?? [];
+  const rings = [canonical, ...options.fallbacks ?? []];
+  const model = options.embeddingOptions?.model ?? DEFAULT_API_EMBEDDING_MODEL;
   const request = createNearbyRequest(options);
   const account = await request("/account", {}, signal);
   if (typeof account.key_id === "string" && account.key_id !== canonical.keyId)
@@ -20202,8 +20392,13 @@ async function migrateMemoriesToRemote(options) {
     );
   const active = account.state === "active";
   let claimed = account.key_id === canonical.keyId;
+  if (!active) await createDecaySweeper({ vaultCtx: options.vaultCtx }).runSweep();
   await backfillTopics(options.vaultCtx);
   const skipped = /* @__PURE__ */ new Map();
+  const reembedded = /* @__PURE__ */ new Set();
+  const unembedded = /* @__PURE__ */ new Set();
+  const placeholders = /* @__PURE__ */ new Set();
+  const truncated = /* @__PURE__ */ new Set();
   let imported = 0;
   for (let pass = 0; ; pass++) {
     const rows = await getAllVaultMemoryRowsOp(options.vaultCtx);
@@ -20219,9 +20414,10 @@ async function migrateMemoriesToRemote(options) {
         candidates.map((raw) => raw.id),
         signal
       );
+      const needsVector = (raw, server) => !!options.embeddingOptions && !embedding(raw, model) && server.embedding_model !== model;
       for (const raw of candidates) {
         const server = remote.get(raw.id);
-        if (server && server.updated_at === raw.updated_at && !sameMetadata(raw, server))
+        if (server && server.updated_at === raw.updated_at && (!sameMetadata(raw, server, model) || needsVector(raw, server)))
           pending.set(raw.id, raw.updated_at + 1);
       }
     }
@@ -20230,7 +20426,11 @@ async function migrateMemoriesToRemote(options) {
         state,
         total: rows.length,
         imported,
-        skipped: [...skipped].map(([memoryId, reason]) => ({ memoryId, reason }))
+        skipped: [...skipped].map(([memoryId, reason]) => ({ memoryId, reason })),
+        reembedded: reembedded.size,
+        unembedded: unembedded.size,
+        placeholderTombstones: placeholders.size,
+        truncatedSourceChunkIds: truncated.size
       });
       if (skipped.size > 0 && !options.allowSkipped) return result("migrating");
       if (!claimed) await importBatch(request, canonical.keyId, [], signal);
@@ -20248,19 +20448,35 @@ async function migrateMemoriesToRemote(options) {
         409,
         "migration_incomplete"
       );
-    const upload = [];
+    const prepared = [];
     for (const raw of candidates) {
       const updatedAt = pending.get(raw.id);
       if (updatedAt === void 0) continue;
       try {
-        const row = await remoteRow(raw, canonical, fallbacks, updatedAt);
-        if (row) upload.push(row);
-        else skipped.set(raw.id, "invalid");
+        prepared.push(await prepareRow(raw, canonical, rings, model, updatedAt));
       } catch (error) {
         if (!(error instanceof MemoryKeyError)) throw error;
         skipped.set(raw.id, "unreadable");
       }
     }
+    const usable = new Set(prepared.filter((p) => p.row.embedding).map((p) => p.row.memory_id));
+    if (options.embeddingOptions)
+      await embedMissing(prepared, options.embeddingOptions, model, signal);
+    const local = new Map(candidates.map((raw) => [raw.id, raw]));
+    const upload = [];
+    for (const { row, plaintext } of prepared) {
+      const id = row.memory_id;
+      if (!fitsNearby(row)) {
+        skipped.set(id, "invalid");
+        continue;
+      }
+      upload.push(row);
+      const track = (set, on) => on ? set.add(id) : set.delete(id);
+      track(reembedded, !!row.embedding && !usable.has(id));
+      track(unembedded, !row.embedding);
+      track(placeholders, plaintext === void 0);
+      track(truncated, row.source_chunk_ids !== text13(local.get(id).source_chunk_ids));
+    }
     let sent = 0;
     options.onProgress?.({ imported: sent, toImport: upload.length });
     for (const batch of chunks(upload, IMPORT_BATCH)) {
@@ -20504,16 +20720,21 @@ function createRemoteMemoryStore(options) {
     const record2 = await persistence.get(id);
     return record2 && !record2.memory.is_deleted ? record2 : null;
   };
-  const mutateLocked = async (id, change, edit) => {
-    const record2 = await live(id);
+  const mutateLocked = async (id, change, edit, writeOptions) => {
+    writeOptions?.signal?.throwIfAborted();
+    const record2 = writeOptions?.signal ? await persistence.get(id, writeOptions.signal) : await live(id);
     if (!record2) return null;
+    if (record2.memory.is_deleted) return null;
+    if (writeOptions?.canWrite && !await writeOptions.canWrite())
+      throw new Error("Memory source is no longer eligible");
+    writeOptions?.signal?.throwIfAborted();
     const next = edit(structuredClone(record2.memory));
     if (!next) return null;
-    const saved = await persistence.put(next, record2);
+    const saved = writeOptions?.signal ? await persistence.put(next, record2, writeOptions.signal) : await persistence.put(next, record2);
     notify(typeof change === "function" ? change(record2.memory) : change, [saved]);
     return saved;
   };
-  const mutate = (id, change, edit) => serialized(id, () => mutateLocked(id, change, edit));
+  const mutate = (id, change, edit, writeOptions) => serialized(id, () => mutateLocked(id, change, edit, writeOptions));
   const serializedAll = (ids, task) => [...new Set(ids)].sort().reduceRight((inner, id) => () => serialized(id, inner), task)();
   const mutateMany = async (ids, change, edit) => {
     const saved = /* @__PURE__ */ new Map();
@@ -21026,13 +21247,21 @@ function createRemoteMemoryStore(options) {
         }))
       );
     },
-    addTopics: async (memoryId, topics) => {
+    addTopics: async (memoryId, topics, writeOptions) => {
       const added = await withKnownKinds(topicInputs(topics, "auto"));
-      const saved = await mutate(memoryId, "edit", (memory) => ({
-        ...memory,
-        topics: serializeTopics(mergeTopics(parseTopics(memory.topics) ?? [], added)),
-        topics_updated_at: Date.now()
-      }));
+      const saved = await mutate(
+        memoryId,
+        "edit",
+        (memory) => {
+          if (writeOptions?.unlessUserManaged && memory.topics_user_managed) return null;
+          return {
+            ...memory,
+            topics: serializeTopics(mergeTopics(parseTopics(memory.topics) ?? [], added)),
+            topics_updated_at: Date.now()
+          };
+        },
+        writeOptions
+      );
       if (!saved) return [];
       const now = /* @__PURE__ */ new Date();
       return mergeTopics([], added).map(
@@ -21883,6 +22112,7 @@ function createDurableAutoExtractor(options) {
   };
   const folderId = options.folderId ?? null;
   let disposed = false;
+  let activeBatch = null;
   let running = false;
   let wakeRequested = false;
   let timer;
@@ -21919,14 +22149,18 @@ function createDurableAutoExtractor(options) {
     }, delay);
   }
   async function extractBatch(messages, conversationId, ids, jobScope, jobFolderId) {
+    if (disposed) throw new Error("Extraction session was disposed");
     let watchdog;
     let cancelled = false;
+    const controller = new AbortController();
+    activeBatch = controller;
     const model = options.modelForScope?.(jobScope) ?? options.extract.model;
     try {
       return await Promise.race([
         new Promise((resolve, reject) => {
           const worker = createAutoExtractor({
             ...options,
+            signal: controller.signal,
             retainCtx: {
               ...options.retainCtx,
               vaultCtx: {
@@ -21955,6 +22189,8 @@ function createDurableAutoExtractor(options) {
       ]);
     } finally {
       cancelled = true;
+      controller.abort();
+      if (activeBatch === controller) activeBatch = null;
       if (watchdog !== void 0) clearTimeout(watchdog);
     }
   }
@@ -21966,6 +22202,7 @@ function createDurableAutoExtractor(options) {
     for (const message of loaded)
       if (message && message.messageId > 0) sequences.set(message.uniqueId, message.messageId);
     await database.write(async () => {
+      if (disposed) return;
       const current = idsOf(job);
       const acknowledged = ids.filter((id) => current.includes(id));
       if (!acknowledged.length) return;
@@ -22138,6 +22375,7 @@ function createDurableAutoExtractor(options) {
               jobScope,
               jobFolderId
             );
+            if (disposed) throw new Error("Extraction session was disposed");
             options.onTurnComplete?.(result);
             return result;
           };
@@ -22174,6 +22412,7 @@ function createDurableAutoExtractor(options) {
           );
           scheduleAfterSuccess = true;
         } catch (error) {
+          if (disposed) break;
           attempts.set(job.id, attempted + 1);
           retry = true;
           reportError(error, conversationId);
@@ -22196,6 +22435,14 @@ function createDurableAutoExtractor(options) {
         schedule(retry ? options.retryDelayMs ?? 3e4 : 0);
     }
   }
+  function dispose() {
+    disposed = true;
+    activeBatch?.abort(options.signal?.reason);
+    if (timer !== void 0) clearTimeout(timer);
+    options.signal?.removeEventListener("abort", dispose);
+  }
+  if (options.signal?.aborted) dispose();
+  else options.signal?.addEventListener("abort", dispose, { once: true });
   schedule(0);
   return {
     processTurn(messages, conversationId) {
@@ -22275,10 +22522,7 @@ function createDurableAutoExtractor(options) {
       return true;
     },
     isProcessing: () => running,
-    dispose() {
-      disposed = true;
-      if (timer !== void 0) clearTimeout(timer);
-    }
+    dispose
   };
 }
 
@@ -25527,6 +25771,7 @@ var CONVERSATION_REDACTOR_LIMIT = 50;
 var NO_CONVERSATION_KEY = "__no_conversation__";
 var NO_STORE_FOLDERS = "Folders are not supported with a memoryStore";
 var NO_STORE_MASK = "piiRedaction needs a memoryStore built with embeddingOptions.maskInput";
+var MEMORY_STORE_NOT_READY = "Memory store is not ready";
 var conversationRedactors = /* @__PURE__ */ new Map();
 var clientToolFilterCache = /* @__PURE__ */ new Map();
 function getConversationRedactor(conversationId, nerDetector) {
@@ -25671,7 +25916,7 @@ function useChatStorage(options) {
     [resolvedPiiRedaction]
   );
   const maskEmbeddingInput = isPiiRedactor(resolvedPiiRedaction) ? maskForEmbedding : void 0;
-  const storeMaskMissing = memoryStore !== void 0 && maskEmbeddingInput !== void 0 && !memoryStore.masksEmbeddingInput;
+  const storeMaskMissing = memoryStore !== void 0 && memoryStore !== null && maskEmbeddingInput !== void 0 && !memoryStore.masksEmbeddingInput;
   const messagesCollection = useMemo(() => database.get("history"), [database]);
   const conversationsCollection = useMemo(
     () => database.get("conversations"),
@@ -25920,6 +26165,7 @@ function useChatStorage(options) {
   }, [vaultEmbeddingCache]);
   const retainVaultMemory = useCallback4(
     async (input) => {
+      if (memoryStore === null) throw new Error(MEMORY_STORE_NOT_READY);
       if (memoryStore) {
         if (storeMaskMissing) throw new Error(NO_STORE_MASK);
         if (input.folderId !== void 0) throw new Error(NO_STORE_FOLDERS);
@@ -25965,6 +26211,7 @@ function useChatStorage(options) {
   );
   const createMemoryVaultTool2 = useCallback4(
     (options2) => {
+      if (memoryStore === null) throw new Error(MEMORY_STORE_NOT_READY);
       if (storeMaskMissing) throw new Error(NO_STORE_MASK);
       return createMemoryVaultTool(
         memoryStore ?? vaultCtx,
@@ -25975,6 +26222,7 @@ function useChatStorage(options) {
   );
   const createRecallTool2 = useCallback4(
     (toolOptions, callbacks) => {
+      if (memoryStore === null) throw new Error(MEMORY_STORE_NOT_READY);
       if (!getToken && !memoryStore) {
         throw new Error("getToken is required for recall tool");
       }
@@ -26020,7 +26268,7 @@ function useChatStorage(options) {
   );
   const recallFn = useCallback4(
     async (query, options2) => {
-      if (!getToken && !memoryStore) {
+      if (memoryStore === null || !getToken && !memoryStore) {
         return {
           memories: [],
           usedBudget: options2?.budget ?? "low",
@@ -26069,6 +26317,7 @@ function useChatStorage(options) {
   );
   const getVaultMemories = useCallback4(
     (options2) => {
+      if (memoryStore === null) return Promise.resolve([]);
       if (!memoryStore) return getAllVaultMemoriesOp(vaultCtx, options2);
       const { folderId, levels, kinds, ...listOptions } = options2 ?? {};
       if (folderId !== void 0) throw new Error(NO_STORE_FOLDERS);
@@ -26079,7 +26328,8 @@ function useChatStorage(options) {
     [vaultCtx, memoryStore]
   );
   const deleteVaultMemory = useCallback4(
-    (id) => {
+    async (id) => {
+      if (memoryStore === null) throw new Error(MEMORY_STORE_NOT_READY);
       return memoryStore ? memoryStore.delete(id) : deleteVaultMemoryOp(vaultCtx, id);
     },
     [vaultCtx, memoryStore]