@superatomai/sdk-node 0.0.4 → 0.0.6

package/dist/index.mjs

@@ -10,9 +10,16 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
   if (typeof require !== "undefined") return require.apply(this, arguments);
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
 var __commonJS = (cb, mod) => function __require2() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
@@ -102,7 +109,7 @@ var require_package = __commonJS({
 var require_main = __commonJS({
   "node_modules/dotenv/lib/main.js"(exports, module) {
     "use strict";
-    var fs7 = __require("fs");
+    var fs8 = __require("fs");
     var path7 = __require("path");
     var os4 = __require("os");
     var crypto2 = __require("crypto");
@@ -244,7 +251,7 @@ var require_main = __commonJS({
       if (options && options.path && options.path.length > 0) {
         if (Array.isArray(options.path)) {
           for (const filepath of options.path) {
-            if (fs7.existsSync(filepath)) {
+            if (fs8.existsSync(filepath)) {
               possibleVaultPath = filepath.endsWith(".vault") ? filepath : `${filepath}.vault`;
             }
           }
@@ -254,7 +261,7 @@ var require_main = __commonJS({
       } else {
         possibleVaultPath = path7.resolve(process.cwd(), ".env.vault");
       }
-      if (fs7.existsSync(possibleVaultPath)) {
+      if (fs8.existsSync(possibleVaultPath)) {
         return possibleVaultPath;
       }
       return null;
@@ -307,7 +314,7 @@ var require_main = __commonJS({
       const parsedAll = {};
       for (const path8 of optionPaths) {
         try {
-          const parsed = DotenvModule.parse(fs7.readFileSync(path8, { encoding }));
+          const parsed = DotenvModule.parse(fs8.readFileSync(path8, { encoding }));
           DotenvModule.populate(parsedAll, parsed, options);
         } catch (e) {
           if (debug) {
@@ -428,6 +435,128 @@ var require_main = __commonJS({
   }
 });
 
+// src/userResponse/utils.ts
+var utils_exports = {};
+__export(utils_exports, {
+  convertTopToLimit: () => convertTopToLimit,
+  ensureQueryLimit: () => ensureQueryLimit,
+  fixScalarSubqueries: () => fixScalarSubqueries,
+  getJsonSizeInBytes: () => getJsonSizeInBytes,
+  validateMessageSize: () => validateMessageSize
+});
+function convertTopToLimit(query) {
+  if (!query || query.trim().length === 0) {
+    return query;
+  }
+  let modifiedQuery = query.replace(/\bSELECT\s+TOP\s+(\d+)\b/gi, "SELECT");
+  if (modifiedQuery !== query) {
+    console.warn(`\u26A0\uFE0F  Query had TOP syntax. Converting to LIMIT for Snowflake compatibility.`);
+  }
+  return modifiedQuery;
+}
+function ensureQueryLimit(query, defaultLimit = 32, maxLimit = 32) {
+  if (!query || query.trim().length === 0) {
+    return query;
+  }
+  let trimmedQuery = query.trim();
+  const isSelectQuery = /^\s*SELECT\b/i.test(trimmedQuery) || /^\s*WITH\b.*\bSELECT\b/is.test(trimmedQuery);
+  if (!isSelectQuery) {
+    return query;
+  }
+  trimmedQuery = convertTopToLimit(trimmedQuery);
+  const hadSemicolon = trimmedQuery.endsWith(";");
+  if (hadSemicolon) {
+    trimmedQuery = trimmedQuery.slice(0, -1).trim();
+  }
+  const limitMatches = trimmedQuery.match(/\bLIMIT\s+(\d+)\b/gi);
+  if (limitMatches && limitMatches.length > 0) {
+    if (limitMatches.length > 1) {
+      console.warn(`\u26A0\uFE0F  Query had ${limitMatches.length} LIMIT clauses. Removing duplicates...`);
+      trimmedQuery = trimmedQuery.replace(/\s*\bLIMIT\s+\d+\b/gi, "").trim();
+    } else {
+      const existingLimitMatch = trimmedQuery.match(/\bLIMIT\s+(\d+)\b/i);
+      if (existingLimitMatch) {
+        const existingLimit = parseInt(existingLimitMatch[1], 10);
+        if (existingLimit <= maxLimit) {
+          if (hadSemicolon) {
+            trimmedQuery += ";";
+          }
+          return trimmedQuery;
+        }
+        console.warn(`\u26A0\uFE0F  Query LIMIT ${existingLimit} exceeds maximum of ${maxLimit}. Reducing to ${maxLimit}...`);
+        trimmedQuery = trimmedQuery.replace(/\bLIMIT\s+\d+\b/i, `LIMIT ${maxLimit}`);
+        if (hadSemicolon) {
+          trimmedQuery += ";";
+        }
+        return trimmedQuery;
+      }
+    }
+  }
+  trimmedQuery = `${trimmedQuery} LIMIT ${defaultLimit}`;
+  if (hadSemicolon) {
+    trimmedQuery += ";";
+  }
+  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;
+}
+function getJsonSizeInBytes(obj) {
+  const jsonString = JSON.stringify(obj);
+  return Buffer.byteLength(jsonString, "utf8");
+}
+function validateMessageSize(message, maxSize = 1048576) {
+  const size = getJsonSizeInBytes(message);
+  return {
+    isValid: size <= maxSize,
+    size,
+    maxSize
+  };
+}
+var init_utils = __esm({
+  "src/userResponse/utils.ts"() {
+    "use strict";
+  }
+});
+
 // src/websocket.ts
 import WebSocket from "ws";
 function createWebSocket(url) {
@@ -624,6 +753,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()
@@ -677,7 +818,8 @@ var UserPromptRequestPayloadSchema = z3.object({
   SA_RUNTIME: z3.object({
     threadId: z3.string(),
     uiBlockId: z3.string()
-  }).optional()
+  }).optional(),
+  responseMode: z3.enum(["component", "text"]).optional()
 });
 var UserPromptRequestMessageSchema = z3.object({
   id: z3.string(),
@@ -724,7 +866,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({
@@ -789,21 +934,97 @@ var ReportsRequestMessageSchema = z3.object({
 });
 
 // src/utils/logger.ts
+import fs from "fs";
 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 LOGSTREAM = fs.createWriteStream("superatom-sdk.log", { flags: "a" });
+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);
+    }
+  }
+  file(...args) {
+    LOGSTREAM.write(args.join(" ") + "\n");
   }
 };
+var logger = new Logger();
 
 // src/threads/uiblock.ts
 import { randomUUID } from "crypto";
@@ -838,13 +1059,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();
   }
   /**
@@ -871,6 +1094,9 @@ var UIBlock = class {
   getComponentMetadata() {
     return this.generatedComponentMetadata;
   }
+  getTextResponse() {
+    return this.textResponse || "";
+  }
   /**
    * Set or update component metadata
    */
@@ -963,6 +1189,12 @@ var UIBlock = class {
     const processedData = this.processDataForStorage(data);
     this.componentData = { ...this.componentData, ...processedData };
   }
+  /**
+   * Set or update text response
+   */
+  setTextResponse(textResponse) {
+    this.textResponse = textResponse;
+  }
   /**
    * Get all actions (only if they are resolved, not if fetching)
    */
@@ -1046,6 +1278,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()
@@ -1146,8 +1379,11 @@ var Thread = class {
       const questionNum = index + 1;
       const question = block.getUserQuestion();
       const metadata = block.getComponentMetadata();
-      let componentSummary = "No component generated";
-      if (metadata && Object.keys(metadata).length > 0) {
+      const textResponse = block.getTextResponse();
+      let assistantResponse = "";
+      const hasComponent = metadata && Object.keys(metadata).length > 0 && metadata.type;
+      const hasTextResponse = textResponse && textResponse.trim().length > 0;
+      if (hasComponent) {
         const parts = [];
         if (metadata.type) {
           parts.push(`Component Type: ${metadata.type}`);
@@ -1167,11 +1403,17 @@ var Thread = class {
           const componentTypes = metadata.props.config.components.map((c) => c.type).join(", ");
           parts.push(`Multi-component with: ${componentTypes}`);
         }
-        componentSummary = parts.join(", ");
+        assistantResponse = parts.join(", ");
+      } else if (hasTextResponse) {
+        assistantResponse = textResponse;
+      } else {
+        assistantResponse = "No response generated";
       }
-      contextLines.push(`Q${questionNum}: ${question}`);
-      contextLines.push(`A${questionNum}: ${componentSummary}`);
-      contextLines.push("");
+      contextLines.push(`User:
+ ${question}`);
+      contextLines.push(`Assistant:
+ ${assistantResponse}`);
+      contextLines.push("---");
     });
     return contextLines.join("\n").trim();
   }
@@ -1347,7 +1589,7 @@ function sendDataResponse(id, collection, op, data, meta, sendMessage) {
 }
 
 // src/bundle.ts
-import * as fs from "fs";
+import * as fs2 from "fs";
 import * as path from "path";
 function getBundleDir(configDir) {
   const bundleDir = configDir || process.env.SA_BUNDLE_DIR;
@@ -1360,16 +1602,16 @@ function getBundleDir(configDir) {
 }
 function getJS(bundleDir) {
   try {
-    if (!fs.existsSync(bundleDir)) {
+    if (!fs2.existsSync(bundleDir)) {
       throw new Error(`Bundle directory does not exist: ${bundleDir}`);
     }
-    const stats = fs.statSync(bundleDir);
+    const stats = fs2.statSync(bundleDir);
     if (!stats.isDirectory()) {
       throw new Error(`Bundle path is not a directory: ${bundleDir}`);
     }
     let files;
     try {
-      files = fs.readdirSync(bundleDir);
+      files = fs2.readdirSync(bundleDir);
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
       throw new Error(`Failed to read bundle directory: ${errorMessage}`);
@@ -1384,7 +1626,7 @@ function getJS(bundleDir) {
     const filePath = path.join(bundleDir, indexFile);
     logger.info(`Loading bundle from ${filePath}`);
     try {
-      return fs.readFileSync(filePath, "utf8");
+      return fs2.readFileSync(filePath, "utf8");
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
       throw new Error(`Failed to read bundle file: ${errorMessage}`);
@@ -1480,9 +1722,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 +1746,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 +1831,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 +1881,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 +1936,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 +1964,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,59 +2018,26 @@ 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);
 }
 
 // src/userResponse/groq.ts
 var import_dotenv = __toESM(require_main());
 
-// src/userResponse/utils.ts
-function convertTopToLimit(query) {
-  if (!query || query.trim().length === 0) {
-    return query;
-  }
-  let modifiedQuery = query.replace(/\bSELECT\s+TOP\s+(\d+)\b/gi, "SELECT");
-  if (modifiedQuery !== query) {
-    console.warn(`\u26A0\uFE0F  Query had TOP syntax. Converting to LIMIT for Snowflake compatibility.`);
-  }
-  return modifiedQuery;
-}
-function ensureQueryLimit(query, defaultLimit = 50) {
-  if (!query || query.trim().length === 0) {
-    return query;
-  }
-  let trimmedQuery = query.trim();
-  const isSelectQuery = /^\s*SELECT\b/i.test(trimmedQuery) || /^\s*WITH\b.*\bSELECT\b/is.test(trimmedQuery);
-  if (!isSelectQuery) {
-    return query;
-  }
-  trimmedQuery = convertTopToLimit(trimmedQuery);
-  const hadSemicolon = trimmedQuery.endsWith(";");
-  if (hadSemicolon) {
-    trimmedQuery = trimmedQuery.slice(0, -1).trim();
-  }
-  const limitMatches = trimmedQuery.match(/\bLIMIT\s+\d+\b/gi);
-  if (limitMatches && limitMatches.length > 0) {
-    if (limitMatches.length > 1) {
-      console.warn(`\u26A0\uFE0F  Query had ${limitMatches.length} LIMIT clauses. Removing duplicates...`);
-      trimmedQuery = trimmedQuery.replace(/\s*\bLIMIT\s+\d+\b/gi, "").trim();
-    } else {
-      if (hadSemicolon) {
-        trimmedQuery += ";";
-      }
-      return trimmedQuery;
-    }
-  }
-  trimmedQuery = `${trimmedQuery} LIMIT ${defaultLimit}`;
-  if (hadSemicolon) {
-    trimmedQuery += ";";
-  }
-  return trimmedQuery;
-}
+// src/userResponse/base-llm.ts
+init_utils();
 
 // src/userResponse/schema.ts
 import path2 from "path";
-import fs2 from "fs";
+import fs3 from "fs";
 var Schema = class {
   constructor(schemaFilePath) {
     this.cachedSchema = null;
@@ -1744,11 +2051,11 @@ var Schema = class {
     logger.info(`SCHEMA_FILE_PATH: ${this.schemaFilePath}`);
     try {
       const dir = path2.dirname(this.schemaFilePath);
-      if (!fs2.existsSync(dir)) {
+      if (!fs3.existsSync(dir)) {
         logger.info(`Creating directory structure: ${dir}`);
-        fs2.mkdirSync(dir, { recursive: true });
+        fs3.mkdirSync(dir, { recursive: true });
       }
-      if (!fs2.existsSync(this.schemaFilePath)) {
+      if (!fs3.existsSync(this.schemaFilePath)) {
         logger.info(`Schema file does not exist at ${this.schemaFilePath}, creating with empty schema`);
         const initialSchema = {
           database: "",
@@ -1757,11 +2064,11 @@ var Schema = class {
           tables: [],
           relationships: []
         };
-        fs2.writeFileSync(this.schemaFilePath, JSON.stringify(initialSchema, null, 4));
+        fs3.writeFileSync(this.schemaFilePath, JSON.stringify(initialSchema, null, 4));
         this.cachedSchema = initialSchema;
         return initialSchema;
       }
-      const fileContent = fs2.readFileSync(this.schemaFilePath, "utf-8");
+      const fileContent = fs3.readFileSync(this.schemaFilePath, "utf-8");
       const schema2 = JSON.parse(fileContent);
       this.cachedSchema = schema2;
       return schema2;
@@ -1862,7 +2169,7 @@ var Schema = class {
 var schema = new Schema();
 
 // src/userResponse/prompt-loader.ts
-import fs3 from "fs";
+import fs4 from "fs";
 import path3 from "path";
 var PromptLoader = class {
   constructor(config) {
@@ -1889,7 +2196,9 @@ var PromptLoader = class {
       "single-component",
       "mutli-component",
       "actions",
-      "container-metadata"
+      "container-metadata",
+      "text-response",
+      "match-text-components"
     ];
     for (const promptType of promptTypes) {
       try {
@@ -1914,9 +2223,9 @@ var PromptLoader = class {
       try {
         const systemPath = path3.join(dir, promptName, "system.md");
         const userPath = path3.join(dir, promptName, "user.md");
-        if (fs3.existsSync(systemPath) && fs3.existsSync(userPath)) {
-          const system = fs3.readFileSync(systemPath, "utf-8");
-          const user = fs3.readFileSync(userPath, "utf-8");
+        if (fs4.existsSync(systemPath) && fs4.existsSync(userPath)) {
+          const system = fs4.readFileSync(systemPath, "utf-8");
+          const user = fs4.readFileSync(userPath, "utf-8");
           logger.debug(`Loaded prompt '${promptName}' from ${dir}`);
           return { system, user };
         }
@@ -2038,6 +2347,14 @@ var LLM = class {
       throw new Error(`Unsupported provider: ${provider}. Use "anthropic" or "groq"`);
     }
   }
+  /* Stream response with tool calling support (Anthropic only for now) */
+  static async streamWithTools(messages, tools, toolHandler, options = {}, maxIterations = 3) {
+    const [provider, modelName] = this._parseModel(options.model);
+    if (provider !== "anthropic") {
+      throw new Error(`Tool calling is only supported for Anthropic models`);
+    }
+    return this._anthropicStreamWithTools(messages, tools, toolHandler, modelName, options, maxIterations);
+  }
   // ============================================================
   // PRIVATE HELPER METHODS
   // ============================================================
@@ -2115,6 +2432,86 @@ var LLM = class {
     }
     return fullText;
   }
+  static async _anthropicStreamWithTools(messages, tools, toolHandler, modelName, options, maxIterations) {
+    const apiKey = options.apiKey || process.env.ANTHROPIC_API_KEY || "";
+    const client = new Anthropic({
+      apiKey
+    });
+    const conversationMessages = [{
+      role: "user",
+      content: messages.user
+    }];
+    let iterations = 0;
+    let finalText = "";
+    while (iterations < maxIterations) {
+      iterations++;
+      const response = await client.messages.create({
+        model: modelName,
+        max_tokens: options.maxTokens || 4e3,
+        temperature: options.temperature,
+        system: messages.sys,
+        messages: conversationMessages,
+        tools
+      });
+      if (response.stop_reason === "end_turn") {
+        const textBlock = response.content.find((block) => block.type === "text");
+        if (textBlock && textBlock.type === "text") {
+          finalText = textBlock.text;
+          if (options.partial) {
+            options.partial(finalText);
+          }
+        }
+        break;
+      }
+      if (response.stop_reason === "tool_use") {
+        const toolUses = response.content.filter((block) => block.type === "tool_use");
+        if (toolUses.length === 0) {
+          break;
+        }
+        conversationMessages.push({
+          role: "assistant",
+          content: response.content
+        });
+        const toolResults = {
+          role: "user",
+          content: []
+        };
+        for (const toolUse of toolUses) {
+          if (toolUse.type === "tool_use") {
+            try {
+              const result = await toolHandler(toolUse.name, toolUse.input);
+              toolResults.content.push({
+                type: "tool_result",
+                tool_use_id: toolUse.id,
+                content: typeof result === "string" ? result : JSON.stringify(result)
+              });
+            } catch (error) {
+              toolResults.content.push({
+                type: "tool_result",
+                tool_use_id: toolUse.id,
+                content: error instanceof Error ? error.message : String(error),
+                is_error: true
+              });
+            }
+          }
+        }
+        conversationMessages.push(toolResults);
+      } else {
+        const textBlock = response.content.find((block) => block.type === "text");
+        if (textBlock && textBlock.type === "text") {
+          finalText = textBlock.text;
+          if (options.partial) {
+            options.partial(finalText);
+          }
+        }
+        break;
+      }
+    }
+    if (iterations >= maxIterations) {
+      throw new Error(`Max iterations (${maxIterations}) reached in tool calling loop`);
+    }
+    return finalText;
+  }
   // ============================================================
   // GROQ IMPLEMENTATION
   // ============================================================
@@ -2241,7 +2638,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 +2678,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 +2705,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 +2827,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 +2871,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 +2925,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 +3003,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 +3037,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,63 +3118,538 @@ 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)
+   * Match components from text response suggestions
+   * Takes a text response with component suggestions (c1:type format) and matches with available components
+   * @param textResponse - The text response containing component suggestions
+   * @param components - List of available components
+   * @param apiKey - Optional API key
+   * @param logCollector - Optional log collector
+   * @returns Object containing matched components, selected layout, and reasoning
    */
-  async handleUserRequest(userPrompt, components, apiKey, logCollector, conversationHistory) {
+  async matchComponentsFromTextResponse(textResponse, components, apiKey, logCollector) {
     try {
-      const classifyMsg = "Classifying user question...";
-      logCollector?.info(classifyMsg);
-      const classification = await this.classifyUserQuestion(userPrompt, apiKey, logCollector, conversationHistory);
-      const classInfo = `Question type: ${classification.questionType}, Visualizations: ${classification.visualizations.join(", ") || "None"}, Multiple components: ${classification.needsMultipleComponents}`;
-      logCollector?.info(classInfo);
-      if (classification.questionType === "analytical") {
-        if (classification.visualizations.length > 1) {
-          const multiMsg = `Matching ${classification.visualizations.length} components for types: ${classification.visualizations.join(", ")}`;
-          logCollector?.info(multiMsg);
-          const componentPromises = classification.visualizations.map((vizType) => {
-            logCollector?.info(`Matching component for type: ${vizType}`);
-            return this.generateAnalyticalComponent(
-              userPrompt,
-              components,
-              vizType,
-              apiKey,
-              logCollector,
-              conversationHistory
-            ).then((result) => ({ vizType, result }));
-          });
-          const settledResults = await Promise.allSettled(componentPromises);
-          const matchedComponents = [];
-          for (const settledResult of settledResults) {
-            if (settledResult.status === "fulfilled") {
-              const { vizType, result } = settledResult.value;
-              if (result.component) {
-                matchedComponents.push(result.component);
-                logCollector?.info(`Matched: ${result.component.name}`);
-                logger.info("Component : ", result.component.name, " props: ", result.component.props);
-              } else {
-                logCollector?.warn(`Failed to match component for type: ${vizType}`);
-              }
-            } else {
-              logCollector?.warn(`Error matching component: ${settledResult.reason?.message || "Unknown error"}`);
-            }
+      logger.debug(`[${this.getProviderName()}] Starting component matching from text response`);
+      let availableComponentsText = "No components available";
+      if (components && components.length > 0) {
+        availableComponentsText = components.map((comp, idx) => {
+          const keywords = comp.keywords ? comp.keywords.join(", ") : "";
+          const propsPreview = comp.props ? JSON.stringify(comp.props, null, 2) : "No props";
+          return `${idx + 1}. ID: ${comp.id}
+   Name: ${comp.name}
+   Type: ${comp.type}
+   Description: ${comp.description || "No description"}
+   Keywords: ${keywords}
+   Props Structure: ${propsPreview}`;
+        }).join("\n\n");
+      }
+      const schemaDoc = schema.generateSchemaDocumentation();
+      const prompts = await promptLoader.loadPrompts("match-text-components", {
+        TEXT_RESPONSE: textResponse,
+        AVAILABLE_COMPONENTS: availableComponentsText,
+        SCHEMA_DOC: schemaDoc
+      });
+      logger.debug(`[${this.getProviderName()}] Loaded match-text-components prompts`);
+      logger.file("\n=============================\nmatch text components system prompt:", prompts.system);
+      logCollector?.info("Matching components from text response...");
+      const rawResponse = await LLM.stream(
+        {
+          sys: prompts.system,
+          user: prompts.user
+        },
+        {
+          model: this.model,
+          maxTokens: 3e3,
+          temperature: 0.2,
+          apiKey: this.getApiKey(apiKey)
+        },
+        false
+        // Don't parse as JSON yet, get raw response
+      );
+      logger.debug(`[${this.getProviderName()}] Raw component matching response length: ${rawResponse?.length || 0}`);
+      logger.file(`[${this.getProviderName()}] Component matching raw response:`, rawResponse);
+      let result;
+      try {
+        let cleanedResponse = rawResponse || "";
+        cleanedResponse = cleanedResponse.replace(/```json\n?/g, "").replace(/```\n?/g, "").trim();
+        const jsonMatch = cleanedResponse.match(/\{[\s\S]*\}/);
+        if (jsonMatch) {
+          cleanedResponse = jsonMatch[0];
+        }
+        result = JSON.parse(cleanedResponse);
+      } catch (parseError) {
+        logger.error(`[${this.getProviderName()}] Failed to parse component matching JSON response`);
+        const errorMsg = parseError instanceof Error ? parseError.message : String(parseError);
+        const posMatch = errorMsg.match(/position (\d+)/);
+        const errorPos = posMatch ? parseInt(posMatch[1]) : -1;
+        if (errorPos > 0 && rawResponse) {
+          const start = Math.max(0, errorPos - 200);
+          const end = Math.min(rawResponse.length, errorPos + 200);
+          logger.debug(`[${this.getProviderName()}] Error context (position ${errorPos}):`);
+          logger.debug(rawResponse.substring(start, end));
+          logger.debug(" ".repeat(Math.min(200, errorPos - start)) + "^--- Error here");
+        }
+        logger.debug(`[${this.getProviderName()}] Raw response (first 2000 chars):`, rawResponse?.substring(0, 2e3));
+        logger.debug(`[${this.getProviderName()}] Parse error:`, parseError);
+        logCollector?.error(`Failed to parse component matching response: ${errorMsg}`);
+        try {
+          logger.info(`[${this.getProviderName()}] Attempting aggressive JSON cleanup...`);
+          let aggressive = rawResponse || "";
+          aggressive = aggressive.replace(/```json\n?/g, "").replace(/```\n?/g, "").trim();
+          const match = aggressive.match(/\{[\s\S]*\}/);
+          if (match) {
+            aggressive = match[0];
           }
-          console.log("matched components: after multi comp", matchedComponents.length);
+          aggressive = aggressive.replace(/,(\s*[}\]])/g, "$1");
+          result = JSON.parse(aggressive);
+          logger.info(`[${this.getProviderName()}] Aggressive cleanup succeeded!`);
+        } catch (secondError) {
+          logger.error(`[${this.getProviderName()}] Aggressive cleanup also failed`);
+          return {
+            components: [],
+            selectedLayout: "MultiComponentContainer",
+            selectedLayoutId: "",
+            selectedLayoutComponent: null,
+            layoutReasoning: "No layout selected"
+          };
+        }
+      }
+      const matchedComponents = result.matchedComponents || [];
+      const selectedLayout = result.selectedLayout || "MultiComponentContainer";
+      const selectedLayoutId = result.selectedLayoutId || "";
+      const layoutReasoning = result.layoutReasoning || "No layout reasoning provided";
+      let selectedLayoutComponent = null;
+      if (selectedLayoutId) {
+        selectedLayoutComponent = components.find((c) => c.id === selectedLayoutId) || null;
+        if (!selectedLayoutComponent) {
+          logger.warn(`[${this.getProviderName()}] Layout component ${selectedLayoutId} not found in available components`);
+        }
+      }
+      logger.info(`[${this.getProviderName()}] Matched ${matchedComponents.length} components from text response`);
+      logger.info(`[${this.getProviderName()}] Selected layout: ${selectedLayout} (ID: ${selectedLayoutId})`);
+      logger.info(`[${this.getProviderName()}] Layout reasoning: ${layoutReasoning}`);
+      if (matchedComponents.length > 0) {
+        logCollector?.info(`Matched ${matchedComponents.length} components for visualization using ${selectedLayout}`);
+        logCollector?.info(`Layout reasoning: ${layoutReasoning}`);
+        matchedComponents.forEach((comp, idx) => {
+          logCollector?.info(`  ${idx + 1}. ${comp.componentName} (${comp.componentType}): ${comp.reasoning}`);
+          if (comp.props?.query) {
+            logCollector?.logQuery(
+              `Component ${idx + 1} query`,
+              comp.props.query,
+              { componentName: comp.componentName, title: comp.props.title }
+            );
+          }
+        });
+      }
+      const finalComponents = matchedComponents.map((mc) => {
+        const originalComponent = components.find((c) => c.id === mc.componentId);
+        if (!originalComponent) {
+          logger.warn(`[${this.getProviderName()}] Component ${mc.componentId} not found in available components`);
+          return null;
+        }
+        return {
+          ...originalComponent,
+          props: {
+            ...originalComponent.props,
+            ...mc.props
+          }
+        };
+      }).filter(Boolean);
+      return {
+        components: finalComponents,
+        selectedLayout,
+        selectedLayoutId,
+        selectedLayoutComponent,
+        layoutReasoning
+      };
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      logger.error(`[${this.getProviderName()}] Error matching components from text response: ${errorMsg}`);
+      logger.debug(`[${this.getProviderName()}] Component matching error details:`, error);
+      logCollector?.error(`Error matching components: ${errorMsg}`);
+      return {
+        components: [],
+        selectedLayout: "MultiComponentContainer",
+        selectedLayoutId: "",
+        selectedLayoutComponent: null,
+        layoutReasoning: "Error occurred during component matching"
+      };
+    }
+  }
+  /**
+   * Generate text-based response for user question
+   * This provides conversational text responses instead of component generation
+   * Supports tool calling for query execution with automatic retry on errors (max 3 attempts)
+   * After generating text response, if components are provided, matches suggested components
+   * @param streamCallback - Optional callback function to receive text chunks as they stream
+   * @param collections - Collection registry for executing database queries via database.execute
+   * @param components - Optional list of available components for matching suggestions
+   */
+  async generateTextResponse(userPrompt, apiKey, logCollector, conversationHistory, streamCallback, collections, components) {
+    const errors = [];
+    logger.debug(`[${this.getProviderName()}] Starting text response generation`);
+    logger.debug(`[${this.getProviderName()}] User prompt: "${userPrompt.substring(0, 50)}..."`);
+    try {
+      const schemaDoc = schema.generateSchemaDocumentation();
+      const prompts = await promptLoader.loadPrompts("text-response", {
+        USER_PROMPT: userPrompt,
+        CONVERSATION_HISTORY: conversationHistory || "No previous conversation",
+        SCHEMA_DOC: schemaDoc
+      });
+      logger.file("\n=============================\nsystem prompt:", prompts.system);
+      logger.file("\n=============================\nuser prompt:", prompts.user);
+      logger.debug(`[${this.getProviderName()}] Loaded text-response prompts with schema`);
+      logger.debug(`[${this.getProviderName()}] System prompt length: ${prompts.system.length}, User prompt length: ${prompts.user.length}`);
+      logCollector?.info("Generating text response with query execution capability...");
+      const tools = [{
+        name: "execute_query",
+        description: "Executes a SQL query against the database and returns the results. Use this when the user asks for data. If the query fails, you will receive the error and can retry with a corrected query.",
+        input_schema: {
+          type: "object",
+          properties: {
+            query: {
+              type: "string",
+              description: "The SQL query to execute. Must be valid SQL syntax using table and column names from the schema."
+            },
+            reasoning: {
+              type: "string",
+              description: "Brief explanation of what this query does and why it answers the user's question."
+            }
+          },
+          required: ["query"]
+        }
+      }];
+      const queryAttempts = /* @__PURE__ */ new Map();
+      const MAX_QUERY_ATTEMPTS = 6;
+      let maxAttemptsReached = false;
+      let fullStreamedText = "";
+      const wrappedStreamCallback = streamCallback ? (chunk) => {
+        fullStreamedText += chunk;
+        streamCallback(chunk);
+      } : void 0;
+      const toolHandler = async (toolName, toolInput) => {
+        if (toolName === "execute_query") {
+          let query = toolInput.query;
+          const reasoning = toolInput.reasoning;
+          const { ensureQueryLimit: ensureQueryLimit2 } = await Promise.resolve().then(() => (init_utils(), utils_exports));
+          query = ensureQueryLimit2(query, 32, 32);
+          const queryKey = query.toLowerCase().replace(/\s+/g, " ").trim();
+          const attempts = (queryAttempts.get(queryKey) || 0) + 1;
+          queryAttempts.set(queryKey, attempts);
+          logger.info(`[${this.getProviderName()}] Executing query (attempt ${attempts}/${MAX_QUERY_ATTEMPTS}): ${query.substring(0, 100)}...`);
+          if (reasoning) {
+            logCollector?.info(`Query reasoning: ${reasoning}`);
+          }
+          if (attempts > MAX_QUERY_ATTEMPTS) {
+            const errorMsg = `Maximum query attempts (${MAX_QUERY_ATTEMPTS}) reached. Unable to generate a valid query for your question.`;
+            logger.error(`[${this.getProviderName()}] ${errorMsg}`);
+            logCollector?.error(errorMsg);
+            maxAttemptsReached = true;
+            if (wrappedStreamCallback) {
+              wrappedStreamCallback(`
+
+\u274C ${errorMsg}
+
+Please try rephrasing your question or simplifying your request.
+
+`);
+            }
+            throw new Error(errorMsg);
+          }
+          try {
+            if (wrappedStreamCallback) {
+              if (attempts === 1) {
+                wrappedStreamCallback(`
+
+\u{1F50D} **Analyzing your question...**
+
+`);
+                if (reasoning) {
+                  wrappedStreamCallback(`\u{1F4AD} ${reasoning}
+
+`);
+                }
+                wrappedStreamCallback(`\u{1F4DD} **Generated SQL Query:**
+\`\`\`sql
+${query}
+\`\`\`
+
+`);
+                wrappedStreamCallback(`\u26A1 **Executing query...**
+
+`);
+              } else {
+                wrappedStreamCallback(`
+
+\u{1F504} **Retrying with corrected query (attempt ${attempts}/${MAX_QUERY_ATTEMPTS})...**
+
+`);
+                if (reasoning) {
+                  wrappedStreamCallback(`\u{1F4AD} ${reasoning}
+
+`);
+                }
+                wrappedStreamCallback(`\u{1F4DD} **Corrected SQL Query:**
+\`\`\`sql
+${query}
+\`\`\`
+
+`);
+                wrappedStreamCallback(`\u26A1 **Executing query...**
+
+`);
+              }
+            }
+            logCollector?.logQuery(
+              `Executing SQL query (attempt ${attempts})`,
+              query,
+              { reasoning, attempt: attempts }
+            );
+            if (!collections || !collections["database"] || !collections["database"]["execute"]) {
+              throw new Error("Database collection not registered. Please register database.execute collection to execute queries.");
+            }
+            const result2 = await collections["database"]["execute"]({ sql: query });
+            const data = result2?.data || result2;
+            const rowCount = result2?.count ?? (Array.isArray(data) ? data.length : "N/A");
+            logger.info(`[${this.getProviderName()}] Query executed successfully, rows returned: ${rowCount}`);
+            logCollector?.info(`Query successful, returned ${rowCount} rows`);
+            if (wrappedStreamCallback) {
+              wrappedStreamCallback(`\u2705 **Query executed successfully!**
+
+`);
+              if (Array.isArray(data) && data.length > 0) {
+                const firstRow = data[0];
+                const columns = Object.keys(firstRow);
+                if (data.length === 1 && columns.length === 1) {
+                  const value = firstRow[columns[0]];
+                  wrappedStreamCallback(`**Result:** ${value}
+
+`);
+                } else if (data.length > 0) {
+                  wrappedStreamCallback(`**Retrieved ${rowCount} rows**
+
+`);
+                  wrappedStreamCallback(`<DataTable>${JSON.stringify(data)}</DataTable>
+
+`);
+                }
+              } else if (Array.isArray(data) && data.length === 0) {
+                wrappedStreamCallback(`**No rows returned.**
+
+`);
+              }
+              wrappedStreamCallback(`\u{1F4CA} **Analyzing results...**
+
+`);
+            }
+            return JSON.stringify(data, null, 2);
+          } catch (error) {
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            logger.error(`[${this.getProviderName()}] Query execution failed (attempt ${attempts}/${MAX_QUERY_ATTEMPTS}): ${errorMsg}`);
+            logCollector?.error(`Query failed (attempt ${attempts}/${MAX_QUERY_ATTEMPTS}): ${errorMsg}`);
+            if (wrappedStreamCallback) {
+              wrappedStreamCallback(`\u274C **Query execution failed:**
+\`\`\`
+${errorMsg}
+\`\`\`
+
+`);
+              if (attempts < MAX_QUERY_ATTEMPTS) {
+                wrappedStreamCallback(`\u{1F527} **Generating corrected query...**
+
+`);
+              }
+            }
+            throw new Error(`Query execution failed: ${errorMsg}`);
+          }
+        }
+        throw new Error(`Unknown tool: ${toolName}`);
+      };
+      const result = await LLM.streamWithTools(
+        {
+          sys: prompts.system,
+          user: prompts.user
+        },
+        tools,
+        toolHandler,
+        {
+          model: this.model,
+          maxTokens: 4e3,
+          temperature: 0.7,
+          apiKey: this.getApiKey(apiKey),
+          partial: wrappedStreamCallback
+          // Pass the wrapped streaming callback to LLM
+        },
+        10
+        // max iterations: allows for 6 retries + final response + buffer
+      );
+      logger.info(`[${this.getProviderName()}] Text response stream completed`);
+      const textResponse = fullStreamedText || result || "I apologize, but I was unable to generate a response.";
+      if (maxAttemptsReached) {
+        logger.warn(`[${this.getProviderName()}] Max query attempts reached, returning failure response`);
+        logCollector?.error("Failed to generate valid query after maximum attempts");
+        return {
+          success: false,
+          errors: [`Maximum query attempts (${MAX_QUERY_ATTEMPTS}) reached. Unable to generate a valid query for your question.`],
+          data: {
+            text: textResponse,
+            // Include the streamed text showing all attempts
+            matchedComponents: [],
+            method: `${this.getProviderName()}-text-response-max-attempts`
+          }
+        };
+      }
+      logCollector?.info(`Text response: ${textResponse.substring(0, 100)}${textResponse.length > 100 ? "..." : ""}`);
+      logCollector?.logExplanation(
+        "Text response generated",
+        "Generated plain text response with component suggestions",
+        {
+          textLength: textResponse.length
+        }
+      );
+      let matchedComponents = [];
+      let selectedLayoutComponent = null;
+      let layoutReasoning = "No layout selected";
+      if (components && components.length > 0) {
+        logger.info(`[${this.getProviderName()}] Matching components from text response...`);
+        const matchResult = await this.matchComponentsFromTextResponse(
+          textResponse,
+          components,
+          apiKey,
+          logCollector
+        );
+        matchedComponents = matchResult.components;
+        selectedLayoutComponent = matchResult.selectedLayoutComponent;
+        layoutReasoning = matchResult.layoutReasoning;
+      }
+      let container_componet = null;
+      if (matchedComponents.length > 0) {
+        if (selectedLayoutComponent) {
+          container_componet = {
+            ...selectedLayoutComponent,
+            id: `${selectedLayoutComponent.id}_${Date.now()}`,
+            description: layoutReasoning,
+            props: {
+              ...selectedLayoutComponent.props,
+              config: {
+                ...selectedLayoutComponent.props?.config || {},
+                components: matchedComponents
+              }
+            }
+          };
+          logger.info(`[${this.getProviderName()}] Created ${selectedLayoutComponent.name} (${selectedLayoutComponent.type}) container with ${matchedComponents.length} components`);
+          logCollector?.info(`Created ${selectedLayoutComponent.name} with ${matchedComponents.length} components: ${layoutReasoning}`);
+        } else {
+          container_componet = {
+            id: `multi_container_${Date.now()}`,
+            name: "MultiComponentContainer",
+            type: "Container",
+            description: layoutReasoning,
+            category: "dynamic",
+            keywords: ["dashboard", "layout", "container"],
+            props: {
+              config: {
+                components: matchedComponents
+              }
+            }
+          };
+          logger.info(`[${this.getProviderName()}] Created fallback MultiComponentContainer with ${matchedComponents.length} components`);
+          logCollector?.info(`Created MultiComponentContainer with ${matchedComponents.length} components: ${layoutReasoning}`);
+        }
+      }
+      return {
+        success: true,
+        data: {
+          text: textResponse,
+          matchedComponents,
+          component: container_componet,
+          layoutReasoning,
+          method: `${this.getProviderName()}-text-response`
+        },
+        errors: []
+      };
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      logger.error(`[${this.getProviderName()}] Error generating text response: ${errorMsg}`);
+      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.",
+          matchedComponents: [],
+          method: `${this.getProviderName()}-text-response-error`
+        }
+      };
+    }
+  }
+  /**
+   * Generate component response for user question
+   * This provides conversational component suggestions based on user question
+   * Supports component generation and matching
+   */
+  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);
+      const classInfo = `Question type: ${classification.questionType}, Visualizations: ${classification.visualizations.join(", ") || "None"}, Multiple components: ${classification.needsMultipleComponents}`;
+      logCollector?.info(classInfo);
+      if (classification.questionType === "analytical") {
+        if (classification.visualizations.length > 1) {
+          const multiMsg = `Matching ${classification.visualizations.length} components for types: ${classification.visualizations.join(", ")}`;
+          logCollector?.info(multiMsg);
+          const componentPromises = classification.visualizations.map((vizType) => {
+            logCollector?.info(`Matching component for type: ${vizType}`);
+            return this.generateAnalyticalComponent(
+              userPrompt,
+              components,
+              vizType,
+              apiKey,
+              logCollector,
+              conversationHistory
+            ).then((result) => ({ vizType, result }));
+          });
+          const settledResults = await Promise.allSettled(componentPromises);
+          const matchedComponents = [];
+          for (const settledResult of settledResults) {
+            if (settledResult.status === "fulfilled") {
+              const { vizType, result } = settledResult.value;
+              if (result.component) {
+                matchedComponents.push(result.component);
+                logCollector?.info(`Matched: ${result.component.name}`);
+                logger.info("Component : ", result.component.name, " props: ", result.component.props);
+              } else {
+                logCollector?.warn(`Failed to match component for type: ${vizType}`);
+              }
+            } else {
+              logCollector?.warn(`Error matching component: ${settledResult.reason?.message || "Unknown error"}`);
+            }
+          }
+          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 +3679,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,29 +3730,104 @@ 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
+   * @param streamCallback - Optional callback function to receive text chunks as they stream (only for text mode)
+   * @param collections - Collection registry for executing database queries (required for text mode)
+   */
+  async handleUserRequest(userPrompt, components, apiKey, logCollector, conversationHistory, responseMode = "component", streamCallback, collections) {
+    const startTime = Date.now();
+    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,
+        streamCallback,
+        collections,
+        components
+      );
+      if (!textResponse.success) {
+        const elapsedTime3 = Date.now() - startTime;
+        logger.error(`[${this.getProviderName()}] Text response generation failed`);
+        logger.info(`[${this.getProviderName()}] Total time taken: ${elapsedTime3}ms (${(elapsedTime3 / 1e3).toFixed(2)}s)`);
+        logCollector?.info(`Total time taken: ${elapsedTime3}ms (${(elapsedTime3 / 1e3).toFixed(2)}s)`);
+        return textResponse;
+      }
+      const elapsedTime2 = Date.now() - startTime;
+      logger.info(`[${this.getProviderName()}] Text response generated successfully`);
+      logger.info(`[${this.getProviderName()}] Total time taken: ${elapsedTime2}ms (${(elapsedTime2 / 1e3).toFixed(2)}s)`);
+      logCollector?.info(`Total time taken: ${elapsedTime2}ms (${(elapsedTime2 / 1e3).toFixed(2)}s)`);
+      return textResponse;
+    }
+    const componentResponse = await this.generateComponentResponse(
+      userPrompt,
+      components,
+      apiKey,
+      logCollector,
+      conversationHistory
+    );
+    if (!componentResponse.success) {
+      const elapsedTime2 = Date.now() - startTime;
+      logger.error(`[${this.getProviderName()}] Component response generation failed`);
+      logger.info(`[${this.getProviderName()}] Total time taken: ${elapsedTime2}ms (${(elapsedTime2 / 1e3).toFixed(2)}s)`);
+      logCollector?.info(`Total time taken: ${elapsedTime2}ms (${(elapsedTime2 / 1e3).toFixed(2)}s)`);
+      return componentResponse;
+    }
+    const elapsedTime = Date.now() - startTime;
+    logger.info(`[${this.getProviderName()}] Component response generated successfully`);
+    logger.info(`[${this.getProviderName()}] Total time taken: ${elapsedTime}ms (${(elapsedTime / 1e3).toFixed(2)}s)`);
+    logCollector?.info(`Total time taken: ${elapsedTime}ms (${(elapsedTime / 1e3).toFixed(2)}s)`);
+    return componentResponse;
+  }
   /**
    * Generate next questions that the user might ask based on the original prompt and generated component
    * This helps provide intelligent suggestions for follow-up queries
@@ -2900,8 +3872,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 +3939,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", streamCallback, collections) => {
+  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, streamCallback, collections);
+  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", streamCallback, collections) => {
+  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, streamCallback, collections);
+  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) => {
+var get_user_response = async (prompt, components, anthropicApiKey, groqApiKey, llmProviders, logCollector, conversationHistory, responseMode = "component", streamCallback, collections) => {
+  logger.debug(`[get_user_response] Starting user response generation for prompt: "${prompt.substring(0, 50)}..."`);
+  logger.debug(`[get_user_response] Response mode: ${responseMode}`);
+  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, streamCallback, collections);
+    } else if (provider === "groq") {
+      result = await useGroqMethod(prompt, components, groqApiKey, logCollector, conversationHistory, responseMode, streamCallback, collections);
+    } 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}`;
+      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 +4070,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 +4095,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
@@ -3221,103 +4238,153 @@ 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, collections) => {
+  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";
+  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");
+  }
+  logger.debug(`[REQUEST ${id}] Full request details - uiBlockId: ${existingUiBlockId}, threadId: ${threadId}, prompt: ${prompt}`);
+  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 responseMode = payload.responseMode || "component";
+  logger.info("responseMode", responseMode);
+  let streamCallback;
+  let accumulatedStreamResponse = "";
+  if (responseMode === "text") {
+    streamCallback = (chunk) => {
+      accumulatedStreamResponse += chunk;
+      logger.debug(`[STREAM] Sending chunk (${chunk.length} chars): "${chunk.substring(0, 20)}..."`);
+      const streamMessage = {
+        id: `stream_${existingUiBlockId}`,
+        // Different ID pattern for streaming
+        type: "USER_PROMPT_STREAM",
+        from: { type: "data-agent" },
+        to: {
+          type: "runtime",
+          id: wsId
+        },
+        payload: {
+          uiBlockId: existingUiBlockId,
+          chunk
+        }
+      };
+      sendMessage(streamMessage);
+      logger.debug(`[STREAM] Chunk sent to wsId: ${wsId}`);
+    };
+  }
+  const userResponse = await get_user_response(
+    prompt,
+    components,
+    anthropicApiKey,
+    groqApiKey,
+    llmProviders,
+    logCollector,
+    conversationHistory,
+    responseMode,
+    streamCallback,
+    collections
+  );
+  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.text;
       }
     }
-    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 finalTextResponse = responseMode === "text" && accumulatedStreamResponse ? accumulatedStreamResponse : textResponse;
+  const uiBlock = new UIBlock(
+    prompt,
+    {},
+    // componentData: initially empty, will be filled later
+    component,
+    // generatedComponentMetadata: full component object (ComponentSchema)
+    [],
+    // actions: empty initially
+    uiBlockId,
+    finalTextResponse
+    // textResponse: FULL streaming response including all intermediate messages
+  );
+  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, collections) {
+  const response = await get_user_request(data, components, sendMessage, anthropicApiKey, groqApiKey, llmProviders, collections);
+  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 +4497,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 +4527,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 +4538,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 +4578,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 +4595,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 +4653,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 +4685,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 +4720,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 +4753,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 +4768,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 +4796,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 +4812,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 +4829,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 +4879,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 +4924,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 +4967,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 +5000,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}`);
@@ -4219,7 +5448,7 @@ function sendResponse5(id, res, sendMessage, clientId) {
 }
 
 // src/auth/user-manager.ts
-import fs4 from "fs";
+import fs5 from "fs";
 import path4 from "path";
 import os from "os";
 var UserManager = class {
@@ -4259,21 +5488,22 @@ var UserManager = class {
   async loadUsersFromFile() {
     try {
       const dir = path4.dirname(this.filePath);
-      if (!fs4.existsSync(dir)) {
+      if (!fs5.existsSync(dir)) {
         logger.info(`Creating directory structure: ${dir}`);
-        fs4.mkdirSync(dir, { recursive: true });
+        fs5.mkdirSync(dir, { recursive: true });
       }
-      if (!fs4.existsSync(this.filePath)) {
+      if (!fs5.existsSync(this.filePath)) {
         logger.info(`Users file does not exist at ${this.filePath}, creating with empty users`);
         const initialData = { users: [] };
-        fs4.writeFileSync(this.filePath, JSON.stringify(initialData, null, 4));
+        fs5.writeFileSync(this.filePath, JSON.stringify(initialData, null, 4));
         this.users = [];
         this.hasChanged = false;
         return;
       }
-      const fileContent = fs4.readFileSync(this.filePath, "utf-8");
-      const data = JSON.parse(fileContent);
-      this.users = Array.isArray(data.users) ? data.users : [];
+      const fileContent = fs5.readFileSync(this.filePath, "utf-8");
+      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) {
@@ -4290,13 +5520,17 @@ var UserManager = class {
     }
     try {
       const dir = path4.dirname(this.filePath);
-      if (!fs4.existsSync(dir)) {
-        fs4.mkdirSync(dir, { recursive: true });
+      if (!fs5.existsSync(dir)) {
+        fs5.mkdirSync(dir, { recursive: true });
       }
-      const data = { users: this.users };
-      fs4.writeFileSync(this.filePath, JSON.stringify(data, null, 4));
+      const usersToSave = this.users.map((user) => {
+        const { wsIds, ...userWithoutWsIds } = user;
+        return userWithoutWsIds;
+      });
+      const data = { users: usersToSave };
+      fs5.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 +5577,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 +5597,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 +5701,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 +5722,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;
@@ -4494,7 +5746,7 @@ var UserManager = class {
 };
 
 // src/dashboards/dashboard-manager.ts
-import fs5 from "fs";
+import fs6 from "fs";
 import path5 from "path";
 import os2 from "os";
 var DashboardManager = class {
@@ -4529,12 +5781,12 @@ var DashboardManager = class {
   createDashboard(dashboardId, dashboard) {
     const dashboardPath = this.getDashboardPath(dashboardId);
     const dashboardDir = path5.dirname(dashboardPath);
-    if (fs5.existsSync(dashboardPath)) {
+    if (fs6.existsSync(dashboardPath)) {
       throw new Error(`Dashboard '${dashboardId}' already exists`);
     }
     const validated = DSLRendererPropsSchema.parse(dashboard);
-    fs5.mkdirSync(dashboardDir, { recursive: true });
-    fs5.writeFileSync(dashboardPath, JSON.stringify(validated, null, 4));
+    fs6.mkdirSync(dashboardDir, { recursive: true });
+    fs6.writeFileSync(dashboardPath, JSON.stringify(validated, null, 4));
     logger.info(`Dashboard created: ${dashboardId}`);
     return validated;
   }
@@ -4545,12 +5797,12 @@ var DashboardManager = class {
    */
   getDashboard(dashboardId) {
     const dashboardPath = this.getDashboardPath(dashboardId);
-    if (!fs5.existsSync(dashboardPath)) {
+    if (!fs6.existsSync(dashboardPath)) {
       logger.warn(`Dashboard not found: ${dashboardId}`);
       return null;
     }
     try {
-      const fileContent = fs5.readFileSync(dashboardPath, "utf-8");
+      const fileContent = fs6.readFileSync(dashboardPath, "utf-8");
       const dashboard = JSON.parse(fileContent);
       const validated = DSLRendererPropsSchema.parse(dashboard);
       return validated;
@@ -4564,16 +5816,16 @@ var DashboardManager = class {
    * @returns Array of dashboard objects with their IDs
    */
   getAllDashboards() {
-    if (!fs5.existsSync(this.dashboardsBasePath)) {
-      fs5.mkdirSync(this.dashboardsBasePath, { recursive: true });
+    if (!fs6.existsSync(this.dashboardsBasePath)) {
+      fs6.mkdirSync(this.dashboardsBasePath, { recursive: true });
       return [];
     }
     const dashboards = [];
     try {
-      const dashboardDirs = fs5.readdirSync(this.dashboardsBasePath);
+      const dashboardDirs = fs6.readdirSync(this.dashboardsBasePath);
       for (const dashboardId of dashboardDirs) {
         const dashboardPath = this.getDashboardPath(dashboardId);
-        if (fs5.existsSync(dashboardPath)) {
+        if (fs6.existsSync(dashboardPath)) {
           const dashboard = this.getDashboard(dashboardId);
           if (dashboard) {
             dashboards.push({ dashboardId, dashboard });
@@ -4595,13 +5847,13 @@ var DashboardManager = class {
    */
   updateDashboard(dashboardId, dashboard) {
     const dashboardPath = this.getDashboardPath(dashboardId);
-    if (!fs5.existsSync(dashboardPath)) {
+    if (!fs6.existsSync(dashboardPath)) {
       logger.warn(`Dashboard not found for update: ${dashboardId}`);
       return null;
     }
     try {
       const validated = DSLRendererPropsSchema.parse(dashboard);
-      fs5.writeFileSync(dashboardPath, JSON.stringify(validated, null, 4));
+      fs6.writeFileSync(dashboardPath, JSON.stringify(validated, null, 4));
       logger.info(`Dashboard updated: ${dashboardId}`);
       return validated;
     } catch (error) {
@@ -4617,12 +5869,12 @@ var DashboardManager = class {
   deleteDashboard(dashboardId) {
     const dashboardPath = this.getDashboardPath(dashboardId);
     const dashboardDir = path5.dirname(dashboardPath);
-    if (!fs5.existsSync(dashboardPath)) {
+    if (!fs6.existsSync(dashboardPath)) {
       logger.warn(`Dashboard not found for deletion: ${dashboardId}`);
       return false;
     }
     try {
-      fs5.rmSync(dashboardDir, { recursive: true, force: true });
+      fs6.rmSync(dashboardDir, { recursive: true, force: true });
       logger.info(`Dashboard deleted: ${dashboardId}`);
       return true;
     } catch (error) {
@@ -4637,21 +5889,21 @@ var DashboardManager = class {
    */
   dashboardExists(dashboardId) {
     const dashboardPath = this.getDashboardPath(dashboardId);
-    return fs5.existsSync(dashboardPath);
+    return fs6.existsSync(dashboardPath);
   }
   /**
    * Get dashboard count
    * @returns Number of dashboards
    */
   getDashboardCount() {
-    if (!fs5.existsSync(this.dashboardsBasePath)) {
+    if (!fs6.existsSync(this.dashboardsBasePath)) {
       return 0;
     }
     try {
-      const dashboardDirs = fs5.readdirSync(this.dashboardsBasePath);
+      const dashboardDirs = fs6.readdirSync(this.dashboardsBasePath);
       return dashboardDirs.filter((dir) => {
         const dashboardPath = this.getDashboardPath(dir);
-        return fs5.existsSync(dashboardPath);
+        return fs6.existsSync(dashboardPath);
       }).length;
     } catch (error) {
       logger.error("Failed to get dashboard count:", error);
@@ -4661,7 +5913,7 @@ var DashboardManager = class {
 };
 
 // src/reports/report-manager.ts
-import fs6 from "fs";
+import fs7 from "fs";
 import path6 from "path";
 import os3 from "os";
 var ReportManager = class {
@@ -4696,12 +5948,12 @@ var ReportManager = class {
   createReport(reportId, report) {
     const reportPath = this.getReportPath(reportId);
     const reportDir = path6.dirname(reportPath);
-    if (fs6.existsSync(reportPath)) {
+    if (fs7.existsSync(reportPath)) {
       throw new Error(`Report '${reportId}' already exists`);
     }
     const validated = DSLRendererPropsSchema2.parse(report);
-    fs6.mkdirSync(reportDir, { recursive: true });
-    fs6.writeFileSync(reportPath, JSON.stringify(validated, null, 4));
+    fs7.mkdirSync(reportDir, { recursive: true });
+    fs7.writeFileSync(reportPath, JSON.stringify(validated, null, 4));
     logger.info(`Report created: ${reportId}`);
     return validated;
   }
@@ -4712,12 +5964,12 @@ var ReportManager = class {
    */
   getReport(reportId) {
     const reportPath = this.getReportPath(reportId);
-    if (!fs6.existsSync(reportPath)) {
+    if (!fs7.existsSync(reportPath)) {
       logger.warn(`Report not found: ${reportId}`);
       return null;
     }
     try {
-      const fileContent = fs6.readFileSync(reportPath, "utf-8");
+      const fileContent = fs7.readFileSync(reportPath, "utf-8");
       const report = JSON.parse(fileContent);
       const validated = DSLRendererPropsSchema2.parse(report);
       return validated;
@@ -4731,16 +5983,16 @@ var ReportManager = class {
    * @returns Array of report objects with their IDs
    */
   getAllReports() {
-    if (!fs6.existsSync(this.reportsBasePath)) {
-      fs6.mkdirSync(this.reportsBasePath, { recursive: true });
+    if (!fs7.existsSync(this.reportsBasePath)) {
+      fs7.mkdirSync(this.reportsBasePath, { recursive: true });
       return [];
     }
     const reports = [];
     try {
-      const reportDirs = fs6.readdirSync(this.reportsBasePath);
+      const reportDirs = fs7.readdirSync(this.reportsBasePath);
       for (const reportId of reportDirs) {
         const reportPath = this.getReportPath(reportId);
-        if (fs6.existsSync(reportPath)) {
+        if (fs7.existsSync(reportPath)) {
           const report = this.getReport(reportId);
           if (report) {
             reports.push({ reportId, report });
@@ -4762,13 +6014,13 @@ var ReportManager = class {
    */
   updateReport(reportId, report) {
     const reportPath = this.getReportPath(reportId);
-    if (!fs6.existsSync(reportPath)) {
+    if (!fs7.existsSync(reportPath)) {
       logger.warn(`Report not found for update: ${reportId}`);
       return null;
     }
     try {
       const validated = DSLRendererPropsSchema2.parse(report);
-      fs6.writeFileSync(reportPath, JSON.stringify(validated, null, 4));
+      fs7.writeFileSync(reportPath, JSON.stringify(validated, null, 4));
       logger.info(`Report updated: ${reportId}`);
       return validated;
     } catch (error) {
@@ -4784,12 +6036,12 @@ var ReportManager = class {
   deleteReport(reportId) {
     const reportPath = this.getReportPath(reportId);
     const reportDir = path6.dirname(reportPath);
-    if (!fs6.existsSync(reportPath)) {
+    if (!fs7.existsSync(reportPath)) {
       logger.warn(`Report not found for deletion: ${reportId}`);
       return false;
     }
     try {
-      fs6.rmSync(reportDir, { recursive: true, force: true });
+      fs7.rmSync(reportDir, { recursive: true, force: true });
       logger.info(`Report deleted: ${reportId}`);
       return true;
     } catch (error) {
@@ -4804,21 +6056,21 @@ var ReportManager = class {
    */
   reportExists(reportId) {
     const reportPath = this.getReportPath(reportId);
-    return fs6.existsSync(reportPath);
+    return fs7.existsSync(reportPath);
   }
   /**
    * Get report count
    * @returns Number of reports
    */
   getReportCount() {
-    if (!fs6.existsSync(this.reportsBasePath)) {
+    if (!fs7.existsSync(this.reportsBasePath)) {
       return 0;
     }
     try {
-      const reportDirs = fs6.readdirSync(this.reportsBasePath);
+      const reportDirs = fs7.readdirSync(this.reportsBasePath);
       return reportDirs.filter((dir) => {
         const reportPath = this.getReportPath(dir);
-        return fs6.existsSync(reportPath);
+        return fs7.existsSync(reportPath);
       }).length;
     } catch (error) {
       logger.error("Failed to get report count:", error);
@@ -5019,6 +6271,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";
@@ -5039,9 +6294,6 @@ var SuperatomSDK = class {
     });
     this.initializeDashboardManager();
     this.initializeReportManager();
-    this.connect().catch((error) => {
-      logger.error("Failed to connect to Superatom:", error);
-    });
   }
   /**
    * Initialize PromptLoader and load prompts into memory
@@ -5107,6 +6359,10 @@ var SuperatomSDK = class {
    * Connect to the Superatom WebSocket service
    */
   async connect() {
+    if (this.connected && this.ws && this.ws.readyState === this.ws.OPEN) {
+      logger.info("Already connected to WebSocket");
+      return Promise.resolve();
+    }
     return new Promise((resolve, reject) => {
       try {
         const url = new URL(this.url);
@@ -5169,7 +6425,7 @@ var SuperatomSDK = class {
           });
           break;
         case "USER_PROMPT_REQ":
-          handleUserPromptRequest(parsed, this.components, (msg) => this.send(msg), this.anthropicApiKey, this.groqApiKey, this.llmProviders).catch((error) => {
+          handleUserPromptRequest(parsed, this.components, (msg) => this.send(msg), this.anthropicApiKey, this.groqApiKey, this.llmProviders, this.collections).catch((error) => {
             logger.error("Failed to handle user prompt request:", error);
           });
           break;
@@ -5321,6 +6577,7 @@ export {
   ThreadManager,
   UIBlock,
   UILogCollector,
-  UserManager
+  UserManager,
+  logger
 };
 //# sourceMappingURL=index.mjs.map