@superatomai/sdk-node 0.0.5 → 0.0.7

package/dist/index.js

@@ -5,6 +5,9 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
 var __commonJS = (cb, mod) => function __require() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
@@ -102,7 +105,7 @@ var require_package = __commonJS({
 var require_main = __commonJS({
   "node_modules/dotenv/lib/main.js"(exports2, module2) {
     "use strict";
-    var fs7 = require("fs");
+    var fs8 = require("fs");
     var path7 = require("path");
     var os4 = require("os");
     var crypto2 = require("crypto");
@@ -244,7 +247,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 +257,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 +310,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 +431,137 @@ var require_main = __commonJS({
   }
 });
 
+// src/userResponse/utils.ts
+var utils_exports = {};
+__export(utils_exports, {
+  convertQuestionsToActions: () => convertQuestionsToActions,
+  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 convertQuestionsToActions(questions) {
+  return questions.map((question, index) => ({
+    id: `action_${index}_${Date.now()}`,
+    name: question,
+    type: "next_question",
+    question
+  }));
+}
+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/index.ts
 var index_exports = {};
 __export(index_exports, {
@@ -707,7 +841,8 @@ var UserPromptRequestPayloadSchema = import_zod3.z.object({
   SA_RUNTIME: import_zod3.z.object({
     threadId: import_zod3.z.string(),
     uiBlockId: import_zod3.z.string()
-  }).optional()
+  }).optional(),
+  responseMode: import_zod3.z.enum(["component", "text"]).optional()
 });
 var UserPromptRequestMessageSchema = import_zod3.z.object({
   id: import_zod3.z.string(),
@@ -729,7 +864,8 @@ var ComponentPropsSchema = import_zod3.z.object({
   query: import_zod3.z.string().optional(),
   title: import_zod3.z.string().optional(),
   description: import_zod3.z.string().optional(),
-  config: import_zod3.z.record(import_zod3.z.unknown()).optional()
+  config: import_zod3.z.record(import_zod3.z.unknown()).optional(),
+  actions: import_zod3.z.array(import_zod3.z.any()).optional()
 });
 var ComponentSchema = import_zod3.z.object({
   id: import_zod3.z.string(),
@@ -822,7 +958,9 @@ var ReportsRequestMessageSchema = import_zod3.z.object({
 });
 
 // src/utils/logger.ts
+var import_fs = __toESM(require("fs"));
 var PREFIX = "[SuperatomSDK]";
+var LOGSTREAM = import_fs.default.createWriteStream("superatom-sdk.log", { flags: "a" });
 var LOG_LEVEL_PRIORITY = {
   errors: 0,
   warnings: 1,
@@ -906,6 +1044,9 @@ var Logger = class {
       console.log(PREFIX, "[DEBUG]", ...args);
     }
   }
+  file(...args) {
+    LOGSTREAM.write(args.join(" ") + "\n");
+  }
 };
 var logger = new Logger();
 
@@ -977,6 +1118,9 @@ var UIBlock = class {
   getComponentMetadata() {
     return this.generatedComponentMetadata;
   }
+  getTextResponse() {
+    return this.textResponse || "";
+  }
   /**
    * Set or update component metadata
    */
@@ -1069,12 +1213,6 @@ var UIBlock = class {
     const processedData = this.processDataForStorage(data);
     this.componentData = { ...this.componentData, ...processedData };
   }
-  /**
-   * Get text response
-   */
-  getTextResponse() {
-    return this.textResponse;
-  }
   /**
    * Set or update text response
    */
@@ -1110,6 +1248,12 @@ var UIBlock = class {
       throw error;
     }
   }
+  /**
+   * Set or replace all actions
+   */
+  setActions(actions) {
+    this.actions = actions;
+  }
   /**
    * Add a single action (only if actions are resolved)
    */
@@ -1265,8 +1409,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}`);
@@ -1286,11 +1433,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();
   }
@@ -1466,7 +1619,7 @@ function sendDataResponse(id, collection, op, data, meta, sendMessage) {
 }
 
 // src/bundle.ts
-var fs = __toESM(require("fs"));
+var fs2 = __toESM(require("fs"));
 var path = __toESM(require("path"));
 function getBundleDir(configDir) {
   const bundleDir = configDir || process.env.SA_BUNDLE_DIR;
@@ -1479,16 +1632,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}`);
@@ -1503,7 +1656,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}`);
@@ -1909,94 +2062,12 @@ function sendDataResponse3(id, res, sendMessage, clientId) {
 // 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;
-}
-function fixScalarSubqueries(query) {
-  if (!query || query.trim().length === 0) {
-    return query;
-  }
-  let modifiedQuery = query;
-  let hasChanges = false;
-  const scalarOperatorPattern = /([=<>!]=?|<>)\s*\(\s*SELECT\s/gi;
-  const matches = [...modifiedQuery.matchAll(scalarOperatorPattern)];
-  for (let i = matches.length - 1; i >= 0; i--) {
-    const match = matches[i];
-    const startPos = match.index + match[0].length - "SELECT ".length;
-    let parenDepth = 1;
-    let endPos = startPos;
-    let foundEnd = false;
-    for (let j = startPos; j < modifiedQuery.length; j++) {
-      const char = modifiedQuery[j];
-      if (char === "(") parenDepth++;
-      if (char === ")") {
-        parenDepth--;
-        if (parenDepth === 0) {
-          endPos = j;
-          foundEnd = true;
-          break;
-        }
-      }
-    }
-    if (!foundEnd) continue;
-    const subquery = modifiedQuery.substring(startPos, endPos);
-    if (/\bLIMIT\s+\d+/i.test(subquery)) {
-      continue;
-    }
-    const fixedSubquery = subquery.trim() + " LIMIT 1";
-    modifiedQuery = modifiedQuery.substring(0, startPos) + fixedSubquery + modifiedQuery.substring(endPos);
-    hasChanges = true;
-    console.warn(`\u26A0\uFE0F  Fixed scalar subquery: added LIMIT 1 to prevent multiple row error`);
-  }
-  if (hasChanges) {
-    console.log("\u2713 Query validated and fixed for PostgreSQL scalar subquery compatibility");
-  }
-  return modifiedQuery;
-}
+// src/userResponse/base-llm.ts
+init_utils();
 
 // src/userResponse/schema.ts
 var import_path = __toESM(require("path"));
-var import_fs = __toESM(require("fs"));
+var import_fs2 = __toESM(require("fs"));
 var Schema = class {
   constructor(schemaFilePath) {
     this.cachedSchema = null;
@@ -2010,11 +2081,11 @@ var Schema = class {
     logger.info(`SCHEMA_FILE_PATH: ${this.schemaFilePath}`);
     try {
       const dir = import_path.default.dirname(this.schemaFilePath);
-      if (!import_fs.default.existsSync(dir)) {
+      if (!import_fs2.default.existsSync(dir)) {
         logger.info(`Creating directory structure: ${dir}`);
-        import_fs.default.mkdirSync(dir, { recursive: true });
+        import_fs2.default.mkdirSync(dir, { recursive: true });
       }
-      if (!import_fs.default.existsSync(this.schemaFilePath)) {
+      if (!import_fs2.default.existsSync(this.schemaFilePath)) {
         logger.info(`Schema file does not exist at ${this.schemaFilePath}, creating with empty schema`);
         const initialSchema = {
           database: "",
@@ -2023,11 +2094,11 @@ var Schema = class {
           tables: [],
           relationships: []
         };
-        import_fs.default.writeFileSync(this.schemaFilePath, JSON.stringify(initialSchema, null, 4));
+        import_fs2.default.writeFileSync(this.schemaFilePath, JSON.stringify(initialSchema, null, 4));
         this.cachedSchema = initialSchema;
         return initialSchema;
       }
-      const fileContent = import_fs.default.readFileSync(this.schemaFilePath, "utf-8");
+      const fileContent = import_fs2.default.readFileSync(this.schemaFilePath, "utf-8");
       const schema2 = JSON.parse(fileContent);
       this.cachedSchema = schema2;
       return schema2;
@@ -2128,7 +2199,7 @@ var Schema = class {
 var schema = new Schema();
 
 // src/userResponse/prompt-loader.ts
-var import_fs2 = __toESM(require("fs"));
+var import_fs3 = __toESM(require("fs"));
 var import_path2 = __toESM(require("path"));
 var PromptLoader = class {
   constructor(config) {
@@ -2156,7 +2227,8 @@ var PromptLoader = class {
       "mutli-component",
       "actions",
       "container-metadata",
-      "text-response"
+      "text-response",
+      "match-text-components"
     ];
     for (const promptType of promptTypes) {
       try {
@@ -2181,9 +2253,9 @@ var PromptLoader = class {
       try {
         const systemPath = import_path2.default.join(dir, promptName, "system.md");
         const userPath = import_path2.default.join(dir, promptName, "user.md");
-        if (import_fs2.default.existsSync(systemPath) && import_fs2.default.existsSync(userPath)) {
-          const system = import_fs2.default.readFileSync(systemPath, "utf-8");
-          const user = import_fs2.default.readFileSync(userPath, "utf-8");
+        if (import_fs3.default.existsSync(systemPath) && import_fs3.default.existsSync(userPath)) {
+          const system = import_fs3.default.readFileSync(systemPath, "utf-8");
+          const user = import_fs3.default.readFileSync(userPath, "utf-8");
           logger.debug(`Loaded prompt '${promptName}' from ${dir}`);
           return { system, user };
         }
@@ -2305,6 +2377,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
   // ============================================================
@@ -2382,6 +2462,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 import_sdk.default({
+      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
   // ============================================================
@@ -2456,6 +2616,42 @@ var LLM = class {
   }
 };
 
+// src/userResponse/knowledge-base.ts
+var getKnowledgeBase = async ({
+  prompt,
+  collections,
+  topK = 1
+}) => {
+  try {
+    if (!collections || !collections["knowledge-base"] || !collections["knowledge-base"]["query"]) {
+      logger.info("[KnowledgeBase] knowledge-base.query collection not registered, skipping");
+      return "";
+    }
+    logger.info(`[KnowledgeBase] Querying knowledge base for: "${prompt.substring(0, 50)}..."`);
+    const result = await collections["knowledge-base"]["query"]({
+      prompt,
+      topK
+    });
+    if (!result || !result.content) {
+      logger.error("[KnowledgeBase] No knowledge base results returned");
+      return "";
+    }
+    logger.info(`[KnowledgeBase] Retrieved knowledge base context (${result.content.length} chars)`);
+    if (result.metadata?.sources && result.metadata.sources.length > 0) {
+      logger.debug(`[KnowledgeBase] Sources: ${result.metadata.sources.map((s) => s.title).join(", ")}`);
+    }
+    return result.content;
+  } catch (error) {
+    const errorMsg = error instanceof Error ? error.message : String(error);
+    logger.warn(`[KnowledgeBase] Error querying knowledge base: ${errorMsg}`);
+    return "";
+  }
+};
+var KB = {
+  getKnowledgeBase
+};
+var knowledge_base_default = KB;
+
 // src/userResponse/base-llm.ts
 var BaseLLM = class {
   constructor(config) {
@@ -2994,62 +3190,485 @@ var BaseLLM = class {
       throw error;
     }
   }
+  /**
+   * Match components from text response suggestions and generate follow-up questions
+   * Takes a text response with component suggestions (c1:type format) and matches with available components
+   * Also generates intelligent follow-up questions (actions) based on the analysis
+   * @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, reasoning, and follow-up actions
+   */
+  async matchComponentsFromTextResponse(textResponse, components, apiKey, logCollector) {
+    try {
+      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}`);
+      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];
+          }
+          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",
+            actions: []
+          };
+        }
+      }
+      const matchedComponents = result.matchedComponents || [];
+      const selectedLayout = result.selectedLayout || "MultiComponentContainer";
+      const selectedLayoutId = result.selectedLayoutId || "";
+      const layoutReasoning = result.layoutReasoning || "No layout reasoning provided";
+      const rawActions = result.actions || [];
+      const actions = convertQuestionsToActions(rawActions);
+      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}`);
+      logger.info(`[${this.getProviderName()}] Generated ${actions.length} follow-up actions`);
+      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 }
+            );
+          }
+        });
+      }
+      if (actions.length > 0) {
+        logCollector?.info(`Generated ${actions.length} follow-up questions`);
+        actions.forEach((action, idx) => {
+          logCollector?.info(`  ${idx + 1}. ${action.name}`);
+        });
+      }
+      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,
+        actions
+      };
+    } 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",
+        actions: []
+      };
+    }
+  }
   /**
    * 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) {
+  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 knowledgeBaseContext = await knowledge_base_default.getKnowledgeBase({
+        prompt: userPrompt,
+        collections,
+        topK: 1
+      });
+      logger.file("\n=============================\nknowledge base context:", knowledgeBaseContext);
       const prompts = await promptLoader.loadPrompts("text-response", {
         USER_PROMPT: userPrompt,
-        CONVERSATION_HISTORY: conversationHistory || "No previous conversation"
+        CONVERSATION_HISTORY: conversationHistory || "No previous conversation",
+        SCHEMA_DOC: schemaDoc,
+        KNOWLEDGE_BASE_CONTEXT: knowledgeBaseContext || "No additional knowledge base context available."
       });
-      logger.debug(`[${this.getProviderName()}] Loaded text-response prompts`);
+      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...");
-      const result = await LLM.stream(
+      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: 1e3,
+          maxTokens: 4e3,
           temperature: 0.7,
-          apiKey: this.getApiKey(apiKey)
+          apiKey: this.getApiKey(apiKey),
+          partial: wrappedStreamCallback
+          // Pass the wrapped streaming callback to LLM
         },
-        true
-        // Parse as JSON
+        10
+        // max iterations: allows for 6 retries + final response + buffer
       );
-      logger.info(`[${this.getProviderName()}] Text response generated successfully`);
-      logger.debug(`[${this.getProviderName()}] Response type: ${result.responseType}, Confidence: ${result.confidence}`);
-      logCollector?.info(`Text response: ${result.text?.substring(0, 100)}${result.text?.length > 100 ? "..." : ""}`);
+      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: [],
+            actions: [],
+            method: `${this.getProviderName()}-text-response-max-attempts`
+          }
+        };
+      }
+      logCollector?.info(`Text response: ${textResponse.substring(0, 100)}${textResponse.length > 100 ? "..." : ""}`);
       logCollector?.logExplanation(
         "Text response generated",
-        result.reasoning || "Generated text response for user question",
+        "Generated plain text response with component suggestions",
         {
-          responseType: result.responseType,
-          confidence: result.confidence,
-          textLength: result.text?.length || 0
+          textLength: textResponse.length
         }
       );
+      let matchedComponents = [];
+      let selectedLayoutComponent = null;
+      let layoutReasoning = "No layout selected";
+      let actions = [];
+      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;
+        actions = matchResult.actions;
+      }
+      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
+              },
+              actions
+            }
+          };
+          logger.info(`[${this.getProviderName()}] Created ${selectedLayoutComponent.name} (${selectedLayoutComponent.type}) container with ${matchedComponents.length} components and ${actions.length} actions`);
+          logCollector?.info(`Created ${selectedLayoutComponent.name} with ${matchedComponents.length} components and ${actions.length} actions: ${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
+              },
+              actions
+            }
+          };
+          logger.info(`[${this.getProviderName()}] Created fallback MultiComponentContainer with ${matchedComponents.length} components and ${actions.length} actions`);
+          logCollector?.info(`Created MultiComponentContainer with ${matchedComponents.length} components and ${actions.length} actions: ${layoutReasoning}`);
+        }
+      }
       return {
         success: true,
         data: {
-          text: result.text || "I apologize, but I was unable to generate a response.",
-          responseType: result.responseType || "answer",
-          confidence: result.confidence || 0.5,
-          reasoning: result.reasoning || "No reasoning provided"
+          text: textResponse,
+          matchedComponents,
+          component: container_componet,
+          layoutReasoning,
+          actions,
+          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}`);
-      logger.debug(`[${this.getProviderName()}] Text response generation error details:`, error);
       logCollector?.error(`Error generating text response: ${errorMsg}`);
       errors.push(errorMsg);
       return {
@@ -3057,9 +3676,9 @@ var BaseLLM = class {
         errors,
         data: {
           text: "I apologize, but I encountered an error while processing your question. Please try rephrasing or ask something else.",
-          responseType: "error",
-          confidence: 0,
-          reasoning: `Error: ${errorMsg}`
+          matchedComponents: [],
+          actions: [],
+          method: `${this.getProviderName()}-text-response-error`
         }
       };
     }
@@ -3250,8 +3869,11 @@ var BaseLLM = class {
    * 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") {
+  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`);
@@ -3260,25 +3882,23 @@ var BaseLLM = class {
         userPrompt,
         apiKey,
         logCollector,
-        conversationHistory
+        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`);
-      return {
-        success: true,
-        data: {
-          textResponse: textResponse.data.text,
-          text: textResponse.data.text,
-          responseType: textResponse.data.responseType,
-          confidence: textResponse.data.confidence,
-          reasoning: textResponse.data.reasoning,
-          method: `${this.getProviderName()}-text-response`
-        },
-        errors: []
-      };
+      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,
@@ -3288,24 +3908,17 @@ var BaseLLM = class {
       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`);
