@superatomai/sdk-node 0.0.71 → 0.0.72

package/dist/index.mjs

@@ -1458,6 +1458,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") {
@@ -1539,15 +1884,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`);
       }
@@ -5964,97 +6319,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") {
@@ -6070,17 +6663,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 };
   }
@@ -6088,7 +6683,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
    */
@@ -6129,10 +6724,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();
@@ -6142,81 +6737,656 @@ 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
+   * @param logCollector - Optional log collector for logging
+   * @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`);
-      let availableComponentsText = "No components available";
-      if (components && components.length > 0) {
-        availableComponentsText = components.map((comp, idx) => {
-          const keywords = comp.keywords ? comp.keywords.join(", ") : "";
-          const propsPreview = comp.props ? JSON.stringify(comp.props, null, 2) : "No props";
-          return `${idx + 1}. ID: ${comp.id}
-   Name: ${comp.name}
-   Type: ${comp.type}
-   Description: ${comp.description || "No description"}
-   Keywords: ${keywords}
-   Props Structure: ${propsPreview}`;
-        }).join("\n\n");
-      }
-      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!)
-							toolName: "${tool.name}"
-							parameters: ${JSON.stringify(tool.params || {})}
-							requiredFields:
-							${JSON.stringify(tool.requiredFields || [], null, 2)}`;
-        }).join("\n\n");
-      }
-      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) => {
-          let outputSchemaText = "Not available";
-          let fieldNamesList = "";
-          let recordCount = "unknown";
-          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"}`;
-            const fieldsText = fields.map(
-              (f) => `     "${f.name}" (${f.type}): ${f.description}`
-            ).join("\n");
-            outputSchemaText = `${tool.outputSchema.description}
-   Fields:
-${fieldsText}`;
-          }
-          return `${idx + 1}. **${tool.name}**
-							toolId: "${tool.id}"
-							toolName: "${tool.name}"
-							parameters: ${JSON.stringify(tool.params || {})}
-							recordCount: ${recordCount} rows returned
-							outputSchema: ${outputSchemaText}${fieldNamesList}`;
-        }).join("\n\n");
-      }
-      const schemaDoc = schema.generateSchemaDocumentation();
+  async validateSingleQuery(component, collections, apiKey, logCollector) {
+    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`);
+        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.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}`);
+        logCollector?.warn(`Query validation failed for ${component.name}: ${lastError}`);
+        if (attempts >= MAX_QUERY_VALIDATION_RETRIES) {
+          logger.error(`[${this.config.providerName}] \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.config.providerName}] 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.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`);
+      logCollector?.warn(`Component ${component.name} excluded from response`);
+    }
+    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
+   * @param logCollector - Optional log collector for logging
+   * @returns Object with validated components and query results map
+   */
+  async validateComponentQueries(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.config.providerName}] Validating ${componentsWithQuery.length} component queries in parallel...`);
+    logCollector?.info(`Validating ${componentsWithQuery.length} component queries in parallel...`);
+    const validationPromises = componentsWithQuery.map(
+      (component) => this.validateSingleQuery(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.config.providerName}] Unexpected error validating ${component.name}: ${result.reason}`);
+        logCollector?.error(`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, logCollector, 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);
+    logger.info(`[${providerName}] Executing query (attempt ${attempts}/${MAX_QUERY_ATTEMPTS}): ${sql.substring(0, 100)}...`);
+    if (Object.keys(params).length > 0) {
+      logger.info(`[${providerName}] 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(`[${providerName}] ${errorMsg}`);
+      logCollector?.error(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();
+        }
+      }
+      logCollector?.logQuery?.(
+        `Executing SQL query (attempt ${attempts})`,
+        { sql, params },
+        { reasoning, attempt: attempts }
+      );
+      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");
+      logger.info(`[${providerName}] Query executed successfully, rows returned: ${rowCount}`);
+      logCollector?.info(`Query successful, returned ${rowCount} rows`);
+      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
+      });
+      logger.info(`[${providerName}] Query result formatted: ${formattedResult.summary.recordsShown}/${formattedResult.summary.totalRecords} records`);
+      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}`);
+      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 (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, logCollector, 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);
+    logger.info(`[${providerName}] 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(`[${providerName}] ${errorMsg}`);
+      logCollector?.error(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
+      );
+      logger.info(`[${providerName}] External tool ${externalTool.name} executed successfully`);
+      logCollector?.info(`\u2713 ${externalTool.name} executed successfully`);
+      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
+        });
+        logger.info(`[${providerName}] Tracked executed tool: ${externalTool.name} with ${formattedForTracking.summary.totalRecords} total records`);
+      }
+      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
+      });
+      logger.info(`[${providerName}] Tool result formatted: ${formattedToolResult.summary.recordsShown}/${formattedToolResult.summary.totalRecords} records`);
+      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}`);
+      logCollector?.error(`\u2717 ${externalTool.name} failed: ${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;
+    logger.info(`[${this.getProviderName()}] Conversation similarity threshold set to: ${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 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
+   */
+  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`);
+      let availableComponentsText = "No components available";
+      if (components && components.length > 0) {
+        availableComponentsText = components.map((comp, idx) => {
+          const keywords = comp.keywords ? comp.keywords.join(", ") : "";
+          const propsPreview = comp.props ? JSON.stringify(comp.props, null, 2) : "No props";
+          return `${idx + 1}. ID: ${comp.id}
+   Name: ${comp.name}
+   Type: ${comp.type}
+   Description: ${comp.description || "No description"}
+   Keywords: ${keywords}
+   Props Structure: ${propsPreview}`;
+        }).join("\n\n");
+      }
+      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!)
+							toolName: "${tool.name}"
+							parameters: ${JSON.stringify(tool.params || {})}
+							requiredFields:
+							${JSON.stringify(tool.requiredFields || [], null, 2)}`;
+        }).join("\n\n");
+      }
+      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" + executedTools.map((tool, idx) => {
+          let outputSchemaText = "Not available";
+          let fieldNamesList = "";
+          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 || [];
+            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"}`;
+            const fieldsText = fields.map(
+              (f) => `     "${f.name}" (${f.type}): ${f.description}`
+            ).join("\n");
+            outputSchemaText = `${tool.outputSchema.description}
+   Fields:
+${fieldsText}`;
+          }
+          return `${idx + 1}. **${tool.name}**
+   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();
       const databaseRules = await promptLoader.loadDatabaseRules();
       let knowledgeBaseContext = "No additional knowledge base context available.";
       if (collections) {
@@ -6224,7 +7394,7 @@ ${fieldsText}`;
           prompt: userPrompt || analysisContent,
           collections,
           userId,
