@anuma/sdk 7.0.0 → 7.0.2

package/dist/server/index.cjs

@@ -16424,6 +16424,7 @@ __export(index_exports, {
   encryptDataBatch: () => encryptDataBatch,
   encryptDataBytes: () => encryptDataBytes,
   encryptDataWithKey: () => encryptDataWithKey,
+  encryptToolCallEventsOp: () => encryptToolCallEventsOp,
   estimateMessagesTokens: () => estimateMessagesTokens,
   estimateTokens: () => estimateTokens,
   exportPublicKey: () => exportPublicKey,
@@ -17668,6 +17669,35 @@ function decodeChunkVector(vector, onMalformed) {
   }
 }
 
+// src/lib/scheduling.ts
+function nowMs() {
+  return typeof performance !== "undefined" && typeof performance.now === "function" ? performance.now() : Date.now();
+}
+function yieldToEventLoop() {
+  const scheduler = globalThis.scheduler;
+  if (typeof scheduler?.yield === "function") return scheduler.yield();
+  if (typeof MessageChannel === "function") {
+    return new Promise((resolve) => {
+      const channel = new MessageChannel();
+      channel.port1.onmessage = () => {
+        channel.port1.close();
+        channel.port2.close();
+        resolve();
+      };
+      channel.port2.postMessage(null);
+    });
+  }
+  return new Promise((resolve) => setTimeout(resolve, 0));
+}
+function createTimeSliceYielder(budgetMs) {
+  let sliceStart = nowMs();
+  return async () => {
+    if (nowMs() - sliceStart < budgetMs) return;
+    await yieldToEventLoop();
+    sliceStart = nowMs();
+  };
+}
+
 // src/lib/db/encryption-utils.ts
 init_logger();
 var ENCRYPTION_PREFIX = "enc:v3:";
@@ -17814,6 +17844,12 @@ async function encryptMessageFields(message, address, signMessage, embeddedWalle
     const encryptedChunks = msg.chunks ? await encryptJsonField(msg.chunks, address, signMessage, embeddedWalletSigner, true) : void 0;
     const encryptedSources = msg.sources ? await encryptJsonField(msg.sources, address, signMessage, embeddedWalletSigner, true) : void 0;
     const encryptedThoughtProcess = msg.thoughtProcess ? await encryptJsonField(msg.thoughtProcess, address, signMessage, embeddedWalletSigner, true) : void 0;
+    const encryptedToolCallEvents = Array.isArray(msg.toolCallEvents) ? await encryptToolCallEvents(
+      msg.toolCallEvents,
+      address,
+      signMessage,
+      embeddedWalletSigner
+    ) : void 0;
     return {
       ...message,
       ...encryptedContent !== void 0 && { content: encryptedContent },
@@ -17821,13 +17857,31 @@ async function encryptMessageFields(message, address, signMessage, embeddedWalle
       ...encryptedVector !== void 0 && { vector: encryptedVector },
       ...encryptedChunks !== void 0 && { chunks: encryptedChunks },
       ...encryptedSources !== void 0 && { sources: encryptedSources },
-      ...encryptedThoughtProcess !== void 0 && { thoughtProcess: encryptedThoughtProcess }
+      ...encryptedThoughtProcess !== void 0 && { thoughtProcess: encryptedThoughtProcess },
+      ...encryptedToolCallEvents !== void 0 && { toolCallEvents: encryptedToolCallEvents }
     };
   } catch (error) {
     getLogger().warn("Failed to encrypt message fields:", error);
     throw error;
   }
 }
+function mapToolCallPayloads(events, transform) {
+  return Promise.all(
+    events.map(async (event) => {
+      if (!event || typeof event !== "object") return event;
+      const mapped = { ...event };
+      if (typeof event.arguments === "string") mapped.arguments = await transform(event.arguments);
+      if (typeof event.output === "string") mapped.output = await transform(event.output);
+      return mapped;
+    })
+  );
+}
+function encryptToolCallEvents(events, address, signMessage, embeddedWalletSigner) {
+  return mapToolCallPayloads(
+    events,
+    (value) => encryptField(value, address, signMessage, embeddedWalletSigner, true)
+  );
+}
 async function decryptMaybeJsonFieldDetailed(value, address) {
   if (value === void 0) return { value: void 0, status: "plaintext" };
   if (value === null) return { value, status: "plaintext" };
@@ -17913,6 +17967,10 @@ async function assembleDecryptedMessage(message, address) {
     message.thoughtProcess,
     address
   );
+  const toolCallEventsResult = await decryptMaybeJsonFieldDetailed(
+    message.toolCallEvents,
+    address
+  );
   let decryptionStatus;
   let refreshProbe;
   const consider = (status, probe) => {
@@ -17931,6 +17989,14 @@ async function assembleDecryptedMessage(message, address) {
   if (thoughtProcessResult.probe) {
     consider(thoughtProcessResult.status, thoughtProcessResult.probe);
   }
+  if (toolCallEventsResult.probe) {
+    consider(toolCallEventsResult.status, toolCallEventsResult.probe);
+  }
+  const toolCallEvents = Array.isArray(toolCallEventsResult.value) ? await mapToolCallPayloads(toolCallEventsResult.value, async (value) => {
+    const detailed = await decryptFieldDetailed(value, address);
+    consider(detailed.status, isEncrypted(value) ? value : void 0);
+    return detailed.value;
+  }) : void 0;
   const statusForConsumer = decryptionStatus === "ok" || decryptionStatus === "plaintext" || !decryptionStatus ? void 0 : decryptionStatus;
   const result = {
     ...message,
@@ -17939,7 +18005,8 @@ async function assembleDecryptedMessage(message, address) {
     vector: vectorResult.value,
     chunks: chunksResult.value,
     sources: sourcesResult.value,
-    thoughtProcess: thoughtProcessResult.value
+    thoughtProcess: thoughtProcessResult.value,
+    toolCallEvents
   };
   if (statusForConsumer) {
     result.decryptionStatus = statusForConsumer;
@@ -18505,7 +18572,7 @@ async function updateMessageChunksOp(ctx, uniqueId, chunks, embeddingModel) {
   });
   return messageToStored(message, ctx.walletAddress, ctx.signMessage, ctx.embeddedWalletSigner);
 }
-var STRIP_CHUNK_TEXT_PAGE_SIZE = 100;
+var RAW_REPAIR_PAGE_SIZE = 100;
 function chunksWithoutText(raw) {
   if (typeof raw !== "string") return null;
   let parsed;
@@ -18528,8 +18595,8 @@ function chunksWithoutText(raw) {
 async function stripLegacyChunkTextOp(ctx) {
   const candidateIds = await ctx.messagesCollection.query(import_watermelondb2.Q.where("chunks", import_watermelondb2.Q.like(`%${import_watermelondb2.Q.sanitizeLikeString('"text":')}%`))).fetchIds();
   let stripped = 0;
-  for (let start = 0; start < candidateIds.length; start += STRIP_CHUNK_TEXT_PAGE_SIZE) {
-    const pageIds = candidateIds.slice(start, start + STRIP_CHUNK_TEXT_PAGE_SIZE);
+  for (let start = 0; start < candidateIds.length; start += RAW_REPAIR_PAGE_SIZE) {
+    const pageIds = candidateIds.slice(start, start + RAW_REPAIR_PAGE_SIZE);
     const rows = await ctx.messagesCollection.query(import_watermelondb2.Q.where("id", import_watermelondb2.Q.oneOf(pageIds))).unsafeFetchRaw();
     const changedIds = rows.filter((row) => chunksWithoutText(row.chunks) !== null).map((row) => String(row.id));
     if (changedIds.length === 0) continue;
@@ -18553,6 +18620,88 @@ async function stripLegacyChunkTextOp(ctx) {
   }
   return stripped;
 }
+async function encryptedToolCallEventsColumn(raw, address, signMessage, embeddedWalletSigner) {
+  if (typeof raw !== "string") return null;
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  if (!Array.isArray(parsed)) return null;
+  const column = JSON.stringify(
+    await encryptToolCallEvents(
+      parsed,
+      address,
+      signMessage,
+      embeddedWalletSigner
+    )
+  );
+  return column === JSON.stringify(parsed) ? null : column;
+}
+async function encryptToolCallEventsOp(ctx) {
+  const { walletAddress: address, signMessage, embeddedWalletSigner } = ctx;
+  if (!address || !signMessage) return 0;
+  if (!await requestEncryptionKey(address, signMessage, embeddedWalletSigner)) return 0;
+  if (!hasEncryptionKey(address)) return 0;
+  if (!await savedKeyOpensExistingData(ctx, address, signMessage, embeddedWalletSigner)) {
+    return 0;
+  }
+  const candidateIds = await ctx.messagesCollection.query(
+    import_watermelondb2.Q.where("tool_call_events", import_watermelondb2.Q.notEq(null)),
+    import_watermelondb2.Q.where("tool_call_events", import_watermelondb2.Q.notIn(["", "[]"]))
+  ).fetchIds();
+  let encrypted = 0;
+  for (let start = 0; start < candidateIds.length; start += RAW_REPAIR_PAGE_SIZE) {
+    const pageIds = candidateIds.slice(start, start + RAW_REPAIR_PAGE_SIZE);
+    const rows = await ctx.messagesCollection.query(import_watermelondb2.Q.where("id", import_watermelondb2.Q.oneOf(pageIds))).unsafeFetchRaw();
+    const repairs = /* @__PURE__ */ new Map();
+    for (const row of rows) {
+      const column = await encryptedToolCallEventsColumn(
+        row.tool_call_events,
+        address,
+        signMessage,
+        embeddedWalletSigner
+      );
+      if (column !== null) repairs.set(String(row.id), { raw: row.tool_call_events, column });
+    }
+    if (repairs.size === 0) continue;
+    await ctx.database.write(async () => {
+      const messages = (await ctx.messagesCollection.query(import_watermelondb2.Q.where("id", import_watermelondb2.Q.oneOf([...repairs.keys()]))).fetch()).filter(
+        (message) => message._raw.tool_call_events === repairs.get(message.id)?.raw
+      );
+      if (messages.length === 0) return;
+      const conversationIds = [...new Set(messages.map((message) => message.conversationId))];
+      const conversations = await ctx.conversationsCollection.query(import_watermelondb2.Q.where("conversation_id", import_watermelondb2.Q.oneOf(conversationIds))).fetch();
+      await ctx.database.batch(
+        ...messages.map(
+          (message) => message.prepareUpdate((msg) => {
+            msg._setRaw("tool_call_events", repairs.get(message.id).column);
+          })
+        ),
+        ...conversations.map((conversation) => conversation.prepareUpdate(() => {
+        }))
+      );
+      encrypted += messages.length;
+    });
+  }
+  return encrypted;
+}
+async function savedKeyOpensExistingData(ctx, address, signMessage, embeddedWalletSigner) {
+  const v3Probe = await findEncryptedContent(ctx, "enc:v3:%");
+  if (v3Probe) {
+    const { status } = await decryptFieldDetailed(v3Probe, address);
+    if (status !== "auth_mismatch" && status !== "key_missing") return true;
+    return refreshEncryptionKeyIfMatches(address, v3Probe, signMessage, embeddedWalletSigner);
+  }
+  const v2Probe = await findEncryptedContent(ctx, "enc:v2:%");
+  if (!v2Probe) return true;
+  return refreshEncryptionKeyIfMatches(address, v2Probe, signMessage, embeddedWalletSigner);
+}
+async function findEncryptedContent(ctx, pattern) {
+  const [row] = await ctx.messagesCollection.query(import_watermelondb2.Q.where("content", import_watermelondb2.Q.like(pattern)), import_watermelondb2.Q.take(1)).unsafeFetchRaw();
+  return row ? String(row.content) : null;
+}
 async function updateMessageErrorOp(ctx, uniqueId, error) {
   let message;
   try {
@@ -18696,6 +18845,95 @@ async function searchMessagesOp(ctx, queryVector, options) {
     })
   );
 }
+var CHUNK_VECTOR_BATCH_SIZE = 50;
+var CHUNK_SCAN_YIELD_BUDGET_MS = 12;
+var hasEmbeddingSql = `(coalesce("chunks", '') != '' or coalesce("vector", '') != '')`;
+function toChunkCandidateKey(raw) {
+  return {
+    id: raw.id,
+    conversationId: String(raw.conversation_id),
+    version: Number(raw.updated_at) || 0,
+    embeddingModel: raw.embedding_model ?? null
+  };
+}
+async function fetchRowsByIds(ctx, ids) {
+  if (ids.length === 0) return [];
+  return await ctx.messagesCollection.query(import_watermelondb2.Q.where("id", import_watermelondb2.Q.oneOf(ids))).unsafeFetchRaw();
+}
+async function projectedChunkRowSource(ctx, filter) {
+  const clauses = [
+    `"history"."_status" is not 'deleted'`,
+    hasEmbeddingSql,
+    `exists (select 1 from "conversations" where "conversations"."conversation_id" = "history"."conversation_id" and "conversations"."is_deleted" = 0 and "conversations"."_status" is not 'deleted')`
+  ];
+  const args = [];
+  if (filter.conversationId !== void 0) {
+    clauses.push(`"history"."conversation_id" = ?`);
+    args.push(filter.conversationId);
+  }
+  if (filter.excludeConversationId !== void 0) {
+    clauses.push(`"history"."conversation_id" != ?`);
+    args.push(filter.excludeConversationId);
+  }
+  const keyRows = await ctx.messagesCollection.query(
+    import_watermelondb2.Q.unsafeSqlQuery(
+      `select "id", "conversation_id", "updated_at", "embedding_model" from "history" where ${clauses.join(" and ")}`,
+      args
+    )
+  ).unsafeFetchRaw();
+  return {
+    keys: keyRows.map(toChunkCandidateKey),
+    loadVectorRows: async (ids) => {
+      if (ids.length === 0) return [];
+      return await ctx.messagesCollection.query(
+        import_watermelondb2.Q.unsafeSqlQuery(
+          `select "id", "updated_at", "chunks", "vector" from "history" where "_status" is not 'deleted' and "id" in (${ids.map(() => "?").join(",")})`,
+          ids
+        )
+      ).unsafeFetchRaw();
+    },
+    loadFullRows: (ids) => fetchRowsByIds(ctx, ids)
+  };
+}
+async function fullScanChunkRowSource(ctx, filter) {
+  const activeConversations = await ctx.conversationsCollection.query(import_watermelondb2.Q.where("is_deleted", false)).fetch();
+  const activeConversationIds = new Set(
+    activeConversations.map((c) => String(c._getRaw("conversation_id")))
+  );
+  const queryConditions = filter.conversationId !== void 0 ? [import_watermelondb2.Q.where("conversation_id", filter.conversationId)] : [];
+  const rows = await ctx.messagesCollection.query(...queryConditions).unsafeFetchRaw();
+  const rowsById = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const conversationId = String(row.conversation_id);
+    if (!activeConversationIds.has(conversationId)) continue;
+    if (filter.excludeConversationId !== void 0 && conversationId === filter.excludeConversationId) {
+      continue;
+    }
+    if (!row.chunks && !row.vector) continue;
+    rowsById.set(row.id, row);
+  }
+  const pick = (ids) => Promise.resolve(
+    ids.flatMap((id) => {
+      const row = rowsById.get(id);
+      return row ? [row] : [];
+    })
+  );
+  return {
+    keys: Array.from(rowsById.values(), toChunkCandidateKey),
+    loadVectorRows: pick,
+    loadFullRows: pick
+  };
+}
+async function chunkRowSource(ctx, filter) {
+  try {
+    return await projectedChunkRowSource(ctx, filter);
+  } catch (err) {
+    getLogger().debug(
+      "searchChunksOp: projected SQL unavailable, using full-load fallback: " + (err instanceof Error ? err.message : String(err))
+    );
+    return fullScanChunkRowSource(ctx, filter);
+  }
+}
 async function searchChunksOp(ctx, queryVector, options) {
   const {
     limit = 10,
@@ -18703,83 +18941,111 @@ async function searchChunksOp(ctx, queryVector, options) {
     conversationId,
     excludeConversationId,
     embeddingModel,
-    chunkCache
+    chunkCache,
+    onStats
   } = options || {};
-  const activeConversations = await ctx.conversationsCollection.query(import_watermelondb2.Q.where("is_deleted", false)).fetch();
-  const activeConversationIds = new Set(
-    activeConversations.map((c) => String(c._getRaw("conversation_id")))
-  );
-  const queryConditions = conversationId ? [import_watermelondb2.Q.where("conversation_id", conversationId)] : [];
-  const messages = await ctx.messagesCollection.query(...queryConditions).unsafeFetchRaw();
+  const source = await chunkRowSource(ctx, { conversationId, excludeConversationId });
+  const yieldIfDue = createTimeSliceYielder(CHUNK_SCAN_YIELD_BUDGET_MS);
   const candidates = [];
   let staleSkipped = 0;
   let unreadableVectors = 0;
-  for (const message of messages) {
-    const msgConvId = String(message.conversation_id);
-    if (!activeConversationIds.has(msgConvId)) continue;
-    if (excludeConversationId !== void 0 && msgConvId === excludeConversationId) continue;
-    if (embeddingModel) {
-      const storedModel = message.embedding_model;
-      if (storedModel !== null && storedModel !== void 0 && storedModel !== embeddingModel) {
-        staleSkipped++;
-        continue;
-      }
+  let cacheHits = 0;
+  const missIds = [];
+  const orderById = /* @__PURE__ */ new Map();
+  for (const [order, key] of source.keys.entries()) {
+    await yieldIfDue();
+    orderById.set(key.id, order);
+    if (embeddingModel && key.embeddingModel !== null && key.embeddingModel !== embeddingModel) {
+      staleSkipped++;
+      continue;
     }
-    const version = Number(message.updated_at) || 0;
-    const cached = chunkCache?.get(message.id);
-    if (cached && cached.version === version) {
-      if (cached.chunks.length > 0) {
-        for (let ci = 0; ci < cached.chunks.length; ci++) {
-          const vec = cached.chunks[ci];
-          if (vec.length === 0) continue;
-          const similarity = cosineSimilarity(queryVector, vec);
-          if (similarity >= minSimilarity) {
-            candidates.push({
-              message,
-              similarity,
-              chunkTextSource: { kind: "chunk-cached", chunkIndex: ci, version }
-            });
-          }
-        }
-      } else if (cached.fallback) {
-        const similarity = cosineSimilarity(queryVector, cached.fallback);
-        if (similarity >= minSimilarity) {
-          candidates.push({ message, similarity, chunkTextSource: { kind: "message" } });
-        }
-      }
+    const cached = chunkCache?.get(key.id);
+    if (!cached || cached.version !== key.version) {
+      missIds.push(key.id);
       continue;
     }
-    const chunks = await readRawJsonField(message, "chunks", ctx.walletAddress);
-    if (chunks && chunks.length > 0) {
-      const vectors = chunks.map(
-        (chunk) => decodeChunkVector(chunk.vector, () => {
-          unreadableVectors++;
-        })
-      );
-      chunkCache?.set(message.id, { version, chunks: vectors });
-      for (let ci = 0; ci < chunks.length; ci++) {
-        const vec = vectors[ci];
+    cacheHits++;
+    if (cached.chunks.length > 0) {
+      for (let ci = 0; ci < cached.chunks.length; ci++) {
+        const vec = cached.chunks[ci];
         if (vec.length === 0) continue;
         const similarity = cosineSimilarity(queryVector, vec);
         if (similarity >= minSimilarity) {
           candidates.push({
-            message,
+            id: key.id,
+            version: key.version,
+            order,
             similarity,
-            chunkTextSource: { kind: "chunk", chunk: chunks[ci], siblings: chunks }
+            chunkTextSource: { kind: "chunk-cached", chunkIndex: ci, version: key.version }
           });
         }
       }
-    } else {
-      const messageVector = await readRawJsonField(message, "vector", ctx.walletAddress);
-      if (!messageVector || messageVector.length === 0) continue;
-      const fallback = Float32Array.from(messageVector);
-      chunkCache?.set(message.id, { version, chunks: [], fallback });
-      const similarity = cosineSimilarity(queryVector, fallback);
+    } else if (cached.fallback) {
+      const similarity = cosineSimilarity(queryVector, cached.fallback);
       if (similarity >= minSimilarity) {
-        candidates.push({ message, similarity, chunkTextSource: { kind: "message" } });
+        candidates.push({
+          id: key.id,
+          version: key.version,
+          order,
+          similarity,
+          chunkTextSource: { kind: "message" }
+        });
+      }
+    }
+  }
+  let rowsFetched = 0;
+  for (let offset = 0; offset < missIds.length; offset += CHUNK_VECTOR_BATCH_SIZE) {
+    const rows = await source.loadVectorRows(
+      missIds.slice(offset, offset + CHUNK_VECTOR_BATCH_SIZE)
+    );
+    rowsFetched += rows.length;
+    for (const row of rows) {
+      await yieldIfDue();
+      const id = row.id;
+      const version = Number(row.updated_at) || 0;
+      const order = orderById.get(id) ?? Number.MAX_SAFE_INTEGER;
+      const chunks = await readRawJsonField(row, "chunks", ctx.walletAddress);
+      if (chunks && chunks.length > 0) {
+        const vectors = chunks.map(
+          (chunk) => decodeChunkVector(chunk.vector, () => {
+            unreadableVectors++;
+          })
+        );
+        chunkCache?.set(id, { version, chunks: vectors });
+        for (let ci = 0; ci < chunks.length; ci++) {
+          const vec = vectors[ci];
+          if (vec.length === 0) continue;
+          const similarity = cosineSimilarity(queryVector, vec);
+          if (similarity >= minSimilarity) {
+            candidates.push({
+              id,
+              version,
+              order,
+              similarity,
+              chunkTextSource: { kind: "chunk", chunk: chunks[ci], siblings: chunks }
+            });
+          }
+        }
+      } else {
+        const messageVector = await readRawJsonField(row, "vector", ctx.walletAddress);
+        if (messageVector && messageVector.length > 0) {
+          const fallback = Float32Array.from(messageVector);
+          chunkCache?.set(id, { version, chunks: [], fallback });
+          const similarity = cosineSimilarity(queryVector, fallback);
+          if (similarity >= minSimilarity) {
+            candidates.push({
+              id,
+              version,
+              order,
+              similarity,
+              chunkTextSource: { kind: "message" }
+            });
+          }
+        }
       }
     }
   }
+  onStats?.({ rowsScanned: source.keys.length, rowsFetched, cacheHits });
   if (staleSkipped > 0) {
     getLogger().warn(
       `searchChunksOp: skipped ${staleSkipped} messages whose embedding model differs from the current model (${embeddingModel}) \u2014 re-embed via chunkAndEmbedAllMessages`
@@ -18790,12 +19056,17 @@ async function searchChunksOp(ctx, queryVector, options) {
       `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`
     );
   }
-  const topK = candidates.sort((a, b) => b.similarity - a.similarity).slice(0, limit);
-  const uniqueMessages = /* @__PURE__ */ new Map();
-  for (const c of topK) uniqueMessages.set(c.message.id, c.message);
+  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);
+  const rowById = new Map(fullRows.map((row) => [row.id, row]));
+  const liveTopK = topK.filter((c) => {
+    const row = rowById.get(c.id);
+    return row !== void 0 && (Number(row.updated_at) || 0) === c.version;
+  });
   const storedById = new Map(
     await Promise.all(
-      Array.from(uniqueMessages, async ([id, m]) => {
+      Array.from(rowById, async ([id, m]) => {
         const stored = await messageRawToStored(
           m,
           ctx.walletAddress,
@@ -18808,24 +19079,24 @@ async function searchChunksOp(ctx, queryVector, options) {
   );
   const chunkStateByMsgId = /* @__PURE__ */ new Map();
   const needsChunkText = /* @__PURE__ */ new Set();
-  for (const c of topK) {
-    if (c.chunkTextSource.kind === "chunk-cached") needsChunkText.add(c.message.id);
+  for (const c of liveTopK) {
+    if (c.chunkTextSource.kind === "chunk-cached") needsChunkText.add(c.id);
   }
   await Promise.all(
     Array.from(needsChunkText, async (id) => {
-      const m = uniqueMessages.get(id);
+      const m = rowById.get(id);
       const parsed = await readRawJsonField(m, "chunks", ctx.walletAddress);
       const version = Number(m.updated_at) || 0;
       if (parsed) chunkStateByMsgId.set(id, { version, chunks: parsed });
     })
   );
-  return topK.map(({ message, similarity, chunkTextSource }) => {
-    const stored = { ...storedById.get(message.id) };
+  return liveTopK.map(({ id, similarity, chunkTextSource }) => {
+    const stored = { ...storedById.get(id) };
     let chunkText2;
     if (chunkTextSource.kind === "chunk") {
       chunkText2 = resolveChunkText(stored.content, chunkTextSource.chunk, chunkTextSource.siblings);
     } else if (chunkTextSource.kind === "chunk-cached") {
-      const state = chunkStateByMsgId.get(message.id);
+      const state = chunkStateByMsgId.get(id);
       const chunk = state && state.version === chunkTextSource.version ? state.chunks[chunkTextSource.chunkIndex] : void 0;
       chunkText2 = resolveChunkText(stored.content, chunk, state?.chunks);
     } else {
@@ -19927,13 +20198,35 @@ async function generateEmbedding(text12, options) {
   if (total === void 0) return embedOne(text12, options, void 0);
   return withDeadline((signal) => embedOne(text12, options, signal), total, "embedding");
 }
+var inFlightByCache = /* @__PURE__ */ new WeakMap();
 async function embedOne(text12, options, outer) {
-  const { baseUrl = BASE_URL, model, cache } = options;
-  const timeoutMs = options.timeoutMs ?? DEFAULT_EMBEDDING_REQUEST_TIMEOUT_MS;
-  if (cache) {
-    const cached = cache.get(text12);
-    if (cached) return Array.from(cached);
+  const { cache } = options;
+  if (!cache) return Array.from(await requestEmbedding(text12, options, outer));
+  const cached = cache.get(text12);
+  if (cached) return Array.from(cached);
+  const inFlight = inFlightByCache.get(cache) ?? /* @__PURE__ */ new Map();
+  inFlightByCache.set(cache, inFlight);
+  const pending = inFlight.get(text12);
+  if (pending) {
+    try {
+      return Array.from(await pending);
+    } catch (err) {
+      if (outer?.aborted) throw err;
+    }
+  }
+  const request = requestEmbedding(text12, options, outer);
+  inFlight.set(text12, request);
+  try {
+    const embedding = await request;
+    cache.set(text12, embedding);
+    return Array.from(embedding);
+  } finally {
+    if (inFlight.get(text12) === request) inFlight.delete(text12);
   }
+}
+async function requestEmbedding(text12, options, outer) {
+  const { baseUrl = BASE_URL, model } = options;
+  const timeoutMs = options.timeoutMs ?? DEFAULT_EMBEDDING_REQUEST_TIMEOUT_MS;
   const headers = {
     ...await resolveAuthHeaders(options, outer),
     ...taskTypeHeader(options.taskType)
@@ -19968,11 +20261,7 @@ async function embedOne(text12, options, outer) {
       totalTokens: response.data.usage.total_tokens ?? 0
     });
   }
-  const f32Embedding = Float32Array.from(embedding);
-  if (cache) {
-    cache.set(text12, f32Embedding);
-  }
-  return Array.from(f32Embedding);
+  return Float32Array.from(embedding);
 }
 var DEFAULT_EMBEDDING_BATCH_SIZE = 100;
 var DEFAULT_EMBEDDING_BATCH_CONCURRENCY = 3;
@@ -30436,9 +30725,9 @@ function recencyMultiplier(updatedAt, opts = {}) {
   const updatedMs = updatedAt.getTime();
   if (!Number.isFinite(updatedMs)) return noDate;
   const now = opts.now ?? /* @__PURE__ */ new Date();
-  const nowMs3 = now.getTime();
-  if (!Number.isFinite(nowMs3)) return noDate;
-  const ageDays2 = Math.max(0, (nowMs3 - updatedMs) / DAY_MS2);
+  const nowMs2 = now.getTime();
+  if (!Number.isFinite(nowMs2)) return noDate;
+  const ageDays2 = Math.max(0, (nowMs2 - updatedMs) / DAY_MS2);
   const perYearDecay = opts.perYearDecay ?? DEFAULT_PER_YEAR_DECAY;
   const floor = opts.floor ?? DEFAULT_FLOOR;
   const decay = perYearDecay * (ageDays2 / 365);
@@ -30950,9 +31239,6 @@ function createVaultEmbeddingCache(maxSize = DEFAULT_VAULT_CACHE_SIZE) {
 
 // src/lib/memoryVault/searchTool.ts
 var DEFAULT_RERANK_TOP_N = 5;
-function nowMs() {
-  return typeof performance !== "undefined" && typeof performance.now === "function" ? performance.now() : Date.now();
-}
 var warnedProgrammaticDecomposeIgnored = false;
 function normalizeEventTimeKind(kind) {
   return kind === "point" || kind === "range" || kind === "ongoing" ? kind : null;
@@ -33854,6 +34140,32 @@ function rankProfileCandidates(inputs, now = Date.now(), options = {}) {
   return ranked;
 }
 
+// src/lib/db/chat/embeddingCache.ts
+var MaskScopedEmbeddingCache = class extends Map {
+  constructor(inner, masked) {
+    super();
+    this.inner = inner;
+    this.masked = masked;
+  }
+  key(text12) {
+    return `${this.masked ? "m" : "r"}:${text12}`;
+  }
+  get(text12) {
+    return this.inner.get(this.key(text12));
+  }
+  set(text12, value) {
+    this.inner.set(this.key(text12), value);
+    return this;
+  }
+};
+var scopedViews = /* @__PURE__ */ new WeakMap();
+function maskScopedEmbeddingCache(cache, masked) {
+  const views = scopedViews.get(cache) ?? {};
+  scopedViews.set(cache, views);
+  const slot = masked ? "masked" : "raw";
+  return views[slot] ?? (views[slot] = new MaskScopedEmbeddingCache(cache, masked));
+}
+
 // src/lib/memory/recall.ts
 init_logger();
 
@@ -34064,9 +34376,6 @@ function scoreEventTimeOverlap(memoryStart, memoryEnd, memoryKind, window2) {
 var DEFAULT_LIMIT = 8;
 var DEFAULT_BUDGET = "low";
 var DEFAULT_FACT_MIN_SCORE = 0.1;
-function nowMs2() {
-  return typeof performance !== "undefined" && typeof performance.now === "function" ? performance.now() : Date.now();
-}
 var DEFAULT_CHUNK_MIN_SCORE = 0.5;
 var DEFAULT_QUERY_EMBED_TOTAL_TIMEOUT_MS = 8e3;
 function flagsForBudget(budget) {
@@ -34104,12 +34413,19 @@ async function recall(query, ctx, options = {}) {
   const subQueries = normalizedFacets.length >= 2 ? normalizedFacets : void 0;
   const embeddingOptions = {
     ...ctx.embeddingOptions,
-    taskType: "memory_recall_embed"
+    taskType: "memory_recall_embed",
+    ...options.embeddingCache && !ctx.embeddingOptions.cache && {
+      cache: maskScopedEmbeddingCache(
+        options.embeddingCache,
+        Boolean(ctx.embeddingOptions.maskInput)
+      )
+    }
   };
-  const t0 = nowMs2();
+  const t0 = nowMs();
   let prepMs = 0;
   let factLaneMs = 0;
   let chunkLaneMs = 0;
+  let chunkStats;
   let fuseMs = 0;
   const factResults = [];
   const chunkResults = [];
@@ -34164,6 +34480,11 @@ async function recall(query, ctx, options = {}) {
       ...decryptLastRan !== void 0 && { decryptLast: decryptLastRan },
       ...vaultRowsDecrypted !== void 0 && { vaultRowsDecrypted },
       ...vaultRowsEmbedded !== void 0 && { vaultRowsEmbedded },
+      ...chunkStats && {
+        chunkRowsScanned: chunkStats.rowsScanned,
+        chunkRowsFetched: chunkStats.rowsFetched,
+        chunkCacheHits: chunkStats.cacheHits
+      },
       factCount: factResults.length,
       chunkCount: chunkResults.length,
       admittedCount: admitted.length,
@@ -34175,7 +34496,7 @@ async function recall(query, ctx, options = {}) {
       temporalLaneCount,
       emptyReason: emptyReasonFor(admitted.length, laneRan),
       timings: {
-        total: nowMs2() - t0,
+        total: nowMs() - t0,
         prep: prepMs,
         factLane: factLaneMs,
         rerank: rerankMs,
@@ -34197,14 +34518,14 @@ async function recall(query, ctx, options = {}) {
   const needsChunkEmbedding = types.includes("chunk") && ctx.storageCtx;
   const wantsTemporal = types.includes("fact") && (ctx.factSource || ctx.vaultCtx);
   const queryEmbedTotalTimeoutMs = options.queryEmbedTotalTimeoutMs ?? DEFAULT_QUERY_EMBED_TOTAL_TIMEOUT_MS;
-  const prepStart = nowMs2();
+  const prepStart = nowMs();
   let sharedEmbedMs = 0;
   const [queryEmbedding, entityRanking, temporalRanking] = await Promise.all([
     needsChunkEmbedding ? generateEmbedding(query, {
       ...embeddingOptions,
       totalTimeoutMs: queryEmbedTotalTimeoutMs
     }).finally(() => {
-      sharedEmbedMs = nowMs2() - prepStart;
+      sharedEmbedMs = nowMs() - prepStart;
     }).then((vec) => {
       if (vec.length === 0) {
         getLogger().warn(
@@ -34237,11 +34558,11 @@ async function recall(query, ctx, options = {}) {
       () => ctx.factSource ? ctx.factSource.temporalRanking(query, options.now) : buildTemporalLaneRanking(query, ctx.vaultCtx, options.now)
     ) : Promise.resolve([])
   ]);
-  prepMs = nowMs2() - prepStart;
+  prepMs = nowMs() - prepStart;
   graphLaneCount = entityRanking.length;
   temporalLaneCount = temporalRanking.length;
   if (types.includes("fact") && (ctx.factSource || ctx.vaultCtx && ctx.vaultCache)) {
-    const factStart = nowMs2();
+    const factStart = nowMs();
     const vaultMinScore = options.minScore ?? DEFAULT_FACT_MIN_SCORE;
     factFloor = vaultMinScore;
     const {
@@ -34317,11 +34638,11 @@ async function recall(query, ctx, options = {}) {
     factLaneRankedOnCosine = factRankedOnCosine;
     decryptLastRan = factDecryptLast;
     vaultRowsDecrypted = factRowsDecrypted;
-    factLaneMs = nowMs2() - factStart;
+    factLaneMs = nowMs() - factStart;
   }
   if (chunkEmbedFailed && !factLaneRankedOnCosine) embeddingsUnavailable = true;
   if (types.includes("chunk") && ctx.storageCtx && queryEmbedding) {
-    const chunkStart = nowMs2();
+    const chunkStart = nowMs();
     const chunkMinScore = options.minScore ?? DEFAULT_CHUNK_MIN_SCORE;
     chunkFloor = chunkMinScore;
     const results = await searchChunksOp(ctx.storageCtx, queryEmbedding, {
@@ -34332,12 +34653,15 @@ async function recall(query, ctx, options = {}) {
       ...options.excludeConversationId && {
         excludeConversationId: options.excludeConversationId
       },
-      ...ctx.chunkCache && { chunkCache: ctx.chunkCache }
+      ...ctx.chunkCache && { chunkCache: ctx.chunkCache },
+      onStats: (stats) => {
+        chunkStats = stats;
+      }
     });
     chunkResults.push(...dedupeBy(results, (r) => r.chunkText.trim()));
-    chunkLaneMs = nowMs2() - chunkStart;
+    chunkLaneMs = nowMs() - chunkStart;
   }
-  const fuseStart = nowMs2();
+  const fuseStart = nowMs();
   if (types.length === 1 || factResults.length === 0 || chunkResults.length === 0) {
     const memories2 = [
       ...factResults.map((r) => toFactMemory(r, options.now)),
@@ -34345,7 +34669,7 @@ async function recall(query, ctx, options = {}) {
     ];
     memories2.sort((a, b) => b.score - a.score);
     const candidateCount = factResults.length + chunkResults.length;
-    fuseMs = nowMs2() - fuseStart;
+    fuseMs = nowMs() - fuseStart;
     const admitted = memories2.slice(0, limit);
     hitLimit = memories2.length > limit;
     emitDiagnostics(candidateCount, admitted);
@@ -34409,7 +34733,7 @@ async function recall(query, ctx, options = {}) {
     memories = selection.out;
   }
   hitLimit = selection.cut;
-  fuseMs = nowMs2() - fuseStart;
+  fuseMs = nowMs() - fuseStart;
   emitDiagnostics(byId.size, memories);
   return {
     memories,
@@ -39427,6 +39751,7 @@ function serverPlatformStorage() {
   encryptDataBatch,
   encryptDataBytes,
   encryptDataWithKey,
+  encryptToolCallEventsOp,
   estimateMessagesTokens,
   estimateTokens,
   exportPublicKey,