@superatomai/sdk-node 0.0.20 → 0.0.22

package/dist/index.mjs

@@ -455,14 +455,25 @@ var ToolSchema = z3.object({
   params: z3.record(z3.string()),
   fn: z3.function().args(z3.any()).returns(z3.any())
 });
+var UserQueryFiltersSchema = z3.object({
+  username: z3.string().optional(),
+  email: z3.string().optional(),
+  role: z3.string().optional(),
+  fullname: z3.string().optional()
+});
 var UsersRequestPayloadSchema = z3.object({
-  operation: z3.enum(["create", "update", "delete", "getAll", "getOne"]),
+  operation: z3.enum(["create", "update", "delete", "getAll", "getOne", "query"]),
   data: z3.object({
+    id: z3.number().optional(),
     username: z3.string().optional(),
     email: z3.string().email("Invalid email format").optional(),
     password: z3.string().optional(),
     fullname: z3.string().optional(),
-    role: z3.string().optional()
+    role: z3.string().optional(),
+    // Query operation fields
+    filters: UserQueryFiltersSchema.optional(),
+    limit: z3.number().optional(),
+    sort: z3.enum(["ASC", "DESC"]).optional()
   }).optional()
 });
 var UsersRequestMessageSchema = z3.object({
@@ -625,15 +636,24 @@ var BookmarkDataSchema = z3.object({
   created_at: z3.string().optional(),
   updated_at: z3.string().optional()
 });
+var BookmarkQueryFiltersSchema = z3.object({
+  userId: z3.number().optional(),
+  threadId: z3.string().optional(),
+  name: z3.string().optional()
+});
 var BookmarksRequestPayloadSchema = z3.object({
-  operation: z3.enum(["create", "update", "delete", "getAll", "getOne", "getByUser", "getByThread"]),
+  operation: z3.enum(["create", "update", "delete", "getAll", "getOne", "query"]),
   data: z3.object({
     id: z3.number().optional(),
     userId: z3.number().optional(),
     threadId: z3.string().optional(),
     name: z3.string().optional(),
     description: z3.string().optional(),
-    uiblock: DBUIBlockSchema.optional()
+    uiblock: DBUIBlockSchema.optional(),
+    // Query operation fields
+    filters: BookmarkQueryFiltersSchema.optional(),
+    limit: z3.number().optional(),
+    sort: z3.enum(["ASC", "DESC"]).optional()
   }).optional()
 });
 var BookmarksRequestMessageSchema = z3.object({
@@ -5663,7 +5683,7 @@ async function handleUserPromptSuggestions(data, components, sendMessage, collec
   try {
     const request = UserPromptSuggestionsMessageSchema.parse(data);
     const { id, payload, from } = request;
-    const { prompt, limit = 5, similarityThreshold = 0.1 } = payload;
+    const { prompt, limit = 5 } = payload;
     const wsId = from.id;
     logger.info(`[USER_PROMPT_SUGGESTIONS_REQ ${id}] Processing user prompt suggestions: ${prompt}`);
     if (!prompt || prompt.trim().length === 0) {
@@ -5723,23 +5743,17 @@ async function handleUserPromptSuggestions(data, components, sendMessage, collec
       await Promise.all(searchPromises);
     }
     if (useEmbeddingSearch && (componentSuggestions.length > 0 || bookmarkSuggestions.length > 0)) {
-      const filteredComponentSuggestions = componentSuggestions.filter(
-        (s) => (s.similarity || 0) >= similarityThreshold
-      );
-      const filteredBookmarkSuggestions = bookmarkSuggestions.filter(
-        (s) => (s.similarity || 0) >= similarityThreshold
-      );
-      const allSuggestions = [...filteredComponentSuggestions, ...filteredBookmarkSuggestions].sort((a, b) => (b.similarity || 0) - (a.similarity || 0)).slice(0, limit);
-      logger.info(`[USER_PROMPT_SUGGESTIONS_REQ ${id}] Filtered by threshold ${similarityThreshold}: ${componentSuggestions.length} -> ${filteredComponentSuggestions.length} components, ${bookmarkSuggestions.length} -> ${filteredBookmarkSuggestions.length} bookmarks`);
+      const allSuggestions = [...componentSuggestions, ...bookmarkSuggestions].sort((a, b) => (b.similarity || 0) - (a.similarity || 0)).slice(0, limit);
+      logger.info(`[USER_PROMPT_SUGGESTIONS_REQ ${id}] Returning all suggestions: ${componentSuggestions.length} components, ${bookmarkSuggestions.length} bookmarks`);
       sendResponse(id, {
         success: true,
         data: {
           prompt,
           suggestions: allSuggestions,
           count: allSuggestions.length,
-          componentCount: filteredComponentSuggestions.length,
-          bookmarkCount: filteredBookmarkSuggestions.length,
-          message: `Found ${allSuggestions.length} suggestions (${filteredComponentSuggestions.length} components, ${filteredBookmarkSuggestions.length} bookmarks)`
+          componentCount: componentSuggestions.length,
+          bookmarkCount: bookmarkSuggestions.length,
+          message: `Found ${allSuggestions.length} suggestions (${componentSuggestions.length} components, ${bookmarkSuggestions.length} bookmarks)`
         }
       }, sendMessage, wsId);
       return;
@@ -6115,17 +6129,28 @@ async function handleComponentListResponse(data, storeComponents, collections) {
 }
 
 // src/handlers/users.ts
-async function handleUsersRequest(data, sendMessage) {
+async function handleUsersRequest(data, collections, sendMessage) {
+  const executeCollection = async (collection, op, params) => {
+    const handler = collections[collection]?.[op];
+    if (!handler) {
+      return null;
+    }
+    return await handler(params);
+  };
   try {
     const request = UsersRequestMessageSchema.parse(data);
     const { id, payload, from } = request;
     const { operation, data: requestData } = payload;
+    const numericId = requestData?.id;
     const username = requestData?.username;
     const email = requestData?.email;
     const password = requestData?.password;
     const fullname = requestData?.fullname;
     const role = requestData?.role;
-    if (from.type !== "admin" && operation !== "getOne" && operation !== "getAll") {
+    const filters = requestData?.filters;
+    const limit = requestData?.limit;
+    const sort = requestData?.sort;
+    if (from.type !== "admin" && operation !== "getOne" && operation !== "getAll" && operation !== "query") {
       sendResponse3(id, {
         success: false,
         error: "Unauthorized: Only admin can manage users"
@@ -6136,19 +6161,22 @@ async function handleUsersRequest(data, sendMessage) {
     const userManager = getUserManager();
     switch (operation) {
       case "create":
-        await handleCreate(id, { username, email, password, fullname, role }, userManager, sendMessage, from.id);
+        await handleCreate(id, { username, email, password, fullname, role }, executeCollection, userManager, sendMessage, from.id);
         break;
       case "update":
-        await handleUpdate(id, { username, email, password, fullname, role }, userManager, sendMessage, from.id);
+        await handleUpdate(id, numericId, { username, email, password, fullname, role }, executeCollection, userManager, sendMessage, from.id);
         break;
       case "delete":
-        await handleDelete(id, username, userManager, sendMessage, from.id);
+        await handleDelete(id, numericId, username, executeCollection, userManager, sendMessage, from.id);
         break;
       case "getAll":
-        await handleGetAll(id, userManager, sendMessage, from.id);
+        await handleGetAll(id, executeCollection, userManager, sendMessage, from.id);
         break;
       case "getOne":
-        await handleGetOne(id, username, userManager, sendMessage, from.id);
+        await handleGetOne(id, numericId, username, executeCollection, userManager, sendMessage, from.id);
+        break;
+      case "query":
+        await handleQuery(id, filters, limit, sort, executeCollection, userManager, sendMessage, from.id);
         break;
       default:
         sendResponse3(id, {
@@ -6164,7 +6192,7 @@ async function handleUsersRequest(data, sendMessage) {
     }, sendMessage);
   }
 }
-async function handleCreate(id, userData, userManager, sendMessage, clientId) {
+async function handleCreate(id, userData, executeCollection, userManager, sendMessage, clientId) {
   const { username, email, password, fullname, role } = userData;
   if (!username || username.trim().length === 0) {
     sendResponse3(id, {
@@ -6190,52 +6218,121 @@ async function handleCreate(id, userData, userManager, sendMessage, clientId) {
       return;
     }
   }
-  if (userManager.userExists(username)) {
+  try {
+    const result = await executeCollection("users", "create", {
+      username,
+      email: email || void 0,
+      password,
+      fullname: fullname || void 0,
+      role: role || void 0
+    });
+    if (result && result.success) {
+      logger.info(`[DB] User created successfully: ${username}`);
+      sendResponse3(id, {
+        success: true,
+        data: {
+          id: result.data?.id,
+          username: result.data?.username,
+          email: result.data?.email,
+          fullname: result.data?.fullname,
+          role: result.data?.role,
+          message: `User '${username}' created successfully (DB)`
+        }
+      }, sendMessage, clientId);
+      return;
+    }
+  } catch (dbError) {
+    logger.warn(`[DB] Failed to create user, falling back to file storage: ${dbError instanceof Error ? dbError.message : "Unknown error"}`);
+  }
+  try {
+    if (userManager.userExists(username)) {
+      sendResponse3(id, {
+        success: false,
+        error: `User '${username}' already exists`
+      }, sendMessage, clientId);
+      return;
+    }
+    if (email && userManager.getUserByEmail(email)) {
+      sendResponse3(id, {
+        success: false,
+        error: `User with email '${email}' already exists`
+      }, sendMessage, clientId);
+      return;
+    }
+    const newUserData = {
+      username,
+      password
+    };
+    if (email && email.trim().length > 0) {
+      newUserData.email = email.trim();
+    }
+    if (fullname && fullname.trim().length > 0) {
+      newUserData.fullname = fullname.trim();
+    }
+    if (role && role.trim().length > 0) {
+      newUserData.role = role.trim();
+    }
+    const newUser = userManager.createUser(newUserData);
+    logger.info(`[FILE] User '${username}' created successfully`);
+    sendResponse3(id, {
+      success: true,
+      data: {
+        username: newUser.username,
+        email: newUser.email,
+        fullname: newUser.fullname,
+        role: newUser.role,
+        message: `User '${username}' created successfully (File)`
+      }
+    }, sendMessage, clientId);
+  } catch (error) {
     sendResponse3(id, {
       success: false,
-      error: `User '${username}' already exists`
+      error: error instanceof Error ? error.message : "Failed to create user"
     }, sendMessage, clientId);
-    return;
   }
-  if (email && userManager.getUserByEmail(email)) {
+}
+async function handleUpdate(id, numericId, userData, executeCollection, userManager, sendMessage, clientId) {
+  const { username, email, password, fullname, role } = userData;
+  if (!numericId && !username) {
     sendResponse3(id, {
       success: false,
-      error: `User with email '${email}' already exists`
+      error: "User ID or username is required"
     }, sendMessage, clientId);
     return;
   }
-  const newUserData = {
-    username,
-    password
-  };
-  if (email && email.trim().length > 0) {
-    newUserData.email = email.trim();
-  }
-  if (fullname && fullname.trim().length > 0) {
-    newUserData.fullname = fullname.trim();
-  }
-  if (role && role.trim().length > 0) {
-    newUserData.role = role.trim();
-  }
-  const newUser = userManager.createUser(newUserData);
-  logger.info(`User created by admin: ${username}${email ? ` (${email})` : ""}`);
-  sendResponse3(id, {
-    success: true,
-    data: {
-      username: newUser.username,
-      email: newUser.email,
-      fullname: newUser.fullname,
-      role: newUser.role,
-      message: `User '${username}' created successfully`
+  if (numericId) {
+    try {
+      const result = await executeCollection("users", "update", {
+        id: numericId,
+        username,
+        email,
+        password,
+        fullname,
+        role
+      });
+      if (result && result.success) {
+        logger.info(`[DB] User updated successfully, ID: ${numericId}`);
+        sendResponse3(id, {
+          success: true,
+          data: {
+            id: result.data?.id,
+            username: result.data?.username,
+            email: result.data?.email,
+            fullname: result.data?.fullname,
+            role: result.data?.role,
+            message: `User updated successfully (DB)`
+          }
+        }, sendMessage, clientId);
+        return;
+      }
+    } catch (dbError) {
+      logger.warn(`[DB] Failed to update user, falling back to file storage: ${dbError instanceof Error ? dbError.message : "Unknown error"}`);
     }
-  }, sendMessage, clientId);
-}
-async function handleUpdate(id, userData, userManager, sendMessage, clientId) {
-  const { username, email, password, fullname, role } = userData;
+  }
   if (!username || username.trim().length === 0) {
     sendResponse3(id, {
       success: false,
-      error: "Username is required and cannot be empty"
+      error: "Username is required for file-based storage update"
     }, sendMessage, clientId);
     return;
   }
@@ -6286,24 +6383,57 @@ async function handleUpdate(id, userData, userManager, sendMessage, clientId) {
     }, sendMessage, clientId);
     return;
   }
-  const updatedUser = userManager.updateUser(username, updates);
-  logger.info(`User updated by admin: ${username}`);
-  sendResponse3(id, {
-    success: true,
-    data: {
-      username: updatedUser.username,
-      email: updatedUser.email,
-      fullname: updatedUser.fullname,
-      role: updatedUser.role,
-      message: `User '${username}' updated successfully`
-    }
-  }, sendMessage, clientId);
+  try {
+    const updatedUser = userManager.updateUser(username, updates);
+    logger.info(`[FILE] User '${username}' updated successfully`);
+    sendResponse3(id, {
+      success: true,
+      data: {
+        username: updatedUser.username,
+        email: updatedUser.email,
+        fullname: updatedUser.fullname,
+        role: updatedUser.role,
+        message: `User '${username}' updated successfully (File)`
+      }
+    }, sendMessage, clientId);
+  } catch (error) {
+    sendResponse3(id, {
+      success: false,
+      error: error instanceof Error ? error.message : "Failed to update user"
+    }, sendMessage, clientId);
+  }
 }
-async function handleDelete(id, username, userManager, sendMessage, clientId) {
+async function handleDelete(id, numericId, username, executeCollection, userManager, sendMessage, clientId) {
+  if (!numericId && !username) {
+    sendResponse3(id, {
+      success: false,
+      error: "User ID or username is required"
+    }, sendMessage, clientId);
+    return;
+  }
+  if (numericId) {
+    try {
+      const result = await executeCollection("users", "delete", { id: numericId });
+      if (result && result.success) {
+        logger.info(`[DB] User deleted successfully, ID: ${numericId}`);
+        sendResponse3(id, {
+          success: true,
+          data: {
+            id: numericId,
+            username: result.data?.username,
+            message: `User deleted successfully (DB)`
+          }
+        }, sendMessage, clientId);
+        return;
+      }
+    } catch (dbError) {
+      logger.warn(`[DB] Failed to delete user, falling back to file storage: ${dbError instanceof Error ? dbError.message : "Unknown error"}`);
+    }
+  }
   if (!username || username.trim().length === 0) {
     sendResponse3(id, {
       success: false,
-      error: "Username is required and cannot be empty"
+      error: "Username is required for file-based storage delete"
     }, sendMessage, clientId);
     return;
   }
@@ -6322,16 +6452,42 @@ async function handleDelete(id, username, userManager, sendMessage, clientId) {
     }, sendMessage, clientId);
     return;
   }
-  logger.info(`User deleted by admin: ${username}`);
+  logger.info(`[FILE] User '${username}' deleted successfully`);
   sendResponse3(id, {
     success: true,
     data: {
       username,
-      message: `User '${username}' deleted successfully`
+      message: `User '${username}' deleted successfully (File)`
     }
   }, sendMessage, clientId);
 }
-async function handleGetAll(id, userManager, sendMessage, clientId) {
+async function handleGetAll(id, executeCollection, userManager, sendMessage, clientId) {
+  try {
+    const result = await executeCollection("users", "getAll", {});
+    if (result && result.success) {
+      const sanitizedUsers2 = result.data.map((user) => ({
+        id: user.id,
+        username: user.username,
+        email: user.email,
+        fullname: user.fullname,
+        role: user.role,
+        createdAt: user.createdAt,
+        updatedAt: user.updatedAt
+      }));
+      logger.info(`[DB] Retrieved ${result.count} users`);
+      sendResponse3(id, {
+        success: true,
+        data: {
+          users: sanitizedUsers2,
+          count: result.count,
+          message: `Retrieved ${result.count} users (DB)`
+        }
+      }, sendMessage, clientId);
+      return;
+    }
+  } catch (dbError) {
+    logger.warn(`[DB] Failed to get all users, falling back to file storage: ${dbError instanceof Error ? dbError.message : "Unknown error"}`);
+  }
   const users = userManager.getAllUsers();
   const sanitizedUsers = users.map((user) => ({
     username: user.username,
@@ -6340,21 +6496,55 @@ async function handleGetAll(id, userManager, sendMessage, clientId) {
     role: user.role,
     wsIds: user.wsIds || []
   }));
-  logger.info(`Admin retrieved all users (count: ${sanitizedUsers.length})`);
+  logger.info(`[FILE] Retrieved ${sanitizedUsers.length} users`);
   sendResponse3(id, {
     success: true,
     data: {
       users: sanitizedUsers,
       count: sanitizedUsers.length,
-      message: `Retrieved ${sanitizedUsers.length} users`
+      message: `Retrieved ${sanitizedUsers.length} users (File)`
     }
   }, sendMessage, clientId);
 }
-async function handleGetOne(id, username, userManager, sendMessage, clientId) {
+async function handleGetOne(id, numericId, username, executeCollection, userManager, sendMessage, clientId) {
+  if (!numericId && !username) {
+    sendResponse3(id, {
+      success: false,
+      error: "User ID or username is required"
+    }, sendMessage, clientId);
+    return;
+  }
+  if (numericId) {
+    try {
+      const result = await executeCollection("users", "getOne", { id: numericId });
+      if (result && result.success) {
+        const sanitizedUser2 = {
+          id: result.data?.id,
+          username: result.data?.username,
+          email: result.data?.email,
+          fullname: result.data?.fullname,
+          role: result.data?.role,
+          createdAt: result.data?.createdAt,
+          updatedAt: result.data?.updatedAt
+        };
+        logger.info(`[DB] Retrieved user ID: ${numericId}`);
+        sendResponse3(id, {
+          success: true,
+          data: {
+            user: sanitizedUser2,
+            message: `Retrieved user (DB)`
+          }
+        }, sendMessage, clientId);
+        return;
+      }
+    } catch (dbError) {
+      logger.warn(`[DB] Failed to get user, falling back to file storage: ${dbError instanceof Error ? dbError.message : "Unknown error"}`);
+    }
+  }
   if (!username || username.trim().length === 0) {
     sendResponse3(id, {
       success: false,
-      error: "Username is required and cannot be empty"
+      error: "Username is required for file-based storage lookup"
     }, sendMessage, clientId);
     return;
   }
@@ -6373,12 +6563,61 @@ async function handleGetOne(id, username, userManager, sendMessage, clientId) {
     role: user.role,
     wsIds: user.wsIds || []
   };
-  logger.info(`Admin retrieved user: ${username}`);
+  logger.info(`[FILE] Retrieved user: ${username}`);
   sendResponse3(id, {
     success: true,
     data: {
       user: sanitizedUser,
-      message: `Retrieved user '${username}'`
+      message: `Retrieved user '${username}' (File)`
+    }
+  }, sendMessage, clientId);
+}
+async function handleQuery(id, filters, limit, sort, executeCollection, userManager, sendMessage, clientId) {
+  try {
+    const result = await executeCollection("users", "query", {
+      filters: filters || {},
+      limit,
+      sort
+    });
+    if (result && result.success) {
+      const sanitizedUsers2 = result.data.map((user) => ({
+        id: user.id,
+        username: user.username,
+        email: user.email,
+        fullname: user.fullname,
+        role: user.role,
+        createdAt: user.createdAt,
+        updatedAt: user.updatedAt
+      }));
+      logger.info(`[DB] Query returned ${result.count} users`);
+      sendResponse3(id, {
+        success: true,
+        data: {
+          users: sanitizedUsers2,
+          count: result.count,
+          message: `Query returned ${result.count} users (DB)`
+        }
+      }, sendMessage, clientId);
+      return;
+    }
+  } catch (dbError) {
+    logger.warn(`[DB] Failed to query users: ${dbError instanceof Error ? dbError.message : "Unknown error"}`);
+  }
+  const users = userManager.getAllUsers();
+  const sanitizedUsers = users.map((user) => ({
+    username: user.username,
+    email: user.email,
+    fullname: user.fullname,
+    role: user.role,
+    wsIds: user.wsIds || []
+  }));
+  logger.info(`[FILE] Retrieved ${sanitizedUsers.length} users (all - no query filter)`);
+  sendResponse3(id, {
+    success: true,
+    data: {
+      users: sanitizedUsers,
+      count: sanitizedUsers.length,
+      message: `Retrieved ${sanitizedUsers.length} users (File - no query filter)`
     }
   }, sendMessage, clientId);
 }
@@ -6461,7 +6700,7 @@ async function handleDashboardsRequest(data, collections, sendMessage) {
         await handleGetOne2(id, numericId, dashboardId, executeCollection, dashboardManager2, sendMessage, from.id);
         break;
       case "query":
-        await handleQuery(id, filters, limit, sort, executeCollection, dashboardManager2, sendMessage, from.id);
+        await handleQuery2(id, filters, limit, sort, executeCollection, dashboardManager2, sendMessage, from.id);
         break;
       default:
         sendResponse4(id, {
@@ -6715,7 +6954,7 @@ async function handleGetOne2(id, numericId, dashboardId, executeCollection, dash
     }
   }, sendMessage, clientId);
 }
-async function handleQuery(id, filters, limit, sort, executeCollection, dashboardManager2, sendMessage, clientId) {
+async function handleQuery2(id, filters, limit, sort, executeCollection, dashboardManager2, sendMessage, clientId) {
   try {
     const result = await executeCollection("dashboards", "query", {
       filters: filters || {},
@@ -6826,7 +7065,7 @@ async function handleReportsRequest(data, collections, sendMessage) {
         await handleGetOne3(id, numericId, reportId, executeCollection, reportManager2, sendMessage, from.id);
         break;
       case "query":
-        await handleQuery2(id, filters, limit, sort, executeCollection, reportManager2, sendMessage, from.id);
+        await handleQuery3(id, filters, limit, sort, executeCollection, reportManager2, sendMessage, from.id);
         break;
       default:
         sendResponse5(id, {
@@ -7080,7 +7319,7 @@ async function handleGetOne3(id, numericId, reportId, executeCollection, reportM
     }
   }, sendMessage, clientId);
 }
-async function handleQuery2(id, filters, limit, sort, executeCollection, reportManager2, sendMessage, clientId) {
+async function handleQuery3(id, filters, limit, sort, executeCollection, reportManager2, sendMessage, clientId) {
   try {
     const result = await executeCollection("reports", "query", {
       filters: filters || {},
@@ -7178,7 +7417,7 @@ async function handleUIsRequest(data, collections, sendMessage) {
         await handleGetOne4(id, numericId, executeCollection, sendMessage, from.id);
         break;
       case "query":
-        await handleQuery3(id, filters, limit, sort, executeCollection, sendMessage, from.id);
+        await handleQuery4(id, filters, limit, sort, executeCollection, sendMessage, from.id);
         break;
       default:
         sendResponse6(id, {
@@ -7374,7 +7613,7 @@ async function handleGetOne4(id, numericId, executeCollection, sendMessage, clie
     }, sendMessage, clientId);
   }
 }
-async function handleQuery3(id, filters, limit, sort, executeCollection, sendMessage, clientId) {
+async function handleQuery4(id, filters, limit, sort, executeCollection, sendMessage, clientId) {
   try {
     const result = await executeCollection("uis", "query", {
       filters: filters || {},
@@ -7439,6 +7678,9 @@ async function handleBookmarksRequest(data, collections, sendMessage) {
     const name = requestData?.name;
     const description = requestData?.description;
     const uiblock = requestData?.uiblock;
+    const filters = requestData?.filters;
+    const limit = requestData?.limit;
+    const sort = requestData?.sort;
     switch (operation) {
       case "create":
         await handleCreate5(id, userId, threadId, name, description, uiblock, executeCollection, sendMessage, from.id);
@@ -7455,11 +7697,8 @@ async function handleBookmarksRequest(data, collections, sendMessage) {
       case "getOne":
         await handleGetOne5(id, bookmarkId, executeCollection, sendMessage, from.id);
         break;
-      case "getByUser":
-        await handleGetByUser(id, userId, threadId, executeCollection, sendMessage, from.id);
-        break;
-      case "getByThread":
-        await handleGetByThread(id, threadId, executeCollection, sendMessage, from.id);
+      case "query":
+        await handleQuery5(id, filters, limit, sort, executeCollection, sendMessage, from.id);
         break;
       default:
         sendResponse7(id, {
@@ -7591,51 +7830,24 @@ async function handleGetOne5(id, bookmarkId, executeCollection, sendMessage, cli
     }, sendMessage, clientId);
   }
 }
-async function handleGetByUser(id, userId, threadId, executeCollection, sendMessage, clientId) {
-  if (!userId) {
-    sendResponse7(id, {
-      success: false,
-      error: "userId is required"
-    }, sendMessage, clientId);
-    return;
-  }
+async function handleQuery5(id, filters, limit, sort, executeCollection, sendMessage, clientId) {
   try {
-    const result = await executeCollection("bookmarks", "getByUser", { userId, threadId });
-    sendResponse7(id, {
-      success: true,
-      data: result.data,
-      count: result.count,
-      message: `Retrieved ${result.count} bookmarks for user ${userId}`
-    }, sendMessage, clientId);
-    logger.info(`Retrieved bookmarks for user ${userId} (count: ${result.count})`);
-  } catch (error) {
-    sendResponse7(id, {
-      success: false,
-      error: error instanceof Error ? error.message : "Failed to get bookmarks by user"
-    }, sendMessage, clientId);
-  }
-}
-async function handleGetByThread(id, threadId, executeCollection, sendMessage, clientId) {
-  if (!threadId) {
-    sendResponse7(id, {
-      success: false,
-      error: "threadId is required"
-    }, sendMessage, clientId);
-    return;
-  }
-  try {
-    const result = await executeCollection("bookmarks", "getByThread", { threadId });
+    const result = await executeCollection("bookmarks", "query", {
+      filters: filters || {},
+      limit,
+      sort
+    });
     sendResponse7(id, {
       success: true,
       data: result.data,
       count: result.count,
-      message: `Retrieved ${result.count} bookmarks for thread ${threadId}`
+      message: `Query returned ${result.count} bookmarks`
     }, sendMessage, clientId);
-    logger.info(`Retrieved bookmarks for thread ${threadId} (count: ${result.count})`);
+    logger.info(`Query returned ${result.count} bookmarks`);
   } catch (error) {
     sendResponse7(id, {
       success: false,
-      error: error instanceof Error ? error.message : "Failed to get bookmarks by thread"
+      error: error instanceof Error ? error.message : "Failed to query bookmarks"
     }, sendMessage, clientId);
   }
 }
@@ -8660,7 +8872,7 @@ var SuperatomSDK = class {
           });
           break;
         case "USERS":
-          handleUsersRequest(parsed, (msg) => this.send(msg)).catch((error) => {
+          handleUsersRequest(parsed, this.collections, (msg) => this.send(msg)).catch((error) => {
             logger.error("Failed to handle users request:", error);
           });
           break;