-          topK: 3
+          topK: KNOWLEDGE_BASE_TOP_K
         });
         knowledgeBaseContext = kbResult.combinedContext || knowledgeBaseContext;
       }
@@ -6240,22 +7410,6 @@ ${fieldsText}`;
         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}
@@ -6332,23 +7486,32 @@ ${executedToolsText}`);
                       { componentName: answerComponent.name, componentType: answerComponent.type, reasoning: answerComponentData.reasoning }
                     );
                   }
-                  const answerQuery = answerComponent.props?.query;
+                  let answerQuery = answerComponent.props?.query;
                   logger.info(`[${this.getProviderName()}] Answer component detected: ${answerComponent.name} (${answerComponent.type}), hasQuery: ${!!answerQuery}, hasDbExecute: ${!!collections?.["database"]?.["execute"]}`);
+                  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;
+                  }
                   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}`);
+                            logger.debug(`[${this.getProviderName()}] Answer component query validation attempt ${attempts}/${maxRetries}`);
                             const result2 = await collections["database"]["execute"]({ sql: cacheKey });
                             queryCache.set(cacheKey, result2);
                             validated = true;
@@ -6363,11 +7526,11 @@ ${executedToolsText}`);
                           }
                         } 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,
                                 {
@@ -6377,7 +7540,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 {
@@ -6418,7 +7581,7 @@ ${executedToolsText}`);
         },
         {
           model: this.getModelForTask("complex"),
-          maxTokens: 8192,
+          maxTokens: MAX_TOKENS_COMPONENT_MATCHING,
           temperature: 0,
           apiKey: this.getApiKey(apiKey),
           partial: partialCallback
@@ -6454,137 +7617,14 @@ ${executedToolsText}`);
           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`);
-        }
+        const cleanedProps = processComponentProps(
+          mc.props,
+          executedTools,
+          {
+            providerName: this.getProviderName(),
+            defaultLimit: this.defaultLimit
+          }
+        );
         return {
           ...originalComponent,
           props: {
@@ -6598,7 +7638,7 @@ ${executedToolsText}`);
         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,
