@superatomai/sdk-node 0.0.14 → 0.0.16

package/dist/index.js

@@ -565,10 +565,14 @@ var ReportsRequestMessageSchema = import_zod3.z.object({
 var UIBlockSchema = import_zod3.z.object({
   id: import_zod3.z.string().optional(),
   userQuestion: import_zod3.z.string().optional(),
+  user_prompt: import_zod3.z.string().optional(),
+  // DB field name
   text: import_zod3.z.string().optional(),
   textResponse: import_zod3.z.string().optional(),
+  analysis: import_zod3.z.string().optional(),
+  // DB field name for textResponse
   component: ComponentSchema.optional(),
-  // Legacy field
+  // DB field name / Legacy field
   generatedComponentMetadata: ComponentSchema.optional(),
   // Actual field used by UIBlock class
   componentData: import_zod3.z.record(import_zod3.z.any()).optional(),
@@ -589,9 +593,11 @@ var BookmarkDataSchema = import_zod3.z.object({
   updated_at: import_zod3.z.string().optional()
 });
 var BookmarksRequestPayloadSchema = import_zod3.z.object({
-  operation: import_zod3.z.enum(["create", "update", "delete", "getAll", "getOne"]),
+  operation: import_zod3.z.enum(["create", "update", "delete", "getAll", "getOne", "getByUser", "getByThread"]),
   data: import_zod3.z.object({
     id: import_zod3.z.number().optional(),
+    userId: import_zod3.z.number().optional(),
+    threadId: import_zod3.z.string().optional(),
     uiblock: import_zod3.z.any().optional()
   }).optional()
 });
@@ -1419,7 +1425,7 @@ async function cleanupUserStorage() {
 }
 
 // src/auth/validator.ts
-function validateUser(credentials) {
+async function validateUser(credentials, collections) {
   const { username, email, password } = credentials;
   const identifier = username || email;
   logger.debug("[validateUser] Starting user validation");
@@ -1431,7 +1437,39 @@ function validateUser(credentials) {
       error: "Username or email and password are required"
     };
   }
-  logger.debug(`[validateUser] Looking up user by identifier: ${identifier}`);
+  if (collections && collections["users"] && collections["users"]["authenticate"]) {
+    logger.debug(`[validateUser] Attempting database authentication for: ${identifier}`);
+    try {
+      const dbResult = await collections["users"]["authenticate"]({
+        identifier,
+        password
+      });
+      logger.info("[validateUser] Database authentication attempt completed", dbResult);
+      if (dbResult && dbResult.success && dbResult.data) {
+        logger.info(`[validateUser] \u2713 User authenticated via database: ${dbResult.data.username}`);
+        return {
+          success: true,
+          data: dbResult.data.username,
+          username: dbResult.data.username,
+          userId: dbResult.data.id
+        };
+      } else {
+        logger.debug(`[validateUser] Database auth failed for ${identifier}: ${dbResult?.error || "Invalid credentials"}`);
+        if (dbResult && dbResult.error === "Invalid credentials") {
+          return {
+            success: false,
+            error: "Invalid credentials"
+          };
+        }
+      }
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      logger.debug(`[validateUser] Database lookup error: ${errorMsg}, falling back to file storage`);
+    }
+  } else {
+    logger.debug("[validateUser] No users collection available, using file storage only");
+  }
+  logger.info(`[validateUser] Attempting file-based validation for: ${identifier}`);
   const user = findUserByUsernameOrEmail(identifier);
   if (!user) {
     logger.warn(`[validateUser] Validation failed: User not found - ${identifier}`);
@@ -1440,7 +1478,7 @@ function validateUser(credentials) {
       error: "Invalid username or email"
     };
   }
-  logger.debug(`[validateUser] User found: ${user.username}, verifying password`);
+  logger.debug(`[validateUser] User found in file storage: ${user.username}, verifying password`);
   const hashedPassword = hashPassword(user.password);
   if (hashedPassword !== password) {
     logger.warn(`[validateUser] Validation failed: Invalid password for user - ${user.username}`);
@@ -1450,19 +1488,18 @@ function validateUser(credentials) {
       error: "Invalid password"
     };
   }
-  logger.info(`[validateUser] \u2713 User validated successfully: ${user.username}`);
-  logger.debug(`[validateUser] Returning user data for: ${user.username}`);
+  logger.info(`[validateUser] \u2713 User validated via file storage: ${user.username}`);
   return {
     success: true,
     data: user.username,
     username: user.username
   };
 }
-function authenticateAndStoreWsId(credentials, wsId) {
+async function authenticateAndStoreWsId(credentials, wsId, collections) {
   const identifier = credentials.username || credentials.email;
   logger.debug("[authenticateAndStoreWsId] Starting authentication and WebSocket ID storage");
   logger.debug("[authenticateAndStoreWsId] Validating user credentials");
-  const validationResult = validateUser(credentials);
+  const validationResult = await validateUser(credentials, collections);
   if (!validationResult.success) {
     logger.warn(`[authenticateAndStoreWsId] User validation failed for: ${identifier}`);
     return validationResult;
@@ -1474,7 +1511,7 @@ function authenticateAndStoreWsId(credentials, wsId) {
   logger.debug(`[authenticateAndStoreWsId] WebSocket ID ${wsId} associated with user ${username}`);
   return validationResult;
 }
-function verifyAuthToken(authToken) {
+async function verifyAuthToken(authToken, collections) {
   try {
     logger.debug("[verifyAuthToken] Starting token verification");
     logger.debug("[verifyAuthToken] Decoding base64 token");
@@ -1484,7 +1521,7 @@ function verifyAuthToken(authToken) {
     logger.debug("[verifyAuthToken] Token decoded and parsed successfully");
     logger.debug(`[verifyAuthToken] Token contains username: ${credentials.username ? "\u2713" : "\u2717"}`);
     logger.debug("[verifyAuthToken] Validating credentials from token");
-    const result = validateUser(credentials);
+    const result = await validateUser(credentials, collections);
     if (result.success) {
       logger.info(`[verifyAuthToken] \u2713 Token verified successfully for user: ${credentials.username || "unknown"}`);
     } else {
@@ -1503,7 +1540,7 @@ function verifyAuthToken(authToken) {
 }
 
 // src/handlers/auth-login-requests.ts
-async function handleAuthLoginRequest(data, sendMessage) {
+async function handleAuthLoginRequest(data, collections, sendMessage) {
   try {
     logger.debug("[AUTH_LOGIN_REQ] Parsing incoming auth login request");
     const authRequest = AuthLoginRequestMessageSchema.parse(data);
@@ -1562,12 +1599,12 @@ async function handleAuthLoginRequest(data, sendMessage) {
       }, sendMessage, wsId);
       return;
     }
-    logger.info(`[AUTH_LOGIN_REQ ${id}] Credentials validated, authenticating user: ${identifier}`);
-    logger.debug(`[AUTH_LOGIN_REQ ${id}] WebSocket ID: ${wsId}`);
+    logger.info(`[AUTH_LOGIN_REQ ${id}] Credentials validated, authenticating user: ${identifier} username: ${username} email: ${email} password: ${password}`);
     logger.debug(`[AUTH_LOGIN_REQ ${id}] Calling authenticateAndStoreWsId for user: ${identifier}`);
-    const authResult = authenticateAndStoreWsId(
+    const authResult = await authenticateAndStoreWsId(
       { username, email, password },
-      wsId
+      wsId,
+      collections
     );
     logger.info(`[AUTH_LOGIN_REQ ${id}] Authentication result for ${identifier}: ${authResult.success ? "success" : "failed"}`);
     if (!authResult.success) {
@@ -1619,7 +1656,7 @@ function sendDataResponse2(id, res, sendMessage, clientId) {
 }
 
 // src/handlers/auth-verify-request.ts
-async function handleAuthVerifyRequest(data, sendMessage) {
+async function handleAuthVerifyRequest(data, collections, sendMessage) {
   try {
     logger.debug("[AUTH_VERIFY_REQ] Parsing incoming auth verify request");
     const authRequest = AuthVerifyRequestMessageSchema.parse(data);
@@ -1649,7 +1686,7 @@ async function handleAuthVerifyRequest(data, sendMessage) {
     logger.debug(`[AUTH_VERIFY_REQ ${id}] WebSocket ID: ${wsId}`);
     logger.debug(`[AUTH_VERIFY_REQ ${id}] Calling verifyAuthToken`);
     const startTime = Date.now();
-    const authResult = verifyAuthToken(token);
+    const authResult = await verifyAuthToken(token, collections);
     const verificationTime = Date.now() - startTime;
     logger.info(`[AUTH_VERIFY_REQ ${id}] Token verification completed in ${verificationTime}ms - ${authResult.success ? "valid" : "invalid"}`);
     if (!authResult.success) {
@@ -3699,13 +3736,13 @@ var BaseLLM = class {
    */
   async adaptUIBlockParameters(currentUserPrompt, originalUserPrompt, matchedUIBlock, apiKey, logCollector) {
     try {
-      if (!matchedUIBlock || !matchedUIBlock.generatedComponentMetadata) {
+      const component = matchedUIBlock?.generatedComponentMetadata || matchedUIBlock?.component;
+      if (!matchedUIBlock || !component) {
         return {
           success: false,
           explanation: "No component found in matched UI block"
         };
       }
-      const component = matchedUIBlock.generatedComponentMetadata;
       const schemaDoc = schema.generateSchemaDocumentation();
       const prompts = await promptLoader.loadPrompts("adapt-ui-block-params", {
         ORIGINAL_USER_PROMPT: originalUserPrompt,
@@ -3781,8 +3818,9 @@ var BaseLLM = class {
    * @param collections - Collection registry for executing database queries via database.execute
    * @param components - Optional list of available components for matching suggestions
    * @param externalTools - Optional array of external tools (email, calendar, etc.) that can be called
+   * @param category - Question category ('data_analysis' | 'data_modification' | 'general'). For data_modification, answer component streaming is skipped. For general, component generation is skipped entirely.
    */
-  async generateTextResponse(userPrompt, apiKey, logCollector, conversationHistory, streamCallback, collections, components, externalTools) {
+  async generateTextResponse(userPrompt, apiKey, logCollector, conversationHistory, streamCallback, collections, components, externalTools, category) {
     const errors = [];
     logger.debug(`[${this.getProviderName()}] Starting text response generation`);
     logger.debug(`[${this.getProviderName()}] User prompt: "${userPrompt.substring(0, 50)}..."`);
@@ -4176,16 +4214,19 @@ ${errorMsg}
           textLength: textResponse.length
         }
       );
-      if (wrappedStreamCallback && components && components.length > 0) {
+      if (wrappedStreamCallback && components && components.length > 0 && category !== "general") {
         wrappedStreamCallback("__TEXT_COMPLETE__COMPONENT_GENERATION_START__");
       }
       let matchedComponents = [];
       let layoutTitle = "Dashboard";
       let layoutDescription = "Multi-component dashboard";
       let actions = [];
-      if (components && components.length > 0) {
+      if (category === "general") {
+        logger.info(`[${this.getProviderName()}] Skipping component generation for general/conversational question`);
+        logCollector?.info("Skipping component generation for general question");
+      } else if (components && components.length > 0) {
         logger.info(`[${this.getProviderName()}] Matching components from text response...`);
-        const componentStreamCallback = wrappedStreamCallback ? (component) => {
+        const componentStreamCallback = wrappedStreamCallback && category !== "data_modification" ? (component) => {
           const answerMarker = `__ANSWER_COMPONENT_START__${JSON.stringify(component)}__ANSWER_COMPONENT_END__`;
           wrappedStreamCallback(answerMarker);
           logger.info(`[${this.getProviderName()}] Streamed answer component to frontend: ${component.name} (${component.type})`);
@@ -4284,52 +4325,78 @@ ${errorMsg}
         logCollector?.info(
           `\u2713 Found similar conversation (${(conversationMatch.similarity * 100).toFixed(2)}% match)`
         );
-        if (conversationMatch.similarity >= 0.99) {
-          const elapsedTime2 = Date.now() - startTime;
-          logger.info(`[${this.getProviderName()}] \u2713 100% match - returning UI block directly without adaptation`);
-          logCollector?.info(`\u2713 Exact match (${(conversationMatch.similarity * 100).toFixed(2)}%) - returning cached result`);
-          logCollector?.info(`Total time taken: ${elapsedTime2}ms (${(elapsedTime2 / 1e3).toFixed(2)}s)`);
-          const component = conversationMatch.uiBlock?.generatedComponentMetadata || conversationMatch.uiBlock?.component;
-          return {
-            success: true,
-            data: {
-              component,
-              reasoning: `Exact match from previous conversation (${(conversationMatch.similarity * 100).toFixed(2)}% similarity)`,
-              method: `${this.getProviderName()}-semantic-match-exact`,
-              semanticSimilarity: conversationMatch.similarity
-            },
-            errors: []
-          };
-        }
-        logCollector?.info(`Adapting parameters for similar question...`);
-        const originalPrompt = conversationMatch.metadata?.userPrompt || "Previous question";
-        const adaptResult = await this.adaptUIBlockParameters(
-          userPrompt,
-          originalPrompt,
-          conversationMatch.uiBlock,
-          apiKey,
-          logCollector
-        );
-        if (adaptResult.success && adaptResult.adaptedComponent) {
-          const elapsedTime2 = Date.now() - startTime;
-          logger.info(`[${this.getProviderName()}] \u2713 Successfully adapted UI block parameters`);
-          logger.info(`[${this.getProviderName()}] Total time taken: ${elapsedTime2}ms (${(elapsedTime2 / 1e3).toFixed(2)}s)`);
-          logCollector?.info(`\u2713 UI block adapted successfully`);
-          logCollector?.info(`Total time taken: ${elapsedTime2}ms (${(elapsedTime2 / 1e3).toFixed(2)}s)`);
-          return {
-            success: true,
-            data: {
-              component: adaptResult.adaptedComponent,
-              reasoning: `Adapted from previous conversation: ${originalPrompt}`,
-              method: `${this.getProviderName()}-semantic-match`,
-              semanticSimilarity: conversationMatch.similarity,
-              parametersChanged: adaptResult.parametersChanged
-            },
-            errors: []
-          };
+        const component = conversationMatch.uiBlock?.component || conversationMatch.uiBlock?.generatedComponentMetadata;
+        const cachedTextResponse = conversationMatch.uiBlock?.analysis || conversationMatch.uiBlock?.textResponse || conversationMatch.uiBlock?.text || "";
+        if (!component) {
+          if (conversationMatch.similarity >= 0.99) {
+            const elapsedTime2 = Date.now() - startTime;
+            logger.info(`[${this.getProviderName()}] \u2713 Exact match for general question - returning cached text response`);
+            logCollector?.info(`\u2713 Exact match for general question - returning cached response`);
+            logCollector?.info(`Total time taken: ${elapsedTime2}ms (${(elapsedTime2 / 1e3).toFixed(2)}s)`);
+            return {
+              success: true,
+              data: {
+                text: cachedTextResponse,
+                component: null,
+                matchedComponents: [],
+                actions: conversationMatch.uiBlock?.actions || [],
+                reasoning: `Exact match from previous general conversation`,
+                method: `${this.getProviderName()}-semantic-match-general`,
+                semanticSimilarity: conversationMatch.similarity
+              },
+              errors: []
+            };
+          } else {
+            logger.info(`[${this.getProviderName()}] Similar match but no component (general question) - processing fresh`);
+            logCollector?.info("Similar match found but was a general conversation - processing as new question");
+          }
         } else {
-          logger.info(`[${this.getProviderName()}] Could not adapt matched conversation, continuing to category classification`);
-          logCollector?.warn(`Could not adapt matched conversation: ${adaptResult.explanation}`);
+          if (conversationMatch.similarity >= 0.99) {
+            const elapsedTime2 = Date.now() - startTime;
+            logger.info(`[${this.getProviderName()}] \u2713 100% match - returning UI block directly without adaptation`);
+            logCollector?.info(`\u2713 Exact match (${(conversationMatch.similarity * 100).toFixed(2)}%) - returning cached result`);
+            logCollector?.info(`Total time taken: ${elapsedTime2}ms (${(elapsedTime2 / 1e3).toFixed(2)}s)`);
+            return {
+              success: true,
+              data: {
+                component,
+                reasoning: `Exact match from previous conversation (${(conversationMatch.similarity * 100).toFixed(2)}% similarity)`,
+                method: `${this.getProviderName()}-semantic-match-exact`,
+                semanticSimilarity: conversationMatch.similarity
+              },
+              errors: []
+            };
+          }
+          logCollector?.info(`Adapting parameters for similar question...`);
+          const originalPrompt = conversationMatch.metadata?.userPrompt || "Previous question";
+          const adaptResult = await this.adaptUIBlockParameters(
+            userPrompt,
+            originalPrompt,
+            conversationMatch.uiBlock,
+            apiKey,
+            logCollector
+          );
+          if (adaptResult.success && adaptResult.adaptedComponent) {
+            const elapsedTime2 = Date.now() - startTime;
+            logger.info(`[${this.getProviderName()}] \u2713 Successfully adapted UI block parameters`);
+            logger.info(`[${this.getProviderName()}] Total time taken: ${elapsedTime2}ms (${(elapsedTime2 / 1e3).toFixed(2)}s)`);
+            logCollector?.info(`\u2713 UI block adapted successfully`);
+            logCollector?.info(`Total time taken: ${elapsedTime2}ms (${(elapsedTime2 / 1e3).toFixed(2)}s)`);
+            return {
+              success: true,
+              data: {
+                component: adaptResult.adaptedComponent,
+                reasoning: `Adapted from previous conversation: ${originalPrompt}`,
+                method: `${this.getProviderName()}-semantic-match`,
+                semanticSimilarity: conversationMatch.similarity,
+                parametersChanged: adaptResult.parametersChanged
+              },
+              errors: []
+            };
+          } else {
+            logger.info(`[${this.getProviderName()}] Could not adapt matched conversation, continuing to category classification`);
+            logCollector?.warn(`Could not adapt matched conversation: ${adaptResult.explanation}`);
+          }
         }
       } else {
         logger.info(`[${this.getProviderName()}] No matching previous conversations found, proceeding to category classification`);
@@ -4371,7 +4438,10 @@ ${errorMsg}
           })()
         })) || [];
       }
-      if (categoryClassification.category === "data_analysis") {
+      if (categoryClassification.category === "general") {
+        logger.info(`[${this.getProviderName()}] Routing to general conversation (no database operations)`);
+        logCollector?.info("Routing to general conversation...");
+      } else if (categoryClassification.category === "data_analysis") {
         logger.info(`[${this.getProviderName()}] Routing to data analysis (SELECT operations)`);
         logCollector?.info("Routing to data analysis...");
       } else if (categoryClassification.category === "data_modification") {
@@ -4386,7 +4456,8 @@ ${errorMsg}
         streamCallback,
         collections,
         components,
-        toolsToUse
+        toolsToUse,
+        categoryClassification.category
       );
       const elapsedTime = Date.now() - startTime;
       logger.info(`[${this.getProviderName()}] Total time taken: ${elapsedTime}ms (${(elapsedTime / 1e3).toFixed(2)}s)`);
@@ -4810,6 +4881,15 @@ var UILogCollector = class {
 };
 
 // src/utils/conversation-saver.ts
+function transformUIBlockForDB(uiblock, userPrompt, uiBlockId) {
+  const component = uiblock?.generatedComponentMetadata && Object.keys(uiblock.generatedComponentMetadata).length > 0 ? uiblock.generatedComponentMetadata : null;
+  return {
+    id: uiBlockId || uiblock?.id || "",
+    component,
+    analysis: uiblock?.textResponse || null,
+    user_prompt: userPrompt || uiblock?.userQuestion || ""
+  };
+}
 async function saveConversation(params) {
   const { userId, userPrompt, uiblock, uiBlockId, threadId, collections } = params;
   if (!userId) {
@@ -4864,10 +4944,12 @@ async function saveConversation(params) {
         error: `Invalid userId: ${userId} (not a valid number)`
       };
     }
+    const dbUIBlock = transformUIBlockForDB(uiblock, userPrompt, uiBlockId);
+    logger.debug(`[CONVERSATION_SAVER] Transformed UIBlock for DB: ${JSON.stringify(dbUIBlock)}`);
     const saveResult = await collections["user-conversations"]["create"]({
       userId: userIdNumber,
       userPrompt,
-      uiblock,
+      uiblock: dbUIBlock,
       threadId
     });
     if (!saveResult?.success) {
@@ -4884,7 +4966,8 @@ async function saveConversation(params) {
         const embedResult = await collections["conversation-history"]["embed"]({
           uiBlockId,
           userPrompt,
-          uiBlock: uiblock,
+          uiBlock: dbUIBlock,
+          // Use the transformed UIBlock
           userId: userIdNumber
         });
         if (embedResult?.success) {
@@ -5031,8 +5114,10 @@ var get_user_request = async (data, components, sendMessage, anthropicApiKey, gr
       if ("component" in userResponse.data) {
         component = userResponse.data.component;
       }
-      if ("textResponse" in userResponse.data) {
+      if ("text" in userResponse.data) {
         textResponse = userResponse.data.text;
+      } else if ("textResponse" in userResponse.data) {
+        textResponse = userResponse.data.textResponse;
       }
       if ("actions" in userResponse.data) {
         actions = userResponse.data.actions || [];
@@ -6184,13 +6269,15 @@ async function handleBookmarksRequest(data, collections, sendMessage) {
     const { id, payload, from } = request;
     const { operation, data: requestData } = payload;
     const bookmarkId = requestData?.id;
+    const userId = requestData?.userId;
+    const threadId = requestData?.threadId;
     const uiblock = requestData?.uiblock;
     switch (operation) {
       case "create":
-        await handleCreate4(id, uiblock, executeCollection, sendMessage, from.id);
+        await handleCreate4(id, userId, threadId, uiblock, executeCollection, sendMessage, from.id);
         break;
       case "update":
-        await handleUpdate4(id, bookmarkId, uiblock, executeCollection, sendMessage, from.id);
+        await handleUpdate4(id, bookmarkId, threadId, uiblock, executeCollection, sendMessage, from.id);
         break;
       case "delete":
         await handleDelete4(id, bookmarkId, executeCollection, sendMessage, from.id);
@@ -6201,6 +6288,12 @@ async function handleBookmarksRequest(data, collections, sendMessage) {
       case "getOne":
         await handleGetOne4(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);
+        break;
       default:
         sendResponse6(id, {
           success: false,
@@ -6215,7 +6308,14 @@ async function handleBookmarksRequest(data, collections, sendMessage) {
     }, sendMessage);
   }
 }
-async function handleCreate4(id, uiblock, executeCollection, sendMessage, clientId) {
+async function handleCreate4(id, userId, threadId, uiblock, executeCollection, sendMessage, clientId) {
+  if (!userId) {
+    sendResponse6(id, {
+      success: false,
+      error: "userId is required"
+    }, sendMessage, clientId);
+    return;
+  }
   if (!uiblock) {
     sendResponse6(id, {
       success: false,
@@ -6224,7 +6324,7 @@ async function handleCreate4(id, uiblock, executeCollection, sendMessage, client
     return;
   }
   try {
-    const result = await executeCollection("bookmarks", "create", { uiblock });
+    const result = await executeCollection("bookmarks", "create", { userId, threadId, uiblock });
     sendResponse6(id, {
       success: true,
       data: result.data,
@@ -6238,7 +6338,7 @@ async function handleCreate4(id, uiblock, executeCollection, sendMessage, client
     }, sendMessage, clientId);
   }
 }
-async function handleUpdate4(id, bookmarkId, uiblock, executeCollection, sendMessage, clientId) {
+async function handleUpdate4(id, bookmarkId, threadId, uiblock, executeCollection, sendMessage, clientId) {
   if (!bookmarkId) {
     sendResponse6(id, {
       success: false,
@@ -6254,7 +6354,7 @@ async function handleUpdate4(id, bookmarkId, uiblock, executeCollection, sendMes
     return;
   }
   try {
-    const result = await executeCollection("bookmarks", "update", { id: bookmarkId, uiblock });
+    const result = await executeCollection("bookmarks", "update", { id: bookmarkId, threadId, uiblock });
     sendResponse6(id, {
       success: true,
       data: result.data,
@@ -6331,6 +6431,54 @@ async function handleGetOne4(id, bookmarkId, executeCollection, sendMessage, cli
     }, sendMessage, clientId);
   }
 }
+async function handleGetByUser(id, userId, threadId, executeCollection, sendMessage, clientId) {
+  if (!userId) {
+    sendResponse6(id, {
+      success: false,
+      error: "userId is required"
+    }, sendMessage, clientId);
+    return;
+  }
+  try {
+    const result = await executeCollection("bookmarks", "getByUser", { userId, threadId });
+    sendResponse6(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) {
+    sendResponse6(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) {
+    sendResponse6(id, {
+      success: false,
+      error: "threadId is required"
+    }, sendMessage, clientId);
+    return;
+  }
+  try {
+    const result = await executeCollection("bookmarks", "getByThread", { threadId });
+    sendResponse6(id, {
+      success: true,
+      data: result.data,
+      count: result.count,
+      message: `Retrieved ${result.count} bookmarks for thread ${threadId}`
+    }, sendMessage, clientId);
+    logger.info(`Retrieved bookmarks for thread ${threadId} (count: ${result.count})`);
+  } catch (error) {
+    sendResponse6(id, {
+      success: false,
+      error: error instanceof Error ? error.message : "Failed to get bookmarks by thread"
+    }, sendMessage, clientId);
+  }
+}
 function sendResponse6(id, res, sendMessage, clientId) {
   const response = {
     id: id || "unknown",
@@ -7317,12 +7465,12 @@ var SuperatomSDK = class {
           });
           break;
         case "AUTH_LOGIN_REQ":
-          handleAuthLoginRequest(parsed, (msg) => this.send(msg)).catch((error) => {
+          handleAuthLoginRequest(parsed, this.collections, (msg) => this.send(msg)).catch((error) => {
             logger.error("Failed to handle auth login request:", error);
           });
           break;
         case "AUTH_VERIFY_REQ":
-          handleAuthVerifyRequest(parsed, (msg) => this.send(msg)).catch((error) => {
+          handleAuthVerifyRequest(parsed, this.collections, (msg) => this.send(msg)).catch((error) => {
             logger.error("Failed to handle auth verify request:", error);
           });
           break;