@anuma/sdk 10.2.6 → 10.3.1

package/dist/react/index.cjs

@@ -14294,6 +14294,25 @@ async function migrateChatsToRemote(options) {
 // src/lib/chatStore/vaultBackend.ts
 var import_uuid3 = require("uuid");
 
+// src/lib/chatStore/vaultCache.ts
+async function saveChatCache(storage, encrypt, snapshot) {
+  await storage.set(snapshot.account, await encrypt(JSON.stringify({ schema: 1, ...snapshot })));
+}
+async function loadChatCache(storage, account, decrypt) {
+  const sealed2 = await storage.get(account);
+  if (!sealed2) return void 0;
+  const parsed = JSON.parse(await decrypt(sealed2));
+  if (parsed.schema !== 1 || parsed.account !== account || typeof parsed.cursor !== "string" || !Array.isArray(parsed.records) || !Array.isArray(parsed.threads) || !Array.isArray(parsed.absent))
+    return void 0;
+  return {
+    account,
+    cursor: parsed.cursor,
+    records: parsed.records,
+    threads: parsed.threads,
+    absent: parsed.absent
+  };
+}
+
 // src/lib/chatStore/vaultOutbox.ts
 function patchKey(patch) {
   return `${patch.kind}/${patch.id}`;
@@ -14398,6 +14417,10 @@ async function loadOutbox(storage, slot, decrypt) {
 
 // src/lib/chatStore/vaultBackend.ts
 var terminalCodes = /* @__PURE__ */ new Set(["key_mismatch", "account_changed", "account_not_found"]);
+var cacheSaveDelayMs = 500;
+function cursorRejected(error) {
+  return error instanceof ChatStoreError && (error.status === 400 || error.status === 410);
+}
 function key2(kind, id2) {
   return `${kind}/${id2}`;
 }
@@ -14442,7 +14465,7 @@ function defaultActivity() {
   };
 }
 function createVaultChatBackend(options) {
-  const { store } = options;
+  const { cache } = options;
   const now = options.now ?? Date.now;
   const threadLimit = options.threadCacheSize ?? 30;
   const pollIntervalMs = options.pollIntervalMs ?? 6e4;
@@ -14469,6 +14492,13 @@ function createVaultChatBackend(options) {
   let persisting = Promise.resolve();
   let readyPromise = null;
   let adopting = null;
+  let connected = typeof options.store === "function" ? void 0 : options.store;
+  const complete = /* @__PURE__ */ new Set();
+  let fromCache = false;
+  let caching = false;
+  let cacheOff = false;
+  let cacheTimer;
+  let saving = Promise.resolve();
   const slot = (0, import_uuid3.v7)();
   const locks = options.outbox?.locks ?? globalThis.navigator?.locks;
   let releaseSlot;
@@ -14505,13 +14535,55 @@ function createVaultChatBackend(options) {
     }
     return out;
   };
+  const cacheSnapshot = () => {
+    const kept = [...threads.keys()].filter((id2) => complete.has(id2) && confirmedLive(id2));
+    const keep = new Set(kept);
+    return {
+      account: cache.account,
+      cursor: cursor ?? "",
+      records: [...confirmed.values()].filter(
+        ({ record: record2 }) => record2.kind === "conversation" || record2.kind !== "project" && keep.has(record2.conversationId)
+      ),
+      threads: kept,
+      absent: [...checked].filter((k) => {
+        const [kind, ...rest] = k.split("/");
+        return (kind === "summary" || kind === "memory_links") && !confirmed.has(k) && keep.has(rest.join("/"));
+      })
+    };
+  };
+  const saveCache = () => {
+    if (!cache || !caching || cacheOff || closed || cacheTimer || cursor === void 0) return;
+    cacheTimer = setTimeout(() => {
+      cacheTimer = void 0;
+      saving = saving.then(
+        () => cacheOff || closed ? void 0 : saveChatCache(cache.storage, cache.seal.encrypt, cacheSnapshot())
+      ).catch(() => void 0);
+    }, cacheSaveDelayMs);
+  };
+  const clearCache = async () => {
+    fromCache = false;
+    cacheOff = true;
+    clearTimeout(cacheTimer);
+    cacheTimer = void 0;
+    await saving;
+    if (cache) await cache.storage.set(cache.account, null);
+  };
+  const wipeIfTerminal = (error) => {
+    if (error instanceof ChatStoreError && terminalCodes.has(error.code ?? ""))
+      void clearCache().catch(() => void 0);
+  };
   const merge = (snapshot) => {
     const k = key2(snapshot.record.kind, snapshot.record.id);
     const known = confirmed.get(k);
     if (known && known.version >= snapshot.version) return false;
     confirmed.set(k, snapshot);
+    saveCache();
     return true;
   };
+  const remote = async () => {
+    await ready();
+    return connected;
+  };
   const persist = () => {
     const storage = options.outbox;
     if (!storage) return Promise.resolve();
@@ -14566,7 +14638,7 @@ function createVaultChatBackend(options) {
       return { kind, id: rest.join("/") };
     });
     if (refs.length === 0) return;
-    const found = await store.getMany(refs);
+    const found = await (await remote()).getMany(refs);
     const seen = new Set(found.map((s) => key2(s.record.kind, s.record.id)));
     for (const snapshot of found) merge(snapshot);
     for (const ref3 of refs) {
@@ -14574,6 +14646,7 @@ function createVaultChatBackend(options) {
       if (!seen.has(k)) confirmed.delete(k);
       checked.add(k);
     }
+    saveCache();
   };
   const drop = (patch, reason) => {
     inflight.delete(patchKey(patch));
@@ -14628,7 +14701,7 @@ function createVaultChatBackend(options) {
       sent.push(patch);
     }
     if (writes.length === 0) return;
-    const results = await store.putMany(writes);
+    const results = await (await remote()).putMany(writes);
     results.forEach((snapshot, i) => {
       merge(snapshot);
       checked.add(patchKey(sent[i]));
@@ -14662,6 +14735,7 @@ function createVaultChatBackend(options) {
     }
     if (terminalCodes.has(error.code ?? "")) {
       stopped = error.code;
+      wipeIfTerminal(error);
       reportOutbox();
       return "stop";
     }
@@ -14728,6 +14802,7 @@ function createVaultChatBackend(options) {
   const forget = (k) => {
     confirmed.delete(k);
     checked.delete(k);
+    saveCache();
   };
   const forgetConversation = (conversationId) => {
     threads.delete(conversationId);
@@ -14754,9 +14829,10 @@ function createVaultChatBackend(options) {
     }
     const loading = (async () => {
       if (!confirmedLive(conversationId)) return;
+      const source = await remote();
       let page;
       do {
-        const result = await store.list({
+        const result = await source.list({
           kind: "message",
           conversationId,
           limit: 200,
@@ -14766,7 +14842,15 @@ function createVaultChatBackend(options) {
         page = result.nextCursor;
       } while (page);
     })();
-    loading.catch(() => threads.delete(conversationId));
+    void loading.then(
+      () => {
+        if (threads.get(conversationId) !== loading) return;
+        complete.add(conversationId);
+        saveCache();
+      },
+      () => threads.delete(conversationId)
+    );
+    complete.delete(conversationId);
     threads.set(conversationId, loading);
     evict();
     return loading;
@@ -14784,20 +14868,58 @@ function createVaultChatBackend(options) {
     const relevant2 = threads.has(record2.conversationId) || confirmed.has(k) || checked.has(k) && record2.kind !== "message";
     if (relevant2 && merge(snapshot)) announce([record2]);
   };
+  const listIndex = async (source) => {
+    const index = [];
+    let page;
+    do {
+      const result = await source.list({
+        kind: "conversation",
+        limit: 200,
+        ...page ? { cursor: page } : {}
+      });
+      index.push(...result.items);
+      page = result.nextCursor;
+    } while (page);
+    return index;
+  };
+  const catchUp = async (source) => {
+    let next = cursor ?? "";
+    for (; ; ) {
+      const page = await source.changes(next || void 0, { limit: 200 });
+      page.items.forEach(applyRemote);
+      next = page.nextCursor ?? page.changesCursor;
+      if (!page.nextCursor) break;
+    }
+    cursor = next;
+  };
+  const refetch = async (source) => {
+    const account = await source.account();
+    const index = await listIndex(source);
+    const reopened = [...threads.keys()];
+    confirmed.clear();
+    checked.clear();
+    threads.clear();
+    complete.clear();
+    cursor = account.changesCursor ?? "";
+    index.forEach(merge);
+    emit({ type: "conversations", origin: "remote" });
+    for (const conversationId of reopened)
+      emit({ type: "messages", conversationId, origin: "remote" });
+  };
   const poll = () => {
     polling ?? (polling = (async () => {
-      await ready();
-      let next = cursor ?? "";
-      for (; ; ) {
-        const page = await store.changes(next || void 0, { limit: 200 });
-        page.items.forEach(applyRemote);
-        next = page.nextCursor ?? page.changesCursor;
-        if (!page.nextCursor) break;
-      }
-      cursor = next;
+      const source = await remote();
+      try {
+        await catchUp(source);
+      } catch (error) {
+        if (!cursorRejected(error)) throw error;
+        await refetch(source);
+      }
       pollFailures = 0;
-    })().catch(() => {
+      saveCache();
+    })().catch((error) => {
       pollFailures++;
+      wipeIfTerminal(error);
     }).finally(() => {
       polling = null;
       schedulePoll();
@@ -14813,26 +14935,27 @@ function createVaultChatBackend(options) {
   };
   const ready = () => {
     readyPromise ?? (readyPromise = (async () => {
-      const account = await store.account();
-      cursor = account.changesCursor ?? "";
-      let page;
-      do {
-        const result = await store.list({
-          kind: "conversation",
-          limit: 200,
-          ...page ? { cursor: page } : {}
-        });
-        result.items.forEach(merge);
-        page = result.nextCursor;
-      } while (page);
+      await seeding;
+      if (!connected && typeof options.store === "function") connected = await options.store();
+      const source = connected;
+      const account = await source.account();
+      if (!fromCache) {
+        cursor = account.changesCursor ?? "";
+        (await listIndex(source)).forEach(merge);
+      }
       await adopt();
       schedulePoll();
     })());
-    readyPromise.catch(() => {
+    readyPromise.catch((error) => {
       readyPromise = null;
+      wipeIfTerminal(error);
     });
     return readyPromise;
   };
+  const available2 = async () => {
+    await seeding;
+    if (!fromCache) await ready();
+  };
   const adoptSlot = async (outbox, other) => {
     const patches = await loadOutbox(outbox.storage, other, outbox.seal.decrypt);
     for (const patch of patches) {
@@ -14877,20 +15000,20 @@ function createVaultChatBackend(options) {
   });
   if (channel) channel.onmessage = () => void poll();
   const conversation = async (conversationId) => {
-    await ready();
+    await available2();
     const k = key2("conversation", conversationId);
     if (!view(k) && !checked.has(k)) {
-      const found = await store.get("conversation", conversationId);
+      const found = await (await remote()).get("conversation", conversationId);
       checked.add(k);
       if (found) merge(found);
     }
     return view(k);
   };
   const message = async (uniqueId) => {
-    await ready();
+    await available2();
     const k = key2("message", uniqueId);
     if (!view(k) && !checked.has(k)) {
-      const found = await store.get("message", uniqueId);
+      const found = await (await remote()).get("message", uniqueId);
       checked.add(k);
       if (found) merge(found);
     }
@@ -14898,17 +15021,18 @@ function createVaultChatBackend(options) {
     return record2 && !record2.isDeleted && conversationLive(record2.conversationId) ? record2 : void 0;
   };
   const child = async (kind, conversationId) => {
-    await ready();
+    await available2();
     const k = key2(kind, conversationId);
     if (!view(k) && !checked.has(k) && conversationLive(conversationId)) {
-      const found = await store.get(kind, conversationId);
+      const found = await (await remote()).get(kind, conversationId);
       checked.add(k);
       if (found) merge(found);
+      saveCache();
     }
     return view(k);
   };
   const thread = async (conversationId) => {
-    await ready();
+    await available2();
     if (!conversationLive(conversationId)) return [];
     await loadThread(conversationId);
     return all("message", conversationId).sort(
@@ -14972,7 +15096,7 @@ function createVaultChatBackend(options) {
       return record2 && !record2.isDeleted ? toConversation(record2) : null;
     },
     async getConversations(query) {
-      await ready();
+      await available2();
       return all("conversation").map(toConversation).filter(
         (c) => query?.projectId === void 0 || (query.projectId === null ? !c.projectId : c.projectId === query.projectId)
       ).sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
@@ -15042,7 +15166,7 @@ function createVaultChatBackend(options) {
       return toSkeletons(await thread(conversationId));
     },
     async getMessagesByIds(uniqueIds) {
-      await ready();
+      await available2();
       const ids = [...new Set(uniqueIds)];
       const unknown = ids.map((id2) => key2("message", id2)).filter((k) => !view(k) && !checked.has(k));
       await refresh(unknown);
@@ -15174,7 +15298,7 @@ function createVaultChatBackend(options) {
       );
     },
     async getAllFiles(query) {
-      await ready();
+      await available2();
       if (query?.conversationId) await loadThread(query.conversationId);
       const files = [];
       for (const record2 of all("message", query?.conversationId)) {
@@ -15199,7 +15323,7 @@ function createVaultChatBackend(options) {
       const vector2 = acceptedVector(queryVector);
       if (!vector2) return [];
       await flush();
-      const hits = await store.search(vector2, {
+      const hits = await (await remote()).search(vector2, {
         limit: Math.min(50, limit),
         kinds: ["message"],
         ...conversationId ? { conversationId } : {},
@@ -15306,8 +15430,9 @@ function createVaultChatBackend(options) {
       let messageCount = 0;
       try {
         for (const batch of batches(conversations))
-          conversationCount += await store.importRecords(batch);
-        for (const batch of batches(messages)) messageCount += await store.importRecords(batch);
+          conversationCount += await connected.importRecords(batch);
+        for (const batch of batches(messages))
+          messageCount += await connected.importRecords(batch);
       } finally {
         for (const { record: record2 } of messages) checked.delete(key2("message", record2.id));
         await refresh(conversations.map(({ record: record2 }) => key2("conversation", record2.id))).catch(
@@ -15322,8 +15447,10 @@ function createVaultChatBackend(options) {
       return { conversations: conversationCount, messages: messageCount };
     },
     status: () => ({ pending: pending.size + inflight.size, ...stopped ? { stopped } : {} }),
+    clearCache,
     close() {
       closed = true;
+      clearTimeout(cacheTimer);
       clearTimeout(flushTimer);
       clearTimeout(retryTimer);
       clearTimeout(pollTimer);
@@ -15340,7 +15467,31 @@ function createVaultChatBackend(options) {
     emit({ type: "conversations", origin: "local" });
     return true;
   };
+  const seed = async () => {
+    if (!cache) return;
+    try {
+      const snapshot = await loadChatCache(cache.storage, cache.account, cache.seal.decrypt).catch(
+        () => void 0
+      );
+      if (!snapshot || cacheOff) return;
+      snapshot.records.forEach(merge);
+      for (const conversationId of snapshot.threads) {
+        if (!confirmedLive(conversationId)) continue;
+        threads.set(conversationId, Promise.resolve());
+        complete.add(conversationId);
+      }
+      evict();
+      for (const k of snapshot.absent) checked.add(k);
+      cursor = snapshot.cursor;
+      fromCache = true;
+      await adopt().catch(() => void 0);
+    } finally {
+      caching = true;
+    }
+  };
+  const seeding = seed();
   void ready().catch(() => void 0);
+  if (cache) void seeding.then(() => fromCache ? poll() : void 0);
   return backend;
 }
 function vaultChatBackend(backend) {
@@ -28123,7 +28274,7 @@ function createRemoteMemoryStore(options) {
   };
   const mutate = (id2, change, edit, writeOptions) => serialized(id2, () => mutateLocked(id2, change, edit, writeOptions));
   const serializedAll = (ids, task) => [...new Set(ids)].sort().reduceRight((inner, id2) => () => serialized(id2, inner), task)();
-  const mutateMany = async (ids, change, edit, leaseToken, signal) => {
+  const mutateMany = async (ids, change, edit, leaseToken, signal, includeEmbeddings = false) => {
     const saved = /* @__PURE__ */ new Map();
     const failed = /* @__PURE__ */ new Map();
     for (const slice of chunks2([...new Set(ids)], MAX_BATCH)) {
@@ -28132,7 +28283,7 @@ function createRemoteMemoryStore(options) {
         const writes = [];
         let read;
         try {
-          read = await readEveryState(slice, signal);
+          read = await readEveryState(slice, signal, includeEmbeddings);
         } catch (error) {
           signal?.throwIfAborted();
           for (const id2 of slice) failed.set(id2, error);
@@ -28191,21 +28342,55 @@ function createRemoteMemoryStore(options) {
     }
     return { saved, failed };
   };
-  const embedInBackground = ({ memory: { memory_id: id2, content } }) => {
-    generateEmbedding(content, embeddingOptions).then(
-      (vector2) => serialized(id2, async () => {
-        const current = await live(id2);
-        if (!current || current.memory.content !== content || current.memory.embedding?.length)
-          return;
-        const saved = await persistence.put(
-          { ...current.memory, embedding: storedVector(vector2), embedding_model: model },
-          current
-        );
-        notify("embedding", [saved]);
-      })
-    ).catch((error) => {
-      getLogger().warn("[memory/remote-store] Failed to embed memory:", error);
-    });
+  const pendingEmbeddings = /* @__PURE__ */ new Map();
+  let embeddingActive = false;
+  const drainEmbeddings = async () => {
+    try {
+      while (pendingEmbeddings.size) {
+        const batch = /* @__PURE__ */ new Map();
+        for (const [id2, content] of pendingEmbeddings) {
+          pendingEmbeddings.delete(id2);
+          batch.set(id2, content);
+          if (batch.size === MAX_BATCH) break;
+        }
+        try {
+          const vectors = await generateEmbeddings([...batch.values()], embeddingOptions);
+          const embeddings2 = /* @__PURE__ */ new Map();
+          [...batch.keys()].forEach((id2, i) => {
+            try {
+              embeddings2.set(id2, storedVector(vectors[i]));
+            } catch (error) {
+              getLogger().warn("[memory/remote-store] Failed to embed memory:", error);
+            }
+          });
+          if (!embeddings2.size) continue;
+          const { failed } = await mutateMany(
+            [...embeddings2.keys()],
+            () => "embedding",
+            (memory) => memory.content !== batch.get(memory.memory_id) || memory.embedding?.length ? null : {
+              ...memory,
+              embedding: embeddings2.get(memory.memory_id),
+              embedding_model: model
+            },
+            void 0,
+            void 0,
+            true
+          );
+          for (const error of failed.values())
+            getLogger().warn("[memory/remote-store] Failed to embed memory:", error);
+        } catch (error) {
+          getLogger().warn("[memory/remote-store] Failed to embed memories:", error);
+        }
+      }
+    } finally {
+      embeddingActive = false;
+    }
+  };
+  const embedInBackground = (records) => {
+    for (const { memory } of records) pendingEmbeddings.set(memory.memory_id, memory.content);
+    if (embeddingActive || !pendingEmbeddings.size) return;
+    embeddingActive = true;
+    void drainEmbeddings();
   };
   const newRow = (input) => {
     const now = Date.now();
@@ -28239,9 +28424,7 @@ function createRemoteMemoryStore(options) {
     };
   };
   const created = (records, inputs) => {
-    records.forEach((record2, i) => {
-      if (inputs[i].embedding === void 0) embedInBackground(record2);
-    });
+    embedInBackground(records.filter((_, i) => inputs[i].embedding === void 0));
     notify("membership", records);
     return records.map((record2) => stored(record2.memory));
   };
@@ -28271,7 +28454,7 @@ function createRemoteMemoryStore(options) {
     };
   };
   const withKnownKinds = async (topics) => topics.map(await knownKinds(topics));
-  const readEveryState = async (ids, signal) => {
+  const readEveryState = async (ids, signal, includeEmbeddings = false) => {
     const records = /* @__PURE__ */ new Map();
     const unreadable = /* @__PURE__ */ new Set();
     for (const memory_ids of chunks2(ids, MAX_QUERY_IDS)) {
@@ -28283,6 +28466,7 @@ function createRemoteMemoryStore(options) {
           include_archived: true,
           include_quarantined: true,
           include_superseded: true,
+          ...includeEmbeddings && { include_embeddings: true },
           limit: 200,
           ...signal && { signal },
           ...cursor2 && { cursor: cursor2 }
@@ -28945,7 +29129,7 @@ function createRemoteMemoryStore(options) {
         }
         return memory;
       });
-      if (saved && patch.embedding === void 0) embedInBackground(saved);
+      if (saved && patch.embedding === void 0) embedInBackground([saved]);
       return asStored(saved);
     },
     delete: async (id2) => !!await mutate(id2, "membership", (memory) => ({ ...memory, is_deleted: true })),