@@ -6638,153 +7678,6 @@ ${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
@@ -6809,24 +7702,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,
@@ -6834,7 +7711,7 @@ ${executedToolsText}`);
         },
         {
           model: this.getModelForTask("simple"),
-          maxTokens: 1500,
+          maxTokens: MAX_TOKENS_CLASSIFICATION,
           temperature: 0,
           apiKey: this.getApiKey(apiKey)
         },
@@ -6907,7 +7784,7 @@ ${executedToolsText}`);
         },
         {
           model: this.getModelForTask("complex"),
-          maxTokens: 8192,
+          maxTokens: MAX_TOKENS_ADAPTATION,
           temperature: 0,
           apiKey: this.getApiKey(apiKey)
         },
@@ -7024,7 +7901,7 @@ ${executedToolsText}`);
         prompt: userPrompt,
         collections,
         userId,
-        topK: 3
+        topK: KNOWLEDGE_BASE_TOP_K
       });
       const knowledgeBaseContext = kbResult.combinedContext;
       const prompts = await promptLoader.loadPrompts("text-response", {
@@ -7036,24 +7913,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.logLLMPrompt("generateTextResponse", "system", extractPromptText(prompts.system));
+      logger.logLLMPrompt("generateTextResponse", "user", extractPromptText(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...");
@@ -7165,324 +8026,24 @@ ${executedToolsText}`);
         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}`);
-        }
-      };
+      const streamBuffer = new StreamBuffer(streamCallback);
+      const toolExecutor = new ToolExecutorService({
+        providerName: this.getProviderName(),
+        collections,
+        streamBuffer,
+        logCollector
+      });
+      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,
@@ -7492,18 +8053,16 @@ ${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");
@@ -7526,10 +8085,10 @@ ${errorMsg}
           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";
@@ -7555,11 +8114,11 @@ ${errorMsg}
         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 setup: hasCallback=${streamBuffer.hasCallback()}, category=${category}`);
+        const componentStreamCallback = streamBuffer.hasCallback() && category !== "data_modification" ? (component) => {
           logger.info(`[${this.getProviderName()}] componentStreamCallback INVOKED for: ${component.name} (${component.type})`);
           const answerMarker = `__ANSWER_COMPONENT_START__${JSON.stringify(component)}__ANSWER_COMPONENT_END__`;
-          wrappedStreamCallback(answerMarker);
+          streamBuffer.write(answerMarker);
           logger.info(`[${this.getProviderName()}] Streamed answer component to frontend: ${component.name} (${component.type})`);
         } : void 0;
         logger.info(`[${this.getProviderName()}] componentStreamCallback created: ${!!componentStreamCallback}`);
@@ -7586,7 +8145,7 @@ ${errorMsg}
           logCollector,
           componentStreamCallback,
           deferredTools,
-          executedToolsList,
+          toolExecutor.getExecutedTools(),
           collections,
           userId
         );
@@ -7670,7 +8229,7 @@ ${errorMsg}
         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`);
@@ -7685,7 +8244,7 @@ ${errorMsg}
           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`);
@@ -7707,7 +8266,7 @@ ${errorMsg}
             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`);
@@ -7902,7 +8461,7 @@ ${errorMsg}
         },
         {
           model: this.getModelForTask("simple"),
-          maxTokens: 1200,
+          maxTokens: MAX_TOKENS_NEXT_QUESTIONS,
           temperature: 0,
           apiKey: this.getApiKey(apiKey)
         },