@superatomai/sdk-node 0.0.4 → 0.0.5

package/dist/index.mjs

@@ -624,6 +624,18 @@ var DSLRendererPropsSchema2 = z2.object({
 });
 
 // src/types.ts
+var UserSchema = z3.object({
+  username: z3.string().min(1, "Username is required"),
+  email: z3.string().email("Invalid email format").optional(),
+  password: z3.string().min(1, "Password is required"),
+  fullname: z3.string().optional(),
+  role: z3.string().optional(),
+  wsIds: z3.array(z3.string()).optional()
+  // Only in memory, not persisted to file
+});
+var UsersDataSchema = z3.object({
+  users: z3.array(UserSchema)
+});
 var MessageParticipantSchema = z3.object({
   id: z3.string().optional(),
   type: z3.string().optional()
@@ -724,7 +736,10 @@ var UsersRequestPayloadSchema = z3.object({
   operation: z3.enum(["create", "update", "delete", "getAll", "getOne"]),
   data: z3.object({
     username: z3.string().optional(),
-    password: z3.string().optional()
+    email: z3.string().email("Invalid email format").optional(),
+    password: z3.string().optional(),
+    fullname: z3.string().optional(),
+    role: z3.string().optional()
   }).optional()
 });
 var UsersRequestMessageSchema = z3.object({
@@ -790,20 +805,91 @@ var ReportsRequestMessageSchema = z3.object({
 
 // src/utils/logger.ts
 var PREFIX = "[SuperatomSDK]";
-var logger = {
-  info: (...args) => {
-    console.log(PREFIX, ...args);
-  },
-  error: (...args) => {
-    console.error(PREFIX, ...args);
-  },
-  warn: (...args) => {
-    console.warn(PREFIX, ...args);
-  },
-  debug: (...args) => {
-    console.log(PREFIX, "[DEBUG]", ...args);
+var LOG_LEVEL_PRIORITY = {
+  errors: 0,
+  warnings: 1,
+  info: 2,
+  verbose: 3
+};
+var MESSAGE_LEVEL_PRIORITY = {
+  error: 0,
+  warn: 1,
+  info: 2,
+  debug: 3
+};
+var Logger = class {
+  constructor() {
+    const envLevel = (process.env.SUPERATOM_LOG_LEVEL || "info").toLowerCase();
+    if (this.isValidLogLevel(envLevel)) {
+      this.currentLevel = envLevel;
+    } else {
+      this.currentLevel = "info";
+      console.warn(
+        `${PREFIX} Invalid log level "${envLevel}". Using default "info". Valid levels: errors, warnings, info, verbose`
+      );
+    }
+    this.currentLevelPriority = LOG_LEVEL_PRIORITY[this.currentLevel];
+  }
+  /**
+   * Check if a string is a valid log level
+   */
+  isValidLogLevel(level) {
+    return level === "errors" || level === "warnings" || level === "info" || level === "verbose";
+  }
+  /**
+   * Check if a message should be logged based on current log level
+   */
+  shouldLog(messageLevel) {
+    const messagePriority = MESSAGE_LEVEL_PRIORITY[messageLevel];
+    return messagePriority <= this.currentLevelPriority;
+  }
+  /**
+   * Get current log level
+   */
+  getLogLevel() {
+    return this.currentLevel;
+  }
+  /**
+   * Set log level programmatically
+   */
+  setLogLevel(level) {
+    this.currentLevel = level;
+    this.currentLevelPriority = LOG_LEVEL_PRIORITY[level];
+  }
+  /**
+   * Log info message (shown for info and verbose levels)
+   */
+  info(...args) {
+    if (this.shouldLog("info")) {
+      console.log(PREFIX, ...args);
+    }
+  }
+  /**
+   * Log error message (shown for all levels)
+   */
+  error(...args) {
+    if (this.shouldLog("error")) {
+      console.error(PREFIX, ...args);
+    }
+  }
+  /**
+   * Log warning message (shown for warnings, info, and verbose levels)
+   */
+  warn(...args) {
+    if (this.shouldLog("warn")) {
+      console.warn(PREFIX, ...args);
+    }
+  }
+  /**
+   * Log debug message (only shown for verbose level)
+   */
+  debug(...args) {
+    if (this.shouldLog("debug")) {
+      console.log(PREFIX, "[DEBUG]", ...args);
+    }
   }
 };
+var logger = new Logger();
 
 // src/threads/uiblock.ts
 import { randomUUID } from "crypto";
@@ -838,13 +924,15 @@ var UIBlock = class {
    * @param generatedComponentMetadata - Optional metadata about the generated component
    * @param actions - Optional array of available actions
    * @param id - Optional custom ID, generates UUID if not provided
+   * @param textResponse - Optional text response from LLM
    */
-  constructor(userQuestion, componentData = {}, generatedComponentMetadata = {}, actions = [], id) {
+  constructor(userQuestion, componentData = {}, generatedComponentMetadata = {}, actions = [], id, textResponse = null) {
     this.id = id || randomUUID();
     this.userQuestion = userQuestion;
     this.componentData = componentData;
     this.generatedComponentMetadata = generatedComponentMetadata;
     this.actions = actions;
+    this.textResponse = textResponse;
     this.createdAt = /* @__PURE__ */ new Date();
   }
   /**
@@ -963,6 +1051,18 @@ var UIBlock = class {
     const processedData = this.processDataForStorage(data);
     this.componentData = { ...this.componentData, ...processedData };
   }
+  /**
+   * Get text response
+   */
+  getTextResponse() {
+    return this.textResponse;
+  }
+  /**
+   * Set or update text response
+   */
+  setTextResponse(textResponse) {
+    this.textResponse = textResponse;
+  }
   /**
    * Get all actions (only if they are resolved, not if fetching)
    */
@@ -1046,6 +1146,7 @@ var UIBlock = class {
       userQuestion: this.userQuestion,
       generatedComponentMetadata: this.generatedComponentMetadata,
       componentData: this.componentData,
+      textResponse: this.textResponse,
       actions: actionsValue,
       isFetchingActions: this.actions instanceof Promise,
       createdAt: this.createdAt.toISOString()
@@ -1480,9 +1581,9 @@ function getUserManager() {
   }
   return currentUserManager;
 }
-function findUserByUsername(username) {
+function findUserByUsernameOrEmail(identifier) {
   const manager = getUserManager();
-  const user = manager.getUser(username);
+  const user = manager.getUserByUsernameOrEmail(identifier);
   return user || null;
 }
 function addWsIdToUser(username, wsId) {
@@ -1504,60 +1605,81 @@ async function cleanupUserStorage() {
 
 // src/auth/validator.ts
 function validateUser(credentials) {
-  const { username, password } = credentials;
-  if (!username || !password) {
-    logger.warn("Validation failed: Username and password are required");
+  const { username, email, password } = credentials;
+  const identifier = username || email;
+  logger.debug("[validateUser] Starting user validation");
+  logger.debug(`[validateUser] Username provided: ${username ? "\u2713" : "\u2717"}, Email provided: ${email ? "\u2713" : "\u2717"}, Password provided: ${password ? "\u2713" : "\u2717"}`);
+  if (!identifier || !password) {
+    logger.warn("[validateUser] Validation failed: Username/email and password are required");
     return {
       success: false,
-      error: "Username and password are required"
+      error: "Username or email and password are required"
     };
   }
-  const user = findUserByUsername(username);
+  logger.debug(`[validateUser] Looking up user by identifier: ${identifier}`);
+  const user = findUserByUsernameOrEmail(identifier);
   if (!user) {
-    logger.warn(`Validation failed: User not found - ${username}`);
+    logger.warn(`[validateUser] Validation failed: User not found - ${identifier}`);
     return {
       success: false,
-      error: "Invalid username"
+      error: "Invalid username or email"
     };
   }
+  logger.debug(`[validateUser] User found: ${user.username}, verifying password`);
   const hashedPassword = hashPassword(user.password);
   if (hashedPassword !== password) {
-    logger.warn(`Validation failed: Invalid password for user - ${username}`);
+    logger.warn(`[validateUser] Validation failed: Invalid password for user - ${user.username}`);
+    logger.debug(`[validateUser] Password hash mismatch for user: ${user.username}`);
     return {
       success: false,
       error: "Invalid password"
     };
   }
-  logger.debug(`User validated successfully: ${username}`);
+  logger.info(`[validateUser] \u2713 User validated successfully: ${user.username}`);
+  logger.debug(`[validateUser] Returning user data for: ${user.username}`);
   return {
     success: true,
-    data: user.username
+    data: user.username,
+    username: user.username
   };
 }
 function authenticateAndStoreWsId(credentials, wsId) {
+  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);
   if (!validationResult.success) {
+    logger.warn(`[authenticateAndStoreWsId] User validation failed for: ${identifier}`);
     return validationResult;
   }
-  const stored = addWsIdToUser(credentials.username, wsId);
-  if (!stored) {
-    logger.error(`Failed to store WebSocket ID for user: ${credentials.username}`);
-    return {
-      success: false,
-      error: "Failed to store user session"
-    };
-  }
-  logger.info(`WebSocket ID stored for user: ${credentials.username}`);
+  const username = validationResult.username;
+  logger.info(`[authenticateAndStoreWsId] User ${username} validated, storing WebSocket ID`);
+  logger.debug(`[authenticateAndStoreWsId] Calling addWsIdToUser for ${username}`);
+  addWsIdToUser(username, wsId);
+  logger.debug(`[authenticateAndStoreWsId] WebSocket ID ${wsId} associated with user ${username}`);
   return validationResult;
 }
 function verifyAuthToken(authToken) {
   try {
+    logger.debug("[verifyAuthToken] Starting token verification");
+    logger.debug("[verifyAuthToken] Decoding base64 token");
     const decodedString = Buffer.from(authToken, "base64").toString("utf-8");
+    logger.debug("[verifyAuthToken] Parsing decoded token as JSON");
     const credentials = JSON.parse(decodedString);
-    logger.debug("Token decoded and parsed successfully");
-    return validateUser(credentials);
+    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);
+    if (result.success) {
+      logger.info(`[verifyAuthToken] \u2713 Token verified successfully for user: ${credentials.username || "unknown"}`);
+    } else {
+      logger.warn(`[verifyAuthToken] Token verification failed: ${result.error}`);
+    }
+    return result;
   } catch (error) {
-    logger.error("Failed to verify auth token:", error);
+    const errorMsg = error instanceof Error ? error.message : String(error);
+    logger.error(`[verifyAuthToken] Failed to verify auth token: ${errorMsg}`);
+    logger.debug("[verifyAuthToken] Token verification error details:", error);
     return {
       success: false,
       error: "Invalid token format"
@@ -1568,36 +1690,49 @@ function verifyAuthToken(authToken) {
 // src/handlers/auth-login-requests.ts
 async function handleAuthLoginRequest(data, sendMessage) {
   try {
+    logger.debug("[AUTH_LOGIN_REQ] Parsing incoming auth login request");
     const authRequest = AuthLoginRequestMessageSchema.parse(data);
     const { id, payload } = authRequest;
     const login_data = payload.login_data;
     const wsId = authRequest.from.id;
+    logger.info(`[AUTH_LOGIN_REQ ${id}] Processing auth login request from client: ${wsId}`);
+    logger.debug(`[AUTH_LOGIN_REQ ${id}] Login data present: ${!!login_data}`);
     if (!login_data) {
+      logger.error(`[AUTH_LOGIN_REQ ${id}] Login data not found in request`);
       sendDataResponse2(id, {
         success: false,
         error: "Login data not found"
       }, sendMessage, wsId);
       return;
     }
+    logger.debug(`[AUTH_LOGIN_REQ ${id}] Decoding base64 login data`);
     let loginData;
     try {
       loginData = decodeBase64ToJson(login_data);
+      logger.debug(`[AUTH_LOGIN_REQ ${id}] Login data decoded successfully`);
     } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      logger.error(`[AUTH_LOGIN_REQ ${id}] Failed to decode login data: ${errorMsg}`);
+      logger.debug(`[AUTH_LOGIN_REQ ${id}] Decode error details:`, error);
       sendDataResponse2(id, {
         success: false,
         error: "Invalid login data format"
       }, sendMessage, wsId);
       return;
     }
-    const { username, password } = loginData;
-    if (!username) {
+    const { username, email, password } = loginData;
+    const identifier = username || email;
+    logger.debug(`[AUTH_LOGIN_REQ ${id}] Validating credentials - username: ${username ? "\u2713" : "\u2717"}, email: ${email ? "\u2713" : "\u2717"}, password: ${password ? "\u2713" : "\u2717"}`);
+    if (!identifier) {
+      logger.error(`[AUTH_LOGIN_REQ ${id}] Username or email not found in login data`);
       sendDataResponse2(id, {
         success: false,
-        error: "Username not found in login data"
+        error: "Username or email is required"
       }, sendMessage, wsId);
       return;
     }
     if (!password) {
+      logger.error(`[AUTH_LOGIN_REQ ${id}] Password not found in login data`);
       sendDataResponse2(id, {
         success: false,
         error: "Password not found in login data"
@@ -1605,20 +1740,46 @@ async function handleAuthLoginRequest(data, sendMessage) {
       return;
     }
     if (!wsId) {
+      logger.error(`[AUTH_LOGIN_REQ ${id}] WebSocket ID not found in request`);
       sendDataResponse2(id, {
         success: false,
         error: "WebSocket ID not found"
       }, sendMessage, wsId);
       return;
     }
+    logger.info(`[AUTH_LOGIN_REQ ${id}] Credentials validated, authenticating user: ${identifier}`);
+    logger.debug(`[AUTH_LOGIN_REQ ${id}] WebSocket ID: ${wsId}`);
+    logger.debug(`[AUTH_LOGIN_REQ ${id}] Calling authenticateAndStoreWsId for user: ${identifier}`);
     const authResult = authenticateAndStoreWsId(
-      { username, password },
+      { username, email, password },
       wsId
     );
+    logger.info(`[AUTH_LOGIN_REQ ${id}] Authentication result for ${identifier}: ${authResult.success ? "success" : "failed"}`);
+    if (!authResult.success) {
+      logger.warn(`[AUTH_LOGIN_REQ ${id}] Authentication failed for ${identifier}: ${authResult.error}`);
+    } else {
+      logger.info(`[AUTH_LOGIN_REQ ${id}] User ${authResult.username || identifier} authenticated successfully`);
+    }
+    logger.debug(`[AUTH_LOGIN_REQ ${id}] Sending auth response to client`);
     sendDataResponse2(id, authResult, sendMessage, wsId);
+    logger.info(`[AUTH_LOGIN_REQ ${id}] ${authResult.success ? "\u2713" : "\u2717"} Auth login request completed`);
     return;
   } catch (error) {
-    logger.error("Failed to handle auth login request:", error);
+    const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
+    const errorStack = error instanceof Error ? error.stack : void 0;
+    logger.error(`[AUTH_LOGIN_REQ] Failed to handle auth login request: ${errorMessage}`);
+    logger.debug(`[AUTH_LOGIN_REQ] Error stack trace:`, errorStack);
+    try {
+      const parsedData = data;
+      if (parsedData?.id) {
+        sendDataResponse2(parsedData.id, {
+          success: false,
+          error: `Internal error: ${errorMessage}`
+        }, sendMessage, parsedData.from?.id);
+      }
+    } catch (sendError) {
+      logger.error("[AUTH_LOGIN_REQ] Failed to send error response:", sendError);
+    }
   }
 }
 function sendDataResponse2(id, res, sendMessage, clientId) {
@@ -1634,17 +1795,27 @@ function sendDataResponse2(id, res, sendMessage, clientId) {
       ...res
     }
   };
+  logger.debug(`[AUTH_LOGIN_RES ${id}] Sending ${res.success ? "successful" : "failed"} auth response to client: ${clientId}`);
+  logger.debug(`[AUTH_LOGIN_RES ${id}] Response payload size: ${JSON.stringify(response).length} bytes`);
+  if (res.error) {
+    logger.debug(`[AUTH_LOGIN_RES ${id}] Error message: ${res.error}`);
+  }
   sendMessage(response);
 }
 
 // src/handlers/auth-verify-request.ts
 async function handleAuthVerifyRequest(data, sendMessage) {
   try {
+    logger.debug("[AUTH_VERIFY_REQ] Parsing incoming auth verify request");
     const authRequest = AuthVerifyRequestMessageSchema.parse(data);
     const { id, payload } = authRequest;
     const token = payload.token;
     const wsId = authRequest.from.id;
+    logger.info(`[AUTH_VERIFY_REQ ${id}] Processing auth verify request from client: ${wsId}`);
+    logger.debug(`[AUTH_VERIFY_REQ ${id}] Token present: ${!!token}`);
+    logger.debug(`[AUTH_VERIFY_REQ ${id}] Token length: ${token ? token.length : 0} characters`);
     if (!token) {
+      logger.error(`[AUTH_VERIFY_REQ ${id}] Token not found in request`);
       sendDataResponse3(id, {
         success: false,
         error: "Token not found"
@@ -1652,17 +1823,45 @@ async function handleAuthVerifyRequest(data, sendMessage) {
       return;
     }
     if (!wsId) {
+      logger.error(`[AUTH_VERIFY_REQ ${id}] WebSocket ID not found in request`);
       sendDataResponse3(id, {
         success: false,
         error: "WebSocket ID not found"
       }, sendMessage, wsId);
       return;
     }
+    logger.info(`[AUTH_VERIFY_REQ ${id}] Token validation starting`);
+    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 verificationTime = Date.now() - startTime;
+    logger.info(`[AUTH_VERIFY_REQ ${id}] Token verification completed in ${verificationTime}ms - ${authResult.success ? "valid" : "invalid"}`);
+    if (!authResult.success) {
+      logger.warn(`[AUTH_VERIFY_REQ ${id}] Token verification failed: ${authResult.error}`);
+    } else {
+      logger.info(`[AUTH_VERIFY_REQ ${id}] Token verified successfully for user: ${authResult.data || "unknown"}`);
+    }
+    logger.debug(`[AUTH_VERIFY_REQ ${id}] Sending verification response to client`);
     sendDataResponse3(id, authResult, sendMessage, wsId);
+    logger.info(`[AUTH_VERIFY_REQ ${id}] ${authResult.success ? "\u2713" : "\u2717"} Auth verify request completed`);
     return;
   } catch (error) {
-    logger.error("Failed to handle auth verify request:", error);
+    const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
+    const errorStack = error instanceof Error ? error.stack : void 0;
+    logger.error(`[AUTH_VERIFY_REQ] Failed to handle auth verify request: ${errorMessage}`);
+    logger.debug(`[AUTH_VERIFY_REQ] Error stack trace:`, errorStack);
+    try {
+      const parsedData = data;
+      if (parsedData?.id) {
+        sendDataResponse3(parsedData.id, {
+          success: false,
+          error: `Internal error: ${errorMessage}`
+        }, sendMessage, parsedData.from?.id);
+      }
+    } catch (sendError) {
+      logger.error("[AUTH_VERIFY_REQ] Failed to send error response:", sendError);
+    }
   }
 }
 function sendDataResponse3(id, res, sendMessage, clientId) {
@@ -1678,6 +1877,14 @@ function sendDataResponse3(id, res, sendMessage, clientId) {
       ...res
     }
   };
+  logger.debug(`[AUTH_VERIFY_RES ${id}] Sending ${res.success ? "successful" : "failed"} verification response to client: ${clientId}`);
+  logger.debug(`[AUTH_VERIFY_RES ${id}] Response payload size: ${JSON.stringify(response).length} bytes`);
+  if (res.error) {
+    logger.debug(`[AUTH_VERIFY_RES ${id}] Error message: ${res.error}`);
+  }
+  if (res.data) {
+    logger.debug(`[AUTH_VERIFY_RES ${id}] User verified: ${res.data}`);
+  }
   sendMessage(response);
 }
 
@@ -1727,6 +1934,47 @@ function ensureQueryLimit(query, defaultLimit = 50) {
   }
   return trimmedQuery;
 }
+function fixScalarSubqueries(query) {
+  if (!query || query.trim().length === 0) {
+    return query;
+  }
+  let modifiedQuery = query;
+  let hasChanges = false;
+  const scalarOperatorPattern = /([=<>!]=?|<>)\s*\(\s*SELECT\s/gi;
+  const matches = [...modifiedQuery.matchAll(scalarOperatorPattern)];
+  for (let i = matches.length - 1; i >= 0; i--) {
+    const match = matches[i];
+    const startPos = match.index + match[0].length - "SELECT ".length;
+    let parenDepth = 1;
+    let endPos = startPos;
+    let foundEnd = false;
+    for (let j = startPos; j < modifiedQuery.length; j++) {
+      const char = modifiedQuery[j];
+      if (char === "(") parenDepth++;
+      if (char === ")") {
+        parenDepth--;
+        if (parenDepth === 0) {
+          endPos = j;
+          foundEnd = true;
+          break;
+        }
+      }
+    }
+    if (!foundEnd) continue;
+    const subquery = modifiedQuery.substring(startPos, endPos);
+    if (/\bLIMIT\s+\d+/i.test(subquery)) {
+      continue;
+    }
+    const fixedSubquery = subquery.trim() + " LIMIT 1";
+    modifiedQuery = modifiedQuery.substring(0, startPos) + fixedSubquery + modifiedQuery.substring(endPos);
+    hasChanges = true;
+    console.warn(`\u26A0\uFE0F  Fixed scalar subquery: added LIMIT 1 to prevent multiple row error`);
+  }
+  if (hasChanges) {
+    console.log("\u2713 Query validated and fixed for PostgreSQL scalar subquery compatibility");
+  }
+  return modifiedQuery;
+}
 
 // src/userResponse/schema.ts
 import path2 from "path";
@@ -1889,7 +2137,8 @@ var PromptLoader = class {
       "single-component",
       "mutli-component",
       "actions",
-      "container-metadata"
+      "container-metadata",
+      "text-response"
     ];
     for (const promptType of promptTypes) {
       try {
@@ -2241,7 +2490,9 @@ var BaseLLM = class {
         needsMultipleComponents: result.needsMultipleComponents || false
       };
     } catch (error) {
-      console.error("Error classifying user question:", error);
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      logger.error(`[${this.getProviderName()}] Error classifying user question: ${errorMsg}`);
+      logger.debug(`[${this.getProviderName()}] Classification error details:`, error);
       throw error;
     }
   }
@@ -2279,6 +2530,7 @@ var BaseLLM = class {
       );
       const props = result.props || originalProps;
       if (props && props.query) {
+        props.query = fixScalarSubqueries(props.query);
         props.query = ensureQueryLimit(props.query, this.defaultLimit);
       }
       if (props && props.query) {
@@ -2305,7 +2557,9 @@ var BaseLLM = class {
         modifications: result.modifications || []
       };
     } catch (error) {
-      console.error(`Error validating/modifying props with ${this.getProviderName()}:`, error);
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      logger.error(`[${this.getProviderName()}] Error validating/modifying props: ${errorMsg}`);
+      logger.debug(`[${this.getProviderName()}] Props validation error details:`, error);
       throw error;
     }
   }
@@ -2425,7 +2679,9 @@ var BaseLLM = class {
         isGenerated: true
       };
     } catch (error) {
-      console.error("Error generating analytical component:", error);
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      logger.error(`[${this.getProviderName()}] Error generating analytical component: ${errorMsg}`);
+      logger.debug(`[${this.getProviderName()}] Analytical component generation error details:`, error);
       throw error;
     }
   }
@@ -2467,7 +2723,9 @@ var BaseLLM = class {
         description: result.description || `Multi-component dashboard showing ${visualizationTypes.join(", ")}`
       };
     } catch (error) {
-      console.error("Error generating container metadata:", error);
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      logger.error(`[${this.getProviderName()}] Error generating container metadata: ${errorMsg}`);
+      logger.debug(`[${this.getProviderName()}] Container metadata error details:`, error);
       return {
         title: `${userPrompt} - Dashboard`,
         description: `Multi-component dashboard showing ${visualizationTypes.join(", ")}`
@@ -2519,24 +2777,24 @@ var BaseLLM = class {
         component = components[componentIndex - 1];
       }
       const matchedMsg = `${this.getProviderName()} matched component: ${component?.name || "None"}`;
-      console.log("\u2713", matchedMsg);
+      logger.info(`[${this.getProviderName()}] \u2713 ${matchedMsg}`);
       logCollector?.info(matchedMsg);
       if (result.alternativeMatches && result.alternativeMatches.length > 0) {
-        console.log("  Alternative matches:");
+        logger.debug(`[${this.getProviderName()}] Alternative matches found: ${result.alternativeMatches.length}`);
         const altMatches = result.alternativeMatches.map(
           (alt) => `${components[alt.index - 1]?.name} (${alt.score}%): ${alt.reason}`
         ).join(" | ");
         logCollector?.info(`Alternative matches: ${altMatches}`);
         result.alternativeMatches.forEach((alt) => {
-          console.log(`    - ${components[alt.index - 1]?.name} (${alt.score}%): ${alt.reason}`);
+          logger.debug(`[${this.getProviderName()}]   - ${components[alt.index - 1]?.name} (${alt.score}%): ${alt.reason}`);
         });
       }
       if (!component) {
         const noMatchMsg = `No matching component found (confidence: ${confidence}%)`;
-        console.log("\u2717", noMatchMsg);
+        logger.warn(`[${this.getProviderName()}] \u2717 ${noMatchMsg}`);
         logCollector?.warn(noMatchMsg);
         const genMsg = "Attempting to match component from analytical question...";
-        console.log("\u2713", genMsg);
+        logger.info(`[${this.getProviderName()}] \u2713 ${genMsg}`);
         logCollector?.info(genMsg);
         const generatedResult = await this.generateAnalyticalComponent(userPrompt, components, void 0, apiKey, logCollector, conversationHistory);
         if (generatedResult.component) {
@@ -2597,8 +2855,10 @@ var BaseLLM = class {
         confidence
       };
     } catch (error) {
-      console.error(`Error matching component with ${this.getProviderName()}:`, error);
-      logCollector?.error(`Error matching component: ${error.message}`);
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      logger.error(`[${this.getProviderName()}] Error matching component: ${errorMsg}`);
+      logger.debug(`[${this.getProviderName()}] Component matching error details:`, error);
+      logCollector?.error(`Error matching component: ${errorMsg}`);
       throw error;
     }
   }
@@ -2629,7 +2889,9 @@ var BaseLLM = class {
         isGenerated: true
       };
     } catch (error) {
-      console.error("Error matching multiple analytical components:", error);
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      logger.error(`[${this.getProviderName()}] Error matching multiple analytical components: ${errorMsg}`);
+      logger.debug(`[${this.getProviderName()}] Multiple components matching error details:`, error);
       return {
         components: [],
         reasoning: "Error occurred while matching components",
@@ -2708,17 +2970,91 @@ var BaseLLM = class {
         isGenerated: true
       };
     } catch (error) {
-      console.error("Error generating multi-component response:", error);
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      logger.error(`[${this.getProviderName()}] Error generating multi-component response: ${errorMsg}`);
+      logger.debug(`[${this.getProviderName()}] Multi-component response error details:`, error);
       throw error;
     }
   }
   /**
-   * Main orchestration function that classifies question and routes to appropriate handler
-   * This is the NEW recommended entry point for handling user requests
-   * ALWAYS returns a SINGLE component (wraps multiple in MultiComponentContainer)
+   * Generate text-based response for user question
+   * This provides conversational text responses instead of component generation
+   */
+  async generateTextResponse(userPrompt, apiKey, logCollector, conversationHistory) {
+    const errors = [];
+    logger.debug(`[${this.getProviderName()}] Starting text response generation`);
+    logger.debug(`[${this.getProviderName()}] User prompt: "${userPrompt.substring(0, 50)}..."`);
+    try {
+      const prompts = await promptLoader.loadPrompts("text-response", {
+        USER_PROMPT: userPrompt,
+        CONVERSATION_HISTORY: conversationHistory || "No previous conversation"
+      });
+      logger.debug(`[${this.getProviderName()}] Loaded text-response prompts`);
+      logger.debug(`[${this.getProviderName()}] System prompt length: ${prompts.system.length}, User prompt length: ${prompts.user.length}`);
+      logCollector?.info("Generating text response...");
+      const result = await LLM.stream(
+        {
+          sys: prompts.system,
+          user: prompts.user
+        },
+        {
+          model: this.model,
+          maxTokens: 1e3,
+          temperature: 0.7,
+          apiKey: this.getApiKey(apiKey)
+        },
+        true
+        // Parse as JSON
+      );
+      logger.info(`[${this.getProviderName()}] Text response generated successfully`);
+      logger.debug(`[${this.getProviderName()}] Response type: ${result.responseType}, Confidence: ${result.confidence}`);
+      logCollector?.info(`Text response: ${result.text?.substring(0, 100)}${result.text?.length > 100 ? "..." : ""}`);
+      logCollector?.logExplanation(
+        "Text response generated",
+        result.reasoning || "Generated text response for user question",
+        {
+          responseType: result.responseType,
+          confidence: result.confidence,
+          textLength: result.text?.length || 0
+        }
+      );
+      return {
+        success: true,
+        data: {
+          text: result.text || "I apologize, but I was unable to generate a response.",
+          responseType: result.responseType || "answer",
+          confidence: result.confidence || 0.5,
+          reasoning: result.reasoning || "No reasoning provided"
+        },
+        errors: []
+      };
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      logger.error(`[${this.getProviderName()}] Error generating text response: ${errorMsg}`);
+      logger.debug(`[${this.getProviderName()}] Text response generation error details:`, error);
+      logCollector?.error(`Error generating text response: ${errorMsg}`);
+      errors.push(errorMsg);
+      return {
+        success: false,
+        errors,
+        data: {
+          text: "I apologize, but I encountered an error while processing your question. Please try rephrasing or ask something else.",
+          responseType: "error",
+          confidence: 0,
+          reasoning: `Error: ${errorMsg}`
+        }
+      };
+    }
+  }
+  /**
+   * Generate component response for user question
+   * This provides conversational component suggestions based on user question
+   * Supports component generation and matching
    */
-  async handleUserRequest(userPrompt, components, apiKey, logCollector, conversationHistory) {
+  async generateComponentResponse(userPrompt, components, apiKey, logCollector, conversationHistory) {
+    const errors = [];
     try {
+      logger.info(`[${this.getProviderName()}] Using component response mode`);
       const classifyMsg = "Classifying user question...";
       logCollector?.info(classifyMsg);
       const classification = await this.classifyUserQuestion(userPrompt, apiKey, logCollector, conversationHistory);
@@ -2755,16 +3091,20 @@ var BaseLLM = class {
               logCollector?.warn(`Error matching component: ${settledResult.reason?.message || "Unknown error"}`);
             }
           }
-          console.log("matched components: after multi comp", matchedComponents.length);
+          logger.debug(`[${this.getProviderName()}] Matched ${matchedComponents.length} components for multi-component container`);
           if (matchedComponents.length === 0) {
             return {
-              component: null,
-              reasoning: "Failed to match any components for the requested visualization types",
-              method: "classification-multi-failed",
-              questionType: classification.questionType,
-              needsMultipleComponents: true,
-              propsModified: false,
-              queryModified: false
+              success: true,
+              data: {
+                component: null,
+                reasoning: "Failed to match any components for the requested visualization types",
+                method: "classification-multi-failed",
+                questionType: classification.questionType,
+                needsMultipleComponents: true,
+                propsModified: false,
+                queryModified: false
+              },
+              errors: []
             };
           }
           logCollector?.info("Generating container metadata...");
@@ -2794,38 +3134,50 @@ var BaseLLM = class {
           };
           logCollector?.info(`Created multi-component container with ${matchedComponents.length} components: "${containerMetadata.title}"`);
           return {
-            component: containerComponent,
-            reasoning: `Matched ${matchedComponents.length} components for visualization types: ${classification.visualizations.join(", ")}`,
-            method: "classification-multi-generated",
-            questionType: classification.questionType,
-            needsMultipleComponents: true,
-            propsModified: false,
-            queryModified: false
+            success: true,
+            data: {
+              component: containerComponent,
+              reasoning: `Matched ${matchedComponents.length} components for visualization types: ${classification.visualizations.join(", ")}`,
+              method: "classification-multi-generated",
+              questionType: classification.questionType,
+              needsMultipleComponents: true,
+              propsModified: false,
+              queryModified: false
+            },
+            errors: []
           };
         } else if (classification.visualizations.length === 1) {
           const vizType = classification.visualizations[0];
           logCollector?.info(`Matching single component for type: ${vizType}`);
           const result = await this.generateAnalyticalComponent(userPrompt, components, vizType, apiKey, logCollector, conversationHistory);
           return {
-            component: result.component,
-            reasoning: result.reasoning,
-            method: "classification-generated",
-            questionType: classification.questionType,
-            needsMultipleComponents: false,
-            propsModified: false,
-            queryModified: false
+            success: true,
+            data: {
+              component: result.component,
+              reasoning: result.reasoning,
+              method: "classification-generated",
+              questionType: classification.questionType,
+              needsMultipleComponents: false,
+              propsModified: false,
+              queryModified: false
+            },
+            errors: []
           };
         } else {
           logCollector?.info("No specific visualization type - matching from all components");
           const result = await this.generateAnalyticalComponent(userPrompt, components, void 0, apiKey, logCollector, conversationHistory);
           return {
-            component: result.component,
-            reasoning: result.reasoning,
-            method: "classification-generated-auto",
-            questionType: classification.questionType,
-            needsMultipleComponents: false,
-            propsModified: false,
-            queryModified: false
+            success: true,
+            data: {
+              component: result.component,
+              reasoning: result.reasoning,
+              method: "classification-generated-auto",
+              questionType: classification.questionType,
+              needsMultipleComponents: false,
+              propsModified: false,
+              queryModified: false
+            },
+            errors: []
           };
         }
       } else if (classification.questionType === "data_modification" || classification.questionType === "general") {
@@ -2833,28 +3185,109 @@ var BaseLLM = class {
         logCollector?.info(matchMsg);
         const matchResult = await this.matchComponent(userPrompt, components, apiKey, logCollector, conversationHistory);
         return {
-          component: matchResult.component,
-          reasoning: matchResult.reasoning,
-          method: "classification-matched",
-          questionType: classification.questionType,
-          needsMultipleComponents: false,
-          propsModified: matchResult.propsModified,
-          queryModified: matchResult.queryModified
+          success: true,
+          data: {
+            component: matchResult.component,
+            reasoning: matchResult.reasoning,
+            method: "classification-matched",
+            questionType: classification.questionType,
+            needsMultipleComponents: false,
+            propsModified: matchResult.propsModified,
+            queryModified: matchResult.queryModified
+          },
+          errors: []
         };
       } else {
         logCollector?.info("General question - no component needed");
         return {
-          component: null,
-          reasoning: "General question - no component needed",
-          method: "classification-general",
-          questionType: classification.questionType,
-          needsMultipleComponents: false
+          success: true,
+          data: {
+            component: null,
+            reasoning: "General question - no component needed",
+            method: "classification-general",
+            questionType: classification.questionType,
+            needsMultipleComponents: false,
+            propsModified: false,
+            queryModified: false
+          },
+          errors: []
         };
       }
     } catch (error) {
-      logCollector?.error(`Error handling user request: ${error.message}`);
-      throw error;
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      logger.error(`[${this.getProviderName()}] Error generating component response: ${errorMsg}`);
+      logger.debug(`[${this.getProviderName()}] Component response generation error details:`, error);
+      logCollector?.error(`Error generating component response: ${errorMsg}`);
+      errors.push(errorMsg);
+      return {
+        success: false,
+        errors,
+        data: void 0
+      };
+    }
+  }
+  /**
+   * Main orchestration function that classifies question and routes to appropriate handler
+   * This is the NEW recommended entry point for handling user requests
+   * Supports both component generation and text response modes
+   *
+   * @param responseMode - 'component' for component generation (default), 'text' for text responses
+   */
+  async handleUserRequest(userPrompt, components, apiKey, logCollector, conversationHistory, responseMode = "component") {
+    logger.info(`[${this.getProviderName()}] handleUserRequest called with responseMode: ${responseMode}`);
+    if (responseMode === "text") {
+      logger.info(`[${this.getProviderName()}] Using text response mode`);
+      logCollector?.info("Generating text response...");
+      const textResponse = await this.generateTextResponse(
+        userPrompt,
+        apiKey,
+        logCollector,
+        conversationHistory
+      );
+      if (!textResponse.success) {
+        logger.error(`[${this.getProviderName()}] Text response generation failed`);
+        return textResponse;
+      }
+      logger.info(`[${this.getProviderName()}] Text response generated successfully`);
+      return {
+        success: true,
+        data: {
+          textResponse: textResponse.data.text,
+          text: textResponse.data.text,
+          responseType: textResponse.data.responseType,
+          confidence: textResponse.data.confidence,
+          reasoning: textResponse.data.reasoning,
+          method: `${this.getProviderName()}-text-response`
+        },
+        errors: []
+      };
     }
+    const componentResponse = await this.generateComponentResponse(
+      userPrompt,
+      components,
+      apiKey,
+      logCollector,
+      conversationHistory
+    );
+    if (!componentResponse.success) {
+      logger.error(`[${this.getProviderName()}] Component response generation failed`);
+      return componentResponse;
+    }
+    logger.info(`[${this.getProviderName()}] Component response generated successfully`);
+    return {
+      success: true,
+      data: {
+        component: componentResponse.data.component,
+        reasoning: componentResponse.data.reasoning,
+        method: componentResponse.data.method,
+        // Preserve the original method name
+        questionType: componentResponse.data.questionType,
+        needsMultipleComponents: componentResponse.data.needsMultipleComponents,
+        propsModified: componentResponse.data.propsModified,
+        queryModified: componentResponse.data.queryModified
+      },
+      errors: []
+    };
   }
   /**
    * Generate next questions that the user might ask based on the original prompt and generated component
@@ -2900,8 +3333,10 @@ var BaseLLM = class {
       );
       return nextQuestions;
     } catch (error) {
-      console.error(`Error generating next questions with ${this.getProviderName()}:`, error);
-      logCollector?.error(`Error generating next questions: ${error.message}`);
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      logger.error(`[${this.getProviderName()}] Error generating next questions: ${errorMsg}`);
+      logger.debug(`[${this.getProviderName()}] Next questions generation error details:`, error);
+      logCollector?.error(`Error generating next questions: ${errorMsg}`);
       return [];
     }
   }
@@ -2965,112 +3400,130 @@ function getLLMProviders() {
     return DEFAULT_PROVIDERS;
   }
 }
-var useAnthropicMethod = async (prompt, components, apiKey, logCollector, conversationHistory) => {
-  const msg = "Using Anthropic Claude matching method...";
-  console.log(msg);
+var useAnthropicMethod = async (prompt, components, apiKey, logCollector, conversationHistory, responseMode = "component") => {
+  logger.debug("[useAnthropicMethod] Initializing Anthropic Claude matching method");
+  logger.debug(`[useAnthropicMethod] Response mode: ${responseMode}`);
+  const msg = `Using Anthropic Claude ${responseMode === "text" ? "text response" : "matching"} method...`;
   logCollector?.info(msg);
-  if (components.length === 0) {
+  if (responseMode === "component" && components.length === 0) {
     const emptyMsg = "Components not loaded in memory. Please ensure components are fetched first.";
+    logger.error("[useAnthropicMethod] No components available");
     logCollector?.error(emptyMsg);
-    return { success: false, reason: emptyMsg };
-  }
-  try {
-    const matchResult = await anthropicLLM.handleUserRequest(prompt, components, apiKey, logCollector, conversationHistory);
-    return { success: true, data: matchResult };
-  } catch (error) {
-    const errorMsg = error instanceof Error ? error.message : String(error);
-    logCollector?.error(`Anthropic method failed: ${errorMsg}`);
-    throw error;
+    return { success: false, errors: [emptyMsg] };
   }
+  logger.debug(`[useAnthropicMethod] Processing with ${components.length} components`);
+  const matchResult = await anthropicLLM.handleUserRequest(prompt, components, apiKey, logCollector, conversationHistory, responseMode);
+  logger.info(`[useAnthropicMethod] Successfully generated ${responseMode} using Anthropic`);
+  return matchResult;
 };
-var useGroqMethod = async (prompt, components, apiKey, logCollector, conversationHistory) => {
-  const msg = "Using Groq LLM matching method...";
-  console.log(msg);
+var useGroqMethod = async (prompt, components, apiKey, logCollector, conversationHistory, responseMode = "component") => {
+  logger.debug("[useGroqMethod] Initializing Groq LLM matching method");
+  logger.debug(`[useGroqMethod] Response mode: ${responseMode}`);
+  const msg = `Using Groq LLM ${responseMode === "text" ? "text response" : "matching"} method...`;
+  logger.info(msg);
   logCollector?.info(msg);
-  if (components.length === 0) {
+  if (responseMode === "component" && components.length === 0) {
     const emptyMsg = "Components not loaded in memory. Please ensure components are fetched first.";
+    logger.error("[useGroqMethod] No components available");
     logCollector?.error(emptyMsg);
-    return { success: false, reason: emptyMsg };
-  }
-  try {
-    const matchResult = await groqLLM.handleUserRequest(prompt, components, apiKey, logCollector, conversationHistory);
-    return { success: true, data: matchResult };
-  } catch (error) {
-    const errorMsg = error instanceof Error ? error.message : String(error);
-    logCollector?.error(`Groq method failed: ${errorMsg}`);
-    throw error;
+    return { success: false, errors: [emptyMsg] };
   }
+  logger.debug(`[useGroqMethod] Processing with ${components.length} components`);
+  const matchResult = await groqLLM.handleUserRequest(prompt, components, apiKey, logCollector, conversationHistory, responseMode);
+  logger.info(`[useGroqMethod] Successfully generated ${responseMode} using Groq`);
+  return matchResult;
 };
 var getUserResponseFromCache = async (prompt) => {
   return false;
 };
 var get_user_response = async (prompt, components, anthropicApiKey, groqApiKey, llmProviders, logCollector, conversationHistory) => {
+  const responseMode = "component";
+  logger.debug(`[get_user_response] Starting user response generation for prompt: "${prompt.substring(0, 50)}..."`);
+  logger.debug("[get_user_response] Checking cache for existing response");
   const userResponse = await getUserResponseFromCache(prompt);
   if (userResponse) {
+    logger.info("[get_user_response] User response found in cache - returning cached result");
     logCollector?.info("User response found in cache");
     return {
       success: true,
-      data: userResponse
+      data: userResponse,
+      errors: []
     };
   }
+  logger.debug("[get_user_response] No cached response found, proceeding with LLM providers");
   const providers = llmProviders || getLLMProviders();
   const errors = [];
   const providerOrder = providers.join(", ");
   logCollector?.info(`LLM Provider order: [${providerOrder}]`);
   if (conversationHistory && conversationHistory.length > 0) {
-    logCollector?.info(`Using conversation history with ${conversationHistory.split("\n").filter((l) => l.startsWith("Q")).length} previous exchanges`);
+    const exchangeCount = conversationHistory.split("\n").filter((l) => l.startsWith("Q")).length;
+    logger.debug(`[get_user_response] Using conversation history with ${exchangeCount} previous exchanges`);
+    logCollector?.info(`Using conversation history with ${exchangeCount} previous exchanges`);
+  } else {
+    logger.debug("[get_user_response] No conversation history available");
   }
   for (let i = 0; i < providers.length; i++) {
     const provider = providers[i];
     const isLastProvider = i === providers.length - 1;
-    try {
-      const attemptMsg = `Attempting provider: ${provider} (${i + 1}/${providers.length})`;
-      logCollector?.info(attemptMsg);
-      let result;
-      if (provider === "anthropic") {
-        result = await useAnthropicMethod(prompt, components, anthropicApiKey, logCollector, conversationHistory);
-      } else if (provider === "groq") {
-        result = await useGroqMethod(prompt, components, groqApiKey, logCollector, conversationHistory);
-      } else {
-        continue;
-      }
-      if (result.success) {
-        const successMsg = `Success with provider: ${provider}`;
-        logCollector?.info(successMsg);
-        return result;
-      } else {
-        errors.push({ provider, error: result.reason || "Unknown error" });
-        const warnMsg = `Provider ${provider} returned unsuccessful result: ${result.reason}`;
-        logCollector?.warn(warnMsg);
-      }
-    } catch (error) {
-      const errorMessage = error.message;
-      errors.push({ provider, error: errorMessage });
-      const errorMsg = `Provider ${provider} failed: ${errorMessage}`;
-      logCollector?.error(errorMsg);
+    const attemptMsg = `Attempting provider: ${provider} (${i + 1}/${providers.length})`;
+    logCollector?.info(attemptMsg);
+    let result;
+    if (provider === "anthropic") {
+      result = await useAnthropicMethod(prompt, components, anthropicApiKey, logCollector, conversationHistory, responseMode);
+    } else if (provider === "groq") {
+      result = await useGroqMethod(prompt, components, groqApiKey, logCollector, conversationHistory, responseMode);
+    } else {
+      logger.warn(`[get_user_response] Unknown provider: ${provider} - skipping`);
+      errors.push(`Unknown provider: ${provider}`);
+      continue;
+    }
+    if (result.success) {
+      const successMsg = `Success with provider: ${provider} result: ${JSON.stringify(result)}`;
+      logger.info(`${successMsg}`);
+      logCollector?.info(successMsg);
+      return result;
+    } else {
+      const providerErrors = result.errors.map((err) => `${provider}: ${err}`);
+      errors.push(...providerErrors);
+      const warnMsg = `Provider ${provider} returned unsuccessful result: ${result.errors.join(", ")}`;
+      logger.warn(`[get_user_response] ${warnMsg}`);
+      logCollector?.warn(warnMsg);
       if (!isLastProvider) {
         const fallbackMsg = "Falling back to next provider...";
+        logger.info(`[get_user_response] ${fallbackMsg}`);
         logCollector?.info(fallbackMsg);
-        continue;
       }
     }
   }
-  const errorSummary = errors.map((e) => `${e.provider}: ${e.error}`).join("; ");
-  const failureMsg = `All LLM providers failed. Errors: ${errorSummary}`;
-  logCollector?.error(failureMsg);
+  const failureMsg = `All LLM providers failed`;
+  logger.error(`[get_user_response] ${failureMsg}. Errors: ${errors.join("; ")}`);
+  logCollector?.error(`${failureMsg}. Errors: ${errors.join("; ")}`);
   return {
     success: false,
-    reason: failureMsg
+    errors
   };
 };
 
 // src/utils/log-collector.ts
+var LOG_LEVEL_PRIORITY2 = {
+  errors: 0,
+  warnings: 1,
+  info: 2,
+  verbose: 3
+};
+var MESSAGE_LEVEL_PRIORITY2 = {
+  error: 0,
+  warn: 1,
+  info: 2,
+  debug: 3
+};
 var UILogCollector = class {
   constructor(clientId, sendMessage, uiBlockId) {
     this.logs = [];
     this.uiBlockId = uiBlockId || null;
     this.clientId = clientId;
     this.sendMessage = sendMessage;
+    this.currentLogLevel = logger.getLogLevel();
   }
   /**
    * Check if logging is enabled (uiBlockId is provided)
@@ -3078,10 +3531,22 @@ var UILogCollector = class {
   isEnabled() {
     return this.uiBlockId !== null;
   }
+  /**
+   * Check if a message should be logged based on current log level
+   */
+  shouldLog(messageLevel) {
+    const currentLevelPriority = LOG_LEVEL_PRIORITY2[this.currentLogLevel];
+    const messagePriority = MESSAGE_LEVEL_PRIORITY2[messageLevel];
+    return messagePriority <= currentLevelPriority;
+  }
   /**
    * Add a log entry with timestamp and immediately send to runtime
+   * Only logs that pass the log level filter are captured and sent
    */
   addLog(level, message, type, data) {
+    if (!this.shouldLog(level)) {
+      return;
+    }
     const log = {
       timestamp: Date.now(),
       level,
@@ -3091,7 +3556,20 @@ var UILogCollector = class {
     };
     this.logs.push(log);
     this.sendLogImmediately(log);
-    console.log("UILogCollector:", log);
+    switch (level) {
+      case "error":
+        logger.error("UILogCollector:", log);
+        break;
+      case "warn":
+        logger.warn("UILogCollector:", log);
+        break;
+      case "info":
+        logger.info("UILogCollector:", log);
+        break;
+      case "debug":
+        logger.debug("UILogCollector:", log);
+        break;
+    }
   }
   /**
    * Send a single log to runtime immediately
@@ -3222,102 +3700,131 @@ var CONTEXT_CONFIG = {
 
 // src/handlers/user-prompt-request.ts
 var processedMessageIds = /* @__PURE__ */ new Set();
-async function handleUserPromptRequest(data, components, sendMessage, anthropicApiKey, groqApiKey, llmProviders) {
-  try {
-    const userPromptRequest = UserPromptRequestMessageSchema.parse(data);
-    const { id, payload } = userPromptRequest;
-    const prompt = payload.prompt;
-    const SA_RUNTIME = payload.SA_RUNTIME;
-    const wsId = userPromptRequest.from.id || "unknown";
-    logger.info(`[REQUEST ${id}] Processing user prompt: "${prompt.substring(0, 50)}..."`);
-    if (processedMessageIds.has(id)) {
-      logger.warn(`[REQUEST ${id}] Duplicate request detected - ignoring`);
-      return;
-    }
-    processedMessageIds.add(id);
-    if (processedMessageIds.size > 100) {
-      const firstId = processedMessageIds.values().next().value;
-      if (firstId) {
-        processedMessageIds.delete(firstId);
+var get_user_request = async (data, components, sendMessage, anthropicApiKey, groqApiKey, llmProviders) => {
+  const errors = [];
+  logger.debug("[USER_PROMPT_REQ] Parsing incoming message data");
+  const parseResult = UserPromptRequestMessageSchema.safeParse(data);
+  if (!parseResult.success) {
+    const zodError = parseResult.error;
+    zodError.errors.forEach((err) => {
+      errors.push(`${err.path.join(".")}: ${err.message}`);
+    });
+    return { success: false, errors };
+  }
+  const userPromptRequest = parseResult.data;
+  const { id, payload } = userPromptRequest;
+  const prompt = payload.prompt;
+  const SA_RUNTIME = payload.SA_RUNTIME;
+  const wsId = userPromptRequest.from.id || "unknown";
+  logger.debug(`[REQUEST ${id}] Full request details - wsId: ${wsId}, prompt length: ${prompt.length}`);
+  if (processedMessageIds.has(id)) {
+    logger.warn(`[REQUEST ${id}] Duplicate request detected - ignoring`);
+  }
+  processedMessageIds.add(id);
+  logger.debug(`[REQUEST ${id}] Message ID marked as processed (${processedMessageIds.size} total)`);
+  if (processedMessageIds.size > 100) {
+    const firstId = processedMessageIds.values().next().value;
+    if (firstId) {
+      processedMessageIds.delete(firstId);
+      logger.debug(`[REQUEST ${id}] Cleaned up old message ID from cache`);
+    }
+  }
+  if (!SA_RUNTIME) {
+    errors.push("SA_RUNTIME is required");
+  }
+  const threadId = SA_RUNTIME?.threadId;
+  const existingUiBlockId = SA_RUNTIME?.uiBlockId;
+  if (!threadId) {
+    errors.push("threadId in SA_RUNTIME is required");
+  }
+  if (!existingUiBlockId) {
+    errors.push("uiBlockId in SA_RUNTIME is required");
+  }
+  if (!prompt) {
+    errors.push("Prompt not found");
+  }
+  if (!components || components.length === 0) {
+    errors.push("Components not found");
+  }
+  if (errors.length > 0) {
+    return { success: false, errors, id, wsId };
+  }
+  const logCollector = new UILogCollector(wsId, sendMessage, existingUiBlockId);
+  const threadManager = ThreadManager.getInstance();
+  let thread = threadManager.getThread(threadId);
+  if (!thread) {
+    thread = threadManager.createThread(threadId);
+    logger.info(`Created new thread: ${threadId}`);
+  }
+  logCollector.info(`Starting user prompt request with ${components.length} components`);
+  const conversationHistory = thread.getConversationContext(CONTEXT_CONFIG.MAX_CONVERSATION_CONTEXT_BLOCKS, existingUiBlockId);
+  logger.info("conversationHistory", conversationHistory);
+  const userResponse = await get_user_response(prompt, components, anthropicApiKey, groqApiKey, llmProviders, logCollector, conversationHistory);
+  logger.info("llm userResponse", userResponse);
+  logCollector.info("User prompt request completed");
+  const uiBlockId = existingUiBlockId;
+  if (!userResponse.success) {
+    logger.error(`User prompt request failed with errors: ${userResponse.errors.join(", ")}`);
+    return {
+      success: false,
+      data: userResponse.data,
+      errors: userResponse.errors,
+      uiBlockId,
+      threadId,
+      id,
+      wsId
+    };
+  }
+  let component = null;
+  let textResponse = null;
+  if (userResponse.data) {
+    if (typeof userResponse.data === "object") {
+      if ("component" in userResponse.data) {
+        component = userResponse.data.component;
+      }
+      if ("textResponse" in userResponse.data) {
+        textResponse = userResponse.data.textResponse;
       }
     }
-    if (!SA_RUNTIME) {
-      sendDataResponse4(id, {
-        success: false,
-        error: "SA_RUNTIME is required"
-      }, sendMessage, wsId);
-      return;
-    }
-    const threadId = SA_RUNTIME.threadId;
-    const existingUiBlockId = SA_RUNTIME.uiBlockId;
-    if (!threadId) {
-      sendDataResponse4(id, {
-        success: false,
-        error: "threadId in SA_RUNTIME is required"
-      }, sendMessage, wsId);
-      return;
-    }
-    if (!existingUiBlockId) {
-      sendDataResponse4(id, {
-        success: false,
-        error: "uiBlockId in SA_RUNTIME is required"
-      }, sendMessage, wsId);
-      return;
-    }
-    const logCollector = new UILogCollector(wsId, sendMessage, existingUiBlockId);
-    if (!prompt) {
-      sendDataResponse4(id, {
-        success: false,
-        error: "Prompt not found"
-      }, sendMessage, wsId);
-      return;
-    }
-    if (!components || components.length === 0) {
-      sendDataResponse4(id, {
-        success: false,
-        error: "Components not found"
-      }, sendMessage, wsId);
-      return;
-    }
-    const threadManager = ThreadManager.getInstance();
-    let thread = threadManager.getThread(threadId);
-    if (!thread) {
-      thread = threadManager.createThread(threadId);
-      logger.info(`Created new thread: ${threadId}`);
-    }
-    logCollector.info(`Starting user prompt request with ${components.length} components`);
-    const conversationHistory = thread.getConversationContext(CONTEXT_CONFIG.MAX_CONVERSATION_CONTEXT_BLOCKS, existingUiBlockId);
-    logger.info("conversationHistory", conversationHistory);
-    const userResponse = await get_user_response(prompt, components, anthropicApiKey, groqApiKey, llmProviders, logCollector, conversationHistory);
-    logger.info("llm userResponse", userResponse);
-    logCollector.info("User prompt request completed");
-    if (userResponse.success && userResponse.data && typeof userResponse.data === "object" && "component" in userResponse.data) {
-      const component = userResponse.data.component;
-      const uiBlockId = existingUiBlockId;
-      const uiBlock = new UIBlock(
-        prompt,
-        {},
-        // componentData: initially empty, will be filled later
-        component || {},
-        // generatedComponentMetadata: full component object (ComponentSchema)
-        [],
-        // actions: empty initially
-        uiBlockId
-      );
-      thread.addUIBlock(uiBlock);
-      logger.info(`Created UIBlock: ${uiBlockId} in Thread: ${threadId}`);
-      sendDataResponse4(id, {
-        ...userResponse,
-        uiBlockId,
-        threadId
-      }, sendMessage, wsId);
-    } else {
-      sendDataResponse4(id, userResponse, sendMessage, wsId);
-    }
-    return;
-  } catch (error) {
-    logger.error("Failed to handle user prompt request:", error);
   }
+  const uiBlock = new UIBlock(
+    prompt,
+    {},
+    // componentData: initially empty, will be filled later
+    component,
+    // generatedComponentMetadata: full component object (ComponentSchema)
+    [],
+    // actions: empty initially
+    uiBlockId,
+    textResponse
+    // textResponse: text response from LLM
+  );
+  thread.addUIBlock(uiBlock);
+  logger.info(`Created UIBlock: ${uiBlockId} in Thread: ${threadId}`);
+  return {
+    success: userResponse.success,
+    data: userResponse.data,
+    errors: userResponse.errors,
+    uiBlockId,
+    threadId,
+    id,
+    wsId
+  };
+};
+async function handleUserPromptRequest(data, components, sendMessage, anthropicApiKey, groqApiKey, llmProviders) {
+  const response = await get_user_request(data, components, sendMessage, anthropicApiKey, groqApiKey, llmProviders);
+  sendDataResponse4(
+    response.id || data.id,
+    {
+      success: response.success,
+      errors: response.errors,
+      data: response.data,
+      uiBlockId: response.uiBlockId,
+      threadId: response.threadId
+    },
+    sendMessage,
+    response.wsId || data.from?.id
+  );
 }
 function sendDataResponse4(id, res, sendMessage, clientId) {
   const response = {
@@ -3430,12 +3937,27 @@ function sendResponse(id, res, sendMessage, clientId) {
 // src/userResponse/next-questions.ts
 async function generateNextQuestions(originalUserPrompt, component, componentData, anthropicApiKey, groqApiKey, llmProviders, logCollector, conversationHistory) {
   try {
+    logger.debug("[generateNextQuestions] Starting next questions generation");
+    logger.debug(`[generateNextQuestions] User prompt: "${originalUserPrompt?.substring(0, 50)}..."`);
+    logger.debug(`[generateNextQuestions] Component: ${component?.name || "unknown"} (${component?.type || "unknown"})`);
+    logger.debug(`[generateNextQuestions] Component data available: ${componentData ? "yes" : "no"}`);
     const providers = llmProviders || ["anthropic"];
-    for (const provider of providers) {
+    logger.info(`[generateNextQuestions] Using LLM providers: [${providers.join(", ")}]`);
+    if (conversationHistory && conversationHistory.length > 0) {
+      const exchangeCount = conversationHistory.split("\n").filter((l) => l.startsWith("Q")).length;
+      logger.debug(`[generateNextQuestions] Using conversation history with ${exchangeCount} previous exchanges`);
+    } else {
+      logger.debug("[generateNextQuestions] No conversation history available");
+    }
+    for (let i = 0; i < providers.length; i++) {
+      const provider = providers[i];
+      const isLastProvider = i === providers.length - 1;
       try {
-        logger.info(`Generating next questions using provider: ${provider}`);
+        logger.info(`[generateNextQuestions] Attempting provider: ${provider} (${i + 1}/${providers.length})`);
+        logCollector?.info(`Generating questions with ${provider}...`);
         let result = [];
         if (provider === "groq") {
+          logger.debug("[generateNextQuestions] Using Groq LLM for next questions");
           result = await groqLLM.generateNextQuestions(
             originalUserPrompt,
             component,
@@ -3445,6 +3967,7 @@ async function generateNextQuestions(originalUserPrompt, component, componentDat
             conversationHistory
           );
         } else {
+          logger.debug("[generateNextQuestions] Using Anthropic LLM for next questions");
           result = await anthropicLLM.generateNextQuestions(
             originalUserPrompt,
             component,
@@ -3455,21 +3978,39 @@ async function generateNextQuestions(originalUserPrompt, component, componentDat
           );
         }
         if (result && result.length > 0) {
-          logger.info(`Successfully generated ${result.length} questions with ${provider}`);
+          logger.info(`[generateNextQuestions] Successfully generated ${result.length} questions with ${provider}`);
+          logger.debug(`[generateNextQuestions] Questions: ${JSON.stringify(result)}`);
+          logCollector?.info(`Generated ${result.length} follow-up questions`);
           return result;
         }
-        logger.warn(`No questions generated from ${provider}, trying next provider...`);
+        const warnMsg = `No questions generated from ${provider}${!isLastProvider ? ", trying next provider..." : ""}`;
+        logger.warn(`[generateNextQuestions] ${warnMsg}`);
+        if (!isLastProvider) {
+          logCollector?.warn(warnMsg);
+        }
       } catch (providerError) {
-        logger.warn(`Provider ${provider} failed:`, providerError);
-        logCollector?.warn(`Provider ${provider} failed, trying next provider...`);
+        const errorMsg = providerError instanceof Error ? providerError.message : String(providerError);
+        logger.error(`[generateNextQuestions] Provider ${provider} failed: ${errorMsg}`);
+        logger.debug(`[generateNextQuestions] Provider error details:`, providerError);
+        if (!isLastProvider) {
+          const fallbackMsg = `Provider ${provider} failed, trying next provider...`;
+          logger.info(`[generateNextQuestions] ${fallbackMsg}`);
+          logCollector?.warn(fallbackMsg);
+        } else {
+          logCollector?.error(`Failed to generate questions with ${provider}`);
+        }
         continue;
       }
     }
-    logger.warn("All providers failed or returned no questions");
+    logger.warn("[generateNextQuestions] All providers failed or returned no questions");
+    logCollector?.warn("Unable to generate follow-up questions");
     return [];
   } catch (error) {
-    logger.error("Error generating next questions:", error);
-    logCollector?.error(`Error generating next questions: ${error.message}`);
+    const errorMsg = error instanceof Error ? error.message : String(error);
+    const errorStack = error instanceof Error ? error.stack : void 0;
+    logger.error(`[generateNextQuestions] Error generating next questions: ${errorMsg}`);
+    logger.debug("[generateNextQuestions] Error stack trace:", errorStack);
+    logCollector?.error(`Error generating next questions: ${errorMsg}`);
     return [];
   }
 }
@@ -3477,11 +4018,15 @@ async function generateNextQuestions(originalUserPrompt, component, componentDat
 // src/handlers/actions-request.ts
 async function handleActionsRequest(data, sendMessage, anthropicApiKey, groqApiKey, llmProviders) {
   try {
+    logger.debug("[ACTIONS_REQ] Parsing incoming actions request");
     const actionsRequest = ActionsRequestMessageSchema.parse(data);
     const { id, payload } = actionsRequest;
     const { SA_RUNTIME } = payload;
     const wsId = actionsRequest.from.id || "unknown";
+    logger.info(`[ACTIONS_REQ ${id}] Processing actions request from client: ${wsId}`);
+    logger.debug(`[ACTIONS_REQ ${id}] Request payload:`, JSON.stringify(payload, null, 2).substring(0, 200));
     if (!SA_RUNTIME) {
+      logger.error(`[ACTIONS_REQ ${id}] SA_RUNTIME missing from request`);
       sendResponse2(id, {
         success: false,
         error: "SA_RUNTIME with threadId and uiBlockId is required"
@@ -3490,31 +4035,54 @@ async function handleActionsRequest(data, sendMessage, anthropicApiKey, groqApiK
     }
     const uiBlockId = SA_RUNTIME.uiBlockId;
     const threadId = SA_RUNTIME.threadId;
+    logger.debug(`[ACTIONS_REQ ${id}] SA_RUNTIME validated - threadId: ${threadId}, uiBlockId: ${uiBlockId}`);
+    logger.debug(`[ACTIONS_REQ ${id}] Retrieving thread: ${threadId}`);
     const threadManager = ThreadManager.getInstance();
     const thread = threadManager.getThread(threadId);
     if (!thread) {
+      logger.error(`[ACTIONS_REQ ${id}] Thread '${threadId}' not found`);
       sendResponse2(id, {
         success: false,
         error: `Thread '${threadId}' not found`
       }, sendMessage, wsId);
       return;
     }
+    logger.debug(`[ACTIONS_REQ ${id}] Thread found with ${thread.getUIBlocks().length} UIBlocks`);
+    logger.debug(`[ACTIONS_REQ ${id}] Retrieving UIBlock: ${uiBlockId}`);
     const uiBlock = thread.getUIBlock(uiBlockId);
     if (!uiBlock) {
+      logger.error(`[ACTIONS_REQ ${id}] UIBlock '${uiBlockId}' not found in thread '${threadId}'`);
       sendResponse2(id, {
         success: false,
         error: `UIBlock '${uiBlockId}' not found in thread '${threadId}'`
       }, sendMessage, wsId);
       return;
     }
+    logger.info(`[ACTIONS_REQ ${id}] UIBlock retrieved successfully`);
+    logger.debug(`[ACTIONS_REQ ${id}] Creating UILogCollector for uiBlockId: ${uiBlockId}`);
     const logCollector = new UILogCollector(wsId, sendMessage, uiBlockId);
+    logger.info(`[ACTIONS_REQ ${id}] UILogCollector initialized`);
+    logger.debug(`[ACTIONS_REQ ${id}] Extracting data from UIBlock`);
     const userQuestion = uiBlock.getUserQuestion();
     const component = uiBlock.getComponentMetadata();
     const componentData = uiBlock.getComponentData();
+    logger.debug(`[ACTIONS_REQ ${id}] User question: "${userQuestion?.substring(0, 50)}..."`);
+    logger.debug(`[ACTIONS_REQ ${id}] Component: ${component?.name || "unknown"} (${component?.type || "unknown"})`);
+    logger.debug(`[ACTIONS_REQ ${id}] Component data available: ${componentData ? "yes" : "no"}`);
+    logger.debug(`[ACTIONS_REQ ${id}] Extracting conversation history (max ${CONTEXT_CONFIG.MAX_CONVERSATION_CONTEXT_BLOCKS} blocks)`);
     const conversationHistory = thread.getConversationContext(CONTEXT_CONFIG.MAX_CONVERSATION_CONTEXT_BLOCKS, uiBlockId);
+    const historyLineCount = conversationHistory.split("\n").filter((l) => l.trim()).length;
+    logger.info(`[ACTIONS_REQ ${id}] Conversation history extracted: ${historyLineCount} lines`);
+    logger.debug(`[ACTIONS_REQ ${id}] Conversation history preview:
+${conversationHistory.substring(0, 200)}...`);
     logCollector.info(`Generating actions for UIBlock: ${uiBlockId}`);
-    logger.info(`Generating actions for component: ${component?.name || "unknown"}`);
+    logger.info(`[ACTIONS_REQ ${id}] Generating actions for component: ${component?.name || "unknown"}`);
+    logger.debug(`[ACTIONS_REQ ${id}] Checking if actions are already cached`);
+    const startTime = Date.now();
     const actions = await uiBlock.getOrFetchActions(async () => {
+      logger.info(`[ACTIONS_REQ ${id}] Actions not cached, generating new actions...`);
+      logCollector.info("Generating follow-up questions...");
+      logger.info(`[ACTIONS_REQ ${id}] Starting next questions generation with ${llmProviders?.join(", ") || "default"} providers`);
       const nextQuestions = await generateNextQuestions(
         userQuestion,
         component,
@@ -3525,14 +4093,28 @@ async function handleActionsRequest(data, sendMessage, anthropicApiKey, groqApiK
         logCollector,
         conversationHistory
       );
-      return nextQuestions.map((question, index) => ({
+      logger.info(`[ACTIONS_REQ ${id}] Generated ${nextQuestions.length} questions`);
+      logger.debug(`[ACTIONS_REQ ${id}] Questions: ${JSON.stringify(nextQuestions)}`);
+      logger.debug(`[ACTIONS_REQ ${id}] Converting questions to actions format`);
+      const convertedActions = nextQuestions.map((question, index) => ({
         id: `action_${index}_${Date.now()}`,
         name: question,
         type: "next_question",
         question
       }));
+      logger.debug(`[ACTIONS_REQ ${id}] Converted ${convertedActions.length} actions`);
+      return convertedActions;
     });
-    logCollector.info(`Generated ${actions.length} actions successfully`);
+    const processingTime = Date.now() - startTime;
+    logger.info(`[ACTIONS_REQ ${id}] Actions retrieved in ${processingTime}ms - ${actions.length} actions total`);
+    if (actions.length > 0) {
+      logCollector.info(`Generated ${actions.length} follow-up questions successfully`);
+      logger.debug(`[ACTIONS_REQ ${id}] Actions: ${actions.map((a) => a.name).join(", ")}`);
+    } else {
+      logger.warn(`[ACTIONS_REQ ${id}] No actions generated`);
+      logCollector.warn("No follow-up questions could be generated");
+    }
+    logger.debug(`[ACTIONS_REQ ${id}] Sending successful response to client`);
     sendResponse2(id, {
       success: true,
       data: {
@@ -3543,12 +4125,26 @@ async function handleActionsRequest(data, sendMessage, anthropicApiKey, groqApiK
         threadId
       }
     }, sendMessage, wsId);
+    logger.info(`[ACTIONS_REQ ${id}] \u2713 Actions request completed successfully`);
   } catch (error) {
-    logger.error("Failed to handle actions request:", error);
+    const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
+    const errorStack = error instanceof Error ? error.stack : void 0;
+    logger.error(`[ACTIONS_REQ] Failed to handle actions request: ${errorMessage}`);
+    logger.debug(`[ACTIONS_REQ] Error stack trace:`, errorStack);
+    try {
+      const parsedData = data;
+      if (parsedData?.id && parsedData?.from?.id) {
+        const logCollector = parsedData?.payload?.SA_RUNTIME?.uiBlockId ? new UILogCollector(parsedData.from.id, sendMessage, parsedData.payload.SA_RUNTIME.uiBlockId) : void 0;
+        logCollector?.error(`Failed to generate actions: ${errorMessage}`);
+      }
+    } catch (logError) {
+      logger.debug("[ACTIONS_REQ] Failed to send error logs to UI:", logError);
+    }
     sendResponse2(null, {
       success: false,
-      error: error instanceof Error ? error.message : "Unknown error occurred"
+      error: errorMessage
     }, sendMessage);
+    logger.info("[ACTIONS_REQ] \u2717 Actions request completed with errors");
   }
 }
 function sendResponse2(id, res, sendMessage, clientId) {
@@ -3564,6 +4160,11 @@ function sendResponse2(id, res, sendMessage, clientId) {
       ...res
     }
   };
+  logger.debug(`[ACTIONS_RES ${id || "unknown"}] Sending ${res.success ? "successful" : "failed"} response to client`);
+  logger.debug(`[ACTIONS_RES ${id || "unknown"}] Response payload size: ${JSON.stringify(response).length} bytes`);
+  if (res.data?.actions) {
+    logger.debug(`[ACTIONS_RES ${id || "unknown"}] Sending ${res.data.actions.length} actions`);
+  }
   sendMessage(response);
 }
 
@@ -3592,7 +4193,10 @@ async function handleUsersRequest(data, sendMessage) {
     const { id, payload, from } = request;
     const { operation, data: requestData } = payload;
     const username = requestData?.username;
+    const email = requestData?.email;
     const password = requestData?.password;
+    const fullname = requestData?.fullname;
+    const role = requestData?.role;
     if (from.type !== "admin") {
       sendResponse3(id, {
         success: false,
@@ -3604,10 +4208,10 @@ async function handleUsersRequest(data, sendMessage) {
     const userManager = getUserManager();
     switch (operation) {
       case "create":
-        await handleCreate(id, username, password, userManager, sendMessage, from.id);
+        await handleCreate(id, { username, email, password, fullname, role }, userManager, sendMessage, from.id);
         break;
       case "update":
-        await handleUpdate(id, username, password, userManager, sendMessage, from.id);
+        await handleUpdate(id, { username, email, password, fullname, role }, userManager, sendMessage, from.id);
         break;
       case "delete":
         await handleDelete(id, username, userManager, sendMessage, from.id);
@@ -3632,7 +4236,8 @@ async function handleUsersRequest(data, sendMessage) {
     }, sendMessage);
   }
 }
-async function handleCreate(id, username, password, userManager, sendMessage, clientId) {
+async function handleCreate(id, userData, userManager, sendMessage, clientId) {
+  const { username, email, password, fullname, role } = userData;
   if (!username || username.trim().length === 0) {
     sendResponse3(id, {
       success: false,
@@ -3647,6 +4252,16 @@ async function handleCreate(id, username, password, userManager, sendMessage, cl
     }, sendMessage, clientId);
     return;
   }
+  if (email && email.trim().length > 0) {
+    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+    if (!emailRegex.test(email)) {
+      sendResponse3(id, {
+        success: false,
+        error: "Invalid email format"
+      }, sendMessage, clientId);
+      return;
+    }
+  }
   if (userManager.userExists(username)) {
     sendResponse3(id, {
       success: false,
@@ -3654,25 +4269,41 @@ async function handleCreate(id, username, password, userManager, sendMessage, cl
     }, sendMessage, clientId);
     return;
   }
-  let wsIds = [];
-  if (clientId) {
-    wsIds.push(clientId);
+  if (email && userManager.getUserByEmail(email)) {
+    sendResponse3(id, {
+      success: false,
+      error: `User with email '${email}' already exists`
+    }, sendMessage, clientId);
+    return;
   }
-  const newUser = userManager.createUser({
+  const newUserData = {
     username,
-    password,
-    wsIds
-  });
-  logger.info(`User created by admin: ${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`
     }
   }, sendMessage, clientId);
 }
-async function handleUpdate(id, username, password, userManager, 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,
@@ -3688,13 +4319,42 @@ async function handleUpdate(id, username, password, userManager, sendMessage, cl
     return;
   }
   const updates = {};
-  if (password && password.trim().length > 0) {
-    updates.password = password;
+  if (email !== void 0) {
+    if (email.trim().length > 0) {
+      const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+      if (!emailRegex.test(email)) {
+        sendResponse3(id, {
+          success: false,
+          error: "Invalid email format"
+        }, sendMessage, clientId);
+        return;
+      }
+      const existingUser = userManager.getUserByEmail(email);
+      if (existingUser && existingUser.username !== username) {
+        sendResponse3(id, {
+          success: false,
+          error: `Email '${email}' is already used by another user`
+        }, sendMessage, clientId);
+        return;
+      }
+      updates.email = email.trim();
+    } else {
+      updates.email = void 0;
+    }
+  }
+  if (password !== void 0 && password.trim().length > 0) {
+    updates.password = password.trim();
+  }
+  if (fullname !== void 0) {
+    updates.fullname = fullname.trim().length > 0 ? fullname.trim() : void 0;
+  }
+  if (role !== void 0) {
+    updates.role = role.trim().length > 0 ? role.trim() : void 0;
   }
   if (Object.keys(updates).length === 0) {
     sendResponse3(id, {
       success: false,
-      error: "No fields to update. Please provide password or other valid fields."
+      error: "No fields to update. Please provide at least one field to update."
     }, sendMessage, clientId);
     return;
   }
@@ -3704,6 +4364,9 @@ async function handleUpdate(id, username, password, userManager, sendMessage, cl
     success: true,
     data: {
       username: updatedUser.username,
+      email: updatedUser.email,
+      fullname: updatedUser.fullname,
+      role: updatedUser.role,
       message: `User '${username}' updated successfully`
     }
   }, sendMessage, clientId);
@@ -3744,6 +4407,9 @@ async function handleGetAll(id, userManager, sendMessage, clientId) {
   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(`Admin retrieved all users (count: ${sanitizedUsers.length})`);
@@ -3774,6 +4440,9 @@ async function handleGetOne(id, username, userManager, sendMessage, clientId) {
   const user = userManager.getUser(username);
   const sanitizedUser = {
     username: user.username,
+    email: user.email,
+    fullname: user.fullname,
+    role: user.role,
     wsIds: user.wsIds || []
   };
   logger.info(`Admin retrieved user: ${username}`);
@@ -4272,8 +4941,9 @@ var UserManager = class {
         return;
       }
       const fileContent = fs4.readFileSync(this.filePath, "utf-8");
-      const data = JSON.parse(fileContent);
-      this.users = Array.isArray(data.users) ? data.users : [];
+      const rawData = JSON.parse(fileContent);
+      const validatedData = UsersDataSchema.parse(rawData);
+      this.users = validatedData.users;
       this.hasChanged = false;
       logger.debug(`Loaded ${this.users.length} users from file`);
     } catch (error) {
@@ -4293,10 +4963,14 @@ var UserManager = class {
       if (!fs4.existsSync(dir)) {
         fs4.mkdirSync(dir, { recursive: true });
       }
-      const data = { users: this.users };
+      const usersToSave = this.users.map((user) => {
+        const { wsIds, ...userWithoutWsIds } = user;
+        return userWithoutWsIds;
+      });
+      const data = { users: usersToSave };
       fs4.writeFileSync(this.filePath, JSON.stringify(data, null, 4));
       this.hasChanged = false;
-      logger.debug(`Synced ${this.users.length} users to file`);
+      logger.debug(`Synced ${this.users.length} users to file (wsIds excluded)`);
     } catch (error) {
       logger.error("Failed to save users to file:", error);
       throw new Error(`Failed to save users to file: ${error instanceof Error ? error.message : "Unknown error"}`);
@@ -4343,13 +5017,17 @@ var UserManager = class {
    * @returns The created user
    */
   createUser(user) {
-    if (this.users.some((u) => u.username === user.username)) {
-      throw new Error(`User with username ${user.username} already exists`);
+    const validatedUser = UserSchema.parse(user);
+    if (this.users.some((u) => u.username === validatedUser.username)) {
+      throw new Error(`User with username ${validatedUser.username} already exists`);
+    }
+    if (validatedUser.email && this.users.some((u) => u.email === validatedUser.email)) {
+      throw new Error(`User with email ${validatedUser.email} already exists`);
     }
-    this.users.push(user);
+    this.users.push(validatedUser);
     this.hasChanged = true;
-    logger.debug(`User created: ${user.username}`);
-    return user;
+    logger.debug(`User created: ${validatedUser.username}`);
+    return validatedUser;
   }
   /**
    * Read a user by username
@@ -4359,6 +5037,22 @@ var UserManager = class {
   getUser(username) {
     return this.users.find((u) => u.username === username);
   }
+  /**
+   * Read a user by email
+   * @param email - Email to retrieve
+   * @returns The user if found, undefined otherwise
+   */
+  getUserByEmail(email) {
+    return this.users.find((u) => u.email === email);
+  }
+  /**
+   * Find user by username or email
+   * @param identifier - Username or email to search for
+   * @returns The user if found, undefined otherwise
+   */
+  getUserByUsernameOrEmail(identifier) {
+    return this.users.find((u) => u.username === identifier || u.email === identifier);
+  }
   /**
    * Read all users
    * @returns Array of all users
@@ -4447,7 +5141,6 @@ var UserManager = class {
     }
     if (!user.wsIds.includes(wsId)) {
       user.wsIds.push(wsId);
-      this.hasChanged = true;
       logger.debug(`WebSocket ID added to user ${username}: ${wsId}`);
     }
     return true;
@@ -4469,7 +5162,6 @@ var UserManager = class {
     const initialLength = user.wsIds.length;
     user.wsIds = user.wsIds.filter((id) => id !== wsId);
     if (user.wsIds.length < initialLength) {
-      this.hasChanged = true;
       logger.debug(`WebSocket ID removed from user ${username}: ${wsId}`);
     }
     return true;
@@ -5019,6 +5711,9 @@ var SuperatomSDK = class {
     this.maxReconnectAttempts = 5;
     this.collections = {};
     this.components = [];
+    if (config.logLevel) {
+      logger.setLogLevel(config.logLevel);
+    }
     this.apiKey = config.apiKey;
     this.projectId = config.projectId;
     this.userId = config.userId || "anonymous";
@@ -5321,6 +6016,7 @@ export {
   ThreadManager,
   UIBlock,
   UILogCollector,
-  UserManager
+  UserManager,
+  logger
 };
 //# sourceMappingURL=index.mjs.map