@superatomai/sdk-node 0.0.72 → 0.0.75

package/dist/index.js

@@ -34,7 +34,6 @@ __export(index_exports, {
   CONTEXT_CONFIG: () => CONTEXT_CONFIG,
   CleanupService: () => CleanupService,
   LLM: () => LLM,
-  SDK_VERSION: () => SDK_VERSION,
   STORAGE_CONFIG: () => STORAGE_CONFIG,
   SuperatomSDK: () => SuperatomSDK,
   Thread: () => Thread,
@@ -3368,24 +3367,20 @@ If adaptation is not possible or would fundamentally change the component:
   "dash-comp-picker": {
     system: `You are a component selection expert that picks the best dashboard component and generates complete props based on user requests.
 
+## CRITICAL - READ FIRST
+
+1. Your ENTIRE response must be ONLY a raw JSON object - start with { end with }
+2. DO NOT explain or answer the user's question in natural language
+3. DO NOT use markdown code blocks (no \`\`\`)
+4. DO NOT add any text before or after the JSON
+5. After executing tools (if needed), return JSON with component selection - NOT a text summary of results
+
 ## Your Task
 
 Analyze the user's request and:
 1. **Select the most appropriate component** from the available components list
-2. **Determine the data source**: Database query OR External tool
-3. **Generate complete props** for the selected component
-
-## Available External Tools
-
-The following external tools are available:
-
-{{AVAILABLE_TOOLS}}
-
-When a tool is needed to complete the user's request:
-1. **Analyze the request** to determine which tool is needed
-2. **Extract parameters** from the user's question
-3. **Execute the tool** by calling it with the extracted parameters
-4. **Use the results** to configure the component (field names for axes, columns, etc.)
+2. **Determine the data source**: Database query OR External tool (ERP)
+3. **Generate complete props** for the selected component including the data retrieval/modification method
 
 ## Component Selection Rules
 
@@ -3415,7 +3410,7 @@ The user prompt may contain an **existing component** to update. Detect this by
 
 ### Use DATABASE when:
 - User asks about data that exists in the database schema
-- Questions about internal business data
+- Questions about internal business data 
 - CRUD operations on database tables
 
 ### Use EXTERNAL TOOL when:
@@ -3428,6 +3423,12 @@ The user prompt may contain an **existing component** to update. Detect this by
 
 **CRITICAL**: Look at each component's "Props Structure" in the available components list. Generate ALL props that the component expects.
 
+**CRITICAL: Each component uses EXACTLY ONE data source - never both!**
+- If using \`query\`, set \`externalTool: null\`
+- If using \`externalTool\`, set \`query: null\`
+- NEVER copy placeholder/description text from component metadata as actual values
+- \`externalTool.parameters\` MUST be an object, never a string
+
 ### For Data Viewing Components (charts, tables, KPIs):
 
 **Option A: Database Query** (when data is in database)
@@ -3436,21 +3437,19 @@ The user prompt may contain an **existing component** to update. Detect this by
   "query": {
     "sql": "SELECT column1, column2 FROM table WHERE condition = $param LIMIT 32",
     "params": { "param": "value" }
-  }
+  },
+  "externalTool": null
 }
 \`\`\`
 
 **Option B: External Tool** (when data is from ERP/external system)
 \`\`\`json
 {
+  "query": null,
   "externalTool": {
     "toolId": "tool_id_from_list",
     "toolName": "Tool Display Name",
-    "action": "get",
-    "params": {
-      "param1": "value1",
-      "param2": "value2"
-    }
+    "parameters": { "param1": "value1", "param2": "value2" }
   }
 }
 \`\`\`
@@ -3464,6 +3463,7 @@ The user prompt may contain an **existing component** to update. Detect this by
     "sql": "INSERT INTO table (col1, col2) VALUES ($col1, $col2)",
     "params": {}
   },
+  "externalTool": null,
   "fields": [
     { "name": "col1", "type": "text", "required": true },
     { "name": "col2", "type": "number", "required": false }
@@ -3471,16 +3471,38 @@ The user prompt may contain an **existing component** to update. Detect this by
 }
 \`\`\`
 
+For UPDATE:
+\`\`\`json
+{
+  "query": {
+    "sql": "UPDATE table SET col1 = $col1, col2 = $col2 WHERE id = $id",
+    "params": { "id": "record_id" }
+  },
+  "externalTool": null
+}
+\`\`\`
+
+For DELETE:
+\`\`\`json
+{
+  "query": {
+    "sql": "DELETE FROM table WHERE id = $id",
+    "params": { "id": "record_id" }
+  },
+  "externalTool": null,
+  "submitButtonText": "Confirm Delete",
+  "submitButtonColor": "danger"
+}
+\`\`\`
+
 **Option B: External Tool Mutation**
 \`\`\`json
 {
+  "query": null,
   "externalTool": {
     "toolId": "tool_id_from_list",
     "toolName": "Tool Display Name",
-    "action": "create|update|delete",
-    "params": {
-      "param1": "value_or_placeholder"
-    }
+    "parameters": { "param1": "value_or_placeholder" }
   },
   "fields": [
     { "name": "param1", "type": "text", "required": true }
@@ -3495,6 +3517,7 @@ The user prompt may contain an **existing component** to update. Detect this by
 
 You MUST respond with ONLY a valid JSON object (no markdown, no code blocks):
 
+\`\`\`json
 {
   "componentId": "id_from_available_list_or_existing_component_id",
   "componentName": "name_of_component",
@@ -3509,6 +3532,7 @@ You MUST respond with ONLY a valid JSON object (no markdown, no code blocks):
     // Include all other required props (title, description, config, fields, etc.)
   }
 }
+\`\`\`
 
 **CRITICAL:**
 - Return ONLY valid JSON (no markdown code blocks, no text before/after)
@@ -3531,7 +3555,8 @@ You MUST respond with ONLY a valid JSON object (no markdown, no code blocks):
 
 ---
 
-## CONTEXT`,
+## CONTEXT
+`,
     user: `{{USER_PROMPT}}`
   },
   "dash-filter-picker": {
@@ -3677,9 +3702,7 @@ var PromptLoader = class {
     this.databaseRulesCache = /* @__PURE__ */ new Map();
     this.isInitialized = false;
     this.databaseType = "postgresql";
-    logger.debug("Initializing PromptLoader...");
     this.promptsDir = config?.promptsDir || import_path.default.join(process.cwd(), ".prompts");
-    logger.debug(`Prompts directory set to: ${this.promptsDir}`);
   }
   /**
    * Load a prompt template from file system OR fallback to hardcoded prompts
@@ -3693,7 +3716,6 @@ var PromptLoader = class {
       if (import_fs2.default.existsSync(systemPath) && import_fs2.default.existsSync(userPath)) {
         const system = import_fs2.default.readFileSync(systemPath, "utf-8");
         const user = import_fs2.default.readFileSync(userPath, "utf-8");
-        logger.info(`\u2713 Loaded prompt '${promptName}' from file system: ${this.promptsDir}`);
         return { system, user };
       }
     } catch (error) {
@@ -3701,7 +3723,6 @@ var PromptLoader = class {
     }
     const hardcodedPrompt = PROMPTS[promptName];
     if (hardcodedPrompt) {
-      logger.info(`\u2713 Loaded prompt '${promptName}' from hardcoded fallback`);
       return hardcodedPrompt;
     }
     throw new Error(`Prompt template '${promptName}' not found in either ${this.promptsDir} or hardcoded prompts. Available prompts: ${Object.keys(PROMPTS).join(", ")}`);
@@ -3715,7 +3736,6 @@ var PromptLoader = class {
       logger.debug("PromptLoader already initialized, skipping...");
       return;
     }
-    logger.info("Loading prompts into memory...");
     const promptTypes = Object.keys(PROMPTS);
     for (const promptName of promptTypes) {
       try {
@@ -3727,7 +3747,6 @@ var PromptLoader = class {
       }
     }
     this.isInitialized = true;
-    logger.info(`Successfully loaded ${this.promptCache.size} prompt templates into memory`);
   }
   /**
    * Replace variables in a template string using {{VARIABLE_NAME}} pattern
@@ -3767,7 +3786,6 @@ var PromptLoader = class {
       const processedContext = this.replaceVariables(contextMarker + contextPart, variables);
       const staticLength = processedStatic.length;
       const contextLength = processedContext.length;
-      logger.debug(`\u2713 Prompt caching enabled for '${promptName}' (cached: ${staticLength} chars, dynamic: ${contextLength} chars)`);
       return {
         system: [
           {
@@ -3804,7 +3822,6 @@ var PromptLoader = class {
     this.promptsDir = dir;
     this.isInitialized = false;
     this.promptCache.clear();
-    logger.debug(`Prompts directory changed to: ${dir}`);
   }
   /**
    * Get current prompts directory
@@ -3832,7 +3849,6 @@ var PromptLoader = class {
   setDatabaseType(type) {
     this.databaseType = type;
     this.databaseRulesCache.clear();
-    logger.debug(`Database type set to: ${type}`);
   }
   /**
    * Get current database type
@@ -3848,7 +3864,6 @@ var PromptLoader = class {
    */
   async loadDatabaseRules() {
     if (this.databaseRulesCache.has(this.databaseType)) {
-      logger.debug(`\u2713 Database rules for '${this.databaseType}' loaded from cache`);
       return this.databaseRulesCache.get(this.databaseType);
     }
     const rulesPath = import_path.default.join(this.promptsDir, "database-rules", `${this.databaseType}.md`);
@@ -3856,7 +3871,6 @@ var PromptLoader = class {
       if (import_fs2.default.existsSync(rulesPath)) {
         const rules = import_fs2.default.readFileSync(rulesPath, "utf-8");
         this.databaseRulesCache.set(this.databaseType, rules);
-        logger.info(`\u2713 Loaded database rules for '${this.databaseType}' from ${rulesPath}`);
         return rules;
       }
     } catch (error) {
@@ -4132,7 +4146,6 @@ var Schema = class {
    * @returns Parsed schema object or null if error occurs
    */
   getDatabaseSchema() {
-    logger.info(`SCHEMA_FILE_PATH: ${this.schemaFilePath}`);
     try {
       const dir = import_path2.default.dirname(this.schemaFilePath);
       if (!import_fs3.default.existsSync(dir)) {
@@ -4401,14 +4414,6 @@ Format: [TIMESTAMP] [REQUEST_ID] [PROVIDER/MODEL] [METHOD]
     Cost: $${entry.costUSD.toFixed(6)} | Time: ${entry.durationMs}ms${toolInfo}${errorInfo}${cacheStatus}
 `;
     this.logStream?.write(logLine);
-    if (entry.cacheReadTokens && entry.cacheReadTokens > 0) {
-      console.log(`[LLM] \u26A1 CACHE HIT: ${entry.cacheReadTokens.toLocaleString()} tokens read from cache (${entry.method})`);
-    } else if (entry.cacheWriteTokens && entry.cacheWriteTokens > 0) {
-      console.log(`[LLM] \u{1F4DD} CACHE WRITE: ${entry.cacheWriteTokens.toLocaleString()} tokens cached for future requests (${entry.method})`);
-    }
-    if (process.env.SUPERATOM_LOG_LEVEL === "verbose") {
-      console.log("\n[LLM-Usage]", logLine);
-    }
   }
   /**
    * Log session summary (call at end of request)
@@ -4441,11 +4446,6 @@ Avg Time/Call: ${Math.round(this.sessionStats.totalDurationMs / this.sessionStat
 
 `;
     this.logStream?.write(summary);
-    console.log("\n[LLM-Usage] Session Summary:");
-    console.log(`  Calls: ${this.sessionStats.totalCalls} | Tokens: ${(this.sessionStats.totalInputTokens + this.sessionStats.totalOutputTokens).toLocaleString()} | Cost: $${this.sessionStats.totalCostUSD.toFixed(4)} | Time: ${(this.sessionStats.totalDurationMs / 1e3).toFixed(2)}s`);
-    if (hasCaching) {
-      console.log(`  Cache: ${this.sessionStats.totalCacheReadTokens.toLocaleString()} read, ${this.sessionStats.totalCacheWriteTokens.toLocaleString()} written | Savings: ~$${cacheReadSavings.toFixed(4)}`);
-    }
   }
   /**
    * Reset session stats (call at start of new user request)
@@ -4486,7 +4486,6 @@ Format: [TIMESTAMP] [REQUEST_ID] [PROVIDER/MODEL] [METHOD]
 `;
       this.logStream.write(header);
       this.resetSession();
-      console.log(`[LLM-Usage] Log file reset for new request: ${this.logPath}`);
     } catch (error) {
       console.error("[LLM-Usage-Logger] Failed to reset log file:", error);
     }
@@ -5401,14 +5400,97 @@ var LLM = class {
     const genAI = new import_generative_ai.GoogleGenerativeAI(apiKey);
     const systemPrompt = typeof messages.sys === "string" ? messages.sys : messages.sys.map((block) => block.text).join("\n");
     try {
+      if (json && options.partial) {
+        const model2 = genAI.getGenerativeModel({
+          model: modelName,
+          systemInstruction: systemPrompt,
+          generationConfig: {
+            maxOutputTokens: options.maxTokens || 1e3,
+            temperature: options.temperature,
+            topP: options.topP,
+            responseMimeType: "application/json"
+          }
+        });
+        const result2 = await model2.generateContentStream(messages.user);
+        let fullText2 = "";
+        let inputTokens2 = 0;
+        let outputTokens2 = 0;
+        for await (const chunk of result2.stream) {
+          try {
+            const text = chunk.text();
+            if (text) {
+              fullText2 += text;
+              options.partial(text);
+            }
+          } catch (chunkError) {
+          }
+          if (chunk.usageMetadata) {
+            inputTokens2 = chunk.usageMetadata.promptTokenCount || 0;
+            outputTokens2 = chunk.usageMetadata.candidatesTokenCount || 0;
+          }
+        }
+        const durationMs2 = Date.now() - startTime;
+        if (inputTokens2 === 0) {
+          inputTokens2 = Math.ceil((systemPrompt.length + messages.user.length) / 4);
+        }
+        if (outputTokens2 === 0) {
+          outputTokens2 = Math.ceil(fullText2.length / 4);
+        }
+        llmUsageLogger.log({
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          requestId,
+          provider: "gemini",
+          model: modelName,
+          method: "stream-json-partial",
+          inputTokens: inputTokens2,
+          outputTokens: outputTokens2,
+          totalTokens: inputTokens2 + outputTokens2,
+          costUSD: llmUsageLogger.calculateCost(modelName, inputTokens2, outputTokens2),
+          durationMs: durationMs2,
+          success: true
+        });
+        return this._parseJSON(fullText2);
+      }
+      if (json) {
+        const model2 = genAI.getGenerativeModel({
+          model: modelName,
+          systemInstruction: systemPrompt,
+          generationConfig: {
+            maxOutputTokens: options.maxTokens || 1e3,
+            temperature: options.temperature,
+            topP: options.topP,
+            responseMimeType: "application/json"
+          }
+        });
+        const result2 = await model2.generateContent(messages.user);
+        const response = result2.response;
+        const fullText2 = response.text();
+        const durationMs2 = Date.now() - startTime;
+        const usage = response.usageMetadata;
+        const inputTokens2 = usage?.promptTokenCount || Math.ceil((systemPrompt.length + messages.user.length) / 4);
+        const outputTokens2 = usage?.candidatesTokenCount || Math.ceil(fullText2.length / 4);
+        llmUsageLogger.log({
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          requestId,
+          provider: "gemini",
+          model: modelName,
+          method: "stream-json",
+          inputTokens: inputTokens2,
+          outputTokens: outputTokens2,
+          totalTokens: inputTokens2 + outputTokens2,
+          costUSD: llmUsageLogger.calculateCost(modelName, inputTokens2, outputTokens2),
+          durationMs: durationMs2,
+          success: true
+        });
+        return this._parseJSON(fullText2);
+      }
       const model = genAI.getGenerativeModel({
         model: modelName,
         systemInstruction: systemPrompt,
         generationConfig: {
           maxOutputTokens: options.maxTokens || 1e3,
           temperature: options.temperature,
-          topP: options.topP,
-          responseMimeType: json ? "application/json" : void 0
+          topP: options.topP
         }
       });
       const result = await model.generateContentStream(messages.user);
@@ -5416,12 +5498,15 @@ var LLM = class {
       let inputTokens = 0;
       let outputTokens = 0;
       for await (const chunk of result.stream) {
-        const text = chunk.text();
-        if (text) {
-          fullText += text;
-          if (options.partial) {
-            options.partial(text);
+        try {
+          const text = chunk.text();
+          if (text) {
+            fullText += text;
+            if (options.partial) {
+              options.partial(text);
+            }
           }
+        } catch (chunkError) {
         }
         if (chunk.usageMetadata) {
           inputTokens = chunk.usageMetadata.promptTokenCount || 0;
@@ -5448,9 +5533,6 @@ var LLM = class {
         durationMs,
         success: true
       });
-      if (json) {
-        return this._parseJSON(fullText);
-      }
       return fullText;
     } catch (error) {
       const durationMs = Date.now() - startTime;
@@ -5471,6 +5553,26 @@ var LLM = class {
       throw error;
     }
   }
+  /**
+   * Recursively strip unsupported JSON Schema properties for Gemini
+   * Gemini doesn't support: additionalProperties, $schema, etc.
+   */
+  static _cleanSchemaForGemini(obj) {
+    if (obj === null || typeof obj !== "object") {
+      return obj;
+    }
+    if (Array.isArray(obj)) {
+      return obj.map((item) => this._cleanSchemaForGemini(item));
+    }
+    const cleaned = {};
+    for (const [key, value] of Object.entries(obj)) {
+      if (key === "additionalProperties" || key === "$schema") {
+        continue;
+      }
+      cleaned[key] = this._cleanSchemaForGemini(value);
+    }
+    return cleaned;
+  }
   static async _geminiStreamWithTools(messages, tools, toolHandler, modelName, options, maxIterations) {
     const methodStartTime = Date.now();
     const apiKey = options.apiKey || process.env.GEMINI_API_KEY || "";
@@ -5481,7 +5583,7 @@ var LLM = class {
       description: tool.description,
       parameters: {
         type: import_generative_ai.SchemaType.OBJECT,
-        properties: tool.input_schema.properties,
+        properties: this._cleanSchemaForGemini(tool.input_schema.properties),
         required: tool.input_schema.required || []
       }
     }));
@@ -5960,21 +6062,20 @@ var getKnowledgeBase = async ({
 }) => {
   try {
     if (!collections || !collections["knowledge-base"] || !collections["knowledge-base"]["query"]) {
-      logger.info("[KnowledgeBase] knowledge-base.query collection not registered, skipping");
+      logger.warn("[KnowledgeBase] knowledge-base.query collection not registered, skipping");
       return "";
     }
-    logger.info(`[KnowledgeBase] Querying knowledge base for: "${prompt.substring(0, 50)}..."`);
     const result = await collections["knowledge-base"]["query"]({
       prompt,
       topK
     });
     if (!result || !result.content) {
-      logger.info("[KnowledgeBase] No knowledge base results returned");
+      logger.warn("[KnowledgeBase] No knowledge base results returned");
       return "";
     }
     logger.info(`[KnowledgeBase] Retrieved knowledge base context (${result.content.length} chars)`);
     if (result.metadata?.sources && result.metadata.sources.length > 0) {
-      logger.debug(`[KnowledgeBase] Sources: ${result.metadata.sources.map((s) => s.title).join(", ")}`);
+      logger.warn(`[KnowledgeBase] Sources: ${result.metadata.sources.map((s) => s.title).join(", ")}`);
     }
     return result.content;
   } catch (error) {
@@ -5989,13 +6090,12 @@ var getGlobalKnowledgeBase = async ({
 }) => {
   try {
     if (!collections || !collections["knowledge-base"] || !collections["knowledge-base"]["getGlobal"]) {
-      logger.info("[KnowledgeBase] knowledge-base.getGlobal collection not registered, skipping");
+      logger.warn("[KnowledgeBase] knowledge-base.getGlobal collection not registered, skipping");
       return "";
     }
-    logger.info("[KnowledgeBase] Fetching global knowledge base nodes...");
     const result = await collections["knowledge-base"]["getGlobal"]({ limit });
     if (!result || !result.content) {
-      logger.info("[KnowledgeBase] No global knowledge base nodes found");
+      logger.warn("[KnowledgeBase] No global knowledge base nodes found");
       return "";
     }
     logger.info(`[KnowledgeBase] Retrieved ${result.count || 0} global knowledge base nodes`);
@@ -6013,14 +6113,13 @@ var getUserKnowledgeBase = async ({
 }) => {
   try {
     if (!userId) {
-      logger.info("[KnowledgeBase] No userId provided, skipping user knowledge base");
+      logger.warn("[KnowledgeBase] No userId provided, skipping user knowledge base");
       return "";
     }
     if (!collections || !collections["knowledge-base"] || !collections["knowledge-base"]["getByUser"]) {
-      logger.info("[KnowledgeBase] knowledge-base.getByUser collection not registered, skipping");
+      logger.warn("[KnowledgeBase] knowledge-base.getByUser collection not registered, skipping");
       return "";
     }
-    logger.info(`[KnowledgeBase] Fetching user knowledge base nodes for userId: ${userId}...`);
     const result = await collections["knowledge-base"]["getByUser"]({
       userId: Number(userId),
       limit
@@ -6043,7 +6142,6 @@ var getAllKnowledgeBase = async ({
   userId,
   topK = 3
 }) => {
-  logger.info("[KnowledgeBase] Fetching all knowledge base contexts...");
   const [globalContext, userContext, queryContext] = await Promise.all([
     getGlobalKnowledgeBase({ collections }),
     getUserKnowledgeBase({ collections, userId }),
@@ -6065,7 +6163,6 @@ var getAllKnowledgeBase = async ({
     combinedContext += "The following information is semantically relevant to the current query:\n\n";
     combinedContext += queryContext + "\n\n";
   }
-  logger.info(`[KnowledgeBase] Combined knowledge base context: global=${globalContext.length} chars, user=${userContext.length} chars, query=${queryContext.length} chars`);
   return {
     globalContext,
     userContext,
@@ -6302,11 +6399,11 @@ var searchConversationsWithReranking = async (options) => {
   } = options;
   try {
     if (!collections || !collections["conversation-history"]) {
-      logger.info("[ConversationSearch] conversation-history collection not registered, skipping");
+      logger.warn("[ConversationSearch] conversation-history collection not registered, skipping");
       return null;
     }
     if (!collections["conversation-history"]["searchMultiple"]) {
-      logger.info("[ConversationSearch] searchMultiple not available, falling back to standard search");
+      logger.warn("[ConversationSearch] searchMultiple not available, falling back to standard search");
       return searchConversations({
         userPrompt,
         collections,
@@ -6314,9 +6411,6 @@ var searchConversationsWithReranking = async (options) => {
         similarityThreshold
       });
     }
-    logger.info(`[ConversationSearch] Hybrid search for: "${userPrompt.substring(0, 50)}..."`);
-    logger.info(`[ConversationSearch] Fetching ${rerankCandidates} candidates for reranking`);
-    logger.info(`[ConversationSearch] Weights - Semantic: ${hybridOptions.semanticWeight}, BM25: ${hybridOptions.bm25Weight}`);
     const results = await collections["conversation-history"]["searchMultiple"]({
       userPrompt,
       userId,
@@ -6357,7 +6451,6 @@ var searchConversationsWithReranking = async (options) => {
     logger.info(
       `[ConversationSearch] \u2713 Found match with semantic score ${(semanticScore * 100).toFixed(2)}%`
     );
-    logger.info(`  - Returning cached result for: "${matchedUserPrompt}"`);
     return {
       uiBlock: best.uiBlock,
       similarity: semanticScore,
@@ -6799,10 +6892,9 @@ Fixed SQL query:`;
    * @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 validateSingleQuery(component, collections, apiKey, logCollector) {
+  async validateSingleQuery(component, collections, apiKey) {
     const query = component.props?.query;
     const originalQueryKey = this.getQueryCacheKey(query);
     const queryStr = typeof query === "string" ? query : query?.sql || "";
@@ -6823,7 +6915,6 @@ Fixed SQL query:`;
         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 = {
@@ -6836,14 +6927,11 @@ Fixed SQL 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,
@@ -6877,7 +6965,6 @@ Fixed SQL query:`;
     }
     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,
@@ -6891,10 +6978,9 @@ Fixed SQL query:`;
    * @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) {
+  async validateComponentQueries(components, collections, apiKey) {
     const queryResults = /* @__PURE__ */ new Map();
     const validatedComponents = [];
     const componentsWithoutQuery = [];
@@ -6911,9 +6997,8 @@ Fixed SQL query:`;
       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)
+      (component) => this.validateSingleQuery(component, collections, apiKey)
     );
     const results = await Promise.allSettled(validationPromises);
     for (let i = 0; i < results.length; i++) {
@@ -6930,7 +7015,6 @@ Fixed SQL query:`;
         }
       } 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`);
@@ -6992,22 +7076,17 @@ var ToolExecutorService = class {
     let sql = toolInput.sql;
     const params = toolInput.params || {};
     const reasoning = toolInput.reasoning;
-    const { streamBuffer, collections, logCollector, providerName } = this.config;
+    const { streamBuffer, collections, providerName } = this.config;
     sql = ensureQueryLimit(sql, MAX_COMPONENT_QUERY_LIMIT, MAX_COMPONENT_QUERY_LIMIT);
     const queryKey = sql.toLowerCase().replace(/\s+/g, " ").trim();
     const attempts = (this.queryAttempts.get(queryKey) || 0) + 1;
     this.queryAttempts.set(queryKey, attempts);
-    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(`
@@ -7067,11 +7146,6 @@ ${sql}
           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.");
       }
@@ -7083,8 +7157,6 @@ ${sql}
       );
       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!**
@@ -7133,7 +7205,6 @@ ${sql}
         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}`);
       }
@@ -7141,7 +7212,6 @@ ${sql}
     } 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:**
@@ -7163,19 +7233,16 @@ ${errorMsg}
    * Execute an external tool with retry tracking and streaming feedback
    */
   async executeExternalTool(toolName, toolInput, externalTools) {
-    const { streamBuffer, logCollector, providerName } = this.config;
+    const { streamBuffer, providerName } = this.config;
     const externalTool = externalTools?.find((t) => t.id === toolName);
     if (!externalTool) {
       throw new Error(`Unknown tool: ${toolName}`);
     }
     const attempts = (this.toolAttempts.get(toolName) || 0) + 1;
     this.toolAttempts.set(toolName, attempts);
-    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(`
 
@@ -7210,8 +7277,6 @@ Please try rephrasing your request or contact support.
         `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,
@@ -7231,7 +7296,6 @@ Please try rephrasing your request or contact support.
           },
           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**
@@ -7245,7 +7309,6 @@ Please try rephrasing your request or contact support.
         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}`);
       }
@@ -7253,7 +7316,6 @@ Please try rephrasing your request or contact support.
     } 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:**
@@ -7331,7 +7393,6 @@ var BaseLLM = class {
       return;
     }
     this.conversationSimilarityThreshold = threshold;
-    logger.info(`[${this.getProviderName()}] Conversation similarity threshold set to: ${threshold}`);
   }
   /**
    * Get the current conversation similarity threshold
@@ -7374,16 +7435,14 @@ var BaseLLM = class {
    * @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) {
+  async matchComponentsFromAnalysis(analysisContent, components, userPrompt, apiKey, componentStreamCallback, deferredTools, executedTools, collections, userId) {
     const methodStartTime = Date.now();
     const methodName = "matchComponentsFromAnalysis";
     logger.info(`[${this.getProviderName()}] [TIMING] START ${methodName} | model: ${this.getModelForTask("complex")}`);
     try {
-      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) => {
@@ -7399,7 +7458,6 @@ var BaseLLM = class {
       }
       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!)
@@ -7411,7 +7469,6 @@ var BaseLLM = class {
       }
       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 = "";
@@ -7467,14 +7524,12 @@ ${fieldsText}`;
         KNOWLEDGE_BASE_CONTEXT: knowledgeBaseContext,
         CURRENT_DATETIME: getCurrentDateTimeForPrompt()
       });
-      logger.debug(`[${this.getProviderName()}] Loaded match-text-components prompts`);
       logger.logLLMPrompt("matchComponentsFromAnalysis", "system", extractPromptText(prompts.system));
       logger.logLLMPrompt("matchComponentsFromAnalysis", "user", `Text Analysis:
 ${analysisContent}
 
 Executed Tools:
 ${executedToolsText}`);
-      logCollector?.info("Matching components from text response...");
       let fullResponseText = "";
       let answerComponentExtracted = false;
       const answerCallback = componentStreamCallback;
@@ -7534,18 +7589,7 @@ ${executedToolsText}`);
                       ...answerComponentData.props
                     }
                   };
-                  const streamTime = (/* @__PURE__ */ new Date()).toISOString();
-                  logger.info(`[${this.getProviderName()}] \u2713 [${streamTime}] Answer component detected in stream: ${answerComponent.name} (${answerComponent.type})`);
-                  logCollector?.info(`\u2713 Answer component: ${answerComponent.name} (${answerComponent.type}) - detected at ${streamTime}`);
-                  if (answerComponentData.props?.query) {
-                    logCollector?.logQuery(
-                      "Answer component query",
-                      answerComponentData.props.query,
-                      { componentName: answerComponent.name, componentType: answerComponent.type, reasoning: answerComponentData.reasoning }
-                    );
-                  }
                   let answerQuery = answerComponent.props?.query;
-                  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);
@@ -7563,24 +7607,18 @@ ${executedToolsText}`);
                       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 < maxRetries && !validated) {
                         attempts++;
                         try {
                           const cacheKey = this.queryService.getQueryCacheKey(currentQuery);
                           if (cacheKey) {
-                            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;
                             if (currentQuery !== answerQuery) {
                               answerComponent.props.query = currentQuery;
                             }
-                            logger.info(`[${this.getProviderName()}] \u2713 Answer component query validated (attempt ${attempts}) - STREAMING TO FRONTEND NOW`);
-                            logCollector?.info(`\u2713 Answer component query validated - streaming to frontend`);
-                            logger.info(`[${this.getProviderName()}] Calling answerCallback for: ${answerComponent.name}`);
                             answerCallback(answerComponent);
-                            logger.info(`[${this.getProviderName()}] answerCallback completed for: ${answerComponent.name}`);
                           }
                         } catch (validationError) {
                           lastError = validationError instanceof Error ? validationError.message : String(validationError);
@@ -7616,7 +7654,6 @@ ${executedToolsText}`);
                       }
                       if (!validated) {
                         logger.warn(`[${this.getProviderName()}] Answer component query validation failed after ${attempts} attempts - component will be excluded`);
-                        logCollector?.warn(`Answer component query validation failed: ${lastError} - component will be excluded from response`);
                       }
                     })();
                   } else {
@@ -7627,7 +7664,7 @@ ${executedToolsText}`);
                 }
               }
             } catch (e) {
-              logger.debug(`[${this.getProviderName()}] Partial answerComponent parse failed, waiting for more data...`);
+              logger.error(`[${this.getProviderName()}] Partial answerComponent parse failed, waiting for more data...`);
             }
           }
         }
@@ -7657,18 +7694,6 @@ ${executedToolsText}`);
       logger.file("\n=============================\nFull LLM response:", JSON.stringify(result, null, 2));
       const rawActions = result.actions || [];
       const actions = convertQuestionsToActions(rawActions);
-      if (matchedComponents.length > 0) {
-        matchedComponents.forEach((comp, idx) => {
-          logCollector?.info(`  ${idx + 1}. ${comp.componentName} (${comp.componentType}): ${comp.reasoning}`);
-          if (comp.props?.query) {
-            logCollector?.logQuery(
-              `Component ${idx + 1} query`,
-              comp.props.query,
-              { componentName: comp.componentName, title: comp.props.title }
-            );
-          }
-        });
-      }
       const finalComponents = matchedComponents.map((mc) => {
         const originalComponent = components.find((c) => c.id === mc.componentId);
         if (!originalComponent) {
@@ -7693,27 +7718,22 @@ ${executedToolsText}`);
       }).filter(Boolean);
       let validatedComponents = finalComponents;
       if (collections?.["database"]?.["execute"]) {
-        logger.info(`[${this.getProviderName()}] Starting query validation for ${finalComponents.length} components...`);
-        logCollector?.info(`Validating queries for ${finalComponents.length} components...`);
         try {
           const validationResult = await this.queryService.validateComponentQueries(
             finalComponents,
             collections,
-            apiKey,
-            logCollector
+            apiKey
           );
           validatedComponents = validationResult.components;
           const queriedComponents = finalComponents.filter((c) => c.props?.query);
           const validatedQueries = validatedComponents.filter((c) => c.props?.query);
           logger.info(`[${this.getProviderName()}] Query validation complete: ${validatedQueries.length}/${queriedComponents.length} queries validated`);
-          logCollector?.info(`Query validation complete: ${validatedQueries.length}/${queriedComponents.length} queries validated`);
         } catch (validationError) {
           const validationErrorMsg = validationError instanceof Error ? validationError.message : String(validationError);
           logger.error(`[${this.getProviderName()}] Query validation error: ${validationErrorMsg}`);
-          logCollector?.error(`Query validation error: ${validationErrorMsg}`);
         }
       } else {
-        logger.debug(`[${this.getProviderName()}] Skipping query validation - database execute function not available`);
+        logger.error(`[${this.getProviderName()}] Skipping query validation - database execute function not available`);
       }
       const methodDuration = Date.now() - methodStartTime;
       logger.info(`[${this.getProviderName()}] [TIMING] DONE ${methodName} in ${methodDuration}ms | components: ${validatedComponents.length} | actions: ${actions.length}`);
@@ -7727,7 +7747,6 @@ ${executedToolsText}`);
       const methodDuration = Date.now() - methodStartTime;
       const errorMsg = error instanceof Error ? error.message : String(error);
       logger.error(`[${this.getProviderName()}] [TIMING] FAILED ${methodName} in ${methodDuration}ms | error: ${errorMsg}`);
-      logCollector?.error(`Failed to match components: ${errorMsg}`);
       return {
         components: [],
         layoutTitle: "Dashboard",
@@ -7740,7 +7759,7 @@ ${executedToolsText}`);
    * Classify user question into category and detect external tools needed
    * Determines if question is for data analysis, requires external tools, or needs text response
    */
-  async classifyQuestionCategory(userPrompt, apiKey, logCollector, conversationHistory, externalTools) {
+  async classifyQuestionCategory(userPrompt, apiKey, conversationHistory, externalTools) {
     const methodStartTime = Date.now();
     const methodName = "classifyQuestionCategory";
     const promptPreview = userPrompt.substring(0, 50) + (userPrompt.length > 50 ? "..." : "");
@@ -7776,16 +7795,6 @@ ${executedToolsText}`);
         true
         // Parse as JSON
       );
-      logCollector?.logExplanation(
-        "Question category classified",
-        result.reasoning || "No reasoning provided",
-        {
-          category: result.category,
-          externalTools: result.externalTools || [],
-          dataAnalysisType: result.dataAnalysisType,
-          confidence: result.confidence
-        }
-      );
       const methodDuration = Date.now() - methodStartTime;
       logger.info(`[${this.getProviderName()}] [TIMING] DONE ${methodName} in ${methodDuration}ms | category: ${result.category} | confidence: ${result.confidence}% | tools: ${(result.externalTools || []).length}`);
       return {
@@ -7799,7 +7808,6 @@ ${executedToolsText}`);
       const methodDuration = Date.now() - methodStartTime;
       const errorMsg = error instanceof Error ? error.message : String(error);
       logger.error(`[${this.getProviderName()}] [TIMING] FAILED ${methodName} in ${methodDuration}ms | error: ${errorMsg}`);
-      logger.debug(`[${this.getProviderName()}] Category classification error details:`, error);
       throw error;
     }
   }
@@ -7808,7 +7816,7 @@ ${executedToolsText}`);
    * Takes a matched UI block from semantic search and modifies its props to answer the new question
    * Also adapts the cached text response to match the new question
    */
-  async adaptUIBlockParameters(currentUserPrompt, originalUserPrompt, matchedUIBlock, apiKey, logCollector, cachedTextResponse) {
+  async adaptUIBlockParameters(currentUserPrompt, originalUserPrompt, matchedUIBlock, apiKey, cachedTextResponse) {
     const methodStartTime = Date.now();
     const methodName = "adaptUIBlockParameters";
     const promptPreview = currentUserPrompt.substring(0, 50) + (currentUserPrompt.length > 50 ? "..." : "");
@@ -7852,11 +7860,6 @@ ${executedToolsText}`);
       if (!result.success) {
         const methodDuration2 = Date.now() - methodStartTime;
         logger.info(`[${this.getProviderName()}] [TIMING] DONE ${methodName} in ${methodDuration2}ms | result: adaptation failed - ${result.reason}`);
-        logCollector?.warn(
-          "Could not adapt matched UI block",
-          "explanation",
-          { reason: result.reason }
-        );
         return {
           success: false,
           explanation: result.explanation || "Adaptation not possible"
@@ -7868,14 +7871,6 @@ ${executedToolsText}`);
           this.defaultLimit
         );
       }
-      logCollector?.logExplanation(
-        "UI block parameters adapted",
-        result.explanation || "Parameters adapted successfully",
-        {
-          parametersChanged: result.parametersChanged || [],
-          componentType: result.adaptedComponent?.type
-        }
-      );
       const methodDuration = Date.now() - methodStartTime;
       logger.info(`[${this.getProviderName()}] [TIMING] DONE ${methodName} in ${methodDuration}ms | result: success | changes: ${(result.parametersChanged || []).length}`);
       return {
@@ -7889,7 +7884,6 @@ ${executedToolsText}`);
       const methodDuration = Date.now() - methodStartTime;
       const errorMsg = error instanceof Error ? error.message : String(error);
       logger.error(`[${this.getProviderName()}] [TIMING] FAILED ${methodName} in ${methodDuration}ms | error: ${errorMsg}`);
-      logger.debug(`[${this.getProviderName()}] Adaptation error details:`, error);
       return {
         success: false,
         explanation: `Error adapting parameters: ${errorMsg}`
@@ -7902,14 +7896,12 @@ ${executedToolsText}`);
    * Supports tool calling for query execution with automatic retry on errors (max 3 attempts)
    * After generating text response, if components are provided, matches suggested components
    */
-  async generateTextResponse(userPrompt, apiKey, logCollector, conversationHistory, streamCallback, collections, components, externalTools, category, userId) {
+  async generateTextResponse(userPrompt, apiKey, conversationHistory, streamCallback, collections, components, externalTools, category, userId) {
     const methodStartTime = Date.now();
     const methodName = "generateTextResponse";
     const promptPreview = userPrompt.substring(0, 50) + (userPrompt.length > 50 ? "..." : "");
     logger.info(`[${this.getProviderName()}] [TIMING] START ${methodName} | model: ${this.getModelForTask("complex")} | category: ${category} | prompt: "${promptPreview}"`);
     const errors = [];
-    logger.debug(`[${this.getProviderName()}] Starting text response generation`);
-    logger.debug(`[${this.getProviderName()}] User prompt: "${userPrompt.substring(0, 50)}..."`);
     try {
       let availableToolsDoc = "No external tools are available for this request.";
       if (externalTools && externalTools.length > 0) {
@@ -7973,9 +7965,6 @@ ${executedToolsText}`);
       });
       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...");
       const tools = [{
         name: "execute_query",
         description: "Executes a parameterized SQL query against the database. CRITICAL: NEVER hardcode literal values in WHERE/HAVING conditions - ALWAYS use $paramName placeholders and pass actual values in params object.",
@@ -8004,7 +7993,6 @@ ${executedToolsText}`);
         const executableTools = externalTools.filter(
           (t) => t.executionType === "immediate" || t.executionType === "deferred" && t.userProvidedData
         );
-        logger.info(`[${this.getProviderName()}] Executable tools: ${executableTools.length} of ${externalTools.length} total`);
         const addedToolIds = /* @__PURE__ */ new Set();
         executableTools.forEach((tool) => {
           if (addedToolIds.has(tool.id)) {
@@ -8012,7 +8000,6 @@ ${executedToolsText}`);
             return;
           }
           addedToolIds.add(tool.id);
-          logger.info(`[${this.getProviderName()}] Processing executable tool:`, JSON.stringify(tool, null, 2));
           const properties = {};
           const required = [];
           Object.entries(tool.params || {}).forEach(([key, typeOrValue]) => {
@@ -8082,14 +8069,13 @@ ${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));
+        logger.debug(`[${this.getProviderName()}] Complete tools array:`, JSON.stringify(tools, null, 2));
       }
       const streamBuffer = new StreamBuffer(streamCallback);
       const toolExecutor = new ToolExecutorService({
         providerName: this.getProviderName(),
         collections,
-        streamBuffer,
-        logCollector
+        streamBuffer
       });
       const executableExternalTools = externalTools?.map((t) => ({
         id: t.id,
@@ -8118,12 +8104,10 @@ ${executedToolsText}`);
         },
         MAX_TOOL_CALLING_ITERATIONS
       );
-      logger.info(`[${this.getProviderName()}] Text response stream completed`);
       const textResponse = streamBuffer.getFullText() || result || "I apologize, but I was unable to generate a response.";
       if (toolExecutor.isMaxAttemptsReached()) {
         const methodDuration2 = Date.now() - methodStartTime;
         logger.warn(`[${this.getProviderName()}] [TIMING] DONE ${methodName} in ${methodDuration2}ms | result: max attempts reached`);
-        logCollector?.error("Failed to generate valid query after maximum attempts");
         return {
           success: false,
           errors: [`Maximum query attempts (${MAX_QUERY_ATTEMPTS}) reached. Unable to generate a valid query for your question.`],
@@ -8135,14 +8119,6 @@ ${executedToolsText}`);
           }
         };
       }
-      logCollector?.info(`Text response: ${textResponse.substring(0, 100)}${textResponse.length > 100 ? "..." : ""}`);
-      logCollector?.logExplanation(
-        "Text response generated",
-        "Generated plain text response with component suggestions",
-        {
-          textLength: textResponse.length
-        }
-      );
       streamBuffer.flush();
       if (streamBuffer.hasCallback() && components && components.length > 0 && category !== "general") {
         streamBuffer.write("\n\n\u{1F4CA} **Generating visualization components...**\n\n");
@@ -8154,8 +8130,6 @@ ${executedToolsText}`);
       let actions = [];
       if (category === "general") {
         logger.info(`[${this.getProviderName()}] Skipping component generation for general/conversational question`);
-        logCollector?.info("Skipping component generation for general question");
-        logger.info(`[${this.getProviderName()}] Generating actions for general question...`);
         const nextQuestions = await this.generateNextQuestions(
           userPrompt,
           null,
@@ -8163,23 +8137,16 @@ ${executedToolsText}`);
           void 0,
           // no component data
           apiKey,
-          logCollector,
           conversationHistory,
           textResponse
           // pass text response as context
         );
         actions = convertQuestionsToActions(nextQuestions);
-        logger.info(`[${this.getProviderName()}] Generated ${actions.length} follow-up actions for general question`);
       } else if (components && components.length > 0) {
-        logger.info(`[${this.getProviderName()}] Matching components from text response...`);
-        logger.info(`[${this.getProviderName()}] componentStreamCallback setup: 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 componentStreamCallback = streamBuffer.hasCallback() && category === "data_analysis" ? (component) => {
           const answerMarker = `__ANSWER_COMPONENT_START__${JSON.stringify(component)}__ANSWER_COMPONENT_END__`;
           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}`);
         const deferredTools = externalTools?.filter((t) => {
           if (t.executionType === "deferred" && !t.userProvidedData) return true;
           if (category === "data_modification" && !t.userProvidedData) {
@@ -8200,7 +8167,6 @@ ${executedToolsText}`);
           components,
           userPrompt,
           apiKey,
-          logCollector,
           componentStreamCallback,
           deferredTools,
           toolExecutor.getExecutedTools(),
@@ -8214,8 +8180,6 @@ ${executedToolsText}`);
       }
       let container_componet = null;
       if (matchedComponents.length > 0) {
-        logger.info(`[${this.getProviderName()}] Created MultiComponentContainer: "${layoutTitle}" with ${matchedComponents.length} components and ${actions.length} actions`);
-        logCollector?.info(`Created dashboard: "${layoutTitle}" with ${matchedComponents.length} components and ${actions.length} actions`);
         container_componet = {
           id: `container_${Date.now()}`,
           name: "MultiComponentContainer",
@@ -8247,7 +8211,6 @@ ${executedToolsText}`);
       const methodDuration = Date.now() - methodStartTime;
       const errorMsg = error instanceof Error ? error.message : String(error);
       logger.error(`[${this.getProviderName()}] [TIMING] FAILED ${methodName} in ${methodDuration}ms | error: ${errorMsg}`);
-      logCollector?.error(`Error generating text response: ${errorMsg}`);
       userPromptErrorLogger.logLlmError(
         this.getProviderName(),
         this.model,
@@ -8275,14 +8238,11 @@ ${executedToolsText}`);
    * 2. Category classification: Determine if data_analysis, requires_external_tools, or text_response
    * 3. Route appropriately based on category and response mode
    */
-  async handleUserRequest(userPrompt, components, apiKey, logCollector, conversationHistory, responseMode = "text", streamCallback, collections, externalTools, userId) {
+  async handleUserRequest(userPrompt, components, apiKey, conversationHistory, responseMode = "text", streamCallback, collections, externalTools, userId) {
     const startTime = Date.now();
-    logger.info(`[${this.getProviderName()}] handleUserRequest called for user prompt: ${userPrompt}`);
-    logCollector?.info(`Starting request processing with mode: ${responseMode}`);
     logger.clearFile();
     logger.logLLMPrompt("handleUserRequest", "user", `User Prompt: ${userPrompt}`);
     try {
-      logger.info(`[${this.getProviderName()}] Step 1: Searching previous conversations...`);
       const conversationMatch = await conversation_search_default.searchConversationsWithReranking({
         userPrompt,
         collections,
@@ -8291,22 +8251,16 @@ ${executedToolsText}`);
       });
       if (conversationMatch) {
         logger.info(`[${this.getProviderName()}] \u2713 Found matching conversation with ${(conversationMatch.similarity * 100).toFixed(2)}% similarity`);
-        logCollector?.info(
-          `\u2713 Found similar conversation (${(conversationMatch.similarity * 100).toFixed(2)}% match)`
-        );
         const rawComponent = conversationMatch.uiBlock?.component || conversationMatch.uiBlock?.generatedComponentMetadata;
         const isValidComponent = rawComponent && typeof rawComponent === "object" && Object.keys(rawComponent).length > 0;
         const component = isValidComponent ? rawComponent : null;
         const cachedTextResponse = conversationMatch.uiBlock?.analysis || conversationMatch.uiBlock?.textResponse || conversationMatch.uiBlock?.text || "";
         if (this.containsFormComponent(component)) {
           logger.info(`[${this.getProviderName()}] Skipping cached result - Form components contain stale defaultValues, fetching fresh data`);
-          logCollector?.info("Skipping cache for form - fetching current values from database...");
         } else if (!component) {
           if (conversationMatch.similarity >= EXACT_MATCH_SIMILARITY_THRESHOLD) {
             const elapsedTime2 = Date.now() - startTime;
-            logger.info(`[${this.getProviderName()}] \u2713 Exact match for general question - returning cached text response`);
-            logCollector?.info(`\u2713 Exact match for general question - returning cached response`);
-            logCollector?.info(`Total time taken: ${elapsedTime2}ms (${(elapsedTime2 / 1e3).toFixed(2)}s)`);
+            logger.info(`[${this.getProviderName()}] \u2713 Exact match for general question - returning cached text response (${elapsedTime2}ms)`);
             return {
               success: true,
               data: {
@@ -8321,14 +8275,11 @@ ${executedToolsText}`);
             };
           } else {
             logger.info(`[${this.getProviderName()}] Similar match but no component (general question) - processing fresh`);
-            logCollector?.info("Similar match found but was a general conversation - processing as new question");
           }
         } else {
           if (conversationMatch.similarity >= EXACT_MATCH_SIMILARITY_THRESHOLD) {
             const elapsedTime2 = Date.now() - startTime;
-            logger.info(`[${this.getProviderName()}] \u2713 100% match - returning UI block directly without adaptation`);
-            logCollector?.info(`\u2713 Exact match (${(conversationMatch.similarity * 100).toFixed(2)}%) - returning cached result`);
-            logCollector?.info(`Total time taken: ${elapsedTime2}ms (${(elapsedTime2 / 1e3).toFixed(2)}s)`);
+            logger.info(`[${this.getProviderName()}] \u2713 100% match - returning UI block directly without adaptation (${elapsedTime2}ms)`);
             if (streamCallback && cachedTextResponse) {
               logger.info(`[${this.getProviderName()}] Streaming cached text response to frontend`);
               streamCallback(cachedTextResponse);
@@ -8347,22 +8298,18 @@ ${executedToolsText}`);
               errors: []
             };
           }
-          logCollector?.info(`Adapting parameters for similar question...`);
+          logger.info(`[${this.getProviderName()}] Adapting parameters for similar question...`);
           const originalPrompt = conversationMatch.metadata?.userPrompt || "Previous question";
           const adaptResult = await this.adaptUIBlockParameters(
             userPrompt,
             originalPrompt,
             conversationMatch.uiBlock,
             apiKey,
-            logCollector,
             cachedTextResponse
           );
           if (adaptResult.success && adaptResult.adaptedComponent) {
             const elapsedTime2 = Date.now() - startTime;
-            logger.info(`[${this.getProviderName()}] \u2713 Successfully adapted UI block parameters`);
-            logger.info(`[${this.getProviderName()}] Total time taken: ${elapsedTime2}ms (${(elapsedTime2 / 1e3).toFixed(2)}s)`);
-            logCollector?.info(`\u2713 UI block adapted successfully`);
-            logCollector?.info(`Total time taken: ${elapsedTime2}ms (${(elapsedTime2 / 1e3).toFixed(2)}s)`);
+            logger.info(`[${this.getProviderName()}] \u2713 Successfully adapted UI block parameters (${elapsedTime2}ms)`);
             const textResponseToUse = adaptResult.adaptedTextResponse || cachedTextResponse;
             if (streamCallback && textResponseToUse) {
               logger.info(`[${this.getProviderName()}] Streaming ${adaptResult.adaptedTextResponse ? "adapted" : "cached"} text response to frontend`);
@@ -8383,65 +8330,57 @@ ${executedToolsText}`);
               errors: []
             };
           } else {
-            logger.info(`[${this.getProviderName()}] Could not adapt matched conversation, continuing to category classification`);
-            logCollector?.warn(`Could not adapt matched conversation: ${adaptResult.explanation}`);
+            logger.info(`[${this.getProviderName()}] Could not adapt matched conversation: ${adaptResult.explanation}, continuing to category classification`);
           }
         }
       } else {
         logger.info(`[${this.getProviderName()}] No matching previous conversations found, proceeding to category classification`);
-        logCollector?.info("No similar previous conversations found. Proceeding to category classification...");
       }
       logger.info(`[${this.getProviderName()}] Step 2: Classifying question category...`);
-      logCollector?.info("Step 2: Classifying question category...");
       const categoryClassification = await this.classifyQuestionCategory(
         userPrompt,
         apiKey,
-        logCollector,
         conversationHistory,
         externalTools
       );
       logger.info(
         `[${this.getProviderName()}] Question classified as: ${categoryClassification.category} (confidence: ${categoryClassification.confidence}%)`
       );
-      logCollector?.info(
-        `Category: ${categoryClassification.category} | Confidence: ${categoryClassification.confidence}%`
-      );
       let toolsToUse = [];
       if (categoryClassification.externalTools && categoryClassification.externalTools.length > 0) {
-        logger.info(`[${this.getProviderName()}] Identified ${categoryClassification.externalTools.length} external tools needed`);
-        logCollector?.info(`Identified external tools: ${categoryClassification.externalTools.map((t) => t.name || t.type).join(", ")}`);
-        logger.info(`[${this.getProviderName()}] Raw external tools from classification: ${JSON.stringify(categoryClassification.externalTools, null, 2)}`);
-        toolsToUse = categoryClassification.externalTools?.map((t) => {
+        logger.info(`[${this.getProviderName()}] Identified ${categoryClassification.externalTools.length} external tools needed: ${categoryClassification.externalTools.map((t) => t.name || t.type).join(", ")}`);
+        logger.debug(`[${this.getProviderName()}] Raw external tools from classification: ${JSON.stringify(categoryClassification.externalTools, null, 2)}`);
+        toolsToUse = categoryClassification.externalTools.reduce((acc, t) => {
           const realTool = externalTools?.find((tool) => tool.id === t.type);
-          logger.info(`[${this.getProviderName()}] Tool ${t.name}: executionType=${t.executionType}, userProvidedData=${t.userProvidedData ? "present" : "null"}`);
-          return {
+          if (!realTool) {
+            logger.warn(`[${this.getProviderName()}] Tool ${t.type} (${t.name}) not found in registered tools - skipping (likely hallucinated)`);
+            return acc;
+          }
+          acc.push({
             id: t.type,
             name: t.name,
             description: t.description,
             params: t.parameters || {},
-            // NEW: Include execution type info from category classification
+            // Include execution type info from category classification
             executionType: t.executionType || "immediate",
             executionReason: t.executionReason || "",
             requiredFields: t.requiredFields || [],
             userProvidedData: t.userProvidedData || null,
-            // CRITICAL: Include outputSchema from real tool for component config generation
-            outputSchema: realTool?.outputSchema,
-            fn: (() => {
-              if (realTool) {
-                logger.info(`[${this.getProviderName()}] Using real tool implementation for ${t.type}`);
-                return realTool.fn;
-              } else {
-                logger.warn(`[${this.getProviderName()}] Tool ${t.type} not found in registered tools`);
-                return async () => ({ success: false, message: `Tool ${t.name || t.type} not registered` });
-              }
-            })()
-          };
-        }) || [];
+            // Include outputSchema from real tool for component config generation
+            outputSchema: realTool.outputSchema,
+            fn: realTool.fn
+          });
+          return acc;
+        }, []);
+        const validCount = toolsToUse.length;
+        const hallucinatedCount = categoryClassification.externalTools.length - validCount;
+        if (hallucinatedCount > 0) {
+          logger.warn(`[${this.getProviderName()}] Filtered out ${hallucinatedCount} hallucinated/non-existent tools, ${validCount} valid tools remaining`);
+        }
       }
       const textResponse = await this.generateTextResponse(
         userPrompt,
         apiKey,
-        logCollector,
         conversationHistory,
         streamCallback,
         collections,
@@ -8452,13 +8391,10 @@ ${executedToolsText}`);
       );
       const elapsedTime = Date.now() - startTime;
       logger.info(`[${this.getProviderName()}] Total time taken: ${elapsedTime}ms (${(elapsedTime / 1e3).toFixed(2)}s)`);
-      logCollector?.info(`Total time taken: ${elapsedTime}ms (${(elapsedTime / 1e3).toFixed(2)}s)`);
       return textResponse;
     } catch (error) {
       const errorMsg = error instanceof Error ? error.message : String(error);
       logger.error(`[${this.getProviderName()}] Error in handleUserRequest: ${errorMsg}`);
-      logger.debug(`[${this.getProviderName()}] Error details:`, error);
-      logCollector?.error(`Error processing request: ${errorMsg}`);
       userPromptErrorLogger.logError(
         "handleUserRequest",
         error instanceof Error ? error : new Error(errorMsg),
@@ -8466,7 +8402,6 @@ ${executedToolsText}`);
       );
       const elapsedTime = Date.now() - startTime;
       logger.info(`[${this.getProviderName()}] Total time taken: ${elapsedTime}ms (${(elapsedTime / 1e3).toFixed(2)}s)`);
-      logCollector?.info(`Total time taken: ${elapsedTime}ms (${(elapsedTime / 1e3).toFixed(2)}s)`);
       return {
         success: false,
         errors: [errorMsg],
@@ -8482,7 +8417,7 @@ ${executedToolsText}`);
    * This helps provide intelligent suggestions for follow-up queries
    * For general/conversational questions without components, pass textResponse instead
    */
-  async generateNextQuestions(originalUserPrompt, component, componentData, apiKey, logCollector, conversationHistory, textResponse) {
+  async generateNextQuestions(originalUserPrompt, component, componentData, apiKey, conversationHistory, textResponse) {
     const methodStartTime = Date.now();
     const methodName = "generateNextQuestions";
     const promptPreview = originalUserPrompt.substring(0, 50) + (originalUserPrompt.length > 50 ? "..." : "");
@@ -8527,14 +8462,6 @@ ${executedToolsText}`);
         // Parse as JSON
       );
       const nextQuestions = result.nextQuestions || [];
-      logCollector?.logExplanation(
-        "Next questions generated",
-        "Generated intelligent follow-up questions based on component",
-        {
-          count: nextQuestions.length,
-          questions: nextQuestions
-        }
-      );
       const methodDuration = Date.now() - methodStartTime;
       logger.info(`[${this.getProviderName()}] [TIMING] DONE ${methodName} in ${methodDuration}ms | questions: ${nextQuestions.length}`);
       return nextQuestions;
@@ -8542,8 +8469,6 @@ ${executedToolsText}`);
       const methodDuration = Date.now() - methodStartTime;
       const errorMsg = error instanceof Error ? error.message : String(error);
       logger.error(`[${this.getProviderName()}] [TIMING] FAILED ${methodName} in ${methodDuration}ms | error: ${errorMsg}`);
-      logger.debug(`[${this.getProviderName()}] Next questions generation error details:`, error);
-      logCollector?.error(`Error generating next questions: ${errorMsg}`);
       return [];
     }
   }
@@ -8600,10 +8525,10 @@ var GeminiLLM = class extends BaseLLM {
     super(config);
   }
   getDefaultModel() {
-    return "gemini/gemini-3-pro-preview";
+    return "gemini/gemini-2.5-flash";
   }
   getDefaultFastModel() {
-    return "gemini/gemini-3-flash-preview";
+    return "gemini/gemini-2.5-flash";
   }
   getDefaultApiKey() {
     return process.env.GEMINI_API_KEY;
@@ -8657,332 +8582,96 @@ function getLLMProviders() {
     return DEFAULT_PROVIDERS;
   }
 }
-var useAnthropicMethod = async (prompt, components, apiKey, logCollector, conversationHistory, responseMode = "component", streamCallback, collections, externalTools, userId) => {
-  logger.debug("[useAnthropicMethod] Initializing Anthropic Claude matching method");
-  logger.debug(`[useAnthropicMethod] Response mode: ${responseMode}`);
-  const msg = `Using Anthropic Claude ${responseMode === "text" ? "text response" : "matching"} method...`;
-  logCollector?.info(msg);
+var useAnthropicMethod = async (prompt, components, apiKey, conversationHistory, responseMode = "component", streamCallback, collections, externalTools, userId) => {
   if (responseMode === "component" && components.length === 0) {
     const emptyMsg = "Components not loaded in memory. Please ensure components are fetched first.";
     logger.error("[useAnthropicMethod] No components available");
-    logCollector?.error(emptyMsg);
     return { success: false, errors: [emptyMsg] };
   }
-  logger.debug(`[useAnthropicMethod] Processing with ${components.length} components`);
-  const matchResult = await anthropicLLM.handleUserRequest(prompt, components, apiKey, logCollector, conversationHistory, responseMode, streamCallback, collections, externalTools, userId);
+  const matchResult = await anthropicLLM.handleUserRequest(prompt, components, apiKey, conversationHistory, responseMode, streamCallback, collections, externalTools, userId);
   logger.info(`[useAnthropicMethod] Successfully generated ${responseMode} using Anthropic`);
   return matchResult;
 };
-var useGroqMethod = async (prompt, components, apiKey, logCollector, conversationHistory, responseMode = "component", streamCallback, collections, externalTools, userId) => {
+var useGroqMethod = async (prompt, components, apiKey, conversationHistory, responseMode = "component", streamCallback, collections, externalTools, userId) => {
   logger.debug("[useGroqMethod] Initializing Groq LLM matching method");
   logger.debug(`[useGroqMethod] Response mode: ${responseMode}`);
-  const msg = `Using Groq LLM ${responseMode === "text" ? "text response" : "matching"} method...`;
-  logger.info(msg);
-  logCollector?.info(msg);
   if (responseMode === "component" && components.length === 0) {
     const emptyMsg = "Components not loaded in memory. Please ensure components are fetched first.";
     logger.error("[useGroqMethod] No components available");
-    logCollector?.error(emptyMsg);
     return { success: false, errors: [emptyMsg] };
   }
   logger.debug(`[useGroqMethod] Processing with ${components.length} components`);
-  const matchResult = await groqLLM.handleUserRequest(prompt, components, apiKey, logCollector, conversationHistory, responseMode, streamCallback, collections, externalTools, userId);
+  const matchResult = await groqLLM.handleUserRequest(prompt, components, apiKey, conversationHistory, responseMode, streamCallback, collections, externalTools, userId);
   logger.info(`[useGroqMethod] Successfully generated ${responseMode} using Groq`);
   return matchResult;
 };
-var useGeminiMethod = async (prompt, components, apiKey, logCollector, conversationHistory, responseMode = "component", streamCallback, collections, externalTools, userId) => {
+var useGeminiMethod = async (prompt, components, apiKey, conversationHistory, responseMode = "component", streamCallback, collections, externalTools, userId) => {
   logger.debug("[useGeminiMethod] Initializing Gemini LLM matching method");
   logger.debug(`[useGeminiMethod] Response mode: ${responseMode}`);
-  const msg = `Using Gemini LLM ${responseMode === "text" ? "text response" : "matching"} method...`;
-  logger.info(msg);
-  logCollector?.info(msg);
   if (responseMode === "component" && components.length === 0) {
     const emptyMsg = "Components not loaded in memory. Please ensure components are fetched first.";
     logger.error("[useGeminiMethod] No components available");
-    logCollector?.error(emptyMsg);
     return { success: false, errors: [emptyMsg] };
   }
   logger.debug(`[useGeminiMethod] Processing with ${components.length} components`);
-  const matchResult = await geminiLLM.handleUserRequest(prompt, components, apiKey, logCollector, conversationHistory, responseMode, streamCallback, collections, externalTools, userId);
+  const matchResult = await geminiLLM.handleUserRequest(prompt, components, apiKey, conversationHistory, responseMode, streamCallback, collections, externalTools, userId);
   logger.info(`[useGeminiMethod] Successfully generated ${responseMode} using Gemini`);
   return matchResult;
 };
-var useOpenAIMethod = async (prompt, components, apiKey, logCollector, conversationHistory, responseMode = "component", streamCallback, collections, externalTools, userId) => {
+var useOpenAIMethod = async (prompt, components, apiKey, conversationHistory, responseMode = "component", streamCallback, collections, externalTools, userId) => {
   logger.debug("[useOpenAIMethod] Initializing OpenAI GPT matching method");
   logger.debug(`[useOpenAIMethod] Response mode: ${responseMode}`);
-  const msg = `Using OpenAI GPT ${responseMode === "text" ? "text response" : "matching"} method...`;
-  logger.info(msg);
-  logCollector?.info(msg);
   if (responseMode === "component" && components.length === 0) {
     const emptyMsg = "Components not loaded in memory. Please ensure components are fetched first.";
     logger.error("[useOpenAIMethod] No components available");
-    logCollector?.error(emptyMsg);
     return { success: false, errors: [emptyMsg] };
   }
   logger.debug(`[useOpenAIMethod] Processing with ${components.length} components`);
-  const matchResult = await openaiLLM.handleUserRequest(prompt, components, apiKey, logCollector, conversationHistory, responseMode, streamCallback, collections, externalTools, userId);
+  const matchResult = await openaiLLM.handleUserRequest(prompt, components, apiKey, conversationHistory, responseMode, streamCallback, collections, externalTools, userId);
   logger.info(`[useOpenAIMethod] Successfully generated ${responseMode} using OpenAI`);
   return matchResult;
 };
-var getUserResponseFromCache = async (prompt) => {
-  return false;
-};
-var get_user_response = async (prompt, components, anthropicApiKey, groqApiKey, geminiApiKey, openaiApiKey, llmProviders, logCollector, conversationHistory, responseMode = "component", streamCallback, collections, externalTools, userId) => {
-  logger.debug(`[get_user_response] Starting user response generation for prompt: "${prompt.substring(0, 50)}..."`);
-  logger.debug(`[get_user_response] Response mode: ${responseMode}`);
-  logger.debug("[get_user_response] Checking cache for existing response");
-  const userResponse = await getUserResponseFromCache(prompt);
-  if (userResponse) {
-    logger.info("[get_user_response] User response found in cache - returning cached result");
-    logCollector?.info("User response found in cache");
-    return {
-      success: true,
-      data: userResponse,
-      errors: []
-    };
-  }
-  logger.debug("[get_user_response] No cached response found, proceeding with LLM providers");
+var get_user_response = async (prompt, components, anthropicApiKey, groqApiKey, geminiApiKey, openaiApiKey, llmProviders, conversationHistory, responseMode = "component", streamCallback, collections, externalTools, userId) => {
   const providers = llmProviders || getLLMProviders();
   const errors = [];
-  const providerOrder = providers.join(", ");
-  logCollector?.info(`LLM Provider order: [${providerOrder}]`);
-  if (conversationHistory && conversationHistory.length > 0) {
-    const exchangeCount = conversationHistory.split("\n").filter((l) => l.startsWith("Q")).length;
-    logger.debug(`[get_user_response] Using conversation history with ${exchangeCount} previous exchanges`);
-    logCollector?.info(`Using conversation history with ${exchangeCount} previous exchanges`);
-  } else {
-    logger.debug("[get_user_response] No conversation history available");
-  }
+  logger.info(`[get_user_response] LLM Provider order: [${providers.join(", ")}]`);
   for (let i = 0; i < providers.length; i++) {
     const provider = providers[i];
     const isLastProvider = i === providers.length - 1;
-    const attemptMsg = `Attempting provider: ${provider} (${i + 1}/${providers.length})`;
-    logCollector?.info(attemptMsg);
+    logger.info(`[get_user_response] Attempting provider: ${provider} (${i + 1}/${providers.length})`);
     let result;
     if (provider === "anthropic") {
-      result = await useAnthropicMethod(prompt, components, anthropicApiKey, logCollector, conversationHistory, responseMode, streamCallback, collections, externalTools, userId);
+      result = await useAnthropicMethod(prompt, components, anthropicApiKey, conversationHistory, responseMode, streamCallback, collections, externalTools, userId);
     } else if (provider === "groq") {
-      result = await useGroqMethod(prompt, components, groqApiKey, logCollector, conversationHistory, responseMode, streamCallback, collections, externalTools, userId);
+      result = await useGroqMethod(prompt, components, groqApiKey, conversationHistory, responseMode, streamCallback, collections, externalTools, userId);
     } else if (provider === "gemini") {
-      result = await useGeminiMethod(prompt, components, geminiApiKey, logCollector, conversationHistory, responseMode, streamCallback, collections, externalTools, userId);
+      result = await useGeminiMethod(prompt, components, geminiApiKey, conversationHistory, responseMode, streamCallback, collections, externalTools, userId);
     } else if (provider === "openai") {
-      result = await useOpenAIMethod(prompt, components, openaiApiKey, logCollector, conversationHistory, responseMode, streamCallback, collections, externalTools, userId);
+      result = await useOpenAIMethod(prompt, components, openaiApiKey, conversationHistory, responseMode, streamCallback, collections, externalTools, userId);
     } else {
       logger.warn(`[get_user_response] Unknown provider: ${provider} - skipping`);
       errors.push(`Unknown provider: ${provider}`);
       continue;
     }
     if (result.success) {
-      const successMsg = `Success with provider: ${provider}`;
-      logger.info(`${successMsg}`);
-      logCollector?.info(successMsg);
+      logger.info(`[get_user_response] Success with provider: ${provider}`);
       return result;
     } else {
       const providerErrors = result.errors.map((err) => `${provider}: ${err}`);
       errors.push(...providerErrors);
-      const warnMsg = `Provider ${provider} returned unsuccessful result: ${result.errors.join(", ")}`;
-      logger.warn(`[get_user_response] ${warnMsg}`);
-      logCollector?.warn(warnMsg);
+      logger.warn(`[get_user_response] Provider ${provider} returned unsuccessful result: ${result.errors.join(", ")}`);
       if (!isLastProvider) {
-        const fallbackMsg = "Falling back to next provider...";
-        logger.info(`[get_user_response] ${fallbackMsg}`);
-        logCollector?.info(fallbackMsg);
+        logger.info("[get_user_response] Falling back to next provider...");
       }
     }
   }
-  const failureMsg = `All LLM providers failed`;
-  logger.error(`[get_user_response] ${failureMsg}. Errors: ${errors.join("; ")}`);
-  logCollector?.error(`${failureMsg}. Errors: ${errors.join("; ")}`);
+  logger.error(`[get_user_response] All LLM providers failed. Errors: ${errors.join("; ")}`);
   return {
     success: false,
     errors
   };
 };
 
-// src/utils/log-collector.ts
-var LOG_LEVEL_PRIORITY2 = {
-  errors: 0,
-  warnings: 1,
-  info: 2,
-  verbose: 3
-};
-var MESSAGE_LEVEL_PRIORITY2 = {
-  error: 0,
-  warn: 1,
-  info: 2,
-  debug: 3
-};
-var UILogCollector = class {
-  constructor(clientId, sendMessage, uiBlockId) {
-    this.logs = [];
-    this.uiBlockId = uiBlockId || null;
-    this.clientId = clientId;
-    this.sendMessage = sendMessage;
-    this.currentLogLevel = logger.getLogLevel();
-  }
-  /**
-   * Check if logging is enabled (uiBlockId is provided)
-   */
-  isEnabled() {
-    return this.uiBlockId !== null;
-  }
-  /**
-   * Check if a message should be logged based on current log level
-   */
-  shouldLog(messageLevel) {
-    const currentLevelPriority = LOG_LEVEL_PRIORITY2[this.currentLogLevel];
-    const messagePriority = MESSAGE_LEVEL_PRIORITY2[messageLevel];
-    return messagePriority <= currentLevelPriority;
-  }
-  /**
-   * Add a log entry with timestamp and immediately send to runtime
-   * Only logs that pass the log level filter are captured and sent
-   */
-  addLog(level, message, type, data) {
-    if (!this.shouldLog(level)) {
-      return;
-    }
-    const log = {
-      timestamp: Date.now(),
-      level,
-      message,
-      ...type && { type },
-      ...data && { data }
-    };
-    this.logs.push(log);
-    this.sendLogImmediately(log);
-    switch (level) {
-      case "error":
-        logger.error("UILogCollector:", log);
-        break;
-      case "warn":
-        logger.warn("UILogCollector:", log);
-        break;
-      case "info":
-        logger.info("UILogCollector:", log);
-        break;
-      case "debug":
-        logger.debug("UILogCollector:", log);
-        break;
-    }
-  }
-  /**
-   * Send a single log to runtime immediately
-   */
-  sendLogImmediately(log) {
-    if (!this.isEnabled()) {
-      return;
-    }
-    const response = {
-      id: this.uiBlockId,
-      type: "UI_LOGS",
-      from: { type: "data-agent" },
-      to: {
-        type: "runtime",
-        id: this.clientId
-      },
-      payload: {
-        logs: [log]
-        // Send single log in array
-      }
-    };
-    this.sendMessage(response);
-  }
-  /**
-   * Log info message
-   */
-  info(message, type, data) {
-    if (this.isEnabled()) {
-      this.addLog("info", message, type, data);
-    }
-  }
-  /**
-   * Log error message
-   */
-  error(message, type, data) {
-    if (this.isEnabled()) {
-      this.addLog("error", message, type, data);
-    }
-  }
-  /**
-   * Log warning message
-   */
-  warn(message, type, data) {
-    if (this.isEnabled()) {
-      this.addLog("warn", message, type, data);
-    }
-  }
-  /**
-   * Log debug message
-   */
-  debug(message, type, data) {
-    if (this.isEnabled()) {
-      this.addLog("debug", message, type, data);
-    }
-  }
-  /**
-   * Log LLM explanation with typed metadata
-   */
-  logExplanation(message, explanation, data) {
-    if (this.isEnabled()) {
-      this.addLog("info", message, "explanation", {
-        explanation,
-        ...data
-      });
-    }
-  }
-  /**
-   * Log generated query with typed metadata
-   */
-  logQuery(message, query, data) {
-    if (this.isEnabled()) {
-      this.addLog("info", message, "query", {
-        query,
-        ...data
-      });
-    }
-  }
-  /**
-   * Send all collected logs at once (optional, for final summary)
-   */
-  sendAllLogs() {
-    if (!this.isEnabled() || this.logs.length === 0) {
-      return;
-    }
-    const response = {
-      id: this.uiBlockId,
-      type: "UI_LOGS",
-      from: { type: "data-agent" },
-      to: {
-        type: "runtime",
-        id: this.clientId
-      },
-      payload: {
-        logs: this.logs
-      }
-    };
-    this.sendMessage(response);
-  }
-  /**
-   * Get all collected logs
-   */
-  getLogs() {
-    return [...this.logs];
-  }
-  /**
-   * Clear all logs
-   */
-  clearLogs() {
-    this.logs = [];
-  }
-  /**
-   * Set uiBlockId (in case it's provided later)
-   */
-  setUIBlockId(uiBlockId) {
-    this.uiBlockId = uiBlockId;
-  }
-};
-
 // src/utils/conversation-saver.ts
 function transformUIBlockForDB(uiblock, userPrompt, uiBlockId) {
   const component = uiblock?.generatedComponentMetadata && Object.keys(uiblock.generatedComponentMetadata).length > 0 ? uiblock.generatedComponentMetadata : null;
@@ -9113,7 +8802,6 @@ var CONTEXT_CONFIG = {
 // src/handlers/user-prompt-request.ts
 var get_user_request = async (data, components, sendMessage, anthropicApiKey, groqApiKey, geminiApiKey, openaiApiKey, llmProviders, collections, externalTools) => {
   const errors = [];
-  logger.debug("[USER_PROMPT_REQ] Parsing incoming message data");
   const parseResult = UserPromptRequestMessageSchema.safeParse(data);
   if (!parseResult.success) {
     const zodError = parseResult.error;
@@ -9145,27 +8833,23 @@ var get_user_request = async (data, components, sendMessage, anthropicApiKey, gr
   if (!prompt) {
     errors.push("Prompt not found");
   }
-  logger.debug(`[REQUEST ${id}] Full request details - uiBlockId: ${existingUiBlockId}, threadId: ${threadId}, prompt: ${prompt}`);
   if (errors.length > 0) {
     return { success: false, errors, id, wsId };
   }
-  const logCollector = new UILogCollector(wsId, sendMessage, existingUiBlockId);
   const threadManager = ThreadManager.getInstance();
   let thread = threadManager.getThread(threadId);
   if (!thread) {
     thread = threadManager.createThread(threadId);
     logger.info(`Created new thread: ${threadId}`);
   }
-  logCollector.info(`Starting user prompt request with ${components.length} components`);
+  logger.info(`Starting user prompt request with ${components.length} components`);
   const conversationHistory = thread.getConversationContext(CONTEXT_CONFIG.MAX_CONVERSATION_CONTEXT_BLOCKS, existingUiBlockId);
   const responseMode = payload.responseMode || "component";
-  logger.info("responseMode", responseMode);
   let streamCallback;
   let accumulatedStreamResponse = "";
   if (responseMode === "text") {
     streamCallback = (chunk) => {
       accumulatedStreamResponse += chunk;
-      logger.debug(`[STREAM] Sending chunk (${chunk.length} chars): "${chunk.substring(0, 20)}..."`);
       const streamMessage = {
         id: `stream_${existingUiBlockId}`,
         // Different ID pattern for streaming
@@ -9181,7 +8865,6 @@ var get_user_request = async (data, components, sendMessage, anthropicApiKey, gr
         }
       };
       sendMessage(streamMessage);
-      logger.debug(`[STREAM] Chunk sent to wsId: ${wsId}`);
     };
   }
   const userResponse = await get_user_response(
@@ -9192,7 +8875,6 @@ var get_user_request = async (data, components, sendMessage, anthropicApiKey, gr
     geminiApiKey,
     openaiApiKey,
     llmProviders,
-    logCollector,
     conversationHistory,
     responseMode,
     streamCallback,
@@ -9200,7 +8882,7 @@ var get_user_request = async (data, components, sendMessage, anthropicApiKey, gr
     externalTools,
     userId
   );
-  logCollector.info("User prompt request completed");
+  logger.info("User prompt request completed");
   const uiBlockId = existingUiBlockId;
   if (!userResponse.success) {
     logger.error(`User prompt request failed with errors: ${userResponse.errors.join(", ")}`);
@@ -9267,9 +8949,6 @@ var get_user_request = async (data, components, sendMessage, anthropicApiKey, gr
       logger.info(
         `Skipping conversation save - response from exact semantic match (${(semanticSimilarity * 100).toFixed(2)}% similarity)`
       );
-      logCollector.info(
-        `Using exact cached result (${(semanticSimilarity * 100).toFixed(2)}% match) - not saving duplicate conversation`
-      );
     } else {
       const uiBlockData = uiBlock.toJSON();
       const saveResult = await saveConversation({
@@ -9477,7 +9156,7 @@ function sendResponse(id, res, sendMessage, clientId) {
 }
 
 // src/userResponse/next-questions.ts
-async function generateNextQuestions(originalUserPrompt, component, componentData, anthropicApiKey, groqApiKey, geminiApiKey, openaiApiKey, llmProviders, logCollector, conversationHistory) {
+async function generateNextQuestions(originalUserPrompt, component, componentData, anthropicApiKey, groqApiKey, geminiApiKey, openaiApiKey, llmProviders, conversationHistory) {
   try {
     logger.debug("[generateNextQuestions] Starting next questions generation");
     logger.debug(`[generateNextQuestions] User prompt: "${originalUserPrompt?.substring(0, 50)}..."`);
@@ -9496,7 +9175,6 @@ async function generateNextQuestions(originalUserPrompt, component, componentDat
       const isLastProvider = i === providers.length - 1;
       try {
         logger.info(`[generateNextQuestions] Attempting provider: ${provider} (${i + 1}/${providers.length})`);
-        logCollector?.info(`Generating questions with ${provider}...`);
         let result = [];
         if (provider === "groq") {
           logger.debug("[generateNextQuestions] Using Groq LLM for next questions");
@@ -9505,7 +9183,6 @@ async function generateNextQuestions(originalUserPrompt, component, componentDat
             component,
             componentData,
             groqApiKey,
-            logCollector,
             conversationHistory
           );
         } else if (provider === "gemini") {
@@ -9515,7 +9192,6 @@ async function generateNextQuestions(originalUserPrompt, component, componentDat
             component,
             componentData,
             geminiApiKey,
-            logCollector,
             conversationHistory
           );
         } else if (provider === "openai") {
@@ -9525,7 +9201,6 @@ async function generateNextQuestions(originalUserPrompt, component, componentDat
             component,
             componentData,
             openaiApiKey,
-            logCollector,
             conversationHistory
           );
         } else {
@@ -9535,44 +9210,32 @@ async function generateNextQuestions(originalUserPrompt, component, componentDat
             component,
             componentData,
             anthropicApiKey,
-            logCollector,
             conversationHistory
           );
         }
         if (result && result.length > 0) {
           logger.info(`[generateNextQuestions] Successfully generated ${result.length} questions with ${provider}`);
           logger.debug(`[generateNextQuestions] Questions: ${JSON.stringify(result)}`);
-          logCollector?.info(`Generated ${result.length} follow-up questions`);
           return result;
         }
-        const warnMsg = `No questions generated from ${provider}${!isLastProvider ? ", trying next provider..." : ""}`;
-        logger.warn(`[generateNextQuestions] ${warnMsg}`);
-        if (!isLastProvider) {
-          logCollector?.warn(warnMsg);
-        }
+        logger.warn(`[generateNextQuestions] No questions generated from ${provider}${!isLastProvider ? ", trying next provider..." : ""}`);
       } catch (providerError) {
         const errorMsg = providerError instanceof Error ? providerError.message : String(providerError);
         logger.error(`[generateNextQuestions] Provider ${provider} failed: ${errorMsg}`);
         logger.debug(`[generateNextQuestions] Provider error details:`, providerError);
         if (!isLastProvider) {
-          const fallbackMsg = `Provider ${provider} failed, trying next provider...`;
-          logger.info(`[generateNextQuestions] ${fallbackMsg}`);
-          logCollector?.warn(fallbackMsg);
-        } else {
-          logCollector?.error(`Failed to generate questions with ${provider}`);
+          logger.info(`[generateNextQuestions] Provider ${provider} failed, trying next provider...`);
         }
         continue;
       }
     }
     logger.warn("[generateNextQuestions] All providers failed or returned no questions");
-    logCollector?.warn("Unable to generate follow-up questions");
     return [];
   } catch (error) {
     const errorMsg = error instanceof Error ? error.message : String(error);
     const errorStack = error instanceof Error ? error.stack : void 0;
     logger.error(`[generateNextQuestions] Error generating next questions: ${errorMsg}`);
     logger.debug("[generateNextQuestions] Error stack trace:", errorStack);
-    logCollector?.error(`Error generating next questions: ${errorMsg}`);
     return [];
   }
 }
@@ -9620,9 +9283,6 @@ async function handleActionsRequest(data, sendMessage, anthropicApiKey, groqApiK
       return;
     }
     logger.info(`[ACTIONS_REQ ${id}] UIBlock retrieved successfully`);
-    logger.debug(`[ACTIONS_REQ ${id}] Creating UILogCollector for uiBlockId: ${uiBlockId}`);
-    const logCollector = new UILogCollector(wsId, sendMessage, uiBlockId);
-    logger.info(`[ACTIONS_REQ ${id}] UILogCollector initialized`);
     logger.debug(`[ACTIONS_REQ ${id}] Extracting data from UIBlock`);
     const userQuestion = uiBlock.getUserQuestion();
     const component = uiBlock.getComponentMetadata();
@@ -9636,13 +9296,11 @@ async function handleActionsRequest(data, sendMessage, anthropicApiKey, groqApiK
     logger.info(`[ACTIONS_REQ ${id}] Conversation history extracted: ${historyLineCount} lines`);
     logger.debug(`[ACTIONS_REQ ${id}] Conversation history preview:
 ${conversationHistory.substring(0, 200)}...`);
-    logCollector.info(`Generating actions for UIBlock: ${uiBlockId}`);
-    logger.info(`[ACTIONS_REQ ${id}] Generating actions for component: ${component?.name || "unknown"}`);
+    logger.info(`[ACTIONS_REQ ${id}] Generating actions for UIBlock: ${uiBlockId}, component: ${component?.name || "unknown"}`);
     logger.debug(`[ACTIONS_REQ ${id}] Checking if actions are already cached`);
     const startTime = Date.now();
     const actions = await uiBlock.getOrFetchActions(async () => {
       logger.info(`[ACTIONS_REQ ${id}] Actions not cached, generating new actions...`);
-      logCollector.info("Generating follow-up questions...");
       logger.info(`[ACTIONS_REQ ${id}] Starting next questions generation with ${llmProviders?.join(", ") || "default"} providers`);
       const nextQuestions = await generateNextQuestions(
         userQuestion,
@@ -9653,7 +9311,6 @@ ${conversationHistory.substring(0, 200)}...`);
         geminiApiKey,
         openaiApiKey,
         llmProviders,
-        logCollector,
         conversationHistory
       );
       logger.info(`[ACTIONS_REQ ${id}] Generated ${nextQuestions.length} questions`);
@@ -9671,11 +9328,10 @@ ${conversationHistory.substring(0, 200)}...`);
     const processingTime = Date.now() - startTime;
     logger.info(`[ACTIONS_REQ ${id}] Actions retrieved in ${processingTime}ms - ${actions.length} actions total`);
     if (actions.length > 0) {
-      logCollector.info(`Generated ${actions.length} follow-up questions successfully`);
+      logger.info(`[ACTIONS_REQ ${id}] Generated ${actions.length} follow-up questions successfully`);
       logger.debug(`[ACTIONS_REQ ${id}] Actions: ${actions.map((a) => a.name).join(", ")}`);
     } else {
       logger.warn(`[ACTIONS_REQ ${id}] No actions generated`);
-      logCollector.warn("No follow-up questions could be generated");
     }
     logger.debug(`[ACTIONS_REQ ${id}] Sending successful response to client`);
     sendResponse2(id, {
@@ -9694,15 +9350,6 @@ ${conversationHistory.substring(0, 200)}...`);
     const errorStack = error instanceof Error ? error.stack : void 0;
     logger.error(`[ACTIONS_REQ] Failed to handle actions request: ${errorMessage}`);
     logger.debug(`[ACTIONS_REQ] Error stack trace:`, errorStack);
-    try {
-      const parsedData = data;
-      if (parsedData?.id && parsedData?.from?.id) {
-        const logCollector = parsedData?.payload?.SA_RUNTIME?.uiBlockId ? new UILogCollector(parsedData.from.id, sendMessage, parsedData.payload.SA_RUNTIME.uiBlockId) : void 0;
-        logCollector?.error(`Failed to generate actions: ${errorMessage}`);
-      }
-    } catch (logError) {
-      logger.debug("[ACTIONS_REQ] Failed to send error logs to UI:", logError);
-    }
     sendResponse2(null, {
       success: false,
       error: errorMessage
@@ -10283,7 +9930,6 @@ function sendResponse3(id, res, sendMessage, clientId) {
 var dashboardManager = null;
 function setDashboardManager(manager) {
   dashboardManager = manager;
-  logger.info("DashboardManager instance set");
 }
 function getDashboardManager() {
   if (!dashboardManager) {
@@ -13610,6 +13256,190 @@ var ReportManager = class {
   }
 };
 
+// src/utils/log-collector.ts
+var LOG_LEVEL_PRIORITY2 = {
+  errors: 0,
+  warnings: 1,
+  info: 2,
+  verbose: 3
+};
+var MESSAGE_LEVEL_PRIORITY2 = {
+  error: 0,
+  warn: 1,
+  info: 2,
+  debug: 3
+};
+var UILogCollector = class {
+  constructor(clientId, sendMessage, uiBlockId) {
+    this.logs = [];
+    this.uiBlockId = uiBlockId || null;
+    this.clientId = clientId;
+    this.sendMessage = sendMessage;
+    this.currentLogLevel = logger.getLogLevel();
+  }
+  /**
+   * Check if logging is enabled (uiBlockId is provided)
+   */
+  isEnabled() {
+    return this.uiBlockId !== null;
+  }
+  /**
+   * Check if a message should be logged based on current log level
+   */
+  shouldLog(messageLevel) {
+    const currentLevelPriority = LOG_LEVEL_PRIORITY2[this.currentLogLevel];
+    const messagePriority = MESSAGE_LEVEL_PRIORITY2[messageLevel];
+    return messagePriority <= currentLevelPriority;
+  }
+  /**
+   * Add a log entry with timestamp and immediately send to runtime
+   * Only logs that pass the log level filter are captured and sent
+   */
+  addLog(level, message, type, data) {
+    if (!this.shouldLog(level)) {
+      return;
+    }
+    const log = {
+      timestamp: Date.now(),
+      level,
+      message,
+      ...type && { type },
+      ...data && { data }
+    };
+    this.logs.push(log);
+    this.sendLogImmediately(log);
+    switch (level) {
+      case "error":
+        logger.error("UILogCollector:", log);
+        break;
+      case "warn":
+        logger.warn("UILogCollector:", log);
+        break;
+      case "info":
+        logger.info("UILogCollector:", log);
+        break;
+      case "debug":
+        logger.debug("UILogCollector:", log);
+        break;
+    }
+  }
+  /**
+   * Send a single log to runtime immediately
+   */
+  sendLogImmediately(log) {
+    if (!this.isEnabled()) {
+      return;
+    }
+    const response = {
+      id: this.uiBlockId,
+      type: "UI_LOGS",
+      from: { type: "data-agent" },
+      to: {
+        type: "runtime",
+        id: this.clientId
+      },
+      payload: {
+        logs: [log]
+        // Send single log in array
+      }
+    };
+    this.sendMessage(response);
+  }
+  /**
+   * Log info message
+   */
+  info(message, type, data) {
+    if (this.isEnabled()) {
+      this.addLog("info", message, type, data);
+    }
+  }
+  /**
+   * Log error message
+   */
+  error(message, type, data) {
+    if (this.isEnabled()) {
+      this.addLog("error", message, type, data);
+    }
+  }
+  /**
+   * Log warning message
+   */
+  warn(message, type, data) {
+    if (this.isEnabled()) {
+      this.addLog("warn", message, type, data);
+    }
+  }
+  /**
+   * Log debug message
+   */
+  debug(message, type, data) {
+    if (this.isEnabled()) {
+      this.addLog("debug", message, type, data);
+    }
+  }
+  /**
+   * Log LLM explanation with typed metadata
+   */
+  logExplanation(message, explanation, data) {
+    if (this.isEnabled()) {
+      this.addLog("info", message, "explanation", {
+        explanation,
+        ...data
+      });
+    }
+  }
+  /**
+   * Log generated query with typed metadata
+   */
+  logQuery(message, query, data) {
+    if (this.isEnabled()) {
+      this.addLog("info", message, "query", {
+        query,
+        ...data
+      });
+    }
+  }
+  /**
+   * Send all collected logs at once (optional, for final summary)
+   */
+  sendAllLogs() {
+    if (!this.isEnabled() || this.logs.length === 0) {
+      return;
+    }
+    const response = {
+      id: this.uiBlockId,
+      type: "UI_LOGS",
+      from: { type: "data-agent" },
+      to: {
+        type: "runtime",
+        id: this.clientId
+      },
+      payload: {
+        logs: this.logs
+      }
+    };
+    this.sendMessage(response);
+  }
+  /**
+   * Get all collected logs
+   */
+  getLogs() {
+    return [...this.logs];
+  }
+  /**
+   * Clear all logs
+   */
+  clearLogs() {
+    this.logs = [];
+  }
+  /**
+   * Set uiBlockId (in case it's provided later)
+   */
+  setUIBlockId(uiBlockId) {
+    this.uiBlockId = uiBlockId;
+  }
+};
+
 // src/services/cleanup-service.ts
 var CleanupService = class _CleanupService {
   constructor() {
@@ -13790,7 +13620,6 @@ var CleanupService = class _CleanupService {
 };
 
 // src/index.ts
-var SDK_VERSION = "0.0.8";
 var DEFAULT_WS_URL = "wss://ws.superatom.ai/websocket";
 var SuperatomSDK = class {
   // 3.5 minutes (PING_INTERVAL + 30s grace)
@@ -13831,7 +13660,7 @@ var SuperatomSDK = class {
     if (config.queryCacheTTL !== void 0) {
       queryCache.setTTL(config.queryCacheTTL);
     }
-    logger.info(`Initializing Superatom SDK v${SDK_VERSION} for project ${this.projectId}, llm providers: ${this.llmProviders.join(", ")}, database type: ${this.databaseType}, model strategy: ${this.modelStrategy}, conversation similarity threshold: ${this.conversationSimilarityThreshold}, query cache TTL: ${queryCache.getTTL()} minutes`);
+    logger.info(`Initializing Superatom SDK for project ${this.projectId}, llm providers: ${this.llmProviders.join(", ")}, database type: ${this.databaseType}, model strategy: ${this.modelStrategy}, query cache TTL: ${queryCache.getTTL()} minutes`);
     this.userManager = new UserManager(this.projectId, 5e3);
     this.dashboardManager = new DashboardManager(this.projectId);
     this.reportManager = new ReportManager(this.projectId);
@@ -13885,7 +13714,6 @@ var SuperatomSDK = class {
    */
   initializeDashboardManager() {
     setDashboardManager(this.dashboardManager);
-    logger.info(`DashboardManager initialized for project: ${this.projectId}`);
   }
   /**
    * Get the DashboardManager instance for this SDK
@@ -13898,7 +13726,6 @@ var SuperatomSDK = class {
    */
   initializeReportManager() {
     setReportManager(this.reportManager);
-    logger.info(`ReportManager initialized for project: ${this.projectId}`);
   }
   /**
    * Get the ReportManager instance for this SDK
@@ -14276,7 +14103,6 @@ var SuperatomSDK = class {
   CONTEXT_CONFIG,
   CleanupService,
   LLM,
-  SDK_VERSION,
   STORAGE_CONFIG,
   SuperatomSDK,
   Thread,