-    return {
-      success: true,
-      data: {
-        component: componentResponse.data.component,
-        reasoning: componentResponse.data.reasoning,
-        method: componentResponse.data.method,
-        // Preserve the original method name
-        questionType: componentResponse.data.questionType,
-        needsMultipleComponents: componentResponse.data.needsMultipleComponents,
-        propsModified: componentResponse.data.propsModified,
-        queryModified: componentResponse.data.queryModified
-      },
-      errors: []
-    };
+    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
@@ -3418,7 +4031,7 @@ function getLLMProviders() {
     return DEFAULT_PROVIDERS;
   }
 }
-var useAnthropicMethod = async (prompt, components, apiKey, logCollector, conversationHistory, responseMode = "component") => {
+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...`;
@@ -3430,11 +4043,11 @@ var useAnthropicMethod = async (prompt, components, apiKey, logCollector, conver
     return { success: false, errors: [emptyMsg] };
   }
   logger.debug(`[useAnthropicMethod] Processing with ${components.length} components`);
-  const matchResult = await anthropicLLM.handleUserRequest(prompt, components, apiKey, logCollector, conversationHistory, responseMode);
+  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, responseMode = "component") => {
+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...`;
@@ -3447,16 +4060,16 @@ var useGroqMethod = async (prompt, components, apiKey, logCollector, conversatio
     return { success: false, errors: [emptyMsg] };
   }
   logger.debug(`[useGroqMethod] Processing with ${components.length} components`);
-  const matchResult = await groqLLM.handleUserRequest(prompt, components, apiKey, logCollector, conversationHistory, responseMode);
+  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) => {
-  const responseMode = "component";
+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) {
@@ -3487,16 +4100,16 @@ var get_user_response = async (prompt, components, anthropicApiKey, groqApiKey,
     logCollector?.info(attemptMsg);
     let result;
     if (provider === "anthropic") {
-      result = await useAnthropicMethod(prompt, components, anthropicApiKey, logCollector, conversationHistory, responseMode);
+      result = await useAnthropicMethod(prompt, components, anthropicApiKey, logCollector, conversationHistory, responseMode, streamCallback, collections);
     } else if (provider === "groq") {
-      result = await useGroqMethod(prompt, components, groqApiKey, logCollector, conversationHistory, responseMode);
+      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} result: ${JSON.stringify(result)}`;
+      const successMsg = `Success with provider: ${provider}`;
       logger.info(`${successMsg}`);
       logCollector?.info(successMsg);
       return result;
@@ -3717,8 +4330,7 @@ var CONTEXT_CONFIG = {
 };
 
 // src/handlers/user-prompt-request.ts
-var processedMessageIds = /* @__PURE__ */ new Set();
-var get_user_request = async (data, components, sendMessage, anthropicApiKey, groqApiKey, llmProviders) => {
+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);
@@ -3734,19 +4346,6 @@ var get_user_request = async (data, components, sendMessage, anthropicApiKey, gr
   const prompt = payload.prompt;
   const SA_RUNTIME = payload.SA_RUNTIME;
   const wsId = userPromptRequest.from.id || "unknown";
-  logger.debug(`[REQUEST ${id}] Full request details - wsId: ${wsId}, prompt length: ${prompt.length}`);
-  if (processedMessageIds.has(id)) {
-    logger.warn(`[REQUEST ${id}] Duplicate request detected - ignoring`);
-  }
-  processedMessageIds.add(id);
-  logger.debug(`[REQUEST ${id}] Message ID marked as processed (${processedMessageIds.size} total)`);
-  if (processedMessageIds.size > 100) {
-    const firstId = processedMessageIds.values().next().value;
-    if (firstId) {
-      processedMessageIds.delete(firstId);
-      logger.debug(`[REQUEST ${id}] Cleaned up old message ID from cache`);
-    }
-  }
   if (!SA_RUNTIME) {
     errors.push("SA_RUNTIME is required");
   }
@@ -3761,9 +4360,7 @@ var get_user_request = async (data, components, sendMessage, anthropicApiKey, gr
   if (!prompt) {
     errors.push("Prompt not found");
   }
-  if (!components || components.length === 0) {
-    errors.push("Components 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 };
   }
@@ -3777,8 +4374,44 @@ var get_user_request = async (data, components, sendMessage, anthropicApiKey, gr
   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);
+  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) {
@@ -3795,16 +4428,21 @@ var get_user_request = async (data, components, sendMessage, anthropicApiKey, gr
   }
   let component = null;
   let textResponse = null;
+  let actions = [];
   if (userResponse.data) {
     if (typeof userResponse.data === "object") {
       if ("component" in userResponse.data) {
         component = userResponse.data.component;
       }
       if ("textResponse" in userResponse.data) {
-        textResponse = userResponse.data.textResponse;
+        textResponse = userResponse.data.text;
+      }
+      if ("actions" in userResponse.data) {
+        actions = userResponse.data.actions || [];
       }
     }
   }
+  const finalTextResponse = responseMode === "text" && accumulatedStreamResponse ? accumulatedStreamResponse : textResponse;
   const uiBlock = new UIBlock(
     prompt,
     {},
@@ -3812,11 +4450,15 @@ var get_user_request = async (data, components, sendMessage, anthropicApiKey, gr
     component,
     // generatedComponentMetadata: full component object (ComponentSchema)
     [],
-    // actions: empty initially
+    // actions: empty initially, will be set below
     uiBlockId,
-    textResponse
-    // textResponse: text response from LLM
+    finalTextResponse
+    // textResponse: FULL streaming response including all intermediate messages
   );
+  if (actions.length > 0) {
+    uiBlock.setActions(actions);
+    logger.info(`Stored ${actions.length} actions in UIBlock: ${uiBlockId}`);
+  }
   thread.addUIBlock(uiBlock);
   logger.info(`Created UIBlock: ${uiBlockId} in Thread: ${threadId}`);
   return {
@@ -3829,8 +4471,8 @@ var get_user_request = async (data, components, sendMessage, anthropicApiKey, gr
     wsId
   };
 };
-async function handleUserPromptRequest(data, components, sendMessage, anthropicApiKey, groqApiKey, llmProviders) {
-  const response = await get_user_request(data, components, sendMessage, anthropicApiKey, groqApiKey, llmProviders);
+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,
     {
@@ -4054,7 +4696,6 @@ 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) {
@@ -4906,7 +5547,7 @@ function sendResponse5(id, res, sendMessage, clientId) {
 }
 
 // src/auth/user-manager.ts
-var import_fs3 = __toESM(require("fs"));
+var import_fs4 = __toESM(require("fs"));
 var import_path3 = __toESM(require("path"));
 var import_os = __toESM(require("os"));
 var UserManager = class {
@@ -4946,19 +5587,19 @@ var UserManager = class {
   async loadUsersFromFile() {
     try {
       const dir = import_path3.default.dirname(this.filePath);
-      if (!import_fs3.default.existsSync(dir)) {
+      if (!import_fs4.default.existsSync(dir)) {
         logger.info(`Creating directory structure: ${dir}`);
-        import_fs3.default.mkdirSync(dir, { recursive: true });
+        import_fs4.default.mkdirSync(dir, { recursive: true });
       }
-      if (!import_fs3.default.existsSync(this.filePath)) {
+      if (!import_fs4.default.existsSync(this.filePath)) {
         logger.info(`Users file does not exist at ${this.filePath}, creating with empty users`);
         const initialData = { users: [] };
-        import_fs3.default.writeFileSync(this.filePath, JSON.stringify(initialData, null, 4));
+        import_fs4.default.writeFileSync(this.filePath, JSON.stringify(initialData, null, 4));
         this.users = [];
         this.hasChanged = false;
         return;
       }
-      const fileContent = import_fs3.default.readFileSync(this.filePath, "utf-8");
+      const fileContent = import_fs4.default.readFileSync(this.filePath, "utf-8");
       const rawData = JSON.parse(fileContent);
       const validatedData = UsersDataSchema.parse(rawData);
       this.users = validatedData.users;
@@ -4978,15 +5619,15 @@ var UserManager = class {
     }
     try {
       const dir = import_path3.default.dirname(this.filePath);
-      if (!import_fs3.default.existsSync(dir)) {
-        import_fs3.default.mkdirSync(dir, { recursive: true });
+      if (!import_fs4.default.existsSync(dir)) {
+        import_fs4.default.mkdirSync(dir, { recursive: true });
       }
       const usersToSave = this.users.map((user) => {
         const { wsIds, ...userWithoutWsIds } = user;
         return userWithoutWsIds;
       });
       const data = { users: usersToSave };
-      import_fs3.default.writeFileSync(this.filePath, JSON.stringify(data, null, 4));
+      import_fs4.default.writeFileSync(this.filePath, JSON.stringify(data, null, 4));
       this.hasChanged = false;
       logger.debug(`Synced ${this.users.length} users to file (wsIds excluded)`);
     } catch (error) {
@@ -5204,7 +5845,7 @@ var UserManager = class {
 };
 
 // src/dashboards/dashboard-manager.ts
-var import_fs4 = __toESM(require("fs"));
+var import_fs5 = __toESM(require("fs"));
 var import_path4 = __toESM(require("path"));
 var import_os2 = __toESM(require("os"));
 var DashboardManager = class {
@@ -5239,12 +5880,12 @@ var DashboardManager = class {
   createDashboard(dashboardId, dashboard) {
     const dashboardPath = this.getDashboardPath(dashboardId);
     const dashboardDir = import_path4.default.dirname(dashboardPath);
-    if (import_fs4.default.existsSync(dashboardPath)) {
+    if (import_fs5.default.existsSync(dashboardPath)) {
       throw new Error(`Dashboard '${dashboardId}' already exists`);
     }
     const validated = DSLRendererPropsSchema.parse(dashboard);
-    import_fs4.default.mkdirSync(dashboardDir, { recursive: true });
-    import_fs4.default.writeFileSync(dashboardPath, JSON.stringify(validated, null, 4));
+    import_fs5.default.mkdirSync(dashboardDir, { recursive: true });
+    import_fs5.default.writeFileSync(dashboardPath, JSON.stringify(validated, null, 4));
     logger.info(`Dashboard created: ${dashboardId}`);
     return validated;
   }
@@ -5255,12 +5896,12 @@ var DashboardManager = class {
    */
   getDashboard(dashboardId) {
     const dashboardPath = this.getDashboardPath(dashboardId);
-    if (!import_fs4.default.existsSync(dashboardPath)) {
+    if (!import_fs5.default.existsSync(dashboardPath)) {
       logger.warn(`Dashboard not found: ${dashboardId}`);
       return null;
     }
     try {
-      const fileContent = import_fs4.default.readFileSync(dashboardPath, "utf-8");
+      const fileContent = import_fs5.default.readFileSync(dashboardPath, "utf-8");
       const dashboard = JSON.parse(fileContent);
       const validated = DSLRendererPropsSchema.parse(dashboard);
       return validated;
@@ -5274,16 +5915,16 @@ var DashboardManager = class {
    * @returns Array of dashboard objects with their IDs
    */
   getAllDashboards() {
-    if (!import_fs4.default.existsSync(this.dashboardsBasePath)) {
-      import_fs4.default.mkdirSync(this.dashboardsBasePath, { recursive: true });
+    if (!import_fs5.default.existsSync(this.dashboardsBasePath)) {
+      import_fs5.default.mkdirSync(this.dashboardsBasePath, { recursive: true });
       return [];
     }
     const dashboards = [];
     try {
-      const dashboardDirs = import_fs4.default.readdirSync(this.dashboardsBasePath);
+      const dashboardDirs = import_fs5.default.readdirSync(this.dashboardsBasePath);
       for (const dashboardId of dashboardDirs) {
         const dashboardPath = this.getDashboardPath(dashboardId);
-        if (import_fs4.default.existsSync(dashboardPath)) {
+        if (import_fs5.default.existsSync(dashboardPath)) {
           const dashboard = this.getDashboard(dashboardId);
           if (dashboard) {
             dashboards.push({ dashboardId, dashboard });
@@ -5305,13 +5946,13 @@ var DashboardManager = class {
    */
   updateDashboard(dashboardId, dashboard) {
     const dashboardPath = this.getDashboardPath(dashboardId);
-    if (!import_fs4.default.existsSync(dashboardPath)) {
+    if (!import_fs5.default.existsSync(dashboardPath)) {
       logger.warn(`Dashboard not found for update: ${dashboardId}`);
       return null;
     }
     try {
       const validated = DSLRendererPropsSchema.parse(dashboard);
-      import_fs4.default.writeFileSync(dashboardPath, JSON.stringify(validated, null, 4));
+      import_fs5.default.writeFileSync(dashboardPath, JSON.stringify(validated, null, 4));
       logger.info(`Dashboard updated: ${dashboardId}`);
       return validated;
     } catch (error) {
@@ -5327,12 +5968,12 @@ var DashboardManager = class {
   deleteDashboard(dashboardId) {
     const dashboardPath = this.getDashboardPath(dashboardId);
     const dashboardDir = import_path4.default.dirname(dashboardPath);
-    if (!import_fs4.default.existsSync(dashboardPath)) {
+    if (!import_fs5.default.existsSync(dashboardPath)) {
       logger.warn(`Dashboard not found for deletion: ${dashboardId}`);
       return false;
     }
     try {
-      import_fs4.default.rmSync(dashboardDir, { recursive: true, force: true });
+      import_fs5.default.rmSync(dashboardDir, { recursive: true, force: true });
       logger.info(`Dashboard deleted: ${dashboardId}`);
       return true;
     } catch (error) {
@@ -5347,21 +5988,21 @@ var DashboardManager = class {
    */
   dashboardExists(dashboardId) {
     const dashboardPath = this.getDashboardPath(dashboardId);
-    return import_fs4.default.existsSync(dashboardPath);
+    return import_fs5.default.existsSync(dashboardPath);
   }
   /**
    * Get dashboard count
    * @returns Number of dashboards
    */
   getDashboardCount() {
-    if (!import_fs4.default.existsSync(this.dashboardsBasePath)) {
+    if (!import_fs5.default.existsSync(this.dashboardsBasePath)) {
       return 0;
     }
     try {
-      const dashboardDirs = import_fs4.default.readdirSync(this.dashboardsBasePath);
+      const dashboardDirs = import_fs5.default.readdirSync(this.dashboardsBasePath);
       return dashboardDirs.filter((dir) => {
         const dashboardPath = this.getDashboardPath(dir);
-        return import_fs4.default.existsSync(dashboardPath);
+        return import_fs5.default.existsSync(dashboardPath);
       }).length;
     } catch (error) {
       logger.error("Failed to get dashboard count:", error);
@@ -5371,7 +6012,7 @@ var DashboardManager = class {
 };
 
 // src/reports/report-manager.ts
-var import_fs5 = __toESM(require("fs"));
+var import_fs6 = __toESM(require("fs"));
 var import_path5 = __toESM(require("path"));
 var import_os3 = __toESM(require("os"));
 var ReportManager = class {
@@ -5406,12 +6047,12 @@ var ReportManager = class {
   createReport(reportId, report) {
     const reportPath = this.getReportPath(reportId);
     const reportDir = import_path5.default.dirname(reportPath);
-    if (import_fs5.default.existsSync(reportPath)) {
+    if (import_fs6.default.existsSync(reportPath)) {
       throw new Error(`Report '${reportId}' already exists`);
     }
     const validated = DSLRendererPropsSchema2.parse(report);
-    import_fs5.default.mkdirSync(reportDir, { recursive: true });
-    import_fs5.default.writeFileSync(reportPath, JSON.stringify(validated, null, 4));
+    import_fs6.default.mkdirSync(reportDir, { recursive: true });
+    import_fs6.default.writeFileSync(reportPath, JSON.stringify(validated, null, 4));
     logger.info(`Report created: ${reportId}`);
     return validated;
   }
@@ -5422,12 +6063,12 @@ var ReportManager = class {
    */
   getReport(reportId) {
     const reportPath = this.getReportPath(reportId);
-    if (!import_fs5.default.existsSync(reportPath)) {
+    if (!import_fs6.default.existsSync(reportPath)) {
       logger.warn(`Report not found: ${reportId}`);
       return null;
     }
     try {
-      const fileContent = import_fs5.default.readFileSync(reportPath, "utf-8");
+      const fileContent = import_fs6.default.readFileSync(reportPath, "utf-8");
       const report = JSON.parse(fileContent);
       const validated = DSLRendererPropsSchema2.parse(report);
       return validated;
@@ -5441,16 +6082,16 @@ var ReportManager = class {
    * @returns Array of report objects with their IDs
    */
   getAllReports() {
-    if (!import_fs5.default.existsSync(this.reportsBasePath)) {
-      import_fs5.default.mkdirSync(this.reportsBasePath, { recursive: true });
+    if (!import_fs6.default.existsSync(this.reportsBasePath)) {
+      import_fs6.default.mkdirSync(this.reportsBasePath, { recursive: true });
       return [];
     }
     const reports = [];
     try {
-      const reportDirs = import_fs5.default.readdirSync(this.reportsBasePath);
+      const reportDirs = import_fs6.default.readdirSync(this.reportsBasePath);
       for (const reportId of reportDirs) {
         const reportPath = this.getReportPath(reportId);
-        if (import_fs5.default.existsSync(reportPath)) {
+        if (import_fs6.default.existsSync(reportPath)) {
           const report = this.getReport(reportId);
           if (report) {
             reports.push({ reportId, report });
@@ -5472,13 +6113,13 @@ var ReportManager = class {
    */
   updateReport(reportId, report) {
     const reportPath = this.getReportPath(reportId);
-    if (!import_fs5.default.existsSync(reportPath)) {
+    if (!import_fs6.default.existsSync(reportPath)) {
       logger.warn(`Report not found for update: ${reportId}`);
       return null;
     }
     try {
       const validated = DSLRendererPropsSchema2.parse(report);
-      import_fs5.default.writeFileSync(reportPath, JSON.stringify(validated, null, 4));
+      import_fs6.default.writeFileSync(reportPath, JSON.stringify(validated, null, 4));
       logger.info(`Report updated: ${reportId}`);
       return validated;
     } catch (error) {
@@ -5494,12 +6135,12 @@ var ReportManager = class {
   deleteReport(reportId) {
     const reportPath = this.getReportPath(reportId);
     const reportDir = import_path5.default.dirname(reportPath);
-    if (!import_fs5.default.existsSync(reportPath)) {
+    if (!import_fs6.default.existsSync(reportPath)) {
       logger.warn(`Report not found for deletion: ${reportId}`);
       return false;
     }
     try {
-      import_fs5.default.rmSync(reportDir, { recursive: true, force: true });
+      import_fs6.default.rmSync(reportDir, { recursive: true, force: true });
       logger.info(`Report deleted: ${reportId}`);
       return true;
     } catch (error) {
@@ -5514,21 +6155,21 @@ var ReportManager = class {
    */
   reportExists(reportId) {
     const reportPath = this.getReportPath(reportId);
-    return import_fs5.default.existsSync(reportPath);
+    return import_fs6.default.existsSync(reportPath);
   }
   /**
    * Get report count
    * @returns Number of reports
    */
   getReportCount() {
-    if (!import_fs5.default.existsSync(this.reportsBasePath)) {
+    if (!import_fs6.default.existsSync(this.reportsBasePath)) {
       return 0;
     }
     try {
-      const reportDirs = import_fs5.default.readdirSync(this.reportsBasePath);
+      const reportDirs = import_fs6.default.readdirSync(this.reportsBasePath);
       return reportDirs.filter((dir) => {
         const reportPath = this.getReportPath(dir);
-        return import_fs5.default.existsSync(reportPath);
+        return import_fs6.default.existsSync(reportPath);
       }).length;
     } catch (error) {
       logger.error("Failed to get report count:", error);
@@ -5752,9 +6393,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
@@ -5820,6 +6458,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);
@@ -5882,7 +6524,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;