@anuma/sdk 10.5.1 → 10.5.3

package/dist/react/index.cjs

@@ -5619,6 +5619,63 @@ async function chunkRowSource(ctx, filter) {
     return fullScanChunkRowSource(ctx, filter);
   }
 }
+async function readChunkVectorRow(ctx, row, onUnreadable) {
+  const version = Number(row.updated_at) || 0;
+  const chunks3 = await readRawJsonField(row, "chunks", ctx.walletAddress);
+  if (chunks3 && chunks3.length > 0) {
+    return {
+      entry: {
+        version,
+        chunks: chunks3.map((chunk) => decodeChunkVector(chunk.vector, onUnreadable))
+      },
+      chunks: chunks3
+    };
+  }
+  const messageVector = await readRawJsonField(row, "vector", ctx.walletAddress);
+  if (!messageVector || messageVector.length === 0) return null;
+  return { entry: { version, chunks: [], fallback: Float32Array.from(messageVector) }, chunks: [] };
+}
+async function warmChunkVectorCacheOp(ctx, options) {
+  const { chunkCache, embeddingModel, limit, signal } = options;
+  const source = await chunkRowSource(ctx, {});
+  const yieldIfDue = createTimeSliceYielder(CHUNK_SCAN_YIELD_BUDGET_MS);
+  let keys = source.keys.filter(
+    (key3) => !embeddingModel || key3.embeddingModel === null || key3.embeddingModel === embeddingModel
+  );
+  if (limit !== void 0 && keys.length > limit) {
+    keys = keys.sort((a, b) => b.version - a.version).slice(0, limit);
+  }
+  const missIds = [];
+  for (const key3 of keys) {
+    await yieldIfDue();
+    if (chunkCache.get(key3.id)?.version !== key3.version) missIds.push(key3.id);
+  }
+  let warmed = 0;
+  let unreadableVectors = 0;
+  for await (const row of loadVectorRowsInBatches(source, missIds)) {
+    await yieldIfDue();
+    const read = await readChunkVectorRow(ctx, row, () => {
+      unreadableVectors++;
+    });
+    if (signal?.aborted) break;
+    if (!read) continue;
+    chunkCache.set(row.id, read.entry);
+    warmed++;
+  }
+  warnUnreadableChunkVectors("warmChunkVectorCacheOp", unreadableVectors);
+  return warmed;
+}
+async function* loadVectorRowsInBatches(source, ids) {
+  for (let offset = 0; offset < ids.length; offset += CHUNK_VECTOR_BATCH_SIZE) {
+    yield* await source.loadVectorRows(ids.slice(offset, offset + CHUNK_VECTOR_BATCH_SIZE));
+  }
+}
+function warnUnreadableChunkVectors(operation, count2) {
+  if (count2 === 0) return;
+  getLogger().warn(
+    `${operation}: could not read ${count2} chunk vectors and left them out of ranking \u2014 the stored value is corrupt, so those chunks stay unsearchable until the message is re-embedded via chunkAndEmbedAllMessages`
+  );
+}
 async function searchChunksOp(ctx, queryVector, options) {
   const {
     limit = 10,
@@ -5687,45 +5744,39 @@ async function searchChunksOp(ctx, queryVector, options) {
     for (const row of rows) {
       await yieldIfDue();
       const id2 = row.id;
-      const version = Number(row.updated_at) || 0;
       const order = orderById.get(id2) ?? Number.MAX_SAFE_INTEGER;
-      const chunks3 = await readRawJsonField(row, "chunks", ctx.walletAddress);
-      if (chunks3 && chunks3.length > 0) {
-        const vectors = chunks3.map(
-          (chunk) => decodeChunkVector(chunk.vector, () => {
-            unreadableVectors++;
-          })
-        );
-        chunkCache?.set(id2, { version, chunks: vectors });
-        for (let ci = 0; ci < chunks3.length; ci++) {
-          const vec = vectors[ci];
-          if (vec.length === 0) continue;
-          const similarity = cosineSimilarity(queryVector, vec);
-          if (similarity >= minSimilarity) {
-            candidates.push({
-              id: id2,
-              version,
-              order,
-              similarity,
-              chunkTextSource: { kind: "chunk", chunk: chunks3[ci], siblings: chunks3 }
-            });
-          }
+      const read = await readChunkVectorRow(ctx, row, () => {
+        unreadableVectors++;
+      });
+      if (!read) continue;
+      const { entry, chunks: chunks3 } = read;
+      const { version } = entry;
+      chunkCache?.set(id2, entry);
+      if (entry.fallback) {
+        const similarity = cosineSimilarity(queryVector, entry.fallback);
+        if (similarity >= minSimilarity) {
+          candidates.push({
+            id: id2,
+            version,
+            order,
+            similarity,
+            chunkTextSource: { kind: "message" }
+          });
         }
-      } else {
-        const messageVector = await readRawJsonField(row, "vector", ctx.walletAddress);
-        if (messageVector && messageVector.length > 0) {
-          const fallback = Float32Array.from(messageVector);
-          chunkCache?.set(id2, { version, chunks: [], fallback });
-          const similarity = cosineSimilarity(queryVector, fallback);
-          if (similarity >= minSimilarity) {
-            candidates.push({
-              id: id2,
-              version,
-              order,
-              similarity,
-              chunkTextSource: { kind: "message" }
-            });
-          }
+        continue;
+      }
+      for (let ci = 0; ci < chunks3.length; ci++) {
+        const vec = entry.chunks[ci];
+        if (vec.length === 0) continue;
+        const similarity = cosineSimilarity(queryVector, vec);
+        if (similarity >= minSimilarity) {
+          candidates.push({
+            id: id2,
+            version,
+            order,
+            similarity,
+            chunkTextSource: { kind: "chunk", chunk: chunks3[ci], siblings: chunks3 }
+          });
         }
       }
     }
@@ -5736,11 +5787,7 @@ async function searchChunksOp(ctx, queryVector, options) {
       `searchChunksOp: skipped ${staleSkipped} messages whose embedding model differs from the current model (${embeddingModel}) \u2014 re-embed via chunkAndEmbedAllMessages`
     );
   }
-  if (unreadableVectors > 0) {
-    getLogger().warn(
-      `searchChunksOp: could not read ${unreadableVectors} chunk vectors and left them out of ranking \u2014 the stored value is corrupt, so those chunks stay unsearchable until the message is re-embedded via chunkAndEmbedAllMessages`
-    );
-  }
+  warnUnreadableChunkVectors("searchChunksOp", unreadableVectors);
   const topK = candidates.sort((a, b) => b.similarity - a.similarity || a.order - b.order).slice(0, limit);
   const topIds = Array.from(new Set(topK.map((c) => c.id)));
   const fullRows = await source.loadFullRows(topIds);
@@ -18392,6 +18439,9 @@ var WatermelonChatStorageAdapter = class {
   searchChunks(queryVector, options) {
     return searchChunksOp(this.ctx, queryVector, options);
   }
+  warmChunkCache(options) {
+    return warmChunkVectorCacheOp(this.ctx, options);
+  }
   getSummary(conversationId) {
     return getConversationSummaryOp(
       createSummaryContext(this.ctx.database, this.ctx),
@@ -23709,12 +23759,16 @@ async function prepareVaultCandidates(query, vaultCtx, embeddingOptions, cache,
     const currentModel = embeddingOptions.model ?? DEFAULT_API_EMBEDDING_MODEL;
     const uncachedTexts = [];
     const uncachedIndices = [];
+    const resolvedVectors = /* @__PURE__ */ new Map();
     let staleReembedCount = 0;
     for (let i = 0; queryEmbedding.length > 0 && i < memories.length; i++) {
       const content = memories[i].content;
       const memoryId = memories[i].uniqueId;
       const cached = cachedRowVector(cache, memoryId, memories[i].updatedAt, content);
-      if (cached && cached.length === queryEmbedding.length) continue;
+      if (cached && cached.length === queryEmbedding.length) {
+        resolvedVectors.set(memoryId, cached);
+        continue;
+      }
       if (cached) cache.delete(memoryId);
       const storedModel = memories[i].embeddingModel;
       const modelCompatible = (storedModel ?? currentModel) === currentModel;
@@ -23722,13 +23776,9 @@ async function prepareVaultCandidates(query, vaultCtx, embeddingOptions, cache,
         try {
           const parsed = JSON.parse(memories[i].embedding);
           if (Array.isArray(parsed) && parsed.length === queryEmbedding.length) {
-            cacheRowVector(
-              cache,
-              memoryId,
-              Float32Array.from(parsed),
-              memories[i].updatedAt,
-              content
-            );
+            const vector2 = Float32Array.from(parsed);
+            resolvedVectors.set(memoryId, vector2);
+            cacheRowVector(cache, memoryId, vector2, memories[i].updatedAt, content);
             continue;
           }
         } catch {
@@ -23761,20 +23811,17 @@ async function prepareVaultCandidates(query, vaultCtx, embeddingOptions, cache,
       }
       if (newEmbeddings) {
         for (let j = 0; j < uncachedTexts.length; j++) {
-          cacheRowVector(
-            cache,
-            memories[uncachedIndices[j]].uniqueId,
-            Float32Array.from(newEmbeddings[j]),
-            memories[uncachedIndices[j]].updatedAt,
-            memories[uncachedIndices[j]].content
-          );
+          const memory = memories[uncachedIndices[j]];
+          const vector2 = Float32Array.from(newEmbeddings[j]);
+          resolvedVectors.set(memory.uniqueId, vector2);
+          cacheRowVector(cache, memory.uniqueId, vector2, memory.updatedAt, memory.content);
         }
       }
     }
     embeddedItems = memories.map((m) => ({
       id: m.uniqueId,
       content: m.content,
-      embedding: cache.get(m.uniqueId) ?? [],
+      embedding: resolvedVectors.get(m.uniqueId) ?? [],
       createdAt: m.createdAt,
       updatedAt: m.updatedAt,
       proofCount: m.proofCount,
@@ -38286,6 +38333,7 @@ function useChatStorage(options) {
     [vaultCtx, vaultEmbeddingCache, memoryStore]
   );
   const chunkVectorCacheRef = (0, import_react7.useRef)(createChunkVectorCache());
+  const recallWarmsRef = (0, import_react7.useRef)(/* @__PURE__ */ new Set());
   const clientToolEmbeddingsCacheRef = (0, import_react7.useRef)(/* @__PURE__ */ new Map());
   (0, import_react7.useEffect)(() => {
     if (!getToken || memoryStore !== void 0) return;
@@ -38299,6 +38347,8 @@ function useChatStorage(options) {
   (0, import_react7.useEffect)(() => {
     return onClearAllEncryptionState(() => {
       vaultEmbeddingCache.clear();
+      for (const warm of recallWarmsRef.current) warm.abort();
+      recallWarmsRef.current.clear();
       chunkVectorCacheRef.current.clear();
     });
   }, [vaultEmbeddingCache]);
@@ -38417,6 +38467,28 @@ function useChatStorage(options) {
       storeMaskMissing
     ]
   );
+  const warmRecallCache = (0, import_react7.useCallback)(
+    async (signal) => {
+      if (!backend.warmChunkCache) return 0;
+      const warm = new AbortController();
+      const stop2 = () => warm.abort(signal?.reason);
+      if (signal?.aborted) stop2();
+      signal?.addEventListener("abort", stop2, { once: true });
+      recallWarmsRef.current.add(warm);
+      try {
+        return await backend.warmChunkCache({
+          chunkCache: chunkVectorCacheRef.current,
+          embeddingModel,
+          limit: DEFAULT_CHUNK_CACHE_SIZE,
+          signal: warm.signal
+        });
+      } finally {
+        recallWarmsRef.current.delete(warm);
+        signal?.removeEventListener("abort", stop2);
+      }
+    },
+    [backend, embeddingModel]
+  );
   const {
     isLoading,
     sendMessage: baseSendMessage,
@@ -39599,6 +39671,7 @@ function useChatStorage(options) {
     createMemoryVaultSearchTool: createMemoryVaultSearchTool2,
     createRecallTool: createRecallTool2,
     recall: recallFn,
+    warmRecallCache,
     searchVaultMemories: searchVaultMemoriesFn,
     vaultEmbeddingCache,
     getVaultMemories,

package/dist/react/index.d.mts

@@ -4899,6 +4899,13 @@ interface ChatBackend extends ChatStorageAdapter {
         uniqueId: string;
     }): Promise<StoredMessage>;
     searchChunks(queryVector: number[], options?: ChatChunkSearchOptions): Promise<ChunkSearchResult[]>;
+    /** Fills a chunk vector cache ahead of the first search, for backends that score on the device. */
+    warmChunkCache?(options: {
+        chunkCache: ChunkVectorCache;
+        embeddingModel?: string;
+        limit?: number;
+        signal?: AbortSignal;
+    }): Promise<number>;
     getSummary(conversationId: string): Promise<StoredConversationSummary | null>;
     upsertSummary(conversationId: string, summary: string, summarizedUpTo: string, tokenCount: number): Promise<StoredConversationSummary>;
     deleteSummary(conversationId: string): Promise<void>;
@@ -13709,6 +13716,7 @@ declare class WatermelonChatStorageAdapter implements ChatBackend {
         uniqueId: string;
     }): Promise<StoredMessage>;
     searchChunks(queryVector: number[], options?: ChatChunkSearchOptions): Promise<ChunkSearchResult[]>;
+    warmChunkCache(options: Parameters<NonNullable<ChatBackend["warmChunkCache"]>>[0]): Promise<number>;
     getSummary(conversationId: string): Promise<StoredConversationSummary | null>;
     upsertSummary(conversationId: string, summary: string, summarizedUpTo: string, tokenCount: number): Promise<StoredConversationSummary>;
     deleteSummary(conversationId: string): Promise<void>;
@@ -15057,6 +15065,11 @@ interface UseChatStorageResult extends BaseUseChatStorageResult {
      * @param options - Optional recall configuration (types, budget, limit, scopes, …)
      */
     recall: (query: string, options?: RecallOptions) => Promise<RecallResult>;
+    /**
+     * Loads the most recent past messages' vectors, up to the recall cache's size, so the first recall does not read them all.
+     * @returns How many it added. It resolves rather than rejects when aborted or signed out, with how many it added before stopping.
+     */
+    warmRecallCache: (signal?: AbortSignal) => Promise<number>;
     /**
      * Search vault memories programmatically using semantic similarity.
      * Returns structured results sorted by descending similarity.

package/dist/react/index.d.ts

@@ -4899,6 +4899,13 @@ interface ChatBackend extends ChatStorageAdapter {
         uniqueId: string;
     }): Promise<StoredMessage>;
     searchChunks(queryVector: number[], options?: ChatChunkSearchOptions): Promise<ChunkSearchResult[]>;
+    /** Fills a chunk vector cache ahead of the first search, for backends that score on the device. */
+    warmChunkCache?(options: {
+        chunkCache: ChunkVectorCache;
+        embeddingModel?: string;
+        limit?: number;
+        signal?: AbortSignal;
+    }): Promise<number>;
     getSummary(conversationId: string): Promise<StoredConversationSummary | null>;
     upsertSummary(conversationId: string, summary: string, summarizedUpTo: string, tokenCount: number): Promise<StoredConversationSummary>;
     deleteSummary(conversationId: string): Promise<void>;
@@ -13709,6 +13716,7 @@ declare class WatermelonChatStorageAdapter implements ChatBackend {
         uniqueId: string;
     }): Promise<StoredMessage>;
     searchChunks(queryVector: number[], options?: ChatChunkSearchOptions): Promise<ChunkSearchResult[]>;
+    warmChunkCache(options: Parameters<NonNullable<ChatBackend["warmChunkCache"]>>[0]): Promise<number>;
     getSummary(conversationId: string): Promise<StoredConversationSummary | null>;
     upsertSummary(conversationId: string, summary: string, summarizedUpTo: string, tokenCount: number): Promise<StoredConversationSummary>;
     deleteSummary(conversationId: string): Promise<void>;
@@ -15057,6 +15065,11 @@ interface UseChatStorageResult extends BaseUseChatStorageResult {
      * @param options - Optional recall configuration (types, budget, limit, scopes, …)
      */
     recall: (query: string, options?: RecallOptions) => Promise<RecallResult>;
+    /**
+     * Loads the most recent past messages' vectors, up to the recall cache's size, so the first recall does not read them all.
+     * @returns How many it added. It resolves rather than rejects when aborted or signed out, with how many it added before stopping.
+     */
+    warmRecallCache: (signal?: AbortSignal) => Promise<number>;
     /**
      * Search vault memories programmatically using semantic similarity.
      * Returns structured results sorted by descending similarity.

package/dist/react/index.mjs

@@ -3773,6 +3773,63 @@ async function chunkRowSource(ctx, filter) {
     return fullScanChunkRowSource(ctx, filter);
   }
 }
+async function readChunkVectorRow(ctx, row, onUnreadable) {
+  const version = Number(row.updated_at) || 0;
+  const chunks3 = await readRawJsonField(row, "chunks", ctx.walletAddress);
+  if (chunks3 && chunks3.length > 0) {
+    return {
+      entry: {
+        version,
+        chunks: chunks3.map((chunk) => decodeChunkVector(chunk.vector, onUnreadable))
+      },
+      chunks: chunks3
+    };
+  }
+  const messageVector = await readRawJsonField(row, "vector", ctx.walletAddress);
+  if (!messageVector || messageVector.length === 0) return null;
+  return { entry: { version, chunks: [], fallback: Float32Array.from(messageVector) }, chunks: [] };
+}
+async function warmChunkVectorCacheOp(ctx, options) {
+  const { chunkCache, embeddingModel, limit, signal } = options;
+  const source = await chunkRowSource(ctx, {});
+  const yieldIfDue = createTimeSliceYielder(CHUNK_SCAN_YIELD_BUDGET_MS);
+  let keys = source.keys.filter(
+    (key3) => !embeddingModel || key3.embeddingModel === null || key3.embeddingModel === embeddingModel
+  );
+  if (limit !== void 0 && keys.length > limit) {
+    keys = keys.sort((a, b) => b.version - a.version).slice(0, limit);
+  }
+  const missIds = [];
+  for (const key3 of keys) {
+    await yieldIfDue();
+    if (chunkCache.get(key3.id)?.version !== key3.version) missIds.push(key3.id);
+  }
+  let warmed = 0;
+  let unreadableVectors = 0;
+  for await (const row of loadVectorRowsInBatches(source, missIds)) {
+    await yieldIfDue();
+    const read = await readChunkVectorRow(ctx, row, () => {
+      unreadableVectors++;
+    });
+    if (signal?.aborted) break;
+    if (!read) continue;
+    chunkCache.set(row.id, read.entry);
+    warmed++;
+  }
+  warnUnreadableChunkVectors("warmChunkVectorCacheOp", unreadableVectors);
+  return warmed;
+}
+async function* loadVectorRowsInBatches(source, ids) {
+  for (let offset = 0; offset < ids.length; offset += CHUNK_VECTOR_BATCH_SIZE) {
+    yield* await source.loadVectorRows(ids.slice(offset, offset + CHUNK_VECTOR_BATCH_SIZE));
+  }
+}
+function warnUnreadableChunkVectors(operation, count2) {
+  if (count2 === 0) return;
+  getLogger().warn(
+    `${operation}: could not read ${count2} chunk vectors and left them out of ranking \u2014 the stored value is corrupt, so those chunks stay unsearchable until the message is re-embedded via chunkAndEmbedAllMessages`
+  );
+}
 async function searchChunksOp(ctx, queryVector, options) {
   const {
     limit = 10,
@@ -3841,45 +3898,39 @@ async function searchChunksOp(ctx, queryVector, options) {
     for (const row of rows) {
       await yieldIfDue();
       const id2 = row.id;
-      const version = Number(row.updated_at) || 0;
       const order = orderById.get(id2) ?? Number.MAX_SAFE_INTEGER;
-      const chunks3 = await readRawJsonField(row, "chunks", ctx.walletAddress);
-      if (chunks3 && chunks3.length > 0) {
-        const vectors = chunks3.map(
-          (chunk) => decodeChunkVector(chunk.vector, () => {
-            unreadableVectors++;
-          })
-        );
-        chunkCache?.set(id2, { version, chunks: vectors });
-        for (let ci = 0; ci < chunks3.length; ci++) {
-          const vec = vectors[ci];
-          if (vec.length === 0) continue;
-          const similarity = cosineSimilarity(queryVector, vec);
-          if (similarity >= minSimilarity) {
-            candidates.push({
-              id: id2,
-              version,
-              order,
-              similarity,
-              chunkTextSource: { kind: "chunk", chunk: chunks3[ci], siblings: chunks3 }
-            });
-          }
+      const read = await readChunkVectorRow(ctx, row, () => {
+        unreadableVectors++;
+      });
+      if (!read) continue;
+      const { entry, chunks: chunks3 } = read;
+      const { version } = entry;
+      chunkCache?.set(id2, entry);
+      if (entry.fallback) {
+        const similarity = cosineSimilarity(queryVector, entry.fallback);
+        if (similarity >= minSimilarity) {
+          candidates.push({
+            id: id2,
+            version,
+            order,
+            similarity,
+            chunkTextSource: { kind: "message" }
+          });
         }
-      } else {
-        const messageVector = await readRawJsonField(row, "vector", ctx.walletAddress);
-        if (messageVector && messageVector.length > 0) {
-          const fallback = Float32Array.from(messageVector);
-          chunkCache?.set(id2, { version, chunks: [], fallback });
-          const similarity = cosineSimilarity(queryVector, fallback);
-          if (similarity >= minSimilarity) {
-            candidates.push({
-              id: id2,
-              version,
-              order,
-              similarity,
-              chunkTextSource: { kind: "message" }
-            });
-          }
+        continue;
+      }
+      for (let ci = 0; ci < chunks3.length; ci++) {
+        const vec = entry.chunks[ci];
+        if (vec.length === 0) continue;
+        const similarity = cosineSimilarity(queryVector, vec);
+        if (similarity >= minSimilarity) {
+          candidates.push({
+            id: id2,
+            version,
+            order,
+            similarity,
+            chunkTextSource: { kind: "chunk", chunk: chunks3[ci], siblings: chunks3 }
+          });
         }
       }
     }
@@ -3890,11 +3941,7 @@ async function searchChunksOp(ctx, queryVector, options) {
       `searchChunksOp: skipped ${staleSkipped} messages whose embedding model differs from the current model (${embeddingModel}) \u2014 re-embed via chunkAndEmbedAllMessages`
     );
   }
-  if (unreadableVectors > 0) {
-    getLogger().warn(
-      `searchChunksOp: could not read ${unreadableVectors} chunk vectors and left them out of ranking \u2014 the stored value is corrupt, so those chunks stay unsearchable until the message is re-embedded via chunkAndEmbedAllMessages`
-    );
-  }
+  warnUnreadableChunkVectors("searchChunksOp", unreadableVectors);
   const topK = candidates.sort((a, b) => b.similarity - a.similarity || a.order - b.order).slice(0, limit);
   const topIds = Array.from(new Set(topK.map((c) => c.id)));
   const fullRows = await source.loadFullRows(topIds);
@@ -16522,6 +16569,9 @@ var WatermelonChatStorageAdapter = class {
   searchChunks(queryVector, options) {
     return searchChunksOp(this.ctx, queryVector, options);
   }
+  warmChunkCache(options) {
+    return warmChunkVectorCacheOp(this.ctx, options);
+  }
   getSummary(conversationId) {
     return getConversationSummaryOp(
       createSummaryContext(this.ctx.database, this.ctx),
@@ -21809,12 +21859,16 @@ async function prepareVaultCandidates(query, vaultCtx, embeddingOptions, cache,
     const currentModel = embeddingOptions.model ?? DEFAULT_API_EMBEDDING_MODEL;
     const uncachedTexts = [];
     const uncachedIndices = [];
+    const resolvedVectors = /* @__PURE__ */ new Map();
     let staleReembedCount = 0;
     for (let i = 0; queryEmbedding.length > 0 && i < memories.length; i++) {
       const content = memories[i].content;
       const memoryId = memories[i].uniqueId;
       const cached = cachedRowVector(cache, memoryId, memories[i].updatedAt, content);
-      if (cached && cached.length === queryEmbedding.length) continue;
+      if (cached && cached.length === queryEmbedding.length) {
+        resolvedVectors.set(memoryId, cached);
+        continue;
+      }
       if (cached) cache.delete(memoryId);
       const storedModel = memories[i].embeddingModel;
       const modelCompatible = (storedModel ?? currentModel) === currentModel;
@@ -21822,13 +21876,9 @@ async function prepareVaultCandidates(query, vaultCtx, embeddingOptions, cache,
         try {
           const parsed = JSON.parse(memories[i].embedding);
           if (Array.isArray(parsed) && parsed.length === queryEmbedding.length) {
-            cacheRowVector(
-              cache,
-              memoryId,
-              Float32Array.from(parsed),
-              memories[i].updatedAt,
-              content
-            );
+            const vector2 = Float32Array.from(parsed);
+            resolvedVectors.set(memoryId, vector2);
+            cacheRowVector(cache, memoryId, vector2, memories[i].updatedAt, content);
             continue;
           }
         } catch {
@@ -21861,20 +21911,17 @@ async function prepareVaultCandidates(query, vaultCtx, embeddingOptions, cache,
       }
       if (newEmbeddings) {
         for (let j = 0; j < uncachedTexts.length; j++) {
-          cacheRowVector(
-            cache,
-            memories[uncachedIndices[j]].uniqueId,
-            Float32Array.from(newEmbeddings[j]),
-            memories[uncachedIndices[j]].updatedAt,
-            memories[uncachedIndices[j]].content
-          );
+          const memory = memories[uncachedIndices[j]];
+          const vector2 = Float32Array.from(newEmbeddings[j]);
+          resolvedVectors.set(memory.uniqueId, vector2);
+          cacheRowVector(cache, memory.uniqueId, vector2, memory.updatedAt, memory.content);
         }
       }
     }
     embeddedItems = memories.map((m) => ({
       id: m.uniqueId,
       content: m.content,
-      embedding: cache.get(m.uniqueId) ?? [],
+      embedding: resolvedVectors.get(m.uniqueId) ?? [],
       createdAt: m.createdAt,
       updatedAt: m.updatedAt,
       proofCount: m.proofCount,
@@ -36347,6 +36394,7 @@ function useChatStorage(options) {
     [vaultCtx, vaultEmbeddingCache, memoryStore]
   );
   const chunkVectorCacheRef = useRef4(createChunkVectorCache());
+  const recallWarmsRef = useRef4(/* @__PURE__ */ new Set());
   const clientToolEmbeddingsCacheRef = useRef4(/* @__PURE__ */ new Map());
   useEffect5(() => {
     if (!getToken || memoryStore !== void 0) return;
@@ -36360,6 +36408,8 @@ function useChatStorage(options) {
   useEffect5(() => {
     return onClearAllEncryptionState(() => {
       vaultEmbeddingCache.clear();
+      for (const warm of recallWarmsRef.current) warm.abort();
+      recallWarmsRef.current.clear();
       chunkVectorCacheRef.current.clear();
     });
   }, [vaultEmbeddingCache]);
@@ -36478,6 +36528,28 @@ function useChatStorage(options) {
       storeMaskMissing
     ]
   );
+  const warmRecallCache = useCallback6(
+    async (signal) => {
+      if (!backend.warmChunkCache) return 0;
+      const warm = new AbortController();
+      const stop2 = () => warm.abort(signal?.reason);
+      if (signal?.aborted) stop2();
+      signal?.addEventListener("abort", stop2, { once: true });
+      recallWarmsRef.current.add(warm);
+      try {
+        return await backend.warmChunkCache({
+          chunkCache: chunkVectorCacheRef.current,
+          embeddingModel,
+          limit: DEFAULT_CHUNK_CACHE_SIZE,
+          signal: warm.signal
+        });
+      } finally {
+        recallWarmsRef.current.delete(warm);
+        signal?.removeEventListener("abort", stop2);
+      }
+    },
+    [backend, embeddingModel]
+  );
   const {
     isLoading,
     sendMessage: baseSendMessage,
@@ -37660,6 +37732,7 @@ function useChatStorage(options) {
     createMemoryVaultSearchTool: createMemoryVaultSearchTool2,
     createRecallTool: createRecallTool2,
     recall: recallFn,
+    warmRecallCache,
     searchVaultMemories: searchVaultMemoriesFn,
     vaultEmbeddingCache,
     getVaultMemories,