@superatomai/sdk-node 0.0.14 → 0.0.15

package/dist/index.mjs

@@ -549,9 +549,11 @@ var BookmarkDataSchema = z3.object({
   updated_at: z3.string().optional()
 });
 var BookmarksRequestPayloadSchema = z3.object({
-  operation: z3.enum(["create", "update", "delete", "getAll", "getOne"]),
+  operation: z3.enum(["create", "update", "delete", "getAll", "getOne", "getByUser", "getByThread"]),
   data: z3.object({
     id: z3.number().optional(),
+    userId: z3.number().optional(),
+    threadId: z3.string().optional(),
     uiblock: z3.any().optional()
   }).optional()
 });
@@ -1379,7 +1381,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");
@@ -1391,7 +1393,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}`);
@@ -1400,7 +1434,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}`);
@@ -1410,19 +1444,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;
@@ -1434,7 +1467,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");
@@ -1444,7 +1477,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 {
@@ -1463,7 +1496,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);
@@ -1522,12 +1555,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) {
@@ -1579,7 +1612,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);
@@ -1609,7 +1642,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) {
@@ -3659,13 +3692,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,
@@ -4770,6 +4803,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) {
@@ -4824,10 +4866,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) {
@@ -4844,7 +4888,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) {
@@ -6144,13 +6189,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);
@@ -6161,6 +6208,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,
@@ -6175,7 +6228,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,
@@ -6184,7 +6244,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,
@@ -6198,7 +6258,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,
@@ -6214,7 +6274,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,
@@ -6291,6 +6351,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",
@@ -7277,12 +7385,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;