@superatomai/sdk-node 0.0.71 → 0.0.74

package/dist/index.js

@@ -34,7 +34,6 @@ __export(index_exports, {
   CONTEXT_CONFIG: () => CONTEXT_CONFIG,
   CleanupService: () => CleanupService,
   LLM: () => LLM,
-  SDK_VERSION: () => SDK_VERSION,
   STORAGE_CONFIG: () => STORAGE_CONFIG,
   SuperatomSDK: () => SuperatomSDK,
   Thread: () => Thread,
@@ -1516,6 +1515,351 @@ var QueryCache = class {
 };
 var queryCache = new QueryCache();
 
+// src/userResponse/llm-result-truncator.ts
+var DEFAULT_MAX_ROWS = 10;
+var DEFAULT_MAX_CHARS_PER_FIELD = 500;
+function inferFieldType(value) {
+  if (value === null || value === void 0) {
+    return "null";
+  }
+  if (typeof value === "string") {
+    if (isDateString(value)) {
+      return "date";
+    }
+    return "string";
+  }
+  if (typeof value === "number") {
+    return "number";
+  }
+  if (typeof value === "boolean") {
+    return "boolean";
+  }
+  if (Array.isArray(value)) {
+    return "array";
+  }
+  if (typeof value === "object") {
+    return "object";
+  }
+  return "unknown";
+}
+function isDateString(value) {
+  const datePatterns = [
+    /^\d{4}-\d{2}-\d{2}$/,
+    // YYYY-MM-DD
+    /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/,
+    // ISO 8601
+    /^\d{2}\/\d{2}\/\d{4}$/,
+    // MM/DD/YYYY
+    /^\d{4}\/\d{2}\/\d{2}$/
+    // YYYY/MM/DD
+  ];
+  return datePatterns.some((pattern) => pattern.test(value));
+}
+function truncateTextField(value, maxLength) {
+  if (value.length <= maxLength) {
+    return { text: value, wasTruncated: false };
+  }
+  const truncated = value.substring(0, maxLength);
+  const remaining = value.length - maxLength;
+  return {
+    text: `${truncated}... (${remaining} more chars)`,
+    wasTruncated: true
+  };
+}
+function truncateFieldValue(value, maxCharsPerField) {
+  if (value === null || value === void 0) {
+    return { value, wasTruncated: false };
+  }
+  if (typeof value === "number" || typeof value === "boolean") {
+    return { value, wasTruncated: false };
+  }
+  if (typeof value === "string") {
+    const result2 = truncateTextField(value, maxCharsPerField);
+    return { value: result2.text, wasTruncated: result2.wasTruncated };
+  }
+  if (Array.isArray(value)) {
+    if (value.length === 0) {
+      return { value: [], wasTruncated: false };
+    }
+    const preview = value.slice(0, 3);
+    const hasMore = value.length > 3;
+    return {
+      value: hasMore ? `[${preview.join(", ")}... (${value.length} items)]` : value,
+      wasTruncated: hasMore
+    };
+  }
+  if (typeof value === "object") {
+    const jsonStr = JSON.stringify(value);
+    const result2 = truncateTextField(jsonStr, maxCharsPerField);
+    return { value: result2.text, wasTruncated: result2.wasTruncated };
+  }
+  const strValue = String(value);
+  const result = truncateTextField(strValue, maxCharsPerField);
+  return { value: result.text, wasTruncated: result.wasTruncated };
+}
+function truncateRow(row, maxCharsPerField) {
+  const truncatedRow = {};
+  const truncatedFields = /* @__PURE__ */ new Set();
+  for (const [key, value] of Object.entries(row)) {
+    const result = truncateFieldValue(value, maxCharsPerField);
+    truncatedRow[key] = result.value;
+    if (result.wasTruncated) {
+      truncatedFields.add(key);
+    }
+  }
+  return { row: truncatedRow, truncatedFields };
+}
+function extractMetadataFromObject(obj, dataKey, maxCharsPerField) {
+  const metadata = {};
+  const truncatedFields = /* @__PURE__ */ new Set();
+  for (const [key, value] of Object.entries(obj)) {
+    if (key === dataKey) {
+      continue;
+    }
+    if (Array.isArray(value)) {
+      continue;
+    }
+    const result = truncateFieldValue(value, maxCharsPerField);
+    metadata[key] = result.value;
+    if (result.wasTruncated) {
+      truncatedFields.add(key);
+    }
+  }
+  return { metadata, truncatedFields };
+}
+function extractSchema(data, truncatedFields = /* @__PURE__ */ new Set()) {
+  if (!data || data.length === 0) {
+    return [];
+  }
+  const firstRow = data[0];
+  const schema2 = [];
+  for (const [name, value] of Object.entries(firstRow)) {
+    schema2.push({
+      name,
+      type: inferFieldType(value),
+      truncated: truncatedFields.has(name) ? true : void 0
+    });
+  }
+  return schema2;
+}
+function truncateDataArray(data, options = {}) {
+  const maxRows = options.maxRows ?? DEFAULT_MAX_ROWS;
+  const maxCharsPerField = options.maxCharsPerField ?? DEFAULT_MAX_CHARS_PER_FIELD;
+  if (!data || !Array.isArray(data)) {
+    return {
+      data: [],
+      totalRecords: 0,
+      recordsShown: 0,
+      truncatedFields: /* @__PURE__ */ new Set()
+    };
+  }
+  const totalRecords = data.length;
+  const rowsToProcess = data.slice(0, maxRows);
+  const truncatedData = [];
+  const allTruncatedFields = /* @__PURE__ */ new Set();
+  for (const row of rowsToProcess) {
+    const { row: truncatedRow, truncatedFields } = truncateRow(row, maxCharsPerField);
+    truncatedData.push(truncatedRow);
+    for (const field of truncatedFields) {
+      allTruncatedFields.add(field);
+    }
+  }
+  return {
+    data: truncatedData,
+    totalRecords,
+    recordsShown: truncatedData.length,
+    truncatedFields: allTruncatedFields
+  };
+}
+function buildTruncationNote(totalRecords, recordsShown, truncatedFields, maxCharsPerField, sourceName) {
+  const parts = [];
+  if (totalRecords > recordsShown) {
+    const source = sourceName ? ` from ${sourceName}` : "";
+    parts.push(`Showing ${recordsShown} of ${totalRecords} total records${source}`);
+  }
+  if (truncatedFields.size > 0) {
+    const fieldList = Array.from(truncatedFields).join(", ");
+    parts.push(`Fields truncated to ${maxCharsPerField} chars: ${fieldList}`);
+  }
+  return parts.length > 0 ? parts.join(". ") + "." : null;
+}
+function formatQueryResultForLLM(data, options = {}) {
+  const maxCharsPerField = options.maxCharsPerField ?? DEFAULT_MAX_CHARS_PER_FIELD;
+  if (!Array.isArray(data)) {
+    if (data !== null && data !== void 0) {
+      return {
+        summary: {
+          totalRecords: 1,
+          recordsShown: 1,
+          schema: [{ name: "result", type: inferFieldType(data) }]
+        },
+        data: [{ result: data }],
+        truncationNote: null
+      };
+    }
+    return {
+      summary: {
+        totalRecords: 0,
+        recordsShown: 0,
+        schema: []
+      },
+      data: [],
+      truncationNote: null
+    };
+  }
+  const {
+    data: truncatedData,
+    totalRecords,
+    recordsShown,
+    truncatedFields
+  } = truncateDataArray(data, options);
+  const schema2 = extractSchema(truncatedData, truncatedFields);
+  const truncationNote = buildTruncationNote(
+    totalRecords,
+    recordsShown,
+    truncatedFields,
+    maxCharsPerField,
+    "query"
+  );
+  return {
+    summary: {
+      totalRecords,
+      recordsShown,
+      schema: schema2
+    },
+    data: truncatedData,
+    truncationNote
+  };
+}
+function formatToolResultForLLM(result, options = {}) {
+  const { toolName, toolLimit } = options;
+  const effectiveMaxRows = toolLimit ?? options.maxRows ?? DEFAULT_MAX_ROWS;
+  const maxCharsPerField = options.maxCharsPerField ?? DEFAULT_MAX_CHARS_PER_FIELD;
+  if (result === null || result === void 0) {
+    return {
+      toolName,
+      summary: {
+        totalRecords: 0,
+        recordsShown: 0,
+        schema: []
+      },
+      data: [],
+      truncationNote: null
+    };
+  }
+  if (typeof result === "string") {
+    const { text, wasTruncated } = truncateTextField(result, maxCharsPerField);
+    return {
+      toolName,
+      summary: {
+        totalRecords: 1,
+        recordsShown: 1,
+        schema: [{ name: "result", type: "string", truncated: wasTruncated || void 0 }]
+      },
+      data: [{ result: text }],
+      truncationNote: wasTruncated ? `Result truncated to ${maxCharsPerField} chars.` : null
+    };
+  }
+  if (Array.isArray(result)) {
+    const {
+      data: truncatedData,
+      totalRecords,
+      recordsShown,
+      truncatedFields
+    } = truncateDataArray(result, {
+      maxRows: effectiveMaxRows,
+      maxCharsPerField
+    });
+    const schema2 = extractSchema(truncatedData, truncatedFields);
+    const truncationNote = buildTruncationNote(
+      totalRecords,
+      recordsShown,
+      truncatedFields,
+      maxCharsPerField,
+      toolName
+    );
+    return {
+      toolName,
+      summary: {
+        totalRecords,
+        recordsShown,
+        schema: schema2
+      },
+      data: truncatedData,
+      truncationNote
+    };
+  }
+  if (typeof result === "object") {
+    const objResult = result;
+    const dataWrapperKeys = ["data", "results", "items", "records", "rows", "list"];
+    for (const key of dataWrapperKeys) {
+      if (Array.isArray(objResult[key])) {
+        const innerData = objResult[key];
+        const {
+          data: truncatedData,
+          totalRecords,
+          recordsShown,
+          truncatedFields: dataTruncatedFields
+        } = truncateDataArray(innerData, {
+          maxRows: effectiveMaxRows,
+          maxCharsPerField
+        });
+        const {
+          metadata,
+          truncatedFields: metadataTruncatedFields
+        } = extractMetadataFromObject(objResult, key, maxCharsPerField);
+        const allTruncatedFields = /* @__PURE__ */ new Set([...dataTruncatedFields, ...metadataTruncatedFields]);
+        const schema3 = extractSchema(truncatedData, dataTruncatedFields);
+        const truncationNote2 = buildTruncationNote(
+          totalRecords,
+          recordsShown,
+          allTruncatedFields,
+          maxCharsPerField,
+          toolName
+        );
+        const hasMetadata = Object.keys(metadata).length > 0;
+        return {
+          toolName,
+          summary: {
+            totalRecords,
+            recordsShown,
+            schema: schema3
+          },
+          ...hasMetadata && { metadata },
+          data: truncatedData,
+          truncationNote: truncationNote2
+        };
+      }
+    }
+    const { row: truncatedRow, truncatedFields } = truncateRow(objResult, maxCharsPerField);
+    const schema2 = extractSchema([truncatedRow], truncatedFields);
+    const truncationNote = truncatedFields.size > 0 ? `Fields truncated to ${maxCharsPerField} chars: ${Array.from(truncatedFields).join(", ")}.` : null;
+    return {
+      toolName,
+      summary: {
+        totalRecords: 1,
+        recordsShown: 1,
+        schema: schema2
+      },
+      data: [truncatedRow],
+      truncationNote
+    };
+  }
+  return {
+    toolName,
+    summary: {
+      totalRecords: 1,
+      recordsShown: 1,
+      schema: [{ name: "result", type: inferFieldType(result) }]
+    },
+    data: [{ result }],
+    truncationNote: null
+  };
+}
+function formatResultAsString(formattedResult) {
+  return JSON.stringify(formattedResult, null, 2);
+}
+
 // src/handlers/data-request.ts
 function getQueryCacheKey(query) {
   if (typeof query === "string") {
@@ -1597,15 +1941,25 @@ async function handleDataRequest(data, collections, sendMessage) {
         }
       }
       if (uiBlock) {
+        const formattedResult = formatToolResultForLLM(result, {
+          maxRows: 3,
+          // Only need a few sample rows for summary
+          maxCharsPerField: 100
+          // Short truncation for summary
+        });
         const dataSummary = {
           _dataReceived: true,
           _timestamp: (/* @__PURE__ */ new Date()).toISOString(),
           _collection: collection,
           _operation: op,
-          _recordCount: Array.isArray(result) ? result.length : result?.data?.length || result?.contacts?.length || result?.salesorders?.length || "unknown"
+          _totalRecords: formattedResult.summary.totalRecords,
+          _recordsShown: formattedResult.summary.recordsShown,
+          _metadata: formattedResult.metadata,
+          // Preserve totalItems, totalDeadstockItems, etc.
+          _schema: formattedResult.summary.schema
         };
         uiBlock.setComponentData(dataSummary);
-        logger.info(`Updated UIBlock ${uiBlockId} with data summary from ${collection}.${op} (full data not stored to save memory)`);
+        logger.info(`Updated UIBlock ${uiBlockId} with data summary from ${collection}.${op} (${formattedResult.summary.totalRecords} total records)`);
       } else {
         logger.warn(`UIBlock ${uiBlockId} not found in threads`);
       }
@@ -3013,24 +3367,20 @@ If adaptation is not possible or would fundamentally change the component:
   "dash-comp-picker": {
     system: `You are a component selection expert that picks the best dashboard component and generates complete props based on user requests.
 
+## CRITICAL - READ FIRST
+
+1. Your ENTIRE response must be ONLY a raw JSON object - start with { end with }
+2. DO NOT explain or answer the user's question in natural language
+3. DO NOT use markdown code blocks (no \`\`\`)
+4. DO NOT add any text before or after the JSON
+5. After executing tools (if needed), return JSON with component selection - NOT a text summary of results
+
 ## Your Task
 
 Analyze the user's request and:
 1. **Select the most appropriate component** from the available components list
-2. **Determine the data source**: Database query OR External tool
-3. **Generate complete props** for the selected component
-
-## Available External Tools
-
-The following external tools are available:
-
-{{AVAILABLE_TOOLS}}
-
-When a tool is needed to complete the user's request:
-1. **Analyze the request** to determine which tool is needed
-2. **Extract parameters** from the user's question
-3. **Execute the tool** by calling it with the extracted parameters
-4. **Use the results** to configure the component (field names for axes, columns, etc.)
+2. **Determine the data source**: Database query OR External tool (ERP)
+3. **Generate complete props** for the selected component including the data retrieval/modification method
 
 ## Component Selection Rules
 
@@ -3060,7 +3410,7 @@ The user prompt may contain an **existing component** to update. Detect this by
 
 ### Use DATABASE when:
 - User asks about data that exists in the database schema
-- Questions about internal business data
+- Questions about internal business data 
 - CRUD operations on database tables
 
 ### Use EXTERNAL TOOL when:
@@ -3073,6 +3423,12 @@ The user prompt may contain an **existing component** to update. Detect this by
 
 **CRITICAL**: Look at each component's "Props Structure" in the available components list. Generate ALL props that the component expects.
 
+**CRITICAL: Each component uses EXACTLY ONE data source - never both!**
+- If using \`query\`, set \`externalTool: null\`
+- If using \`externalTool\`, set \`query: null\`
+- NEVER copy placeholder/description text from component metadata as actual values
+- \`externalTool.parameters\` MUST be an object, never a string
+
 ### For Data Viewing Components (charts, tables, KPIs):
 
 **Option A: Database Query** (when data is in database)
@@ -3081,21 +3437,19 @@ The user prompt may contain an **existing component** to update. Detect this by
   "query": {
     "sql": "SELECT column1, column2 FROM table WHERE condition = $param LIMIT 32",
     "params": { "param": "value" }
-  }
+  },
+  "externalTool": null
 }
 \`\`\`
 
 **Option B: External Tool** (when data is from ERP/external system)
 \`\`\`json
 {
+  "query": null,
   "externalTool": {
     "toolId": "tool_id_from_list",
     "toolName": "Tool Display Name",
-    "action": "get",
-    "params": {
-      "param1": "value1",
-      "param2": "value2"
-    }
+    "parameters": { "param1": "value1", "param2": "value2" }
   }
 }
 \`\`\`
@@ -3109,6 +3463,7 @@ The user prompt may contain an **existing component** to update. Detect this by
     "sql": "INSERT INTO table (col1, col2) VALUES ($col1, $col2)",
     "params": {}
   },
+  "externalTool": null,
   "fields": [
     { "name": "col1", "type": "text", "required": true },
     { "name": "col2", "type": "number", "required": false }
@@ -3116,16 +3471,38 @@ The user prompt may contain an **existing component** to update. Detect this by
 }
 \`\`\`
 
+For UPDATE:
+\`\`\`json
+{
+  "query": {
+    "sql": "UPDATE table SET col1 = $col1, col2 = $col2 WHERE id = $id",
+    "params": { "id": "record_id" }
+  },
+  "externalTool": null
+}
+\`\`\`
+
+For DELETE:
+\`\`\`json
+{
+  "query": {
+    "sql": "DELETE FROM table WHERE id = $id",
+    "params": { "id": "record_id" }
+  },
+  "externalTool": null,
+  "submitButtonText": "Confirm Delete",
+  "submitButtonColor": "danger"
+}
+\`\`\`
+
 **Option B: External Tool Mutation**
 \`\`\`json
 {
+  "query": null,
   "externalTool": {
     "toolId": "tool_id_from_list",
     "toolName": "Tool Display Name",
-    "action": "create|update|delete",
-    "params": {
-      "param1": "value_or_placeholder"
-    }
+    "parameters": { "param1": "value_or_placeholder" }
   },
   "fields": [
     { "name": "param1", "type": "text", "required": true }
@@ -3140,6 +3517,7 @@ The user prompt may contain an **existing component** to update. Detect this by
 
 You MUST respond with ONLY a valid JSON object (no markdown, no code blocks):
 
+\`\`\`json
 {
   "componentId": "id_from_available_list_or_existing_component_id",
   "componentName": "name_of_component",
@@ -3154,6 +3532,7 @@ You MUST respond with ONLY a valid JSON object (no markdown, no code blocks):
     // Include all other required props (title, description, config, fields, etc.)
   }
 }
+\`\`\`
 
 **CRITICAL:**
 - Return ONLY valid JSON (no markdown code blocks, no text before/after)
@@ -3176,7 +3555,8 @@ You MUST respond with ONLY a valid JSON object (no markdown, no code blocks):
 
 ---
 
-## CONTEXT`,
+## CONTEXT
+`,
     user: `{{USER_PROMPT}}`
   },
   "dash-filter-picker": {
@@ -3322,9 +3702,7 @@ var PromptLoader = class {
     this.databaseRulesCache = /* @__PURE__ */ new Map();
     this.isInitialized = false;
     this.databaseType = "postgresql";
-    logger.debug("Initializing PromptLoader...");
     this.promptsDir = config?.promptsDir || import_path.default.join(process.cwd(), ".prompts");
-    logger.debug(`Prompts directory set to: ${this.promptsDir}`);
   }
   /**
    * Load a prompt template from file system OR fallback to hardcoded prompts
@@ -3338,7 +3716,6 @@ var PromptLoader = class {
       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");
-        logger.info(`\u2713 Loaded prompt '${promptName}' from file system: ${this.promptsDir}`);
         return { system, user };
       }
     } catch (error) {
@@ -3346,7 +3723,6 @@ var PromptLoader = class {
     }
     const hardcodedPrompt = PROMPTS[promptName];
     if (hardcodedPrompt) {
-      logger.info(`\u2713 Loaded prompt '${promptName}' from hardcoded fallback`);
       return hardcodedPrompt;
     }
     throw new Error(`Prompt template '${promptName}' not found in either ${this.promptsDir} or hardcoded prompts. Available prompts: ${Object.keys(PROMPTS).join(", ")}`);
@@ -3360,7 +3736,6 @@ var PromptLoader = class {
       logger.debug("PromptLoader already initialized, skipping...");
       return;
     }
-    logger.info("Loading prompts into memory...");
     const promptTypes = Object.keys(PROMPTS);
     for (const promptName of promptTypes) {
       try {
@@ -3372,7 +3747,6 @@ var PromptLoader = class {
       }
     }
     this.isInitialized = true;
-    logger.info(`Successfully loaded ${this.promptCache.size} prompt templates into memory`);
   }
   /**
    * Replace variables in a template string using {{VARIABLE_NAME}} pattern
@@ -3412,7 +3786,6 @@ var PromptLoader = class {
       const processedContext = this.replaceVariables(contextMarker + contextPart, variables);
       const staticLength = processedStatic.length;
       const contextLength = processedContext.length;
-      logger.debug(`\u2713 Prompt caching enabled for '${promptName}' (cached: ${staticLength} chars, dynamic: ${contextLength} chars)`);
       return {
         system: [
           {
@@ -3449,7 +3822,6 @@ var PromptLoader = class {
     this.promptsDir = dir;
     this.isInitialized = false;
     this.promptCache.clear();
-    logger.debug(`Prompts directory changed to: ${dir}`);
   }
   /**
    * Get current prompts directory
@@ -3477,7 +3849,6 @@ var PromptLoader = class {
   setDatabaseType(type) {
     this.databaseType = type;
     this.databaseRulesCache.clear();
-    logger.debug(`Database type set to: ${type}`);
   }
   /**
    * Get current database type
@@ -3493,7 +3864,6 @@ var PromptLoader = class {
    */
   async loadDatabaseRules() {
     if (this.databaseRulesCache.has(this.databaseType)) {
-      logger.debug(`\u2713 Database rules for '${this.databaseType}' loaded from cache`);
       return this.databaseRulesCache.get(this.databaseType);
     }
     const rulesPath = import_path.default.join(this.promptsDir, "database-rules", `${this.databaseType}.md`);
@@ -3501,7 +3871,6 @@ var PromptLoader = class {
       if (import_fs2.default.existsSync(rulesPath)) {
         const rules = import_fs2.default.readFileSync(rulesPath, "utf-8");
         this.databaseRulesCache.set(this.databaseType, rules);
-        logger.info(`\u2713 Loaded database rules for '${this.databaseType}' from ${rulesPath}`);
         return rules;
       }
     } catch (error) {
@@ -3777,7 +4146,6 @@ var Schema = class {
    * @returns Parsed schema object or null if error occurs
    */
   getDatabaseSchema() {
-    logger.info(`SCHEMA_FILE_PATH: ${this.schemaFilePath}`);
     try {
       const dir = import_path2.default.dirname(this.schemaFilePath);
       if (!import_fs3.default.existsSync(dir)) {
@@ -4046,14 +4414,6 @@ Format: [TIMESTAMP] [REQUEST_ID] [PROVIDER/MODEL] [METHOD]
     Cost: $${entry.costUSD.toFixed(6)} | Time: ${entry.durationMs}ms${toolInfo}${errorInfo}${cacheStatus}
 `;
     this.logStream?.write(logLine);
-    if (entry.cacheReadTokens && entry.cacheReadTokens > 0) {
-      console.log(`[LLM] \u26A1 CACHE HIT: ${entry.cacheReadTokens.toLocaleString()} tokens read from cache (${entry.method})`);
-    } else if (entry.cacheWriteTokens && entry.cacheWriteTokens > 0) {
-      console.log(`[LLM] \u{1F4DD} CACHE WRITE: ${entry.cacheWriteTokens.toLocaleString()} tokens cached for future requests (${entry.method})`);
-    }
-    if (process.env.SUPERATOM_LOG_LEVEL === "verbose") {
-      console.log("\n[LLM-Usage]", logLine);
-    }
   }
   /**
    * Log session summary (call at end of request)
@@ -4086,11 +4446,6 @@ Avg Time/Call: ${Math.round(this.sessionStats.totalDurationMs / this.sessionStat
 
 `;
     this.logStream?.write(summary);
-    console.log("\n[LLM-Usage] Session Summary:");
-    console.log(`  Calls: ${this.sessionStats.totalCalls} | Tokens: ${(this.sessionStats.totalInputTokens + this.sessionStats.totalOutputTokens).toLocaleString()} | Cost: $${this.sessionStats.totalCostUSD.toFixed(4)} | Time: ${(this.sessionStats.totalDurationMs / 1e3).toFixed(2)}s`);
-    if (hasCaching) {
-      console.log(`  Cache: ${this.sessionStats.totalCacheReadTokens.toLocaleString()} read, ${this.sessionStats.totalCacheWriteTokens.toLocaleString()} written | Savings: ~$${cacheReadSavings.toFixed(4)}`);
-    }
   }
   /**
    * Reset session stats (call at start of new user request)
@@ -4131,7 +4486,6 @@ Format: [TIMESTAMP] [REQUEST_ID] [PROVIDER/MODEL] [METHOD]
 `;
       this.logStream.write(header);
       this.resetSession();
-      console.log(`[LLM-Usage] Log file reset for new request: ${this.logPath}`);
     } catch (error) {
       console.error("[LLM-Usage-Logger] Failed to reset log file:", error);
     }
@@ -5605,21 +5959,20 @@ var getKnowledgeBase = async ({
 }) => {
   try {
     if (!collections || !collections["knowledge-base"] || !collections["knowledge-base"]["query"]) {
-      logger.info("[KnowledgeBase] knowledge-base.query collection not registered, skipping");
+      logger.warn("[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.info("[KnowledgeBase] No knowledge base results returned");
+      logger.warn("[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(", ")}`);
+      logger.warn(`[KnowledgeBase] Sources: ${result.metadata.sources.map((s) => s.title).join(", ")}`);
     }
     return result.content;
   } catch (error) {
@@ -5634,13 +5987,12 @@ var getGlobalKnowledgeBase = async ({
 }) => {
   try {
     if (!collections || !collections["knowledge-base"] || !collections["knowledge-base"]["getGlobal"]) {
-      logger.info("[KnowledgeBase] knowledge-base.getGlobal collection not registered, skipping");
+      logger.warn("[KnowledgeBase] knowledge-base.getGlobal collection not registered, skipping");
       return "";
     }
-    logger.info("[KnowledgeBase] Fetching global knowledge base nodes...");
     const result = await collections["knowledge-base"]["getGlobal"]({ limit });
     if (!result || !result.content) {
-      logger.info("[KnowledgeBase] No global knowledge base nodes found");
+      logger.warn("[KnowledgeBase] No global knowledge base nodes found");
       return "";
     }
     logger.info(`[KnowledgeBase] Retrieved ${result.count || 0} global knowledge base nodes`);
@@ -5658,14 +6010,13 @@ var getUserKnowledgeBase = async ({
 }) => {
   try {
     if (!userId) {
-      logger.info("[KnowledgeBase] No userId provided, skipping user knowledge base");
+      logger.warn("[KnowledgeBase] No userId provided, skipping user knowledge base");
       return "";
     }
     if (!collections || !collections["knowledge-base"] || !collections["knowledge-base"]["getByUser"]) {
-      logger.info("[KnowledgeBase] knowledge-base.getByUser collection not registered, skipping");
+      logger.warn("[KnowledgeBase] knowledge-base.getByUser collection not registered, skipping");
       return "";
     }
-    logger.info(`[KnowledgeBase] Fetching user knowledge base nodes for userId: ${userId}...`);
     const result = await collections["knowledge-base"]["getByUser"]({
       userId: Number(userId),
       limit
@@ -5688,7 +6039,6 @@ var getAllKnowledgeBase = async ({
   userId,
   topK = 3
 }) => {
-  logger.info("[KnowledgeBase] Fetching all knowledge base contexts...");
   const [globalContext, userContext, queryContext] = await Promise.all([
     getGlobalKnowledgeBase({ collections }),
     getUserKnowledgeBase({ collections, userId }),
@@ -5710,7 +6060,6 @@ var getAllKnowledgeBase = async ({
     combinedContext += "The following information is semantically relevant to the current query:\n\n";
     combinedContext += queryContext + "\n\n";
   }
-  logger.info(`[KnowledgeBase] Combined knowledge base context: global=${globalContext.length} chars, user=${userContext.length} chars, query=${queryContext.length} chars`);
   return {
     globalContext,
     userContext,
@@ -5947,11 +6296,11 @@ var searchConversationsWithReranking = async (options) => {
   } = options;
   try {
     if (!collections || !collections["conversation-history"]) {
-      logger.info("[ConversationSearch] conversation-history collection not registered, skipping");
+      logger.warn("[ConversationSearch] conversation-history collection not registered, skipping");
       return null;
     }
     if (!collections["conversation-history"]["searchMultiple"]) {
-      logger.info("[ConversationSearch] searchMultiple not available, falling back to standard search");
+      logger.warn("[ConversationSearch] searchMultiple not available, falling back to standard search");
       return searchConversations({
         userPrompt,
         collections,
@@ -5959,9 +6308,6 @@ var searchConversationsWithReranking = async (options) => {
         similarityThreshold
       });
     }
-    logger.info(`[ConversationSearch] Hybrid search for: "${userPrompt.substring(0, 50)}..."`);
-    logger.info(`[ConversationSearch] Fetching ${rerankCandidates} candidates for reranking`);
-    logger.info(`[ConversationSearch] Weights - Semantic: ${hybridOptions.semanticWeight}, BM25: ${hybridOptions.bm25Weight}`);
     const results = await collections["conversation-history"]["searchMultiple"]({
       userPrompt,
       userId,
@@ -6002,7 +6348,6 @@ var searchConversationsWithReranking = async (options) => {
     logger.info(
       `[ConversationSearch] \u2713 Found match with semantic score ${(semanticScore * 100).toFixed(2)}%`
     );
-    logger.info(`  - Returning cached result for: "${matchedUserPrompt}"`);
     return {
       uiBlock: best.uiBlock,
       similarity: semanticScore,
@@ -6022,97 +6367,335 @@ var ConversationSearch = {
 };
 var conversation_search_default = ConversationSearch;
 
-// src/userResponse/base-llm.ts
-var BaseLLM = class {
-  constructor(config) {
-    this.model = config?.model || this.getDefaultModel();
-    this.fastModel = config?.fastModel || this.getDefaultFastModel();
-    this.defaultLimit = config?.defaultLimit || 10;
-    this.apiKey = config?.apiKey;
-    this.modelStrategy = config?.modelStrategy || "fast";
-    this.conversationSimilarityThreshold = config?.conversationSimilarityThreshold || 0.8;
+// src/userResponse/prompt-extractor.ts
+function extractPromptText(content) {
+  if (content === null || content === void 0) {
+    return "";
   }
-  /**
-   * Get the appropriate model based on task type and model strategy
-   * @param taskType - 'complex' for text generation/matching, 'simple' for classification/actions
-   * @returns The model string to use for this task
-   */
-  getModelForTask(taskType) {
-    switch (this.modelStrategy) {
-      case "best":
-        return this.model;
-      case "fast":
-        return this.fastModel;
-      case "balanced":
-      default:
-        return taskType === "complex" ? this.model : this.fastModel;
+  if (typeof content === "string") {
+    return content;
+  }
+  if (Array.isArray(content)) {
+    return content.map((item) => extractContentBlockText(item)).filter((text) => text.length > 0).join("\n\n---\n\n");
+  }
+  if (content && typeof content === "object") {
+    return extractObjectText(content);
+  }
+  return String(content);
+}
+function extractContentBlockText(item) {
+  if (typeof item === "string") {
+    return item;
+  }
+  if (item && typeof item === "object") {
+    const obj = item;
+    if (typeof obj.text === "string") {
+      return obj.text;
+    }
+    if (typeof obj.content === "string") {
+      return obj.content;
     }
+    return JSON.stringify(item, null, 2);
+  }
+  return String(item);
+}
+function extractObjectText(obj) {
+  if (typeof obj.text === "string") {
+    return obj.text;
+  }
+  if (typeof obj.content === "string") {
+    return obj.content;
+  }
+  return JSON.stringify(obj, null, 2);
+}
+
+// src/userResponse/constants.ts
+var MAX_QUERY_VALIDATION_RETRIES = 3;
+var MAX_QUERY_ATTEMPTS = 6;
+var MAX_TOOL_ATTEMPTS = 3;
+var STREAM_FLUSH_INTERVAL_MS = 50;
+var PROGRESS_HEARTBEAT_INTERVAL_MS = 800;
+var STREAM_DELAY_MS = 50;
+var STREAM_IMMEDIATE_FLUSH_THRESHOLD = 100;
+var MAX_TOKENS_QUERY_FIX = 2048;
+var MAX_TOKENS_COMPONENT_MATCHING = 8192;
+var MAX_TOKENS_CLASSIFICATION = 1500;
+var MAX_TOKENS_ADAPTATION = 8192;
+var MAX_TOKENS_TEXT_RESPONSE = 4e3;
+var MAX_TOKENS_NEXT_QUESTIONS = 1200;
+var DEFAULT_MAX_ROWS_FOR_LLM = 10;
+var DEFAULT_MAX_CHARS_PER_FIELD2 = 500;
+var STREAM_PREVIEW_MAX_ROWS = 10;
+var STREAM_PREVIEW_MAX_CHARS = 200;
+var TOOL_TRACKING_MAX_ROWS = 5;
+var TOOL_TRACKING_MAX_CHARS = 200;
+var TOOL_TRACKING_SAMPLE_ROWS = 3;
+var MAX_COMPONENT_QUERY_LIMIT = 10;
+var EXACT_MATCH_SIMILARITY_THRESHOLD = 0.99;
+var DEFAULT_CONVERSATION_SIMILARITY_THRESHOLD = 0.8;
+var MAX_TOOL_CALLING_ITERATIONS = 20;
+var KNOWLEDGE_BASE_TOP_K = 3;
+
+// src/userResponse/stream-buffer.ts
+var StreamBuffer = class {
+  constructor(callback) {
+    this.buffer = "";
+    this.flushTimer = null;
+    this.fullText = "";
+    this.callback = callback;
   }
   /**
-   * Set the model strategy at runtime
-   * @param strategy - 'best', 'fast', or 'balanced'
+   * Check if the buffer has a callback configured
    */
-  setModelStrategy(strategy) {
-    this.modelStrategy = strategy;
-    logger.info(`[${this.getProviderName()}] Model strategy set to: ${strategy}`);
+  hasCallback() {
+    return !!this.callback;
   }
   /**
-   * Get the current model strategy
-   * @returns The current model strategy
+   * Get all text that has been written (including already flushed)
    */
-  getModelStrategy() {
-    return this.modelStrategy;
+  getFullText() {
+    return this.fullText;
   }
   /**
-   * Set the conversation similarity threshold at runtime
-   * @param threshold - Value between 0 and 1 (e.g., 0.8 = 80% similarity required)
+   * Write a chunk to the buffer
+   * Large chunks or chunks with newlines are flushed immediately
+   * Small chunks are batched and flushed after a short interval
+   *
+   * @param chunk - Text chunk to write
    */
-  setConversationSimilarityThreshold(threshold) {
-    if (threshold < 0 || threshold > 1) {
-      logger.warn(`[${this.getProviderName()}] Invalid threshold ${threshold}, must be between 0 and 1. Using default 0.8`);
-      this.conversationSimilarityThreshold = 0.8;
+  write(chunk) {
+    this.fullText += chunk;
+    if (!this.callback) {
       return;
     }
-    this.conversationSimilarityThreshold = threshold;
-    logger.info(`[${this.getProviderName()}] Conversation similarity threshold set to: ${threshold}`);
+    this.buffer += chunk;
+    if (chunk.includes("\n") || chunk.length > STREAM_IMMEDIATE_FLUSH_THRESHOLD) {
+      this.flushNow();
+    } else if (!this.flushTimer) {
+      this.flushTimer = setTimeout(() => this.flushNow(), STREAM_FLUSH_INTERVAL_MS);
+    }
   }
   /**
-   * Get the current conversation similarity threshold
-   * @returns The current threshold value
+   * Flush the buffer immediately
+   * Call this before tool execution or other operations that need clean output
    */
-  getConversationSimilarityThreshold() {
-    return this.conversationSimilarityThreshold;
+  flush() {
+    this.flushNow();
   }
   /**
-   * Get the API key (from instance, parameter, or environment)
+   * Internal flush implementation
    */
-  getApiKey(apiKey) {
-    return apiKey || this.apiKey || this.getDefaultApiKey();
+  flushNow() {
+    if (this.flushTimer) {
+      clearTimeout(this.flushTimer);
+      this.flushTimer = null;
+    }
+    if (this.buffer && this.callback) {
+      this.callback(this.buffer);
+      this.buffer = "";
+    }
   }
   /**
-   * Check if a component contains a Form (data_modification component)
-   * Forms have hardcoded defaultValues that become stale when cached
-   * This checks both single Form components and Forms inside MultiComponentContainer
+   * Clean up resources
+   * Call this when done with the buffer
    */
-  containsFormComponent(component) {
-    if (!component) return false;
-    if (component.type === "Form" || component.name === "DynamicForm") {
-      return true;
+  dispose() {
+    this.flush();
+    this.callback = void 0;
+  }
+};
+function streamDelay(ms = STREAM_DELAY_MS) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function withProgressHeartbeat(operation, progressMessage, streamBuffer, intervalMs = PROGRESS_HEARTBEAT_INTERVAL_MS) {
+  if (!streamBuffer.hasCallback()) {
+    return operation();
+  }
+  const startTime = Date.now();
+  await streamDelay(30);
+  streamBuffer.write(`\u23F3 ${progressMessage}`);
+  const heartbeatInterval = setInterval(() => {
+    const elapsedSeconds = Math.floor((Date.now() - startTime) / 1e3);
+    if (elapsedSeconds >= 1) {
+      streamBuffer.write(` (${elapsedSeconds}s)`);
+    }
+  }, intervalMs);
+  try {
+    const result = await operation();
+    return result;
+  } finally {
+    clearInterval(heartbeatInterval);
+    streamBuffer.write("\n\n");
+  }
+}
+
+// src/userResponse/utils/component-props-processor.ts
+var NUMERIC_CONFIG_KEYS = ["yAxisKey", "valueKey", "aggregationField", "sizeKey"];
+var STRING_CONFIG_KEYS = ["xAxisKey", "nameKey", "labelKey", "groupBy"];
+var CONFIG_FIELDS_TO_VALIDATE = [
+  "xAxisKey",
+  "yAxisKey",
+  "valueKey",
+  "nameKey",
+  "labelKey",
+  "groupBy",
+  "aggregationField",
+  "seriesKey",
+  "sizeKey",
+  "xAggregationField",
+  "yAggregationField"
+];
+function findMatchingField(fieldName, configKey, validFieldNames, fieldTypes, providerName) {
+  if (!fieldName) return null;
+  const lowerField = fieldName.toLowerCase();
+  const validFieldNamesLower = validFieldNames.map((n) => n.toLowerCase());
+  const exactIdx = validFieldNamesLower.indexOf(lowerField);
+  if (exactIdx !== -1) return validFieldNames[exactIdx];
+  const containsMatches = validFieldNames.filter(
+    (_, i) => validFieldNamesLower[i].includes(lowerField) || lowerField.includes(validFieldNamesLower[i])
+  );
+  if (containsMatches.length === 1) return containsMatches[0];
+  if (NUMERIC_CONFIG_KEYS.includes(configKey)) {
+    const numericFields = validFieldNames.filter((f) => fieldTypes[f] === "number");
+    const match = numericFields.find(
+      (f) => f.toLowerCase().includes(lowerField) || lowerField.includes(f.toLowerCase())
+    );
+    if (match) return match;
+    if (numericFields.length > 0) {
+      logger.warn(`[${providerName}] No match for "${fieldName}", using first numeric field: ${numericFields[0]}`);
+      return numericFields[0];
     }
-    if (component.type === "Container" || component.name === "MultiComponentContainer") {
-      const nestedComponents = component.props?.config?.components || [];
-      for (const nested of nestedComponents) {
-        if (nested.type === "Form" || nested.name === "DynamicForm") {
-          return true;
+  }
+  if (STRING_CONFIG_KEYS.includes(configKey)) {
+    const stringFields = validFieldNames.filter((f) => fieldTypes[f] === "string");
+    const match = stringFields.find(
+      (f) => f.toLowerCase().includes(lowerField) || lowerField.includes(f.toLowerCase())
+    );
+    if (match) return match;
+    if (stringFields.length > 0) {
+      logger.warn(`[${providerName}] No match for "${fieldName}", using first string field: ${stringFields[0]}`);
+      return stringFields[0];
+    }
+  }
+  logger.warn(`[${providerName}] No match for "${fieldName}", using first field: ${validFieldNames[0]}`);
+  return validFieldNames[0];
+}
+function validateConfigFieldNames(config, outputSchema, providerName) {
+  if (!outputSchema?.fields || !config) return config;
+  const validFieldNames = outputSchema.fields.map((f) => f.name);
+  const fieldTypes = outputSchema.fields.reduce((acc, f) => {
+    acc[f.name] = f.type;
+    return acc;
+  }, {});
+  const correctedConfig = { ...config };
+  for (const configKey of CONFIG_FIELDS_TO_VALIDATE) {
+    const fieldValue = correctedConfig[configKey];
+    if (fieldValue && typeof fieldValue === "string") {
+      if (!validFieldNames.includes(fieldValue)) {
+        const correctedField = findMatchingField(fieldValue, configKey, validFieldNames, fieldTypes, providerName);
+        if (correctedField) {
+          logger.warn(`[${providerName}] Correcting config.${configKey}: "${fieldValue}" \u2192 "${correctedField}"`);
+          correctedConfig[configKey] = correctedField;
         }
       }
     }
-    return false;
+  }
+  if (Array.isArray(correctedConfig.series)) {
+    correctedConfig.series = correctedConfig.series.map((s) => {
+      if (s.dataKey && typeof s.dataKey === "string" && !validFieldNames.includes(s.dataKey)) {
+        const correctedField = findMatchingField(s.dataKey, "yAxisKey", validFieldNames, fieldTypes, providerName);
+        if (correctedField) {
+          logger.warn(`[${providerName}] Correcting series.dataKey: "${s.dataKey}" \u2192 "${correctedField}"`);
+          return { ...s, dataKey: correctedField };
+        }
+      }
+      return s;
+    });
+  }
+  return correctedConfig;
+}
+function validateExternalTool(externalTool, executedTools, providerName) {
+  if (!externalTool) {
+    return { valid: true };
+  }
+  const toolId = externalTool.toolId;
+  const validToolIds = (executedTools || []).map((t) => t.id);
+  const isValidTool = toolId && typeof toolId === "string" && validToolIds.includes(toolId);
+  if (!isValidTool) {
+    logger.warn(`[${providerName}] externalTool.toolId "${toolId}" not found in executed tools [${validToolIds.join(", ")}], setting to null`);
+    return { valid: false };
+  }
+  const executedTool = executedTools?.find((t) => t.id === toolId);
+  return { valid: true, executedTool };
+}
+function validateAndCleanQuery(query, config) {
+  if (!query) {
+    return { query: null, wasModified: false };
+  }
+  let wasModified = false;
+  let cleanedQuery = query;
+  const queryStr = typeof query === "string" ? query : query?.sql || "";
+  if (queryStr.includes("OPENJSON") || queryStr.includes("JSON_VALUE")) {
+    logger.warn(`[${config.providerName}] Query contains OPENJSON/JSON_VALUE (invalid - cannot parse tool result), setting query to null`);
+    return { query: null, wasModified: true };
+  }
+  const { query: fixedQuery, fixed, fixes } = validateAndFixSqlQuery(queryStr);
+  if (fixed) {
+    logger.warn(`[${config.providerName}] SQL fixes applied to component query: ${fixes.join("; ")}`);
+    wasModified = true;
+    if (typeof cleanedQuery === "string") {
+      cleanedQuery = fixedQuery;
+    } else if (cleanedQuery?.sql) {
+      cleanedQuery = { ...cleanedQuery, sql: fixedQuery };
+    }
+  }
+  if (typeof cleanedQuery === "string") {
+    const limitedQuery = ensureQueryLimit(cleanedQuery, config.defaultLimit, MAX_COMPONENT_QUERY_LIMIT);
+    if (limitedQuery !== cleanedQuery) wasModified = true;
+    cleanedQuery = limitedQuery;
+  } else if (cleanedQuery?.sql) {
+    const limitedSql = ensureQueryLimit(cleanedQuery.sql, config.defaultLimit, MAX_COMPONENT_QUERY_LIMIT);
+    if (limitedSql !== cleanedQuery.sql) wasModified = true;
+    cleanedQuery = { ...cleanedQuery, sql: limitedSql };
+  }
+  return { query: cleanedQuery, wasModified };
+}
+function processComponentProps(props, executedTools, config) {
+  let cleanedProps = { ...props };
+  if (cleanedProps.externalTool) {
+    const { valid, executedTool } = validateExternalTool(
+      cleanedProps.externalTool,
+      executedTools,
+      config.providerName
+    );
+    if (!valid) {
+      cleanedProps.externalTool = null;
+    } else if (executedTool?.outputSchema?.fields && cleanedProps.config) {
+      cleanedProps.config = validateConfigFieldNames(
+        cleanedProps.config,
+        executedTool.outputSchema,
+        config.providerName
+      );
+    }
+  }
+  if (cleanedProps.query) {
+    const { query } = validateAndCleanQuery(cleanedProps.query, config);
+    cleanedProps.query = query;
+  }
+  if (cleanedProps.query && cleanedProps.externalTool) {
+    logger.info(`[${config.providerName}] Both query and externalTool exist, keeping both - frontend will decide`);
+  }
+  return cleanedProps;
+}
+
+// src/userResponse/services/query-execution-service.ts
+var QueryExecutionService = class {
+  constructor(config) {
+    this.config = config;
   }
   /**
-   * Get the cache key for a query (the exact sql param that would be sent to execute)
+   * Get the cache key for a query
    * This ensures the cache key matches what the frontend will send
-   * Used for both caching and internal deduplication
    */
   getQueryCacheKey(query) {
     if (typeof query === "string") {
@@ -6128,17 +6711,19 @@ var BaseLLM = class {
     return "";
   }
   /**
-   * Execute a query against the database for validation and caching
+   * Execute a query against the database
    * @param query - The SQL query to execute (string or object with sql/values)
    * @param collections - Collections object containing database execute function
    * @returns Object with result data and cache key
-   * @throws Error if query execution fails
    */
-  async executeQueryForValidation(query, collections) {
+  async executeQuery(query, collections) {
     const cacheKey = this.getQueryCacheKey(query);
     if (!cacheKey) {
       throw new Error("Invalid query format: expected string or object with sql property");
     }
+    if (!collections?.["database"]?.["execute"]) {
+      throw new Error("Database collection not registered. Please register database.execute collection to execute queries.");
+    }
     const result = await collections["database"]["execute"]({ sql: cacheKey });
     return { result, cacheKey };
   }
@@ -6146,7 +6731,7 @@ var BaseLLM = class {
    * Request the LLM to fix a failed SQL query
    * @param failedQuery - The query that failed execution
    * @param errorMessage - The error message from the failed execution
-   * @param componentContext - Context about the component (name, type, title)
+   * @param componentContext - Context about the component
    * @param apiKey - Optional API key
    * @returns Fixed query string
    */
@@ -6187,10 +6772,10 @@ Fixed SQL query:`;
         user: prompt
       },
       {
-        model: this.getModelForTask("simple"),
-        maxTokens: 2048,
+        model: this.config.getModelForTask("simple"),
+        maxTokens: MAX_TOKENS_QUERY_FIX,
         temperature: 0,
-        apiKey: this.getApiKey(apiKey)
+        apiKey: this.config.getApiKey(apiKey)
       }
     );
     let fixedQuery = response.trim();
@@ -6200,23 +6785,561 @@ Fixed SQL query:`;
     return validatedQuery;
   }
   /**
-   * 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 title, description, and intelligent follow-up questions (actions) based on the analysis
-   * All components are placed in a default MultiComponentContainer layout
-   * @param analysisContent - The text response containing component suggestions
-   * @param components - List of available components
-   * @param apiKey - Optional API key
-   * @param logCollector - Optional log collector
-   * @param componentStreamCallback - Optional callback to stream primary KPI component as soon as it's identified
-   * @returns Object containing matched components, layout title/description, and follow-up actions
+   * Validate a single component's query with retry logic
+   * @param component - The component to validate
+   * @param collections - Collections object containing database execute function
+   * @param apiKey - Optional API key for LLM calls
+   * @returns Validation result with component, query key, and result
    */
-  async matchComponentsFromAnalysis(analysisContent, components, userPrompt, apiKey, logCollector, componentStreamCallback, deferredTools, executedTools, collections, userId) {
-    const methodStartTime = Date.now();
-    const methodName = "matchComponentsFromAnalysis";
-    logger.info(`[${this.getProviderName()}] [TIMING] START ${methodName} | model: ${this.getModelForTask("complex")}`);
-    try {
-      logger.debug(`[${this.getProviderName()}] Starting component matching from text response`);
+  async validateSingleQuery(component, collections, apiKey) {
+    const query = component.props?.query;
+    const originalQueryKey = this.getQueryCacheKey(query);
+    const queryStr = typeof query === "string" ? query : query?.sql || "";
+    let finalQueryKey = originalQueryKey;
+    let currentQuery = typeof query === "string" ? query : { sql: query?.sql || "", values: query?.values, params: query?.params };
+    let currentQueryStr = queryStr;
+    let validated = false;
+    let lastError = "";
+    let result = null;
+    let attempts = 0;
+    logger.info(`[${this.config.providerName}] Validating query for component: ${component.name} (${component.type})`);
+    while (attempts < MAX_QUERY_VALIDATION_RETRIES && !validated) {
+      attempts++;
+      try {
+        logger.debug(`[${this.config.providerName}] Query validation attempt ${attempts}/${MAX_QUERY_VALIDATION_RETRIES} for ${component.name}`);
+        const validationResult = await this.executeQuery(currentQuery, collections);
+        result = validationResult.result;
+        validated = true;
+        queryCache.set(validationResult.cacheKey, result);
+        logger.info(`[${this.config.providerName}] \u2713 Query validated for ${component.name} (attempt ${attempts}) - cached for frontend`);
+        if (currentQueryStr !== queryStr) {
+          const fixedQuery = typeof query === "string" ? currentQueryStr : { ...query, sql: currentQueryStr };
+          component.props = {
+            ...component.props,
+            query: fixedQuery
+          };
+          finalQueryKey = this.getQueryCacheKey(fixedQuery);
+          logger.info(`[${this.config.providerName}] Updated ${component.name} with fixed query`);
+        }
+      } catch (error) {
+        lastError = error instanceof Error ? error.message : String(error);
+        logger.warn(`[${this.config.providerName}] Query validation failed for ${component.name} (attempt ${attempts}/${MAX_QUERY_VALIDATION_RETRIES}): ${lastError}`);
+        if (attempts >= MAX_QUERY_VALIDATION_RETRIES) {
+          logger.error(`[${this.config.providerName}] \u2717 Max retries reached for ${component.name}, excluding from response`);
+          break;
+        }
+        logger.info(`[${this.config.providerName}] Requesting query fix from LLM for ${component.name}...`);
+        try {
+          const fixedQueryStr = await this.requestQueryFix(
+            currentQueryStr,
+            lastError,
+            {
+              name: component.name,
+              type: component.type,
+              title: component.props?.title
+            },
+            apiKey
+          );
+          if (fixedQueryStr && fixedQueryStr !== currentQueryStr) {
+            logger.info(`[${this.config.providerName}] Received fixed query for ${component.name}, retrying...`);
+            const limitedFixedQuery = ensureQueryLimit(fixedQueryStr, this.config.defaultLimit, MAX_COMPONENT_QUERY_LIMIT);
+            currentQueryStr = limitedFixedQuery;
+            if (typeof currentQuery === "string") {
+              currentQuery = limitedFixedQuery;
+            } else {
+              currentQuery = { ...currentQuery, sql: limitedFixedQuery };
+            }
+          } else {
+            logger.warn(`[${this.config.providerName}] LLM returned same or empty query, stopping retries`);
+            break;
+          }
+        } catch (fixError) {
+          const fixErrorMsg = fixError instanceof Error ? fixError.message : String(fixError);
+          logger.error(`[${this.config.providerName}] Failed to get query fix from LLM: ${fixErrorMsg}`);
+          break;
+        }
+      }
+    }
+    if (!validated) {
+      logger.warn(`[${this.config.providerName}] Component ${component.name} excluded from response due to failed query validation`);
+    }
+    return {
+      component: validated ? component : null,
+      queryKey: finalQueryKey,
+      result,
+      validated
+    };
+  }
+  /**
+   * Validate multiple component queries in parallel
+   * @param components - Array of components with potential queries
+   * @param collections - Collections object containing database execute function
+   * @param apiKey - Optional API key for LLM calls
+   * @returns Object with validated components and query results map
+   */
+  async validateComponentQueries(components, collections, apiKey) {
+    const queryResults = /* @__PURE__ */ new Map();
+    const validatedComponents = [];
+    const componentsWithoutQuery = [];
+    const componentsWithQuery = [];
+    for (const component of components) {
+      if (!component.props?.query) {
+        componentsWithoutQuery.push(component);
+      } else {
+        componentsWithQuery.push(component);
+      }
+    }
+    validatedComponents.push(...componentsWithoutQuery);
+    if (componentsWithQuery.length === 0) {
+      return { components: validatedComponents, queryResults };
+    }
+    logger.info(`[${this.config.providerName}] Validating ${componentsWithQuery.length} component queries in parallel...`);
+    const validationPromises = componentsWithQuery.map(
+      (component) => this.validateSingleQuery(component, collections, apiKey)
+    );
+    const results = await Promise.allSettled(validationPromises);
+    for (let i = 0; i < results.length; i++) {
+      const result = results[i];
+      const component = componentsWithQuery[i];
+      if (result.status === "fulfilled") {
+        const { component: validatedComponent, queryKey, result: queryResult, validated } = result.value;
+        if (validated && validatedComponent) {
+          validatedComponents.push(validatedComponent);
+          if (queryResult) {
+            queryResults.set(queryKey, queryResult);
+            queryResults.set(`${component.id}:${queryKey}`, queryResult);
+          }
+        }
+      } else {
+        logger.error(`[${this.config.providerName}] Unexpected error validating ${component.name}: ${result.reason}`);
+      }
+    }
+    logger.info(`[${this.config.providerName}] Parallel validation complete: ${validatedComponents.length}/${components.length} components validated`);
+    return {
+      components: validatedComponents,
+      queryResults
+    };
+  }
+};
+
+// src/userResponse/services/tool-executor-service.ts
+var ToolExecutorService = class {
+  constructor(config) {
+    this.queryAttempts = /* @__PURE__ */ new Map();
+    this.toolAttempts = /* @__PURE__ */ new Map();
+    this.executedToolsList = [];
+    this.maxAttemptsReached = false;
+    this.config = config;
+  }
+  /**
+   * Reset state for a new execution
+   */
+  reset() {
+    this.queryAttempts.clear();
+    this.toolAttempts.clear();
+    this.executedToolsList = [];
+    this.maxAttemptsReached = false;
+  }
+  /**
+   * Get list of successfully executed tools
+   */
+  getExecutedTools() {
+    return this.executedToolsList;
+  }
+  /**
+   * Check if max attempts were reached
+   */
+  isMaxAttemptsReached() {
+    return this.maxAttemptsReached;
+  }
+  /**
+   * Create a tool handler function for LLM.streamWithTools
+   * @param externalTools - List of available external tools
+   * @returns Tool handler function
+   */
+  createToolHandler(externalTools) {
+    return async (toolName, toolInput) => {
+      if (toolName === "execute_query") {
+        return this.executeQuery(toolInput);
+      } else {
+        return this.executeExternalTool(toolName, toolInput, externalTools);
+      }
+    };
+  }
+  /**
+   * Execute a SQL query with retry tracking and streaming feedback
+   */
+  async executeQuery(toolInput) {
+    let sql = toolInput.sql;
+    const params = toolInput.params || {};
+    const reasoning = toolInput.reasoning;
+    const { streamBuffer, collections, providerName } = this.config;
+    sql = ensureQueryLimit(sql, MAX_COMPONENT_QUERY_LIMIT, MAX_COMPONENT_QUERY_LIMIT);
+    const queryKey = sql.toLowerCase().replace(/\s+/g, " ").trim();
+    const attempts = (this.queryAttempts.get(queryKey) || 0) + 1;
+    this.queryAttempts.set(queryKey, attempts);
+    if (Object.keys(params).length > 0) {
+      logger.info(`[${providerName}] Query params: ${JSON.stringify(params)}`);
+    }
+    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(`[${providerName}] ${errorMsg}`);
+      this.maxAttemptsReached = true;
+      if (streamBuffer.hasCallback()) {
+        streamBuffer.write(`
+
+\u274C ${errorMsg}
+
+Please try rephrasing your question or simplifying your request.
+
+`);
+      }
+      throw new Error(errorMsg);
+    }
+    try {
+      streamBuffer.flush();
+      if (streamBuffer.hasCallback()) {
+        const paramsDisplay = Object.keys(params).length > 0 ? `
+**Parameters:** ${JSON.stringify(params)}` : "";
+        if (attempts === 1) {
+          streamBuffer.write(`
+
+\u{1F50D} **Analyzing your question...**
+
+`);
+          await streamDelay();
+          if (reasoning) {
+            streamBuffer.write(`\u{1F4AD} ${reasoning}
+
+`);
+            await streamDelay();
+          }
+          streamBuffer.write(`\u{1F4DD} **Generated SQL Query:**
+\`\`\`sql
+${sql}
+\`\`\`${paramsDisplay}
+
+`);
+          await streamDelay();
+        } else {
+          streamBuffer.write(`
+
+\u{1F504} **Retrying with corrected query (attempt ${attempts}/${MAX_QUERY_ATTEMPTS})...**
+
+`);
+          await streamDelay();
+          if (reasoning) {
+            streamBuffer.write(`\u{1F4AD} ${reasoning}
+
+`);
+            await streamDelay();
+          }
+          streamBuffer.write(`\u{1F4DD} **Corrected SQL Query:**
+\`\`\`sql
+${sql}
+\`\`\`${paramsDisplay}
+
+`);
+          await streamDelay();
+        }
+      }
+      if (!collections?.["database"]?.["execute"]) {
+        throw new Error("Database collection not registered. Please register database.execute collection to execute queries.");
+      }
+      const queryPayload = Object.keys(params).length > 0 ? { sql: JSON.stringify({ sql, values: params }) } : { sql };
+      const result = await withProgressHeartbeat(
+        () => collections["database"]["execute"](queryPayload),
+        "Executing database query",
+        streamBuffer
+      );
+      const data = result?.data || result;
+      const rowCount = result?.count ?? (Array.isArray(data) ? data.length : "N/A");
+      if (streamBuffer.hasCallback()) {
+        streamBuffer.write(`
+\u2705 **Query executed successfully!**
+
+`);
+        await streamDelay();
+        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]];
+            streamBuffer.write(`**Result:** ${value}
+
+`);
+            await streamDelay();
+          } else if (data.length > 0) {
+            streamBuffer.write(`**Retrieved ${rowCount} rows**
+
+`);
+            await streamDelay();
+            const streamPreview = formatQueryResultForLLM(data, {
+              maxRows: STREAM_PREVIEW_MAX_ROWS,
+              maxCharsPerField: STREAM_PREVIEW_MAX_CHARS
+            });
+            streamBuffer.write(`<DataTable>${JSON.stringify(streamPreview.data)}</DataTable>
+
+`);
+            if (streamPreview.truncationNote) {
+              streamBuffer.write(`*${streamPreview.truncationNote}*
+
+`);
+            }
+            await streamDelay();
+          }
+        } else if (Array.isArray(data) && data.length === 0) {
+          streamBuffer.write(`**No rows returned.**
+
+`);
+          await streamDelay();
+        }
+        streamBuffer.write(`\u{1F4CA} **Analyzing results...**
+
+`);
+      }
+      const formattedResult = formatQueryResultForLLM(data, {
+        maxRows: DEFAULT_MAX_ROWS_FOR_LLM,
+        maxCharsPerField: DEFAULT_MAX_CHARS_PER_FIELD2
+      });
+      if (formattedResult.truncationNote) {
+        logger.info(`[${providerName}] Truncation: ${formattedResult.truncationNote}`);
+      }
+      return formatResultAsString(formattedResult);
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      logger.error(`[${providerName}] Query execution failed (attempt ${attempts}/${MAX_QUERY_ATTEMPTS}): ${errorMsg}`);
+      userPromptErrorLogger.logSqlError(sql, error instanceof Error ? error : new Error(errorMsg), Object.keys(params).length > 0 ? Object.values(params) : void 0);
+      if (streamBuffer.hasCallback()) {
+        streamBuffer.write(`\u274C **Query execution failed:**
+\`\`\`
+${errorMsg}
+\`\`\`
+
+`);
+        if (attempts < MAX_QUERY_ATTEMPTS) {
+          streamBuffer.write(`\u{1F527} **Generating corrected query...**
+
+`);
+        }
+      }
+      throw new Error(`Query execution failed: ${errorMsg}`);
+    }
+  }
+  /**
+   * Execute an external tool with retry tracking and streaming feedback
+   */
+  async executeExternalTool(toolName, toolInput, externalTools) {
+    const { streamBuffer, providerName } = this.config;
+    const externalTool = externalTools?.find((t) => t.id === toolName);
+    if (!externalTool) {
+      throw new Error(`Unknown tool: ${toolName}`);
+    }
+    const attempts = (this.toolAttempts.get(toolName) || 0) + 1;
+    this.toolAttempts.set(toolName, attempts);
+    if (attempts > MAX_TOOL_ATTEMPTS) {
+      const errorMsg = `Maximum attempts (${MAX_TOOL_ATTEMPTS}) reached for tool: ${externalTool.name}`;
+      logger.error(`[${providerName}] ${errorMsg}`);
+      if (streamBuffer.hasCallback()) {
+        streamBuffer.write(`
+
+\u274C ${errorMsg}
+
+Please try rephrasing your request or contact support.
+
+`);
+      }
+      throw new Error(errorMsg);
+    }
+    try {
+      streamBuffer.flush();
+      if (streamBuffer.hasCallback()) {
+        if (attempts === 1) {
+          streamBuffer.write(`
+
+\u{1F517} **Executing ${externalTool.name}...**
+
+`);
+        } else {
+          streamBuffer.write(`
+
+\u{1F504} **Retrying ${externalTool.name} (attempt ${attempts}/${MAX_TOOL_ATTEMPTS})...**
+
+`);
+        }
+        await streamDelay();
+      }
+      const result = await withProgressHeartbeat(
+        () => externalTool.fn(toolInput),
+        `Running ${externalTool.name}`,
+        streamBuffer
+      );
+      if (!this.executedToolsList.find((t) => t.id === externalTool.id)) {
+        const formattedForTracking = formatToolResultForLLM(result, {
+          toolName: externalTool.name,
+          toolLimit: externalTool.limit,
+          maxRows: TOOL_TRACKING_MAX_ROWS,
+          maxCharsPerField: TOOL_TRACKING_MAX_CHARS
+        });
+        this.executedToolsList.push({
+          id: externalTool.id,
+          name: externalTool.name,
+          params: toolInput,
+          result: {
+            _totalRecords: formattedForTracking.summary.totalRecords,
+            _recordsShown: formattedForTracking.summary.recordsShown,
+            _metadata: formattedForTracking.metadata,
+            _sampleData: formattedForTracking.data.slice(0, TOOL_TRACKING_SAMPLE_ROWS)
+          },
+          outputSchema: externalTool.outputSchema
+        });
+      }
+      if (streamBuffer.hasCallback()) {
+        streamBuffer.write(`\u2705 **${externalTool.name} completed successfully**
+
+`);
+        await streamDelay();
+      }
+      const formattedToolResult = formatToolResultForLLM(result, {
+        toolName: externalTool.name,
+        toolLimit: externalTool.limit,
+        maxRows: DEFAULT_MAX_ROWS_FOR_LLM,
+        maxCharsPerField: DEFAULT_MAX_CHARS_PER_FIELD2
+      });
+      if (formattedToolResult.truncationNote) {
+        logger.info(`[${providerName}] Truncation: ${formattedToolResult.truncationNote}`);
+      }
+      return formatResultAsString(formattedToolResult);
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      logger.error(`[${providerName}] External tool ${externalTool.name} failed (attempt ${attempts}/${MAX_TOOL_ATTEMPTS}): ${errorMsg}`);
+      userPromptErrorLogger.logToolError(externalTool.name, toolInput, error instanceof Error ? error : new Error(errorMsg));
+      if (streamBuffer.hasCallback()) {
+        streamBuffer.write(`\u274C **${externalTool.name} failed:**
+\`\`\`
+${errorMsg}
+\`\`\`
+
+`);
+        if (attempts < MAX_TOOL_ATTEMPTS) {
+          streamBuffer.write(`\u{1F527} **Retrying with adjusted parameters...**
+
+`);
+        }
+      }
+      throw new Error(`Tool execution failed: ${errorMsg}`);
+    }
+  }
+};
+
+// src/userResponse/base-llm.ts
+var BaseLLM = class {
+  constructor(config) {
+    this.model = config?.model || this.getDefaultModel();
+    this.fastModel = config?.fastModel || this.getDefaultFastModel();
+    this.defaultLimit = config?.defaultLimit || 10;
+    this.apiKey = config?.apiKey;
+    this.modelStrategy = config?.modelStrategy || "fast";
+    this.conversationSimilarityThreshold = config?.conversationSimilarityThreshold || DEFAULT_CONVERSATION_SIMILARITY_THRESHOLD;
+    this.queryService = new QueryExecutionService({
+      defaultLimit: this.defaultLimit,
+      getModelForTask: (taskType) => this.getModelForTask(taskType),
+      getApiKey: (apiKey) => this.getApiKey(apiKey),
+      providerName: this.getProviderName()
+    });
+  }
+  /**
+   * Get the appropriate model based on task type and model strategy
+   * @param taskType - 'complex' for text generation/matching, 'simple' for classification/actions
+   * @returns The model string to use for this task
+   */
+  getModelForTask(taskType) {
+    switch (this.modelStrategy) {
+      case "best":
+        return this.model;
+      case "fast":
+        return this.fastModel;
+      case "balanced":
+      default:
+        return taskType === "complex" ? this.model : this.fastModel;
+    }
+  }
+  /**
+   * Set the model strategy at runtime
+   * @param strategy - 'best', 'fast', or 'balanced'
+   */
+  setModelStrategy(strategy) {
+    this.modelStrategy = strategy;
+    logger.info(`[${this.getProviderName()}] Model strategy set to: ${strategy}`);
+  }
+  /**
+   * Get the current model strategy
+   * @returns The current model strategy
+   */
+  getModelStrategy() {
+    return this.modelStrategy;
+  }
+  /**
+   * Set the conversation similarity threshold at runtime
+   * @param threshold - Value between 0 and 1 (e.g., 0.8 = 80% similarity required)
+   */
+  setConversationSimilarityThreshold(threshold) {
+    if (threshold < 0 || threshold > 1) {
+      logger.warn(`[${this.getProviderName()}] Invalid threshold ${threshold}, must be between 0 and 1. Using default ${DEFAULT_CONVERSATION_SIMILARITY_THRESHOLD}`);
+      this.conversationSimilarityThreshold = DEFAULT_CONVERSATION_SIMILARITY_THRESHOLD;
+      return;
+    }
+    this.conversationSimilarityThreshold = threshold;
+  }
+  /**
+   * Get the current conversation similarity threshold
+   * @returns The current threshold value
+   */
+  getConversationSimilarityThreshold() {
+    return this.conversationSimilarityThreshold;
+  }
+  /**
+   * Get the API key (from instance, parameter, or environment)
+   */
+  getApiKey(apiKey) {
+    return apiKey || this.apiKey || this.getDefaultApiKey();
+  }
+  /**
+   * Check if a component contains a Form (data_modification component)
+   * Forms have hardcoded defaultValues that become stale when cached
+   * This checks both single Form components and Forms inside MultiComponentContainer
+   */
+  containsFormComponent(component) {
+    if (!component) return false;
+    if (component.type === "Form" || component.name === "DynamicForm") {
+      return true;
+    }
+    if (component.type === "Container" || component.name === "MultiComponentContainer") {
+      const nestedComponents = component.props?.config?.components || [];
+      for (const nested of nestedComponents) {
+        if (nested.type === "Form" || nested.name === "DynamicForm") {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+  /**
+   * 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 title, description, and intelligent follow-up questions (actions) based on the analysis
+   * All components are placed in a default MultiComponentContainer layout
+   * @param analysisContent - The text response containing component suggestions
+   * @param components - List of available components
+   * @param apiKey - Optional API key
+   * @param componentStreamCallback - Optional callback to stream primary KPI component as soon as it's identified
+   * @returns Object containing matched components, layout title/description, and follow-up actions
+   */
+  async matchComponentsFromAnalysis(analysisContent, components, userPrompt, apiKey, componentStreamCallback, deferredTools, executedTools, collections, userId) {
+    const methodStartTime = Date.now();
+    const methodName = "matchComponentsFromAnalysis";
+    logger.info(`[${this.getProviderName()}] [TIMING] START ${methodName} | model: ${this.getModelForTask("complex")}`);
+    try {
       let availableComponentsText = "No components available";
       if (components && components.length > 0) {
         availableComponentsText = components.map((comp, idx) => {
@@ -6232,7 +7355,6 @@ Fixed SQL query:`;
       }
       let deferredToolsText = "No deferred external tools for this request.";
       if (deferredTools && deferredTools.length > 0) {
-        logger.info(`[${this.getProviderName()}] Passing ${deferredTools.length} deferred tools to component matching`);
         deferredToolsText = "The following external tools need user input via a Form component.\n**IMPORTANT: Use these EXACT values when generating Form externalTool prop.**\n\n" + deferredTools.map((tool, idx) => {
           return `${idx + 1}. **${tool.name}**
 							toolId: "${tool.id}" (USE THIS EXACT VALUE - do not modify!)
@@ -6244,21 +7366,23 @@ Fixed SQL query:`;
       }
       let executedToolsText = "No external tools were executed for data fetching.";
       if (executedTools && executedTools.length > 0) {
-        logger.info(`[${this.getProviderName()}] Passing ${executedTools.length} executed tools to component matching`);
-        executedToolsText = "The following external tools were executed to fetch data.\n" + // '**IMPORTANT: For components displaying this data, use externalTool prop instead of query.**\n' +
-        // '**IMPORTANT: Use ONLY the field names listed in outputSchema for config keys.**\n\n' +
-        executedTools.map((tool, idx) => {
+        executedToolsText = "The following external tools were executed to fetch data.\n" + executedTools.map((tool, idx) => {
           let outputSchemaText = "Not available";
           let fieldNamesList = "";
-          let recordCount = "unknown";
+          const recordCount = tool.result?._totalRecords ?? "unknown";
+          let metadataText = "";
+          if (tool.result?._metadata && Object.keys(tool.result._metadata).length > 0) {
+            const metadataEntries = Object.entries(tool.result._metadata).map(([key, value]) => `${key}: ${value}`).join(", ");
+            metadataText = `
+   \u{1F4CB} METADATA: ${metadataEntries}`;
+          }
           if (tool.outputSchema) {
             const fields = tool.outputSchema.fields || [];
-            recordCount = tool.result?._recordCount || (Array.isArray(tool.result) ? tool.result.length : "unknown");
             const numericFields = fields.filter((f) => f.type === "number").map((f) => f.name);
             const stringFields = fields.filter((f) => f.type === "string").map((f) => f.name);
             fieldNamesList = `
-							\u{1F4CA} NUMERIC FIELDS (use for yAxisKey, valueKey, aggregationField): ${numericFields.join(", ") || "none"}
-							\u{1F4DD} STRING FIELDS (use for xAxisKey, groupBy, nameKey): ${stringFields.join(", ") || "none"}`;
+   \u{1F4CA} NUMERIC FIELDS (use for yAxisKey, valueKey, aggregationField): ${numericFields.join(", ") || "none"}
+   \u{1F4DD} STRING FIELDS (use for xAxisKey, groupBy, nameKey): ${stringFields.join(", ") || "none"}`;
             const fieldsText = fields.map(
               (f) => `     "${f.name}" (${f.type}): ${f.description}`
             ).join("\n");
@@ -6267,11 +7391,11 @@ Fixed SQL query:`;
 ${fieldsText}`;
           }
           return `${idx + 1}. **${tool.name}**
-							toolId: "${tool.id}"
-							toolName: "${tool.name}"
-							parameters: ${JSON.stringify(tool.params || {})}
-							recordCount: ${recordCount} rows returned
-							outputSchema: ${outputSchemaText}${fieldNamesList}`;
+   toolId: "${tool.id}"
+   toolName: "${tool.name}"
+   parameters: ${JSON.stringify(tool.params || {})}
+   recordCount: ${recordCount} rows returned${metadataText}
+   outputSchema: ${outputSchemaText}${fieldNamesList}`;
         }).join("\n\n");
       }
       const schemaDoc = schema.generateSchemaDocumentation();
@@ -6282,7 +7406,7 @@ ${fieldsText}`;
           prompt: userPrompt || analysisContent,
           collections,
           userId,
-          topK: 3
+          topK: KNOWLEDGE_BASE_TOP_K
         });
         knowledgeBaseContext = kbResult.combinedContext || knowledgeBaseContext;
       }
@@ -6297,30 +7421,12 @@ ${fieldsText}`;
         KNOWLEDGE_BASE_CONTEXT: knowledgeBaseContext,
         CURRENT_DATETIME: getCurrentDateTimeForPrompt()
       });
-      logger.debug(`[${this.getProviderName()}] Loaded match-text-components prompts`);
-      const extractPromptText = (content) => {
-        if (typeof content === "string") return content;
-        if (Array.isArray(content)) {
-          return content.map((item) => {
-            if (typeof item === "string") return item;
-            if (item && typeof item.text === "string") return item.text;
-            if (item && item.content && typeof item.content === "string") return item.content;
-            return JSON.stringify(item, null, 2);
-          }).join("\n\n---\n\n");
-        }
-        if (content && typeof content === "object") {
-          if (typeof content.text === "string") return content.text;
-          return JSON.stringify(content, null, 2);
-        }
-        return String(content);
-      };
       logger.logLLMPrompt("matchComponentsFromAnalysis", "system", extractPromptText(prompts.system));
       logger.logLLMPrompt("matchComponentsFromAnalysis", "user", `Text Analysis:
 ${analysisContent}
 
 Executed Tools:
 ${executedToolsText}`);
-      logCollector?.info("Matching components from text response...");
       let fullResponseText = "";
       let answerComponentExtracted = false;
       const answerCallback = componentStreamCallback;
@@ -6380,52 +7486,44 @@ ${executedToolsText}`);
                       ...answerComponentData.props
                     }
                   };
-                  const streamTime = (/* @__PURE__ */ new Date()).toISOString();
-                  logger.info(`[${this.getProviderName()}] \u2713 [${streamTime}] Answer component detected in stream: ${answerComponent.name} (${answerComponent.type})`);
-                  logCollector?.info(`\u2713 Answer component: ${answerComponent.name} (${answerComponent.type}) - detected at ${streamTime}`);
-                  if (answerComponentData.props?.query) {
-                    logCollector?.logQuery(
-                      "Answer component query",
-                      answerComponentData.props.query,
-                      { componentName: answerComponent.name, componentType: answerComponent.type, reasoning: answerComponentData.reasoning }
-                    );
+                  let answerQuery = answerComponent.props?.query;
+                  if (answerQuery) {
+                    if (typeof answerQuery === "string") {
+                      answerQuery = ensureQueryLimit(answerQuery, this.defaultLimit, MAX_COMPONENT_QUERY_LIMIT);
+                    } else if (answerQuery?.sql) {
+                      const queryObj = answerQuery;
+                      answerQuery = { ...queryObj, sql: ensureQueryLimit(queryObj.sql, this.defaultLimit, MAX_COMPONENT_QUERY_LIMIT) };
+                    }
+                    answerComponent.props.query = answerQuery;
                   }
-                  const answerQuery = answerComponent.props?.query;
-                  logger.info(`[${this.getProviderName()}] Answer component detected: ${answerComponent.name} (${answerComponent.type}), hasQuery: ${!!answerQuery}, hasDbExecute: ${!!collections?.["database"]?.["execute"]}`);
                   if (answerQuery && collections?.["database"]?.["execute"]) {
                     (async () => {
-                      const MAX_RETRIES = 3;
+                      const maxRetries = MAX_QUERY_VALIDATION_RETRIES;
                       let attempts = 0;
                       let validated = false;
                       let currentQuery = answerQuery;
                       let currentQueryStr = typeof answerQuery === "string" ? answerQuery : answerQuery?.sql || "";
                       let lastError = "";
-                      logger.info(`[${this.getProviderName()}] Validating answer component query before streaming...`);
-                      while (attempts < MAX_RETRIES && !validated) {
+                      while (attempts < maxRetries && !validated) {
                         attempts++;
                         try {
-                          const cacheKey = this.getQueryCacheKey(currentQuery);
+                          const cacheKey = this.queryService.getQueryCacheKey(currentQuery);
                           if (cacheKey) {
-                            logger.debug(`[${this.getProviderName()}] Answer component query validation attempt ${attempts}/${MAX_RETRIES}`);
                             const result2 = await collections["database"]["execute"]({ sql: cacheKey });
                             queryCache.set(cacheKey, result2);
                             validated = true;
                             if (currentQuery !== answerQuery) {
                               answerComponent.props.query = currentQuery;
                             }
-                            logger.info(`[${this.getProviderName()}] \u2713 Answer component query validated (attempt ${attempts}) - STREAMING TO FRONTEND NOW`);
-                            logCollector?.info(`\u2713 Answer component query validated - streaming to frontend`);
-                            logger.info(`[${this.getProviderName()}] Calling answerCallback for: ${answerComponent.name}`);
                             answerCallback(answerComponent);
-                            logger.info(`[${this.getProviderName()}] answerCallback completed for: ${answerComponent.name}`);
                           }
                         } catch (validationError) {
                           lastError = validationError instanceof Error ? validationError.message : String(validationError);
-                          logger.warn(`[${this.getProviderName()}] Answer component query validation failed (attempt ${attempts}/${MAX_RETRIES}): ${lastError}`);
-                          if (attempts < MAX_RETRIES) {
+                          logger.warn(`[${this.getProviderName()}] Answer component query validation failed (attempt ${attempts}/${maxRetries}): ${lastError}`);
+                          if (attempts < maxRetries) {
                             try {
                               logger.info(`[${this.getProviderName()}] Requesting LLM to fix answer component query...`);
-                              const fixedQueryStr = await this.requestQueryFix(
+                              const fixedQueryStr = await this.queryService.requestQueryFix(
                                 currentQueryStr,
                                 lastError,
                                 {
@@ -6435,7 +7533,7 @@ ${executedToolsText}`);
                                 },
                                 apiKey
                               );
-                              const limitedFixedQuery = ensureQueryLimit(fixedQueryStr, this.defaultLimit, 10);
+                              const limitedFixedQuery = ensureQueryLimit(fixedQueryStr, this.defaultLimit, MAX_COMPONENT_QUERY_LIMIT);
                               if (typeof currentQuery === "string") {
                                 currentQuery = limitedFixedQuery;
                               } else {
@@ -6453,7 +7551,6 @@ ${executedToolsText}`);
                       }
                       if (!validated) {
                         logger.warn(`[${this.getProviderName()}] Answer component query validation failed after ${attempts} attempts - component will be excluded`);
-                        logCollector?.warn(`Answer component query validation failed: ${lastError} - component will be excluded from response`);
                       }
                     })();
                   } else {
@@ -6464,7 +7561,7 @@ ${executedToolsText}`);
                 }
               }
             } catch (e) {
-              logger.debug(`[${this.getProviderName()}] Partial answerComponent parse failed, waiting for more data...`);
+              logger.error(`[${this.getProviderName()}] Partial answerComponent parse failed, waiting for more data...`);
             }
           }
         }
@@ -6476,7 +7573,7 @@ ${executedToolsText}`);
         },
         {
           model: this.getModelForTask("complex"),
-          maxTokens: 8192,
+          maxTokens: MAX_TOKENS_COMPONENT_MATCHING,
           temperature: 0,
           apiKey: this.getApiKey(apiKey),
           partial: partialCallback
@@ -6494,155 +7591,20 @@ ${executedToolsText}`);
       logger.file("\n=============================\nFull LLM response:", JSON.stringify(result, null, 2));
       const rawActions = result.actions || [];
       const actions = convertQuestionsToActions(rawActions);
-      if (matchedComponents.length > 0) {
-        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;
-        }
-        let cleanedProps = { ...mc.props };
-        if (cleanedProps.externalTool) {
-          const toolId = cleanedProps.externalTool.toolId;
-          const validToolIds = (executedTools || []).map((t) => t.id);
-          const isValidTool = toolId && typeof toolId === "string" && validToolIds.includes(toolId);
-          if (!isValidTool) {
-            logger.warn(`[${this.getProviderName()}] externalTool.toolId "${toolId}" not found in executed tools [${validToolIds.join(", ")}], setting to null`);
-            cleanedProps.externalTool = null;
-          } else {
-            const executedTool = executedTools?.find((t) => t.id === toolId);
-            if (executedTool?.outputSchema?.fields && cleanedProps.config) {
-              const validFieldNames = executedTool.outputSchema.fields.map((f) => f.name);
-              const validFieldNamesLower = validFieldNames.map((n) => n.toLowerCase());
-              const findMatchingField = (fieldName, configKey) => {
-                if (!fieldName) return null;
-                const lowerField = fieldName.toLowerCase();
-                const exactIdx = validFieldNamesLower.indexOf(lowerField);
-                if (exactIdx !== -1) return validFieldNames[exactIdx];
-                const containsMatches = validFieldNames.filter(
-                  (_, i) => validFieldNamesLower[i].includes(lowerField) || lowerField.includes(validFieldNamesLower[i])
-                );
-                if (containsMatches.length === 1) return containsMatches[0];
-                const fieldTypes = executedTool.outputSchema.fields.reduce((acc, f) => {
-                  acc[f.name] = f.type;
-                  return acc;
-                }, {});
-                const numericConfigKeys = ["yAxisKey", "valueKey", "aggregationField", "sizeKey"];
-                const stringConfigKeys = ["xAxisKey", "nameKey", "labelKey", "groupBy"];
-                if (numericConfigKeys.includes(configKey)) {
-                  const numericFields = validFieldNames.filter((f) => fieldTypes[f] === "number");
-                  const match = numericFields.find((f) => f.toLowerCase().includes(lowerField) || lowerField.includes(f.toLowerCase()));
-                  if (match) return match;
-                  if (numericFields.length > 0) {
-                    logger.warn(`[${this.getProviderName()}] No match for "${fieldName}", using first numeric field: ${numericFields[0]}`);
-                    return numericFields[0];
-                  }
-                }
-                if (stringConfigKeys.includes(configKey)) {
-                  const stringFields = validFieldNames.filter((f) => fieldTypes[f] === "string");
-                  const match = stringFields.find((f) => f.toLowerCase().includes(lowerField) || lowerField.includes(f.toLowerCase()));
-                  if (match) return match;
-                  if (stringFields.length > 0) {
-                    logger.warn(`[${this.getProviderName()}] No match for "${fieldName}", using first string field: ${stringFields[0]}`);
-                    return stringFields[0];
-                  }
-                }
-                logger.warn(`[${this.getProviderName()}] No match for "${fieldName}", using first field: ${validFieldNames[0]}`);
-                return validFieldNames[0];
-              };
-              const configFieldsToValidate = [
-                "xAxisKey",
-                "yAxisKey",
-                "valueKey",
-                "nameKey",
-                "labelKey",
-                "groupBy",
-                "aggregationField",
-                "seriesKey",
-                "sizeKey",
-                "xAggregationField",
-                "yAggregationField"
-              ];
-              for (const configKey of configFieldsToValidate) {
-                const fieldValue = cleanedProps.config[configKey];
-                if (fieldValue && typeof fieldValue === "string") {
-                  if (!validFieldNames.includes(fieldValue)) {
-                    const correctedField = findMatchingField(fieldValue, configKey);
-                    if (correctedField) {
-                      logger.warn(`[${this.getProviderName()}] Correcting config.${configKey}: "${fieldValue}" \u2192 "${correctedField}"`);
-                      cleanedProps.config[configKey] = correctedField;
-                    }
-                  }
-                }
-              }
-              if (Array.isArray(cleanedProps.config.series)) {
-                cleanedProps.config.series = cleanedProps.config.series.map((s) => {
-                  if (s.dataKey && typeof s.dataKey === "string" && !validFieldNames.includes(s.dataKey)) {
-                    const correctedField = findMatchingField(s.dataKey, "yAxisKey");
-                    if (correctedField) {
-                      logger.warn(`[${this.getProviderName()}] Correcting series.dataKey: "${s.dataKey}" \u2192 "${correctedField}"`);
-                      return { ...s, dataKey: correctedField };
-                    }
-                  }
-                  return s;
-                });
-              }
-            }
-          }
-        }
-        if (cleanedProps.query) {
-          const queryStr = typeof cleanedProps.query === "string" ? cleanedProps.query : cleanedProps.query?.sql || "";
-          if (queryStr.includes("OPENJSON") || queryStr.includes("JSON_VALUE")) {
-            logger.warn(`[${this.getProviderName()}] Query contains OPENJSON/JSON_VALUE (invalid - cannot parse tool result), setting query to null`);
-            cleanedProps.query = null;
-          }
-        }
-        if (cleanedProps.query) {
-          const queryStr = typeof cleanedProps.query === "string" ? cleanedProps.query : cleanedProps.query?.sql || "";
-          const { query: fixedQuery, fixed, fixes } = validateAndFixSqlQuery(queryStr);
-          if (fixed) {
-            logger.warn(`[${this.getProviderName()}] SQL fixes applied to component query: ${fixes.join("; ")}`);
-            if (typeof cleanedProps.query === "string") {
-              cleanedProps.query = fixedQuery;
-            } else if (cleanedProps.query?.sql) {
-              cleanedProps.query.sql = fixedQuery;
-            }
-          }
-        }
-        if (cleanedProps.query) {
-          if (typeof cleanedProps.query === "string") {
-            cleanedProps.query = ensureQueryLimit(
-              cleanedProps.query,
-              this.defaultLimit,
-              10
-              // maxLimit - enforce maximum of 10 rows for component queries
-            );
-          } else if (cleanedProps.query?.sql) {
-            cleanedProps.query = {
-              ...cleanedProps.query,
-              sql: ensureQueryLimit(
-                cleanedProps.query.sql,
-                this.defaultLimit,
-                10
-                // maxLimit - enforce maximum of 10 rows for component queries
-              )
-            };
-          }
-        }
-        if (cleanedProps.query && cleanedProps.externalTool) {
-          logger.info(`[${this.getProviderName()}] Both query and externalTool exist, keeping both - frontend will decide`);
+          logger.warn(`[${this.getProviderName()}] Component ${mc.componentId} not found in available components`);
+          return null;
         }
+        const cleanedProps = processComponentProps(
+          mc.props,
+          executedTools,
+          {
+            providerName: this.getProviderName(),
+            defaultLimit: this.defaultLimit
+          }
+        );
         return {
           ...originalComponent,
           props: {
@@ -6653,27 +7615,22 @@ ${executedToolsText}`);
       }).filter(Boolean);
       let validatedComponents = finalComponents;
       if (collections?.["database"]?.["execute"]) {
-        logger.info(`[${this.getProviderName()}] Starting query validation for ${finalComponents.length} components...`);
-        logCollector?.info(`Validating queries for ${finalComponents.length} components...`);
         try {
-          const validationResult = await this.validateAndRetryComponentQueries(
+          const validationResult = await this.queryService.validateComponentQueries(
             finalComponents,
             collections,
-            apiKey,
-            logCollector
+            apiKey
           );
           validatedComponents = validationResult.components;
           const queriedComponents = finalComponents.filter((c) => c.props?.query);
           const validatedQueries = validatedComponents.filter((c) => c.props?.query);
           logger.info(`[${this.getProviderName()}] Query validation complete: ${validatedQueries.length}/${queriedComponents.length} queries validated`);
-          logCollector?.info(`Query validation complete: ${validatedQueries.length}/${queriedComponents.length} queries validated`);
         } catch (validationError) {
           const validationErrorMsg = validationError instanceof Error ? validationError.message : String(validationError);
           logger.error(`[${this.getProviderName()}] Query validation error: ${validationErrorMsg}`);
-          logCollector?.error(`Query validation error: ${validationErrorMsg}`);
         }
       } else {
-        logger.debug(`[${this.getProviderName()}] Skipping query validation - database execute function not available`);
+        logger.error(`[${this.getProviderName()}] Skipping query validation - database execute function not available`);
       }
       const methodDuration = Date.now() - methodStartTime;
       logger.info(`[${this.getProviderName()}] [TIMING] DONE ${methodName} in ${methodDuration}ms | components: ${validatedComponents.length} | actions: ${actions.length}`);
@@ -6687,7 +7644,6 @@ ${executedToolsText}`);
       const methodDuration = Date.now() - methodStartTime;
       const errorMsg = error instanceof Error ? error.message : String(error);
       logger.error(`[${this.getProviderName()}] [TIMING] FAILED ${methodName} in ${methodDuration}ms | error: ${errorMsg}`);
-      logCollector?.error(`Failed to match components: ${errorMsg}`);
       return {
         components: [],
         layoutTitle: "Dashboard",
@@ -6696,158 +7652,11 @@ ${executedToolsText}`);
       };
     }
   }
-  /**
-   * Validate a single component's query with retry logic
-   * @param component - The component to validate
-   * @param collections - Collections object containing database execute function
-   * @param apiKey - Optional API key for LLM calls
-   * @param logCollector - Optional log collector for logging
-   * @returns Object with validated component (or null if failed) and query result
-   */
-  async validateSingleComponentQuery(component, collections, apiKey, logCollector) {
-    const MAX_RETRIES = 3;
-    const query = component.props?.query;
-    const originalQueryKey = this.getQueryCacheKey(query);
-    const queryStr = typeof query === "string" ? query : query?.sql || "";
-    let finalQueryKey = originalQueryKey;
-    let currentQuery = typeof query === "string" ? query : { sql: query?.sql || "", values: query?.values, params: query?.params };
-    let currentQueryStr = queryStr;
-    let validated = false;
-    let lastError = "";
-    let result = null;
-    let attempts = 0;
-    logger.info(`[${this.getProviderName()}] Validating query for component: ${component.name} (${component.type})`);
-    while (attempts < MAX_RETRIES && !validated) {
-      attempts++;
-      try {
-        logger.debug(`[${this.getProviderName()}] Query validation attempt ${attempts}/${MAX_RETRIES} for ${component.name}`);
-        const validationResult = await this.executeQueryForValidation(currentQuery, collections);
-        result = validationResult.result;
-        validated = true;
-        queryCache.set(validationResult.cacheKey, result);
-        logger.info(`[${this.getProviderName()}] \u2713 Query validated for ${component.name} (attempt ${attempts}) - cached for frontend`);
-        logCollector?.info(`\u2713 Query validated for ${component.name}`);
-        if (currentQueryStr !== queryStr) {
-          const fixedQuery = typeof query === "string" ? currentQueryStr : { ...query, sql: currentQueryStr };
-          component.props = {
-            ...component.props,
-            query: fixedQuery
-          };
-          finalQueryKey = this.getQueryCacheKey(fixedQuery);
-          logger.info(`[${this.getProviderName()}] Updated ${component.name} with fixed query`);
-        }
-      } catch (error) {
-        lastError = error instanceof Error ? error.message : String(error);
-        logger.warn(`[${this.getProviderName()}] Query validation failed for ${component.name} (attempt ${attempts}/${MAX_RETRIES}): ${lastError}`);
-        logCollector?.warn(`Query validation failed for ${component.name}: ${lastError}`);
-        if (attempts >= MAX_RETRIES) {
-          logger.error(`[${this.getProviderName()}] \u2717 Max retries reached for ${component.name}, excluding from response`);
-          logCollector?.error(`Max retries reached for ${component.name}, component excluded from response`);
-          break;
-        }
-        logger.info(`[${this.getProviderName()}] Requesting query fix from LLM for ${component.name}...`);
-        logCollector?.info(`Requesting query fix for ${component.name}...`);
-        try {
-          const fixedQueryStr = await this.requestQueryFix(
-            currentQueryStr,
-            lastError,
-            {
-              name: component.name,
-              type: component.type,
-              title: component.props?.title
-            },
-            apiKey
-          );
-          if (fixedQueryStr && fixedQueryStr !== currentQueryStr) {
-            logger.info(`[${this.getProviderName()}] Received fixed query for ${component.name}, retrying...`);
-            const limitedFixedQuery = ensureQueryLimit(fixedQueryStr, this.defaultLimit, 10);
-            currentQueryStr = limitedFixedQuery;
-            if (typeof currentQuery === "string") {
-              currentQuery = limitedFixedQuery;
-            } else {
-              currentQuery = { ...currentQuery, sql: limitedFixedQuery };
-            }
-          } else {
-            logger.warn(`[${this.getProviderName()}] LLM returned same or empty query, stopping retries`);
-            break;
-          }
-        } catch (fixError) {
-          const fixErrorMsg = fixError instanceof Error ? fixError.message : String(fixError);
-          logger.error(`[${this.getProviderName()}] Failed to get query fix from LLM: ${fixErrorMsg}`);
-          break;
-        }
-      }
-    }
-    if (!validated) {
-      logger.warn(`[${this.getProviderName()}] Component ${component.name} excluded from response due to failed query validation`);
-      logCollector?.warn(`Component ${component.name} excluded from response`);
-    }
-    return {
-      component: validated ? component : null,
-      queryKey: finalQueryKey,
-      result,
-      validated
-    };
-  }
-  /**
-   * Validate component queries against the database and retry with LLM fixes if they fail
-   * Uses parallel execution for faster validation
-   * @param components - Array of components with potential queries
-   * @param collections - Collections object containing database execute function
-   * @param apiKey - Optional API key for LLM calls
-   * @param logCollector - Optional log collector for logging
-   * @returns Object with validated components and a map of query results
-   */
-  async validateAndRetryComponentQueries(components, collections, apiKey, logCollector) {
-    const queryResults = /* @__PURE__ */ new Map();
-    const validatedComponents = [];
-    const componentsWithoutQuery = [];
-    const componentsWithQuery = [];
-    for (const component of components) {
-      if (!component.props?.query) {
-        componentsWithoutQuery.push(component);
-      } else {
-        componentsWithQuery.push(component);
-      }
-    }
-    validatedComponents.push(...componentsWithoutQuery);
-    if (componentsWithQuery.length === 0) {
-      return { components: validatedComponents, queryResults };
-    }
-    logger.info(`[${this.getProviderName()}] Validating ${componentsWithQuery.length} component queries in parallel...`);
-    logCollector?.info(`Validating ${componentsWithQuery.length} component queries in parallel...`);
-    const validationPromises = componentsWithQuery.map(
-      (component) => this.validateSingleComponentQuery(component, collections, apiKey, logCollector)
-    );
-    const results = await Promise.allSettled(validationPromises);
-    for (let i = 0; i < results.length; i++) {
-      const result = results[i];
-      const component = componentsWithQuery[i];
-      if (result.status === "fulfilled") {
-        const { component: validatedComponent, queryKey, result: queryResult, validated } = result.value;
-        if (validated && validatedComponent) {
-          validatedComponents.push(validatedComponent);
-          if (queryResult) {
-            queryResults.set(queryKey, queryResult);
-            queryResults.set(`${component.id}:${queryKey}`, queryResult);
-          }
-        }
-      } else {
-        logger.error(`[${this.getProviderName()}] Unexpected error validating ${component.name}: ${result.reason}`);
-        logCollector?.error(`Unexpected error validating ${component.name}: ${result.reason}`);
-      }
-    }
-    logger.info(`[${this.getProviderName()}] Parallel validation complete: ${validatedComponents.length}/${components.length} components validated`);
-    return {
-      components: validatedComponents,
-      queryResults
-    };
-  }
   /**
    * Classify user question into category and detect external tools needed
    * Determines if question is for data analysis, requires external tools, or needs text response
    */
-  async classifyQuestionCategory(userPrompt, apiKey, logCollector, conversationHistory, externalTools) {
+  async classifyQuestionCategory(userPrompt, apiKey, conversationHistory, externalTools) {
     const methodStartTime = Date.now();
     const methodName = "classifyQuestionCategory";
     const promptPreview = userPrompt.substring(0, 50) + (userPrompt.length > 50 ? "..." : "");
@@ -6867,24 +7676,8 @@ ${executedToolsText}`);
         SCHEMA_DOC: schemaDoc || "No database schema available",
         CURRENT_DATETIME: getCurrentDateTimeForPrompt()
       });
-      const extractTextContent = (content) => {
-        if (typeof content === "string") return content;
-        if (Array.isArray(content)) {
-          return content.map((item) => {
-            if (typeof item === "string") return item;
-            if (item && typeof item.text === "string") return item.text;
-            if (item && item.content && typeof item.content === "string") return item.content;
-            return JSON.stringify(item, null, 2);
-          }).join("\n\n---\n\n");
-        }
-        if (content && typeof content === "object") {
-          if (typeof content.text === "string") return content.text;
-          return JSON.stringify(content, null, 2);
-        }
-        return String(content);
-      };
-      logger.logLLMPrompt("classifyQuestionCategory", "system", extractTextContent(prompts.system));
-      logger.logLLMPrompt("classifyQuestionCategory", "user", extractTextContent(prompts.user));
+      logger.logLLMPrompt("classifyQuestionCategory", "system", extractPromptText(prompts.system));
+      logger.logLLMPrompt("classifyQuestionCategory", "user", extractPromptText(prompts.user));
       const result = await LLM.stream(
         {
           sys: prompts.system,
@@ -6892,23 +7685,13 @@ ${executedToolsText}`);
         },
         {
           model: this.getModelForTask("simple"),
-          maxTokens: 1500,
+          maxTokens: MAX_TOKENS_CLASSIFICATION,
           temperature: 0,
           apiKey: this.getApiKey(apiKey)
         },
         true
         // Parse as JSON
       );
-      logCollector?.logExplanation(
-        "Question category classified",
-        result.reasoning || "No reasoning provided",
-        {
-          category: result.category,
-          externalTools: result.externalTools || [],
-          dataAnalysisType: result.dataAnalysisType,
-          confidence: result.confidence
-        }
-      );
       const methodDuration = Date.now() - methodStartTime;
       logger.info(`[${this.getProviderName()}] [TIMING] DONE ${methodName} in ${methodDuration}ms | category: ${result.category} | confidence: ${result.confidence}% | tools: ${(result.externalTools || []).length}`);
       return {
@@ -6922,7 +7705,6 @@ ${executedToolsText}`);
       const methodDuration = Date.now() - methodStartTime;
       const errorMsg = error instanceof Error ? error.message : String(error);
       logger.error(`[${this.getProviderName()}] [TIMING] FAILED ${methodName} in ${methodDuration}ms | error: ${errorMsg}`);
-      logger.debug(`[${this.getProviderName()}] Category classification error details:`, error);
       throw error;
     }
   }
@@ -6931,7 +7713,7 @@ ${executedToolsText}`);
    * Takes a matched UI block from semantic search and modifies its props to answer the new question
    * Also adapts the cached text response to match the new question
    */
-  async adaptUIBlockParameters(currentUserPrompt, originalUserPrompt, matchedUIBlock, apiKey, logCollector, cachedTextResponse) {
+  async adaptUIBlockParameters(currentUserPrompt, originalUserPrompt, matchedUIBlock, apiKey, cachedTextResponse) {
     const methodStartTime = Date.now();
     const methodName = "adaptUIBlockParameters";
     const promptPreview = currentUserPrompt.substring(0, 50) + (currentUserPrompt.length > 50 ? "..." : "");
@@ -6965,7 +7747,7 @@ ${executedToolsText}`);
         },
         {
           model: this.getModelForTask("complex"),
-          maxTokens: 8192,
+          maxTokens: MAX_TOKENS_ADAPTATION,
           temperature: 0,
           apiKey: this.getApiKey(apiKey)
         },
@@ -6975,11 +7757,6 @@ ${executedToolsText}`);
       if (!result.success) {
         const methodDuration2 = Date.now() - methodStartTime;
         logger.info(`[${this.getProviderName()}] [TIMING] DONE ${methodName} in ${methodDuration2}ms | result: adaptation failed - ${result.reason}`);
-        logCollector?.warn(
-          "Could not adapt matched UI block",
-          "explanation",
-          { reason: result.reason }
-        );
         return {
           success: false,
           explanation: result.explanation || "Adaptation not possible"
@@ -6991,14 +7768,6 @@ ${executedToolsText}`);
           this.defaultLimit
         );
       }
-      logCollector?.logExplanation(
-        "UI block parameters adapted",
-        result.explanation || "Parameters adapted successfully",
-        {
-          parametersChanged: result.parametersChanged || [],
-          componentType: result.adaptedComponent?.type
-        }
-      );
       const methodDuration = Date.now() - methodStartTime;
       logger.info(`[${this.getProviderName()}] [TIMING] DONE ${methodName} in ${methodDuration}ms | result: success | changes: ${(result.parametersChanged || []).length}`);
       return {
@@ -7012,7 +7781,6 @@ ${executedToolsText}`);
       const methodDuration = Date.now() - methodStartTime;
       const errorMsg = error instanceof Error ? error.message : String(error);
       logger.error(`[${this.getProviderName()}] [TIMING] FAILED ${methodName} in ${methodDuration}ms | error: ${errorMsg}`);
-      logger.debug(`[${this.getProviderName()}] Adaptation error details:`, error);
       return {
         success: false,
         explanation: `Error adapting parameters: ${errorMsg}`
@@ -7025,14 +7793,12 @@ ${executedToolsText}`);
    * 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
    */
-  async generateTextResponse(userPrompt, apiKey, logCollector, conversationHistory, streamCallback, collections, components, externalTools, category, userId) {
+  async generateTextResponse(userPrompt, apiKey, conversationHistory, streamCallback, collections, components, externalTools, category, userId) {
     const methodStartTime = Date.now();
     const methodName = "generateTextResponse";
     const promptPreview = userPrompt.substring(0, 50) + (userPrompt.length > 50 ? "..." : "");
     logger.info(`[${this.getProviderName()}] [TIMING] START ${methodName} | model: ${this.getModelForTask("complex")} | category: ${category} | prompt: "${promptPreview}"`);
     const errors = [];
-    logger.debug(`[${this.getProviderName()}] Starting text response generation`);
-    logger.debug(`[${this.getProviderName()}] User prompt: "${userPrompt.substring(0, 50)}..."`);
     try {
       let availableToolsDoc = "No external tools are available for this request.";
       if (externalTools && externalTools.length > 0) {
@@ -7082,7 +7848,7 @@ ${executedToolsText}`);
         prompt: userPrompt,
         collections,
         userId,
-        topK: 3
+        topK: KNOWLEDGE_BASE_TOP_K
       });
       const knowledgeBaseContext = kbResult.combinedContext;
       const prompts = await promptLoader.loadPrompts("text-response", {
@@ -7094,27 +7860,8 @@ ${executedToolsText}`);
         AVAILABLE_EXTERNAL_TOOLS: availableToolsDoc,
         CURRENT_DATETIME: getCurrentDateTimeForPrompt()
       });
-      const extractText = (content) => {
-        if (typeof content === "string") return content;
-        if (Array.isArray(content)) {
-          return content.map((item) => {
-            if (typeof item === "string") return item;
-            if (item && typeof item.text === "string") return item.text;
-            if (item && item.content && typeof item.content === "string") return item.content;
-            return JSON.stringify(item, null, 2);
-          }).join("\n\n---\n\n");
-        }
-        if (content && typeof content === "object") {
-          if (typeof content.text === "string") return content.text;
-          return JSON.stringify(content, null, 2);
-        }
-        return String(content);
-      };
-      logger.logLLMPrompt("generateTextResponse", "system", extractText(prompts.system));
-      logger.logLLMPrompt("generateTextResponse", "user", extractText(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...");
+      logger.logLLMPrompt("generateTextResponse", "system", extractPromptText(prompts.system));
+      logger.logLLMPrompt("generateTextResponse", "user", extractPromptText(prompts.user));
       const tools = [{
         name: "execute_query",
         description: "Executes a parameterized SQL query against the database. CRITICAL: NEVER hardcode literal values in WHERE/HAVING conditions - ALWAYS use $paramName placeholders and pass actual values in params object.",
@@ -7143,7 +7890,6 @@ ${executedToolsText}`);
         const executableTools = externalTools.filter(
           (t) => t.executionType === "immediate" || t.executionType === "deferred" && t.userProvidedData
         );
-        logger.info(`[${this.getProviderName()}] Executable tools: ${executableTools.length} of ${externalTools.length} total`);
         const addedToolIds = /* @__PURE__ */ new Set();
         executableTools.forEach((tool) => {
           if (addedToolIds.has(tool.id)) {
@@ -7151,7 +7897,6 @@ ${executedToolsText}`);
             return;
           }
           addedToolIds.add(tool.id);
-          logger.info(`[${this.getProviderName()}] Processing executable tool:`, JSON.stringify(tool, null, 2));
           const properties = {};
           const required = [];
           Object.entries(tool.params || {}).forEach(([key, typeOrValue]) => {
@@ -7220,327 +7965,26 @@ ${executedToolsText}`);
             input_schema: inputSchema
           });
         });
-        logger.info(`[${this.getProviderName()}] Added ${addedToolIds.size} unique tool definitions from ${executableTools.length} tool calls (${externalTools.length - executableTools.length} deferred tools await form input)`);
-        logger.info(`[${this.getProviderName()}] Complete tools array:`, JSON.stringify(tools, null, 2));
-      }
-      const queryAttempts = /* @__PURE__ */ new Map();
-      const MAX_QUERY_ATTEMPTS = 6;
-      const toolAttempts = /* @__PURE__ */ new Map();
-      const MAX_TOOL_ATTEMPTS = 3;
-      const executedToolsList = [];
-      let maxAttemptsReached = false;
-      let fullStreamedText = "";
-      let streamBuffer = "";
-      let flushTimer = null;
-      const FLUSH_INTERVAL = 50;
-      const flushStreamBuffer = () => {
-        if (streamBuffer && streamCallback) {
-          streamCallback(streamBuffer);
-          streamBuffer = "";
-        }
-        flushTimer = null;
-      };
-      const wrappedStreamCallback = streamCallback ? (chunk) => {
-        fullStreamedText += chunk;
-        streamBuffer += chunk;
-        if (chunk.includes("\n") || chunk.length > 100) {
-          if (flushTimer) {
-            clearTimeout(flushTimer);
-            flushTimer = null;
-          }
-          flushStreamBuffer();
-        } else if (!flushTimer) {
-          flushTimer = setTimeout(flushStreamBuffer, FLUSH_INTERVAL);
-        }
-      } : void 0;
-      const flushStream = () => {
-        if (flushTimer) {
-          clearTimeout(flushTimer);
-          flushTimer = null;
-        }
-        flushStreamBuffer();
-      };
-      const streamDelay = (ms = 50) => new Promise((resolve) => setTimeout(resolve, ms));
-      const withProgressHeartbeat = async (operation, progressMessage, intervalMs = 1e3) => {
-        if (!wrappedStreamCallback) {
-          return operation();
-        }
-        const startTime = Date.now();
-        await streamDelay(30);
-        wrappedStreamCallback(`\u23F3 ${progressMessage}`);
-        const heartbeatInterval = setInterval(() => {
-          const elapsedSeconds = Math.floor((Date.now() - startTime) / 1e3);
-          if (elapsedSeconds >= 1) {
-            wrappedStreamCallback(` (${elapsedSeconds}s)`);
-          }
-        }, intervalMs);
-        try {
-          const result2 = await operation();
-          return result2;
-        } finally {
-          clearInterval(heartbeatInterval);
-          wrappedStreamCallback("\n\n");
-        }
-      };
-      const toolHandler = async (toolName, toolInput) => {
-        if (toolName === "execute_query") {
-          let sql = toolInput.sql;
-          const params = toolInput.params || {};
-          const reasoning = toolInput.reasoning;
-          sql = ensureQueryLimit(sql, 10, 10);
-          const queryKey = sql.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}): ${sql.substring(0, 100)}...`);
-          if (Object.keys(params).length > 0) {
-            logger.info(`[${this.getProviderName()}] Query params: ${JSON.stringify(params)}`);
-          }
-          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 {
-            flushStream();
-            if (wrappedStreamCallback) {
-              const paramsDisplay = Object.keys(params).length > 0 ? `
-**Parameters:** ${JSON.stringify(params)}` : "";
-              if (attempts === 1) {
-                wrappedStreamCallback(`
-
-\u{1F50D} **Analyzing your question...**
-
-`);
-                await streamDelay(50);
-                if (reasoning) {
-                  wrappedStreamCallback(`\u{1F4AD} ${reasoning}
-
-`);
-                  await streamDelay(50);
-                }
-                wrappedStreamCallback(`\u{1F4DD} **Generated SQL Query:**
-\`\`\`sql
-${sql}
-\`\`\`${paramsDisplay}
-
-`);
-                await streamDelay(50);
-              } else {
-                wrappedStreamCallback(`
-
-\u{1F504} **Retrying with corrected query (attempt ${attempts}/${MAX_QUERY_ATTEMPTS})...**
-
-`);
-                await streamDelay(50);
-                if (reasoning) {
-                  wrappedStreamCallback(`\u{1F4AD} ${reasoning}
-
-`);
-                  await streamDelay(50);
-                }
-                wrappedStreamCallback(`\u{1F4DD} **Corrected SQL Query:**
-\`\`\`sql
-${sql}
-\`\`\`${paramsDisplay}
-
-`);
-                await streamDelay(50);
-              }
-            }
-            logCollector?.logQuery(
-              `Executing SQL query (attempt ${attempts})`,
-              { sql, params },
-              { 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 queryPayload = Object.keys(params).length > 0 ? { sql: JSON.stringify({ sql, values: params }) } : { sql };
-            const result2 = await withProgressHeartbeat(
-              () => collections["database"]["execute"](queryPayload),
-              "Executing database query",
-              800
-              // Send heartbeat every 800ms for responsive feedback
-            );
-            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!**
-
-`);
-              await streamDelay(50);
-              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}
-
-`);
-                  await streamDelay(50);
-                } else if (data.length > 0) {
-                  wrappedStreamCallback(`**Retrieved ${rowCount} rows**
-
-`);
-                  await streamDelay(50);
-                  wrappedStreamCallback(`<DataTable>${JSON.stringify(data)}</DataTable>
-
-`);
-                  await streamDelay(50);
-                }
-              } else if (Array.isArray(data) && data.length === 0) {
-                wrappedStreamCallback(`**No rows returned.**
-
-`);
-                await streamDelay(50);
-              }
-              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}`);
-            userPromptErrorLogger.logSqlError(sql, error instanceof Error ? error : new Error(errorMsg), Object.keys(params).length > 0 ? Object.values(params) : void 0);
-            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}`);
-          }
-        } else {
-          const externalTool = externalTools?.find((t) => t.id === toolName);
-          if (externalTool) {
-            const attempts = (toolAttempts.get(toolName) || 0) + 1;
-            toolAttempts.set(toolName, attempts);
-            logger.info(`[${this.getProviderName()}] Executing external tool: ${externalTool.name} (attempt ${attempts}/${MAX_TOOL_ATTEMPTS})`);
-            logCollector?.info(`Executing external tool: ${externalTool.name} (attempt ${attempts}/${MAX_TOOL_ATTEMPTS})...`);
-            if (attempts > MAX_TOOL_ATTEMPTS) {
-              const errorMsg = `Maximum attempts (${MAX_TOOL_ATTEMPTS}) reached for tool: ${externalTool.name}`;
-              logger.error(`[${this.getProviderName()}] ${errorMsg}`);
-              logCollector?.error(errorMsg);
-              if (wrappedStreamCallback) {
-                wrappedStreamCallback(`
-
-\u274C ${errorMsg}
-
-Please try rephrasing your request or contact support.
-
-`);
-              }
-              throw new Error(errorMsg);
-            }
-            try {
-              flushStream();
-              if (wrappedStreamCallback) {
-                if (attempts === 1) {
-                  wrappedStreamCallback(`
-
-\u{1F517} **Executing ${externalTool.name}...**
-
-`);
-                } else {
-                  wrappedStreamCallback(`
-
-\u{1F504} **Retrying ${externalTool.name} (attempt ${attempts}/${MAX_TOOL_ATTEMPTS})...**
-
-`);
-                }
-                await streamDelay(50);
-              }
-              const result2 = await withProgressHeartbeat(
-                () => externalTool.fn(toolInput),
-                `Running ${externalTool.name}`,
-                800
-                // Send heartbeat every 800ms
-              );
-              logger.info(`[${this.getProviderName()}] External tool ${externalTool.name} executed successfully`);
-              logCollector?.info(`\u2713 ${externalTool.name} executed successfully`);
-              if (!executedToolsList.find((t) => t.id === externalTool.id)) {
-                let resultSummary = null;
-                if (result2) {
-                  const resultStr = typeof result2 === "string" ? result2 : JSON.stringify(result2);
-                  if (resultStr.length > 1e3) {
-                    resultSummary = {
-                      _preview: resultStr.substring(0, 1e3) + "... (truncated)",
-                      _totalLength: resultStr.length,
-                      _recordCount: Array.isArray(result2) ? result2.length : result2?.data?.length || result2?.contacts?.length || result2?.salesorders?.length || "unknown"
-                    };
-                  } else {
-                    resultSummary = result2;
-                  }
-                }
-                executedToolsList.push({
-                  id: externalTool.id,
-                  name: externalTool.name,
-                  params: toolInput,
-                  // The actual parameters used in this execution
-                  result: resultSummary,
-                  // Store summary instead of full result to save memory
-                  outputSchema: externalTool.outputSchema
-                  // Include output schema for component config generation
-                });
-                logger.info(`[${this.getProviderName()}] Tracked executed tool: ${externalTool.name} with params: ${JSON.stringify(toolInput)}`);
-              }
-              if (wrappedStreamCallback) {
-                wrappedStreamCallback(`\u2705 **${externalTool.name} completed successfully**
-
-`);
-                await streamDelay(50);
-              }
-              return JSON.stringify(result2, null, 2);
-            } catch (error) {
-              const errorMsg = error instanceof Error ? error.message : String(error);
-              logger.error(`[${this.getProviderName()}] External tool ${externalTool.name} failed (attempt ${attempts}/${MAX_TOOL_ATTEMPTS}): ${errorMsg}`);
-              logCollector?.error(`\u2717 ${externalTool.name} failed: ${errorMsg}`);
-              userPromptErrorLogger.logToolError(externalTool.name, toolInput, error instanceof Error ? error : new Error(errorMsg));
-              if (wrappedStreamCallback) {
-                wrappedStreamCallback(`\u274C **${externalTool.name} failed:**
-\`\`\`
-${errorMsg}
-\`\`\`
-
-`);
-                if (attempts < MAX_TOOL_ATTEMPTS) {
-                  wrappedStreamCallback(`\u{1F527} **Retrying with adjusted parameters...**
-
-`);
-                }
-              }
-              throw new Error(`Tool execution failed: ${errorMsg}`);
-            }
-          }
-          throw new Error(`Unknown tool: ${toolName}`);
-        }
-      };
+        logger.info(`[${this.getProviderName()}] Added ${addedToolIds.size} unique tool definitions from ${executableTools.length} tool calls (${externalTools.length - executableTools.length} deferred tools await form input)`);
+        logger.debug(`[${this.getProviderName()}] Complete tools array:`, JSON.stringify(tools, null, 2));
+      }
+      const streamBuffer = new StreamBuffer(streamCallback);
+      const toolExecutor = new ToolExecutorService({
+        providerName: this.getProviderName(),
+        collections,
+        streamBuffer
+      });
+      const executableExternalTools = externalTools?.map((t) => ({
+        id: t.id,
+        name: t.name,
+        description: t.description,
+        fn: t.fn,
+        limit: t.limit,
+        outputSchema: t.outputSchema,
+        executionType: t.executionType,
+        userProvidedData: t.userProvidedData
+      })) || [];
+      const toolHandler = toolExecutor.createToolHandler(executableExternalTools);
       const result = await LLM.streamWithTools(
         {
           sys: prompts.system,
@@ -7550,21 +7994,17 @@ ${errorMsg}
         toolHandler,
         {
           model: this.getModelForTask("complex"),
-          maxTokens: 4e3,
+          maxTokens: MAX_TOKENS_TEXT_RESPONSE,
           temperature: 0,
           apiKey: this.getApiKey(apiKey),
-          partial: wrappedStreamCallback
-          // Pass the wrapped streaming callback to LLM
+          partial: streamBuffer.hasCallback() ? (chunk) => streamBuffer.write(chunk) : void 0
         },
-        20
-        // max iterations: allows for 6 query retries + 3 tool retries + final response + buffer
+        MAX_TOOL_CALLING_ITERATIONS
       );
-      logger.info(`[${this.getProviderName()}] Text response stream completed`);
-      const textResponse = fullStreamedText || result || "I apologize, but I was unable to generate a response.";
-      if (maxAttemptsReached) {
+      const textResponse = streamBuffer.getFullText() || result || "I apologize, but I was unable to generate a response.";
+      if (toolExecutor.isMaxAttemptsReached()) {
         const methodDuration2 = Date.now() - methodStartTime;
         logger.warn(`[${this.getProviderName()}] [TIMING] DONE ${methodName} in ${methodDuration2}ms | result: max attempts reached`);
-        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.`],
@@ -7576,18 +8016,10 @@ ${errorMsg}
           }
         };
       }
-      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
-        }
-      );
-      flushStream();
-      if (wrappedStreamCallback && components && components.length > 0 && category !== "general") {
-        wrappedStreamCallback("\n\n\u{1F4CA} **Generating visualization components...**\n\n");
-        wrappedStreamCallback("__TEXT_COMPLETE__COMPONENT_GENERATION_START__");
+      streamBuffer.flush();
+      if (streamBuffer.hasCallback() && components && components.length > 0 && category !== "general") {
+        streamBuffer.write("\n\n\u{1F4CA} **Generating visualization components...**\n\n");
+        streamBuffer.write("__TEXT_COMPLETE__COMPONENT_GENERATION_START__");
       }
       let matchedComponents = [];
       let layoutTitle = "Dashboard";
@@ -7595,8 +8027,6 @@ ${errorMsg}
       let actions = [];
       if (category === "general") {
         logger.info(`[${this.getProviderName()}] Skipping component generation for general/conversational question`);
-        logCollector?.info("Skipping component generation for general question");
-        logger.info(`[${this.getProviderName()}] Generating actions for general question...`);
         const nextQuestions = await this.generateNextQuestions(
           userPrompt,
           null,
@@ -7604,23 +8034,16 @@ ${errorMsg}
           void 0,
           // no component data
           apiKey,
-          logCollector,
           conversationHistory,
           textResponse
           // pass text response as context
         );
         actions = convertQuestionsToActions(nextQuestions);
-        logger.info(`[${this.getProviderName()}] Generated ${actions.length} follow-up actions for general question`);
       } else if (components && components.length > 0) {
-        logger.info(`[${this.getProviderName()}] Matching components from text response...`);
-        logger.info(`[${this.getProviderName()}] componentStreamCallback setup: wrappedStreamCallback=${!!wrappedStreamCallback}, category=${category}`);
-        const componentStreamCallback = wrappedStreamCallback && category !== "data_modification" ? (component) => {
-          logger.info(`[${this.getProviderName()}] componentStreamCallback INVOKED for: ${component.name} (${component.type})`);
+        const componentStreamCallback = streamBuffer.hasCallback() && category === "data_analysis" ? (component) => {
           const answerMarker = `__ANSWER_COMPONENT_START__${JSON.stringify(component)}__ANSWER_COMPONENT_END__`;
-          wrappedStreamCallback(answerMarker);
-          logger.info(`[${this.getProviderName()}] Streamed answer component to frontend: ${component.name} (${component.type})`);
+          streamBuffer.write(answerMarker);
         } : void 0;
-        logger.info(`[${this.getProviderName()}] componentStreamCallback created: ${!!componentStreamCallback}`);
         const deferredTools = externalTools?.filter((t) => {
           if (t.executionType === "deferred" && !t.userProvidedData) return true;
           if (category === "data_modification" && !t.userProvidedData) {
@@ -7641,10 +8064,9 @@ ${errorMsg}
           components,
           userPrompt,
           apiKey,
-          logCollector,
           componentStreamCallback,
           deferredTools,
-          executedToolsList,
+          toolExecutor.getExecutedTools(),
           collections,
           userId
         );
@@ -7655,8 +8077,6 @@ ${errorMsg}
       }
       let container_componet = null;
       if (matchedComponents.length > 0) {
-        logger.info(`[${this.getProviderName()}] Created MultiComponentContainer: "${layoutTitle}" with ${matchedComponents.length} components and ${actions.length} actions`);
-        logCollector?.info(`Created dashboard: "${layoutTitle}" with ${matchedComponents.length} components and ${actions.length} actions`);
         container_componet = {
           id: `container_${Date.now()}`,
           name: "MultiComponentContainer",
@@ -7688,7 +8108,6 @@ ${errorMsg}
       const methodDuration = Date.now() - methodStartTime;
       const errorMsg = error instanceof Error ? error.message : String(error);
       logger.error(`[${this.getProviderName()}] [TIMING] FAILED ${methodName} in ${methodDuration}ms | error: ${errorMsg}`);
-      logCollector?.error(`Error generating text response: ${errorMsg}`);
       userPromptErrorLogger.logLlmError(
         this.getProviderName(),
         this.model,
@@ -7716,38 +8135,29 @@ ${errorMsg}
    * 2. Category classification: Determine if data_analysis, requires_external_tools, or text_response
    * 3. Route appropriately based on category and response mode
    */
-  async handleUserRequest(userPrompt, components, apiKey, logCollector, conversationHistory, responseMode = "text", streamCallback, collections, externalTools, userId) {
+  async handleUserRequest(userPrompt, components, apiKey, conversationHistory, responseMode = "text", streamCallback, collections, externalTools, userId) {
     const startTime = Date.now();
-    logger.info(`[${this.getProviderName()}] handleUserRequest called for user prompt: ${userPrompt}`);
-    logCollector?.info(`Starting request processing with mode: ${responseMode}`);
     logger.clearFile();
     logger.logLLMPrompt("handleUserRequest", "user", `User Prompt: ${userPrompt}`);
     try {
-      logger.info(`[${this.getProviderName()}] Step 1: Searching previous conversations...`);
       const conversationMatch = await conversation_search_default.searchConversationsWithReranking({
         userPrompt,
         collections,
         userId,
-        similarityThreshold: 0.99
+        similarityThreshold: EXACT_MATCH_SIMILARITY_THRESHOLD
       });
       if (conversationMatch) {
         logger.info(`[${this.getProviderName()}] \u2713 Found matching conversation with ${(conversationMatch.similarity * 100).toFixed(2)}% similarity`);
-        logCollector?.info(
-          `\u2713 Found similar conversation (${(conversationMatch.similarity * 100).toFixed(2)}% match)`
-        );
         const rawComponent = conversationMatch.uiBlock?.component || conversationMatch.uiBlock?.generatedComponentMetadata;
         const isValidComponent = rawComponent && typeof rawComponent === "object" && Object.keys(rawComponent).length > 0;
         const component = isValidComponent ? rawComponent : null;
         const cachedTextResponse = conversationMatch.uiBlock?.analysis || conversationMatch.uiBlock?.textResponse || conversationMatch.uiBlock?.text || "";
         if (this.containsFormComponent(component)) {
           logger.info(`[${this.getProviderName()}] Skipping cached result - Form components contain stale defaultValues, fetching fresh data`);
-          logCollector?.info("Skipping cache for form - fetching current values from database...");
         } else if (!component) {
-          if (conversationMatch.similarity >= 0.99) {
+          if (conversationMatch.similarity >= EXACT_MATCH_SIMILARITY_THRESHOLD) {
             const elapsedTime2 = Date.now() - startTime;
-            logger.info(`[${this.getProviderName()}] \u2713 Exact match for general question - returning cached text response`);
-            logCollector?.info(`\u2713 Exact match for general question - returning cached response`);
-            logCollector?.info(`Total time taken: ${elapsedTime2}ms (${(elapsedTime2 / 1e3).toFixed(2)}s)`);
+            logger.info(`[${this.getProviderName()}] \u2713 Exact match for general question - returning cached text response (${elapsedTime2}ms)`);
             return {
               success: true,
               data: {
@@ -7762,14 +8172,11 @@ ${errorMsg}
             };
           } else {
             logger.info(`[${this.getProviderName()}] Similar match but no component (general question) - processing fresh`);
-            logCollector?.info("Similar match found but was a general conversation - processing as new question");
           }
         } else {
-          if (conversationMatch.similarity >= 0.99) {
+          if (conversationMatch.similarity >= EXACT_MATCH_SIMILARITY_THRESHOLD) {
             const elapsedTime2 = Date.now() - startTime;
-            logger.info(`[${this.getProviderName()}] \u2713 100% match - returning UI block directly without adaptation`);
-            logCollector?.info(`\u2713 Exact match (${(conversationMatch.similarity * 100).toFixed(2)}%) - returning cached result`);
-            logCollector?.info(`Total time taken: ${elapsedTime2}ms (${(elapsedTime2 / 1e3).toFixed(2)}s)`);
+            logger.info(`[${this.getProviderName()}] \u2713 100% match - returning UI block directly without adaptation (${elapsedTime2}ms)`);
             if (streamCallback && cachedTextResponse) {
               logger.info(`[${this.getProviderName()}] Streaming cached text response to frontend`);
               streamCallback(cachedTextResponse);
@@ -7788,22 +8195,18 @@ ${errorMsg}
               errors: []
             };
           }
-          logCollector?.info(`Adapting parameters for similar question...`);
+          logger.info(`[${this.getProviderName()}] Adapting parameters for similar question...`);
           const originalPrompt = conversationMatch.metadata?.userPrompt || "Previous question";
           const adaptResult = await this.adaptUIBlockParameters(
             userPrompt,
             originalPrompt,
             conversationMatch.uiBlock,
             apiKey,
-            logCollector,
             cachedTextResponse
           );
           if (adaptResult.success && adaptResult.adaptedComponent) {
             const elapsedTime2 = Date.now() - startTime;
-            logger.info(`[${this.getProviderName()}] \u2713 Successfully adapted UI block parameters`);
-            logger.info(`[${this.getProviderName()}] Total time taken: ${elapsedTime2}ms (${(elapsedTime2 / 1e3).toFixed(2)}s)`);
-            logCollector?.info(`\u2713 UI block adapted successfully`);
-            logCollector?.info(`Total time taken: ${elapsedTime2}ms (${(elapsedTime2 / 1e3).toFixed(2)}s)`);
+            logger.info(`[${this.getProviderName()}] \u2713 Successfully adapted UI block parameters (${elapsedTime2}ms)`);
             const textResponseToUse = adaptResult.adaptedTextResponse || cachedTextResponse;
             if (streamCallback && textResponseToUse) {
               logger.info(`[${this.getProviderName()}] Streaming ${adaptResult.adaptedTextResponse ? "adapted" : "cached"} text response to frontend`);
@@ -7824,65 +8227,57 @@ ${errorMsg}
               errors: []
             };
           } else {
-            logger.info(`[${this.getProviderName()}] Could not adapt matched conversation, continuing to category classification`);
-            logCollector?.warn(`Could not adapt matched conversation: ${adaptResult.explanation}`);
+            logger.info(`[${this.getProviderName()}] Could not adapt matched conversation: ${adaptResult.explanation}, continuing to category classification`);
           }
         }
       } else {
         logger.info(`[${this.getProviderName()}] No matching previous conversations found, proceeding to category classification`);
-        logCollector?.info("No similar previous conversations found. Proceeding to category classification...");
       }
       logger.info(`[${this.getProviderName()}] Step 2: Classifying question category...`);
-      logCollector?.info("Step 2: Classifying question category...");
       const categoryClassification = await this.classifyQuestionCategory(
         userPrompt,
         apiKey,
-        logCollector,
         conversationHistory,
         externalTools
       );
       logger.info(
         `[${this.getProviderName()}] Question classified as: ${categoryClassification.category} (confidence: ${categoryClassification.confidence}%)`
       );
-      logCollector?.info(
-        `Category: ${categoryClassification.category} | Confidence: ${categoryClassification.confidence}%`
-      );
       let toolsToUse = [];
       if (categoryClassification.externalTools && categoryClassification.externalTools.length > 0) {
-        logger.info(`[${this.getProviderName()}] Identified ${categoryClassification.externalTools.length} external tools needed`);
-        logCollector?.info(`Identified external tools: ${categoryClassification.externalTools.map((t) => t.name || t.type).join(", ")}`);
-        logger.info(`[${this.getProviderName()}] Raw external tools from classification: ${JSON.stringify(categoryClassification.externalTools, null, 2)}`);
-        toolsToUse = categoryClassification.externalTools?.map((t) => {
+        logger.info(`[${this.getProviderName()}] Identified ${categoryClassification.externalTools.length} external tools needed: ${categoryClassification.externalTools.map((t) => t.name || t.type).join(", ")}`);
+        logger.debug(`[${this.getProviderName()}] Raw external tools from classification: ${JSON.stringify(categoryClassification.externalTools, null, 2)}`);
+        toolsToUse = categoryClassification.externalTools.reduce((acc, t) => {
           const realTool = externalTools?.find((tool) => tool.id === t.type);
-          logger.info(`[${this.getProviderName()}] Tool ${t.name}: executionType=${t.executionType}, userProvidedData=${t.userProvidedData ? "present" : "null"}`);
-          return {
+          if (!realTool) {
+            logger.warn(`[${this.getProviderName()}] Tool ${t.type} (${t.name}) not found in registered tools - skipping (likely hallucinated)`);
+            return acc;
+          }
+          acc.push({
             id: t.type,
             name: t.name,
             description: t.description,
             params: t.parameters || {},
-            // NEW: Include execution type info from category classification
+            // Include execution type info from category classification
             executionType: t.executionType || "immediate",
             executionReason: t.executionReason || "",
             requiredFields: t.requiredFields || [],
             userProvidedData: t.userProvidedData || null,
-            // CRITICAL: Include outputSchema from real tool for component config generation
-            outputSchema: realTool?.outputSchema,
-            fn: (() => {
-              if (realTool) {
-                logger.info(`[${this.getProviderName()}] Using real tool implementation for ${t.type}`);
-                return realTool.fn;
-              } else {
-                logger.warn(`[${this.getProviderName()}] Tool ${t.type} not found in registered tools`);
-                return async () => ({ success: false, message: `Tool ${t.name || t.type} not registered` });
-              }
-            })()
-          };
-        }) || [];
+            // Include outputSchema from real tool for component config generation
+            outputSchema: realTool.outputSchema,
+            fn: realTool.fn
+          });
+          return acc;
+        }, []);
+        const validCount = toolsToUse.length;
+        const hallucinatedCount = categoryClassification.externalTools.length - validCount;
+        if (hallucinatedCount > 0) {
+          logger.warn(`[${this.getProviderName()}] Filtered out ${hallucinatedCount} hallucinated/non-existent tools, ${validCount} valid tools remaining`);
+        }
       }
       const textResponse = await this.generateTextResponse(
         userPrompt,
         apiKey,
-        logCollector,
         conversationHistory,
         streamCallback,
         collections,
@@ -7893,13 +8288,10 @@ ${errorMsg}
       );
       const elapsedTime = Date.now() - startTime;
       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 textResponse;
     } catch (error) {
       const errorMsg = error instanceof Error ? error.message : String(error);
       logger.error(`[${this.getProviderName()}] Error in handleUserRequest: ${errorMsg}`);
-      logger.debug(`[${this.getProviderName()}] Error details:`, error);
-      logCollector?.error(`Error processing request: ${errorMsg}`);
       userPromptErrorLogger.logError(
         "handleUserRequest",
         error instanceof Error ? error : new Error(errorMsg),
@@ -7907,7 +8299,6 @@ ${errorMsg}
       );
       const elapsedTime = Date.now() - startTime;
       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 {
         success: false,
         errors: [errorMsg],
@@ -7923,7 +8314,7 @@ ${errorMsg}
    * This helps provide intelligent suggestions for follow-up queries
    * For general/conversational questions without components, pass textResponse instead
    */
-  async generateNextQuestions(originalUserPrompt, component, componentData, apiKey, logCollector, conversationHistory, textResponse) {
+  async generateNextQuestions(originalUserPrompt, component, componentData, apiKey, conversationHistory, textResponse) {
     const methodStartTime = Date.now();
     const methodName = "generateNextQuestions";
     const promptPreview = originalUserPrompt.substring(0, 50) + (originalUserPrompt.length > 50 ? "..." : "");
@@ -7960,7 +8351,7 @@ ${errorMsg}
         },
         {
           model: this.getModelForTask("simple"),
-          maxTokens: 1200,
+          maxTokens: MAX_TOKENS_NEXT_QUESTIONS,
           temperature: 0,
           apiKey: this.getApiKey(apiKey)
         },
@@ -7968,14 +8359,6 @@ ${errorMsg}
         // Parse as JSON
       );
       const nextQuestions = result.nextQuestions || [];
-      logCollector?.logExplanation(
-        "Next questions generated",
-        "Generated intelligent follow-up questions based on component",
-        {
-          count: nextQuestions.length,
-          questions: nextQuestions
-        }
-      );
       const methodDuration = Date.now() - methodStartTime;
       logger.info(`[${this.getProviderName()}] [TIMING] DONE ${methodName} in ${methodDuration}ms | questions: ${nextQuestions.length}`);
       return nextQuestions;
@@ -7983,8 +8366,6 @@ ${errorMsg}
       const methodDuration = Date.now() - methodStartTime;
       const errorMsg = error instanceof Error ? error.message : String(error);
       logger.error(`[${this.getProviderName()}] [TIMING] FAILED ${methodName} in ${methodDuration}ms | error: ${errorMsg}`);
-      logger.debug(`[${this.getProviderName()}] Next questions generation error details:`, error);
-      logCollector?.error(`Error generating next questions: ${errorMsg}`);
       return [];
     }
   }
@@ -8098,330 +8479,94 @@ function getLLMProviders() {
     return DEFAULT_PROVIDERS;
   }
 }
-var useAnthropicMethod = async (prompt, components, apiKey, logCollector, conversationHistory, responseMode = "component", streamCallback, collections, externalTools, userId) => {
-  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);
+var useAnthropicMethod = async (prompt, components, apiKey, conversationHistory, responseMode = "component", streamCallback, collections, externalTools, userId) => {
   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, errors: [emptyMsg] };
   }
-  logger.debug(`[useAnthropicMethod] Processing with ${components.length} components`);
-  const matchResult = await anthropicLLM.handleUserRequest(prompt, components, apiKey, logCollector, conversationHistory, responseMode, streamCallback, collections, externalTools, userId);
+  const matchResult = await anthropicLLM.handleUserRequest(prompt, components, apiKey, conversationHistory, responseMode, streamCallback, collections, externalTools, userId);
   logger.info(`[useAnthropicMethod] Successfully generated ${responseMode} using Anthropic`);
   return matchResult;
 };
-var useGroqMethod = async (prompt, components, apiKey, logCollector, conversationHistory, responseMode = "component", streamCallback, collections, externalTools, userId) => {
+var useGroqMethod = async (prompt, components, apiKey, conversationHistory, responseMode = "component", streamCallback, collections, externalTools, userId) => {
   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 (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, errors: [emptyMsg] };
-  }
-  logger.debug(`[useGroqMethod] Processing with ${components.length} components`);
-  const matchResult = await groqLLM.handleUserRequest(prompt, components, apiKey, logCollector, conversationHistory, responseMode, streamCallback, collections, externalTools, userId);
-  logger.info(`[useGroqMethod] Successfully generated ${responseMode} using Groq`);
-  return matchResult;
-};
-var useGeminiMethod = async (prompt, components, apiKey, logCollector, conversationHistory, responseMode = "component", streamCallback, collections, externalTools, userId) => {
-  logger.debug("[useGeminiMethod] Initializing Gemini LLM matching method");
-  logger.debug(`[useGeminiMethod] Response mode: ${responseMode}`);
-  const msg = `Using Gemini LLM ${responseMode === "text" ? "text response" : "matching"} method...`;
-  logger.info(msg);
-  logCollector?.info(msg);
-  if (responseMode === "component" && components.length === 0) {
-    const emptyMsg = "Components not loaded in memory. Please ensure components are fetched first.";
-    logger.error("[useGeminiMethod] No components available");
-    logCollector?.error(emptyMsg);
-    return { success: false, errors: [emptyMsg] };
-  }
-  logger.debug(`[useGeminiMethod] Processing with ${components.length} components`);
-  const matchResult = await geminiLLM.handleUserRequest(prompt, components, apiKey, logCollector, conversationHistory, responseMode, streamCallback, collections, externalTools, userId);
-  logger.info(`[useGeminiMethod] Successfully generated ${responseMode} using Gemini`);
-  return matchResult;
-};
-var useOpenAIMethod = async (prompt, components, apiKey, logCollector, conversationHistory, responseMode = "component", streamCallback, collections, externalTools, userId) => {
-  logger.debug("[useOpenAIMethod] Initializing OpenAI GPT matching method");
-  logger.debug(`[useOpenAIMethod] Response mode: ${responseMode}`);
-  const msg = `Using OpenAI GPT ${responseMode === "text" ? "text response" : "matching"} method...`;
-  logger.info(msg);
-  logCollector?.info(msg);
   if (responseMode === "component" && components.length === 0) {
     const emptyMsg = "Components not loaded in memory. Please ensure components are fetched first.";
-    logger.error("[useOpenAIMethod] No components available");
-    logCollector?.error(emptyMsg);
-    return { success: false, errors: [emptyMsg] };
-  }
-  logger.debug(`[useOpenAIMethod] Processing with ${components.length} components`);
-  const matchResult = await openaiLLM.handleUserRequest(prompt, components, apiKey, logCollector, conversationHistory, responseMode, streamCallback, collections, externalTools, userId);
-  logger.info(`[useOpenAIMethod] Successfully generated ${responseMode} using OpenAI`);
-  return matchResult;
-};
-var getUserResponseFromCache = async (prompt) => {
-  return false;
-};
-var get_user_response = async (prompt, components, anthropicApiKey, groqApiKey, geminiApiKey, openaiApiKey, llmProviders, logCollector, conversationHistory, responseMode = "component", streamCallback, collections, externalTools, userId) => {
-  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,
-      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) {
-    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;
-    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, externalTools, userId);
-    } else if (provider === "groq") {
-      result = await useGroqMethod(prompt, components, groqApiKey, logCollector, conversationHistory, responseMode, streamCallback, collections, externalTools, userId);
-    } else if (provider === "gemini") {
-      result = await useGeminiMethod(prompt, components, geminiApiKey, logCollector, conversationHistory, responseMode, streamCallback, collections, externalTools, userId);
-    } else if (provider === "openai") {
-      result = await useOpenAIMethod(prompt, components, openaiApiKey, logCollector, conversationHistory, responseMode, streamCallback, collections, externalTools, userId);
-    } 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);
-      }
-    }
-  }
-  const failureMsg = `All LLM providers failed`;
-  logger.error(`[get_user_response] ${failureMsg}. Errors: ${errors.join("; ")}`);
-  logCollector?.error(`${failureMsg}. Errors: ${errors.join("; ")}`);
-  return {
-    success: false,
-    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)
-   */
-  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,
-      message,
-      ...type && { type },
-      ...data && { data }
-    };
-    this.logs.push(log);
-    this.sendLogImmediately(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
-   */
-  sendLogImmediately(log) {
-    if (!this.isEnabled()) {
-      return;
-    }
-    const response = {
-      id: this.uiBlockId,
-      type: "UI_LOGS",
-      from: { type: "data-agent" },
-      to: {
-        type: "runtime",
-        id: this.clientId
-      },
-      payload: {
-        logs: [log]
-        // Send single log in array
-      }
-    };
-    this.sendMessage(response);
-  }
-  /**
-   * Log info message
-   */
-  info(message, type, data) {
-    if (this.isEnabled()) {
-      this.addLog("info", message, type, data);
-    }
-  }
-  /**
-   * Log error message
-   */
-  error(message, type, data) {
-    if (this.isEnabled()) {
-      this.addLog("error", message, type, data);
-    }
-  }
-  /**
-   * Log warning message
-   */
-  warn(message, type, data) {
-    if (this.isEnabled()) {
-      this.addLog("warn", message, type, data);
-    }
-  }
-  /**
-   * Log debug message
-   */
-  debug(message, type, data) {
-    if (this.isEnabled()) {
-      this.addLog("debug", message, type, data);
-    }
-  }
-  /**
-   * Log LLM explanation with typed metadata
-   */
-  logExplanation(message, explanation, data) {
-    if (this.isEnabled()) {
-      this.addLog("info", message, "explanation", {
-        explanation,
-        ...data
-      });
-    }
-  }
-  /**
-   * Log generated query with typed metadata
-   */
-  logQuery(message, query, data) {
-    if (this.isEnabled()) {
-      this.addLog("info", message, "query", {
-        query,
-        ...data
-      });
-    }
-  }
-  /**
-   * Send all collected logs at once (optional, for final summary)
-   */
-  sendAllLogs() {
-    if (!this.isEnabled() || this.logs.length === 0) {
-      return;
-    }
-    const response = {
-      id: this.uiBlockId,
-      type: "UI_LOGS",
-      from: { type: "data-agent" },
-      to: {
-        type: "runtime",
-        id: this.clientId
-      },
-      payload: {
-        logs: this.logs
-      }
-    };
-    this.sendMessage(response);
-  }
-  /**
-   * Get all collected logs
-   */
-  getLogs() {
-    return [...this.logs];
+    logger.error("[useGroqMethod] No components available");
+    return { success: false, errors: [emptyMsg] };
   }
-  /**
-   * Clear all logs
-   */
-  clearLogs() {
-    this.logs = [];
+  logger.debug(`[useGroqMethod] Processing with ${components.length} components`);
+  const matchResult = await groqLLM.handleUserRequest(prompt, components, apiKey, conversationHistory, responseMode, streamCallback, collections, externalTools, userId);
+  logger.info(`[useGroqMethod] Successfully generated ${responseMode} using Groq`);
+  return matchResult;
+};
+var useGeminiMethod = async (prompt, components, apiKey, conversationHistory, responseMode = "component", streamCallback, collections, externalTools, userId) => {
+  logger.debug("[useGeminiMethod] Initializing Gemini LLM matching method");
+  logger.debug(`[useGeminiMethod] Response mode: ${responseMode}`);
+  if (responseMode === "component" && components.length === 0) {
+    const emptyMsg = "Components not loaded in memory. Please ensure components are fetched first.";
+    logger.error("[useGeminiMethod] No components available");
+    return { success: false, errors: [emptyMsg] };
   }
-  /**
-   * Set uiBlockId (in case it's provided later)
-   */
-  setUIBlockId(uiBlockId) {
-    this.uiBlockId = uiBlockId;
+  logger.debug(`[useGeminiMethod] Processing with ${components.length} components`);
+  const matchResult = await geminiLLM.handleUserRequest(prompt, components, apiKey, conversationHistory, responseMode, streamCallback, collections, externalTools, userId);
+  logger.info(`[useGeminiMethod] Successfully generated ${responseMode} using Gemini`);
+  return matchResult;
+};
+var useOpenAIMethod = async (prompt, components, apiKey, conversationHistory, responseMode = "component", streamCallback, collections, externalTools, userId) => {
+  logger.debug("[useOpenAIMethod] Initializing OpenAI GPT matching method");
+  logger.debug(`[useOpenAIMethod] Response mode: ${responseMode}`);
+  if (responseMode === "component" && components.length === 0) {
+    const emptyMsg = "Components not loaded in memory. Please ensure components are fetched first.";
+    logger.error("[useOpenAIMethod] No components available");
+    return { success: false, errors: [emptyMsg] };
   }
+  logger.debug(`[useOpenAIMethod] Processing with ${components.length} components`);
+  const matchResult = await openaiLLM.handleUserRequest(prompt, components, apiKey, conversationHistory, responseMode, streamCallback, collections, externalTools, userId);
+  logger.info(`[useOpenAIMethod] Successfully generated ${responseMode} using OpenAI`);
+  return matchResult;
+};
+var get_user_response = async (prompt, components, anthropicApiKey, groqApiKey, geminiApiKey, openaiApiKey, llmProviders, conversationHistory, responseMode = "component", streamCallback, collections, externalTools, userId) => {
+  const providers = llmProviders || getLLMProviders();
+  const errors = [];
+  logger.info(`[get_user_response] LLM Provider order: [${providers.join(", ")}]`);
+  for (let i = 0; i < providers.length; i++) {
+    const provider = providers[i];
+    const isLastProvider = i === providers.length - 1;
+    logger.info(`[get_user_response] Attempting provider: ${provider} (${i + 1}/${providers.length})`);
+    let result;
+    if (provider === "anthropic") {
+      result = await useAnthropicMethod(prompt, components, anthropicApiKey, conversationHistory, responseMode, streamCallback, collections, externalTools, userId);
+    } else if (provider === "groq") {
+      result = await useGroqMethod(prompt, components, groqApiKey, conversationHistory, responseMode, streamCallback, collections, externalTools, userId);
+    } else if (provider === "gemini") {
+      result = await useGeminiMethod(prompt, components, geminiApiKey, conversationHistory, responseMode, streamCallback, collections, externalTools, userId);
+    } else if (provider === "openai") {
+      result = await useOpenAIMethod(prompt, components, openaiApiKey, conversationHistory, responseMode, streamCallback, collections, externalTools, userId);
+    } else {
+      logger.warn(`[get_user_response] Unknown provider: ${provider} - skipping`);
+      errors.push(`Unknown provider: ${provider}`);
+      continue;
+    }
+    if (result.success) {
+      logger.info(`[get_user_response] Success with provider: ${provider}`);
+      return result;
+    } else {
+      const providerErrors = result.errors.map((err) => `${provider}: ${err}`);
+      errors.push(...providerErrors);
+      logger.warn(`[get_user_response] Provider ${provider} returned unsuccessful result: ${result.errors.join(", ")}`);
+      if (!isLastProvider) {
+        logger.info("[get_user_response] Falling back to next provider...");
+      }
+    }
+  }
+  logger.error(`[get_user_response] All LLM providers failed. Errors: ${errors.join("; ")}`);
+  return {
+    success: false,
+    errors
+  };
 };
 
 // src/utils/conversation-saver.ts
@@ -8554,7 +8699,6 @@ var CONTEXT_CONFIG = {
 // src/handlers/user-prompt-request.ts
 var get_user_request = async (data, components, sendMessage, anthropicApiKey, groqApiKey, geminiApiKey, openaiApiKey, llmProviders, collections, externalTools) => {
   const errors = [];
-  logger.debug("[USER_PROMPT_REQ] Parsing incoming message data");
   const parseResult = UserPromptRequestMessageSchema.safeParse(data);
   if (!parseResult.success) {
     const zodError = parseResult.error;
@@ -8586,27 +8730,23 @@ var get_user_request = async (data, components, sendMessage, anthropicApiKey, gr
   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`);
+  logger.info(`Starting user prompt request with ${components.length} components`);
   const conversationHistory = thread.getConversationContext(CONTEXT_CONFIG.MAX_CONVERSATION_CONTEXT_BLOCKS, existingUiBlockId);
   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
@@ -8622,7 +8762,6 @@ var get_user_request = async (data, components, sendMessage, anthropicApiKey, gr
         }
       };
       sendMessage(streamMessage);
-      logger.debug(`[STREAM] Chunk sent to wsId: ${wsId}`);
     };
   }
   const userResponse = await get_user_response(
@@ -8633,7 +8772,6 @@ var get_user_request = async (data, components, sendMessage, anthropicApiKey, gr
     geminiApiKey,
     openaiApiKey,
     llmProviders,
-    logCollector,
     conversationHistory,
     responseMode,
     streamCallback,
@@ -8641,7 +8779,7 @@ var get_user_request = async (data, components, sendMessage, anthropicApiKey, gr
     externalTools,
     userId
   );
-  logCollector.info("User prompt request completed");
+  logger.info("User prompt request completed");
   const uiBlockId = existingUiBlockId;
   if (!userResponse.success) {
     logger.error(`User prompt request failed with errors: ${userResponse.errors.join(", ")}`);
@@ -8708,9 +8846,6 @@ var get_user_request = async (data, components, sendMessage, anthropicApiKey, gr
       logger.info(
         `Skipping conversation save - response from exact semantic match (${(semanticSimilarity * 100).toFixed(2)}% similarity)`
       );
-      logCollector.info(
-        `Using exact cached result (${(semanticSimilarity * 100).toFixed(2)}% match) - not saving duplicate conversation`
-      );
     } else {
       const uiBlockData = uiBlock.toJSON();
       const saveResult = await saveConversation({
@@ -8918,7 +9053,7 @@ function sendResponse(id, res, sendMessage, clientId) {
 }
 
 // src/userResponse/next-questions.ts
-async function generateNextQuestions(originalUserPrompt, component, componentData, anthropicApiKey, groqApiKey, geminiApiKey, openaiApiKey, llmProviders, logCollector, conversationHistory) {
+async function generateNextQuestions(originalUserPrompt, component, componentData, anthropicApiKey, groqApiKey, geminiApiKey, openaiApiKey, llmProviders, conversationHistory) {
   try {
     logger.debug("[generateNextQuestions] Starting next questions generation");
     logger.debug(`[generateNextQuestions] User prompt: "${originalUserPrompt?.substring(0, 50)}..."`);
@@ -8937,7 +9072,6 @@ async function generateNextQuestions(originalUserPrompt, component, componentDat
       const isLastProvider = i === providers.length - 1;
       try {
         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");
@@ -8946,7 +9080,6 @@ async function generateNextQuestions(originalUserPrompt, component, componentDat
             component,
             componentData,
             groqApiKey,
-            logCollector,
             conversationHistory
           );
         } else if (provider === "gemini") {
@@ -8956,7 +9089,6 @@ async function generateNextQuestions(originalUserPrompt, component, componentDat
             component,
             componentData,
             geminiApiKey,
-            logCollector,
             conversationHistory
           );
         } else if (provider === "openai") {
@@ -8966,7 +9098,6 @@ async function generateNextQuestions(originalUserPrompt, component, componentDat
             component,
             componentData,
             openaiApiKey,
-            logCollector,
             conversationHistory
           );
         } else {
@@ -8976,44 +9107,32 @@ async function generateNextQuestions(originalUserPrompt, component, componentDat
             component,
             componentData,
             anthropicApiKey,
-            logCollector,
             conversationHistory
           );
         }
         if (result && result.length > 0) {
           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;
         }
-        const warnMsg = `No questions generated from ${provider}${!isLastProvider ? ", trying next provider..." : ""}`;
-        logger.warn(`[generateNextQuestions] ${warnMsg}`);
-        if (!isLastProvider) {
-          logCollector?.warn(warnMsg);
-        }
+        logger.warn(`[generateNextQuestions] No questions generated from ${provider}${!isLastProvider ? ", trying next provider..." : ""}`);
       } catch (providerError) {
         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}`);
+          logger.info(`[generateNextQuestions] Provider ${provider} failed, trying next provider...`);
         }
         continue;
       }
     }
     logger.warn("[generateNextQuestions] All providers failed or returned no questions");
-    logCollector?.warn("Unable to generate follow-up questions");
     return [];
   } catch (error) {
     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 [];
   }
 }
@@ -9061,9 +9180,6 @@ async function handleActionsRequest(data, sendMessage, anthropicApiKey, groqApiK
       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();
@@ -9077,13 +9193,11 @@ async function handleActionsRequest(data, sendMessage, anthropicApiKey, groqApiK
     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(`[ACTIONS_REQ ${id}] Generating actions for component: ${component?.name || "unknown"}`);
+    logger.info(`[ACTIONS_REQ ${id}] Generating actions for UIBlock: ${uiBlockId}, 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,
@@ -9094,7 +9208,6 @@ ${conversationHistory.substring(0, 200)}...`);
         geminiApiKey,
         openaiApiKey,
         llmProviders,
-        logCollector,
         conversationHistory
       );
       logger.info(`[ACTIONS_REQ ${id}] Generated ${nextQuestions.length} questions`);
@@ -9112,11 +9225,10 @@ ${conversationHistory.substring(0, 200)}...`);
     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.info(`[ACTIONS_REQ ${id}] 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, {
@@ -9135,15 +9247,6 @@ ${conversationHistory.substring(0, 200)}...`);
     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: errorMessage
@@ -9724,7 +9827,6 @@ function sendResponse3(id, res, sendMessage, clientId) {
 var dashboardManager = null;
 function setDashboardManager(manager) {
   dashboardManager = manager;
-  logger.info("DashboardManager instance set");
 }
 function getDashboardManager() {
   if (!dashboardManager) {
@@ -13051,6 +13153,190 @@ var ReportManager = class {
   }
 };
 
+// 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)
+   */
+  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,
+      message,
+      ...type && { type },
+      ...data && { data }
+    };
+    this.logs.push(log);
+    this.sendLogImmediately(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
+   */
+  sendLogImmediately(log) {
+    if (!this.isEnabled()) {
+      return;
+    }
+    const response = {
+      id: this.uiBlockId,
+      type: "UI_LOGS",
+      from: { type: "data-agent" },
+      to: {
+        type: "runtime",
+        id: this.clientId
+      },
+      payload: {
+        logs: [log]
+        // Send single log in array
+      }
+    };
+    this.sendMessage(response);
+  }
+  /**
+   * Log info message
+   */
+  info(message, type, data) {
+    if (this.isEnabled()) {
+      this.addLog("info", message, type, data);
+    }
+  }
+  /**
+   * Log error message
+   */
+  error(message, type, data) {
+    if (this.isEnabled()) {
+      this.addLog("error", message, type, data);
+    }
+  }
+  /**
+   * Log warning message
+   */
+  warn(message, type, data) {
+    if (this.isEnabled()) {
+      this.addLog("warn", message, type, data);
+    }
+  }
+  /**
+   * Log debug message
+   */
+  debug(message, type, data) {
+    if (this.isEnabled()) {
+      this.addLog("debug", message, type, data);
+    }
+  }
+  /**
+   * Log LLM explanation with typed metadata
+   */
+  logExplanation(message, explanation, data) {
+    if (this.isEnabled()) {
+      this.addLog("info", message, "explanation", {
+        explanation,
+        ...data
+      });
+    }
+  }
+  /**
+   * Log generated query with typed metadata
+   */
+  logQuery(message, query, data) {
+    if (this.isEnabled()) {
+      this.addLog("info", message, "query", {
+        query,
+        ...data
+      });
+    }
+  }
+  /**
+   * Send all collected logs at once (optional, for final summary)
+   */
+  sendAllLogs() {
+    if (!this.isEnabled() || this.logs.length === 0) {
+      return;
+    }
+    const response = {
+      id: this.uiBlockId,
+      type: "UI_LOGS",
+      from: { type: "data-agent" },
+      to: {
+        type: "runtime",
+        id: this.clientId
+      },
+      payload: {
+        logs: this.logs
+      }
+    };
+    this.sendMessage(response);
+  }
+  /**
+   * Get all collected logs
+   */
+  getLogs() {
+    return [...this.logs];
+  }
+  /**
+   * Clear all logs
+   */
+  clearLogs() {
+    this.logs = [];
+  }
+  /**
+   * Set uiBlockId (in case it's provided later)
+   */
+  setUIBlockId(uiBlockId) {
+    this.uiBlockId = uiBlockId;
+  }
+};
+
 // src/services/cleanup-service.ts
 var CleanupService = class _CleanupService {
   constructor() {
@@ -13231,7 +13517,6 @@ var CleanupService = class _CleanupService {
 };
 
 // src/index.ts
-var SDK_VERSION = "0.0.8";
 var DEFAULT_WS_URL = "wss://ws.superatom.ai/websocket";
 var SuperatomSDK = class {
   // 3.5 minutes (PING_INTERVAL + 30s grace)
@@ -13272,7 +13557,7 @@ var SuperatomSDK = class {
     if (config.queryCacheTTL !== void 0) {
       queryCache.setTTL(config.queryCacheTTL);
     }
-    logger.info(`Initializing Superatom SDK v${SDK_VERSION} for project ${this.projectId}, llm providers: ${this.llmProviders.join(", ")}, database type: ${this.databaseType}, model strategy: ${this.modelStrategy}, conversation similarity threshold: ${this.conversationSimilarityThreshold}, query cache TTL: ${queryCache.getTTL()} minutes`);
+    logger.info(`Initializing Superatom SDK for project ${this.projectId}, llm providers: ${this.llmProviders.join(", ")}, database type: ${this.databaseType}, model strategy: ${this.modelStrategy}, query cache TTL: ${queryCache.getTTL()} minutes`);
     this.userManager = new UserManager(this.projectId, 5e3);
     this.dashboardManager = new DashboardManager(this.projectId);
     this.reportManager = new ReportManager(this.projectId);
@@ -13326,7 +13611,6 @@ var SuperatomSDK = class {
    */
   initializeDashboardManager() {
     setDashboardManager(this.dashboardManager);
-    logger.info(`DashboardManager initialized for project: ${this.projectId}`);
   }
   /**
    * Get the DashboardManager instance for this SDK
@@ -13339,7 +13623,6 @@ var SuperatomSDK = class {
    */
   initializeReportManager() {
     setReportManager(this.reportManager);
-    logger.info(`ReportManager initialized for project: ${this.projectId}`);
   }
   /**
    * Get the ReportManager instance for this SDK
@@ -13717,7 +14000,6 @@ var SuperatomSDK = class {
   CONTEXT_CONFIG,
   CleanupService,
   LLM,
-  SDK_VERSION,
   STORAGE_CONFIG,
   SuperatomSDK,
   Thread,