@anuma/sdk 1.1.5 → 1.2.0

package/dist/react/index.cjs

@@ -2468,50 +2468,84 @@ async function getMessagesPageOp(ctx, convId, opts) {
     )
   );
 }
-async function getMessageSkeletonsOp(ctx, convId) {
-  const results = await ctx.messagesCollection.query(import_watermelondb.Q.where("conversation_id", convId), import_watermelondb.Q.sortBy("message_id", import_watermelondb.Q.asc)).fetch();
-  const roleById = /* @__PURE__ */ new Map();
-  for (const msg of results) {
-    roleById.set(msg.id, msg.role);
-  }
-  const skeletons = results.map((msg) => ({
-    uniqueId: msg.id,
-    messageId: msg.messageId,
-    conversationId: String(msg._getRaw("conversation_id")),
-    role: msg.role,
-    createdAt: msg.createdAt,
-    // WatermelonDB surfaces unset text columns as null at runtime — normalize
-    // to undefined so `parentMessageId ?? undefined` keying works everywhere.
-    parentMessageId: msg.parentMessageId ?? void 0,
-    model: msg.model ?? void 0
-  }));
-  const artifactIndices = [];
-  for (let i = 0; i < results.length; i++) {
-    const msg = results[i];
-    if (msg.role !== "user" || !msg.parentMessageId) continue;
-    if (roleById.get(msg.parentMessageId) === "user") {
-      artifactIndices.push(i);
+function narrowSkeletonRow(raw) {
+  return {
+    id: raw.id,
+    message_id: raw.message_id,
+    conversation_id: raw.conversation_id,
+    role: raw.role,
+    created_at: raw.created_at,
+    parent_message_id: raw.parent_message_id ?? null,
+    model: raw.model ?? null,
+    content: raw.content ?? null
+  };
+}
+async function fetchThreadSkeletonRawPaged(collection, convId, pageSize = SKELETON_PAGE_SIZE) {
+  const all = [];
+  let cursor;
+  for (; ; ) {
+    const clauses = [import_watermelondb.Q.where("conversation_id", convId)];
+    if (cursor) {
+      clauses.push(
+        import_watermelondb.Q.or(
+          import_watermelondb.Q.where("message_id", import_watermelondb.Q.gt(cursor.messageId)),
+          import_watermelondb.Q.and(import_watermelondb.Q.where("message_id", cursor.messageId), import_watermelondb.Q.where("id", import_watermelondb.Q.gt(cursor.id)))
+        )
+      );
     }
+    const page = await collection.query(...clauses, import_watermelondb.Q.sortBy("message_id", import_watermelondb.Q.asc), import_watermelondb.Q.sortBy("id", import_watermelondb.Q.asc), import_watermelondb.Q.take(pageSize)).unsafeFetchRaw();
+    if (page.length === 0) break;
+    for (const raw of page) all.push(narrowSkeletonRow(raw));
+    if (page.length < pageSize) break;
+    const last = all[all.length - 1];
+    cursor = { messageId: last.message_id, id: last.id };
+  }
+  return all;
+}
+function collectArtifactIndices(rows, roleById) {
+  const indices = [];
+  for (let i = 0; i < rows.length; i++) {
+    const row = rows[i];
+    if (row.role !== "user" || !row.parent_message_id) continue;
+    if (roleById.get(row.parent_message_id) === "user") indices.push(i);
   }
+  return indices;
+}
+async function decryptArtifactContent(skeletons, rows, artifactIndices, ctx) {
   const address = ctx.walletAddress;
-  if (artifactIndices.length > 0 && address) {
-    if (ctx.signMessage) {
-      try {
-        await requestEncryptionKey(address, ctx.signMessage, ctx.embeddedWalletSigner);
-      } catch (error) {
-        getLogger().warn("Failed to request encryption key for skeleton decryption:", error);
-      }
-    }
-    await Promise.all(
-      artifactIndices.map(async (i) => {
-        skeletons[i].content = await decryptField(results[i].content, address);
-      })
-    );
-  } else {
-    for (const i of artifactIndices) {
-      skeletons[i].content = results[i].content;
+  if (artifactIndices.length === 0 || !address) {
+    for (const i of artifactIndices) skeletons[i].content = rows[i].content ?? void 0;
+    return;
+  }
+  if (ctx.signMessage) {
+    try {
+      await requestEncryptionKey(address, ctx.signMessage, ctx.embeddedWalletSigner);
+    } catch (error) {
+      getLogger().warn("Failed to request encryption key for skeleton decryption:", error);
     }
   }
+  await Promise.all(
+    artifactIndices.map(async (i) => {
+      skeletons[i].content = await decryptField(rows[i].content ?? "", address);
+    })
+  );
+}
+async function getMessageSkeletonsOp(ctx, convId) {
+  const rows = await fetchThreadSkeletonRawPaged(ctx.messagesCollection, convId);
+  const roleById = /* @__PURE__ */ new Map();
+  for (const row of rows) roleById.set(row.id, row.role);
+  const skeletons = rows.map((row) => ({
+    uniqueId: row.id,
+    messageId: row.message_id,
+    conversationId: String(row.conversation_id),
+    role: row.role,
+    createdAt: new Date(row.created_at),
+    // WatermelonDB surfaces unset text columns as null at runtime — normalize
+    // to undefined so `parentMessageId ?? undefined` keying works everywhere.
+    parentMessageId: row.parent_message_id ?? void 0,
+    model: row.model ?? void 0
+  }));
+  await decryptArtifactContent(skeletons, rows, collectArtifactIndices(rows, roleById), ctx);
   return skeletons;
 }
 async function clearMessagesOp(ctx, convId) {
@@ -2902,7 +2936,7 @@ function makeSyntheticStoredConversation(opts, defaultTitle) {
     isDeleted: false
   };
 }
-var import_watermelondb, import_uuid2;
+var import_watermelondb, import_uuid2, SKELETON_PAGE_SIZE;
 var init_operations = __esm({
   "src/lib/db/chat/operations.ts"() {
     "use strict";
@@ -2915,6 +2949,7 @@ var init_operations = __esm({
     init_conversationEncryption();
     init_encryption();
     init_types2();
+    SKELETON_PAGE_SIZE = 2e3;
   }
 });
 
@@ -19941,6 +19976,7 @@ var DatabaseManager = class {
         from: this.currentWalletAddress,
         to: walletAddress
       });
+      void this.disposeAdapter(this.database);
       this.database = null;
     }
     if (this.database) {
@@ -19970,11 +20006,37 @@ var DatabaseManager = class {
   async resetDatabase() {
     const db = this.database;
     if (db) {
+      this.database = null;
+      this.currentWalletAddress = void 0;
       await db.write(async () => {
         await db.unsafeResetDatabase();
       });
-      this.database = null;
-      this.currentWalletAddress = void 0;
+      await this.disposeAdapter(db);
+    }
+  }
+  /**
+   * Best-effort dispose of the adapter backing a Database, if it exposes one.
+   *
+   * OPFS/SQLite adapters use this to terminate their dedicated worker and release
+   * the exclusive SAHPool (+ WASM heap) they hold. The SDK only sees a generic
+   * `DatabaseAdapter`, so we probe `adapter.underlyingAdapter.dispose` rather than
+   * type it. Client-side implementations are refcounted + idempotent, so calling
+   * this is safe even when the adapter factory also disposes.
+   *
+   * Awaitable and never rejects: a sync throw or async rejection from `dispose`
+   * is caught + logged. Awaited on the async `resetDatabase` path so teardown
+   * completes before the caller reopens; fire-and-forget on the synchronous
+   * `getDatabase` path (which cannot block).
+   */
+  async disposeAdapter(db) {
+    try {
+      const underlying = db.adapter?.underlyingAdapter;
+      await underlying?.dispose?.();
+    } catch (error) {
+      this.logger.warn?.("Adapter dispose failed", {
+        component: "DatabaseManager",
+        error
+      });
     }
   }
   /**

package/dist/react/index.d.mts

@@ -8103,6 +8103,21 @@ declare class DatabaseManager {
      * Reset the current database (useful for logout or testing).
      */
     resetDatabase(): Promise<void>;
+    /**
+     * Best-effort dispose of the adapter backing a Database, if it exposes one.
+     *
+     * OPFS/SQLite adapters use this to terminate their dedicated worker and release
+     * the exclusive SAHPool (+ WASM heap) they hold. The SDK only sees a generic
+     * `DatabaseAdapter`, so we probe `adapter.underlyingAdapter.dispose` rather than
+     * type it. Client-side implementations are refcounted + idempotent, so calling
+     * this is safe even when the adapter factory also disposes.
+     *
+     * Awaitable and never rejects: a sync throw or async rejection from `dispose`
+     * is caught + logged. Awaited on the async `resetDatabase` path so teardown
+     * completes before the caller reopens; fire-and-forget on the synchronous
+     * `getDatabase` path (which cannot block).
+     */
+    private disposeAdapter;
     /**
      * Check and handle schema migrations for a specific wallet.
      * Returns true if a destructive migration is in progress.

package/dist/react/index.d.ts

@@ -8103,6 +8103,21 @@ declare class DatabaseManager {
      * Reset the current database (useful for logout or testing).
      */
     resetDatabase(): Promise<void>;
+    /**
+     * Best-effort dispose of the adapter backing a Database, if it exposes one.
+     *
+     * OPFS/SQLite adapters use this to terminate their dedicated worker and release
+     * the exclusive SAHPool (+ WASM heap) they hold. The SDK only sees a generic
+     * `DatabaseAdapter`, so we probe `adapter.underlyingAdapter.dispose` rather than
+     * type it. Client-side implementations are refcounted + idempotent, so calling
+     * this is safe even when the adapter factory also disposes.
+     *
+     * Awaitable and never rejects: a sync throw or async rejection from `dispose`
+     * is caught + logged. Awaited on the async `resetDatabase` path so teardown
+     * completes before the caller reopens; fire-and-forget on the synchronous
+     * `getDatabase` path (which cannot block).
+     */
+    private disposeAdapter;
     /**
      * Check and handle schema migrations for a specific wallet.
      * Returns true if a destructive migration is in progress.

package/dist/react/index.mjs

@@ -121,7 +121,7 @@ import {
   updateVaultMemoryEmbeddingOp,
   updateVaultMemoryOp,
   useEncryption
-} from "./chunk-KQZ4KVYY.mjs";
+} from "./chunk-DC6J5RX5.mjs";
 import {
   PiiRedactor,
   createStreamingDeAnonymizer,
@@ -12664,6 +12664,7 @@ var DatabaseManager = class {
         from: this.currentWalletAddress,
         to: walletAddress
       });
+      void this.disposeAdapter(this.database);
       this.database = null;
     }
     if (this.database) {
@@ -12693,11 +12694,37 @@ var DatabaseManager = class {
   async resetDatabase() {
     const db = this.database;
     if (db) {
+      this.database = null;
+      this.currentWalletAddress = void 0;
       await db.write(async () => {
         await db.unsafeResetDatabase();
       });
-      this.database = null;
-      this.currentWalletAddress = void 0;
+      await this.disposeAdapter(db);
+    }
+  }
+  /**
+   * Best-effort dispose of the adapter backing a Database, if it exposes one.
+   *
+   * OPFS/SQLite adapters use this to terminate their dedicated worker and release
+   * the exclusive SAHPool (+ WASM heap) they hold. The SDK only sees a generic
+   * `DatabaseAdapter`, so we probe `adapter.underlyingAdapter.dispose` rather than
+   * type it. Client-side implementations are refcounted + idempotent, so calling
+   * this is safe even when the adapter factory also disposes.
+   *
+   * Awaitable and never rejects: a sync throw or async rejection from `dispose`
+   * is caught + logged. Awaited on the async `resetDatabase` path so teardown
+   * completes before the caller reopens; fire-and-forget on the synchronous
+   * `getDatabase` path (which cannot block).
+   */
+  async disposeAdapter(db) {
+    try {
+      const underlying = db.adapter?.underlyingAdapter;
+      await underlying?.dispose?.();
+    } catch (error) {
+      this.logger.warn?.("Adapter dispose failed", {
+        component: "DatabaseManager",
+        error
+      });
     }
   }
   /**

package/dist/react/{recall-Z2HUBS2Y.mjs → recall-RGKS2OIP.mjs}

@@ -1,6 +1,6 @@
 import {
   recall
-} from "./chunk-KQZ4KVYY.mjs";
+} from "./chunk-DC6J5RX5.mjs";
 import "./chunk-DFVCS3QQ.mjs";
 import "./chunk-GYKJOWEO.mjs";
 export {

package/dist/server/{chunk-KLJBJWWI.mjs → chunk-MKRSHU4S.mjs}

@@ -18838,7 +18838,7 @@ function createMemoryVaultSearchTool(vaultCtx, embeddingOptions, cache, searchOp
             legacy.map((r) => ({ id: r.uniqueId, content: r.content, score: r.similarity }))
           );
         }
-        const { recall: recall2 } = await import("./recall-IF2HX7ZA.mjs");
+        const { recall: recall2 } = await import("./recall-V4763HKS.mjs");
         const result = await recall2(
           query,
           { vaultCtx, embeddingOptions, vaultCache: cache },

package/dist/server/index.cjs

@@ -22877,6 +22877,7 @@ var DatabaseManager = class {
         from: this.currentWalletAddress,
         to: walletAddress
       });
+      void this.disposeAdapter(this.database);
       this.database = null;
     }
     if (this.database) {
@@ -22906,11 +22907,37 @@ var DatabaseManager = class {
   async resetDatabase() {
     const db = this.database;
     if (db) {
+      this.database = null;
+      this.currentWalletAddress = void 0;
       await db.write(async () => {
         await db.unsafeResetDatabase();
       });
-      this.database = null;
-      this.currentWalletAddress = void 0;
+      await this.disposeAdapter(db);
+    }
+  }
+  /**
+   * Best-effort dispose of the adapter backing a Database, if it exposes one.
+   *
+   * OPFS/SQLite adapters use this to terminate their dedicated worker and release
+   * the exclusive SAHPool (+ WASM heap) they hold. The SDK only sees a generic
+   * `DatabaseAdapter`, so we probe `adapter.underlyingAdapter.dispose` rather than
+   * type it. Client-side implementations are refcounted + idempotent, so calling
+   * this is safe even when the adapter factory also disposes.
+   *
+   * Awaitable and never rejects: a sync throw or async rejection from `dispose`
+   * is caught + logged. Awaited on the async `resetDatabase` path so teardown
+   * completes before the caller reopens; fire-and-forget on the synchronous
+   * `getDatabase` path (which cannot block).
+   */
+  async disposeAdapter(db) {
+    try {
+      const underlying = db.adapter?.underlyingAdapter;
+      await underlying?.dispose?.();
+    } catch (error) {
+      this.logger.warn?.("Adapter dispose failed", {
+        component: "DatabaseManager",
+        error
+      });
     }
   }
   /**
@@ -27162,6 +27189,7 @@ var TOOL_CATALOG = {
   // Slack (src/tools/slack.ts)
   slack_get_me: { label: "Get my Slack profile", provider: "slack", connector: "Slack" },
   slack_list_channels: { label: "List channels", provider: "slack", connector: "Slack" },
+  slack_list_dms: { label: "List direct messages", provider: "slack", connector: "Slack" },
   slack_search_messages: { label: "Search messages", provider: "slack", connector: "Slack" },
   slack_list_users: { label: "List members", provider: "slack", connector: "Slack" },
   slack_get_channel_history: {

package/dist/server/index.d.mts

@@ -274,6 +274,21 @@ declare class DatabaseManager {
      * Reset the current database (useful for logout or testing).
      */
     resetDatabase(): Promise<void>;
+    /**
+     * Best-effort dispose of the adapter backing a Database, if it exposes one.
+     *
+     * OPFS/SQLite adapters use this to terminate their dedicated worker and release
+     * the exclusive SAHPool (+ WASM heap) they hold. The SDK only sees a generic
+     * `DatabaseAdapter`, so we probe `adapter.underlyingAdapter.dispose` rather than
+     * type it. Client-side implementations are refcounted + idempotent, so calling
+     * this is safe even when the adapter factory also disposes.
+     *
+     * Awaitable and never rejects: a sync throw or async rejection from `dispose`
+     * is caught + logged. Awaited on the async `resetDatabase` path so teardown
+     * completes before the caller reopens; fire-and-forget on the synchronous
+     * `getDatabase` path (which cannot block).
+     */
+    private disposeAdapter;
     /**
      * Check and handle schema migrations for a specific wallet.
      * Returns true if a destructive migration is in progress.

package/dist/server/index.d.ts

@@ -274,6 +274,21 @@ declare class DatabaseManager {
      * Reset the current database (useful for logout or testing).
      */
     resetDatabase(): Promise<void>;
+    /**
+     * Best-effort dispose of the adapter backing a Database, if it exposes one.
+     *
+     * OPFS/SQLite adapters use this to terminate their dedicated worker and release
+     * the exclusive SAHPool (+ WASM heap) they hold. The SDK only sees a generic
+     * `DatabaseAdapter`, so we probe `adapter.underlyingAdapter.dispose` rather than
+     * type it. Client-side implementations are refcounted + idempotent, so calling
+     * this is safe even when the adapter factory also disposes.
+     *
+     * Awaitable and never rejects: a sync throw or async rejection from `dispose`
+     * is caught + logged. Awaited on the async `resetDatabase` path so teardown
+     * completes before the caller reopens; fire-and-forget on the synchronous
+     * `getDatabase` path (which cannot block).
+     */
+    private disposeAdapter;
     /**
      * Check and handle schema migrations for a specific wallet.
      * Returns true if a destructive migration is in progress.

package/dist/server/index.mjs

@@ -95,7 +95,7 @@ import {
   updateVaultMemoryEmbeddingOp,
   updateVaultMemoryOp,
   upsertMessageOp
-} from "./chunk-KLJBJWWI.mjs";
+} from "./chunk-MKRSHU4S.mjs";
 import {
   createStreamingDeAnonymizer,
   resolvePiiRedactor
@@ -1984,6 +1984,7 @@ var DatabaseManager = class {
         from: this.currentWalletAddress,
         to: walletAddress
       });
+      void this.disposeAdapter(this.database);
       this.database = null;
     }
     if (this.database) {
@@ -2013,11 +2014,37 @@ var DatabaseManager = class {
   async resetDatabase() {
     const db = this.database;
     if (db) {
+      this.database = null;
+      this.currentWalletAddress = void 0;
       await db.write(async () => {
         await db.unsafeResetDatabase();
       });
-      this.database = null;
-      this.currentWalletAddress = void 0;
+      await this.disposeAdapter(db);
+    }
+  }
+  /**
+   * Best-effort dispose of the adapter backing a Database, if it exposes one.
+   *
+   * OPFS/SQLite adapters use this to terminate their dedicated worker and release
+   * the exclusive SAHPool (+ WASM heap) they hold. The SDK only sees a generic
+   * `DatabaseAdapter`, so we probe `adapter.underlyingAdapter.dispose` rather than
+   * type it. Client-side implementations are refcounted + idempotent, so calling
+   * this is safe even when the adapter factory also disposes.
+   *
+   * Awaitable and never rejects: a sync throw or async rejection from `dispose`
+   * is caught + logged. Awaited on the async `resetDatabase` path so teardown
+   * completes before the caller reopens; fire-and-forget on the synchronous
+   * `getDatabase` path (which cannot block).
+   */
+  async disposeAdapter(db) {
+    try {
+      const underlying = db.adapter?.underlyingAdapter;
+      await underlying?.dispose?.();
+    } catch (error) {
+      this.logger.warn?.("Adapter dispose failed", {
+        component: "DatabaseManager",
+        error
+      });
     }
   }
   /**
@@ -6217,6 +6244,7 @@ var TOOL_CATALOG = {
   // Slack (src/tools/slack.ts)
   slack_get_me: { label: "Get my Slack profile", provider: "slack", connector: "Slack" },
   slack_list_channels: { label: "List channels", provider: "slack", connector: "Slack" },
+  slack_list_dms: { label: "List direct messages", provider: "slack", connector: "Slack" },
   slack_search_messages: { label: "Search messages", provider: "slack", connector: "Slack" },
   slack_list_users: { label: "List members", provider: "slack", connector: "Slack" },
   slack_get_channel_history: {

package/dist/server/{recall-IF2HX7ZA.mjs → recall-V4763HKS.mjs}

@@ -1,6 +1,6 @@
 import {
   recall
-} from "./chunk-KLJBJWWI.mjs";
+} from "./chunk-MKRSHU4S.mjs";
 import "./chunk-RCCKRTBI.mjs";
 import "./chunk-FMGZTVXQ.mjs";
 export {